Discussion :

[enicnath]

Bonjour,
Je cherche à représenter le nombre 2 puissance 30 au format binaire dans SAS/IML.
Dans une étape data ordinaire, je procèderais comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
data _null_;
   X=30;
   Y=exp(30*log(2)); /*je n'ai pas trouvé la fonction puissance*/
   Z=put(Y,binary32.);
   put X Y Z;
run;

Comment faire sous SAS/IML ?
Mon problème est que je n'arrive pas à transformer Y en Z ; l'instruction Z=put(Y,binary32.); n'est pas acceptée.

[datametric]

Effectivement, je n'ai pas l'impression que l'on peut appliquer un format pour convertir un autre champ

[frajen]

Bonjour,

Il existe une commande dans le module SAS/IML, MATTRIB dont vous trouverez la documentation avec un exemple ici

Je pense que vous pourrez réaliser ce que vous souhaitez avec cela.

Cordialement
Jérémy NOEL
Consultant Support CLient SAS

[enicnath]

Il existe une commande dans le module SAS/IML, MATTRIB dont vous trouverez la documentation avec un exemple ici

Merci de votre réponse, mais quelquechose ne semble toujours pas fonctionner.
Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
proc iml;
   Y=exp(29*log(2));
   print Y;
   mattrib Y format=binary29.;
   print Y;
quit;

Au 1er affichage de Y, on obtient sa valeur, 536870912
Au second, on obtient une suite de 0 00000000000000000000000000000

Peut-être quelquechose que je n'ai pas compris ?

[enicnath]

Je continue ma question
J'essaie donc d'afficher les puissances de 2 au format binaire. Voici le code.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
proc iml;
   do i=1 to 30;
      X=exp(i*log(2));
      Y=X;
      mattrib Y format=binary32.; 
      print i X Y; 
   end;
quit;

A chaque ligne, je devrais avoir des 0 et un seul 1, chaque fois décalé d'une unité vers la gauche 0001, 0010, 0100, ....
Ce n'est pas ce qu'on obtient. Voici les premières lignes de résultat du programme précédent :
pour i=1, X=2, Y=000000000000000000000000000010
pour i=2, X=4, Y=000000000000000000000000000100
pour i=3, X=8, Y=000000000000000000000000000111
pour i=4, X=16, Y=000000000000000000000000001111
pour i=5, X=32, Y=000000000000000000000000100000

[enicnath]

En fait, mon problème initial était le suivant :
je cherche à représenter un nombre, sous la forme d'un vecteur binaire.
Par exemple, 12 peut être représenté en binaire par 1100 (ou 00001100 si on ajoute des 0).
Je voudrais donc avoir les vecteurs suivants

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
X=12
 
   0
Y= 0
   1  
   1  
   0 
   0

Le problème de MATTRIB, outre celui de ne pas me donner la bonne suite de 0 et 1 comme vu dans mon précédent message, ne transforme pas réellement la valeur. Il s'agit juste d'un affichage (c'est aussi le sens de l'instruction FORMAT).
A l'origine, j'envisageais d'utiliser un formatage pour transformer le nombre 12 en 1100. Parce que c'est ce que je veux obtenir in fine.
Mais il faut peut-être faire autrement.

Quelqu'un a t'il le moyen de faire cela ?

[enicnath]

En fait, j'ai trouvé une méthode pour faire cette conversion :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
   V=j(6,2,0); V[n,1]=12;
   do i=6 to 2 by -1;
     V[i,2]=mod(V[i,1],2);
     if V[i,2]=0 then V[i-1,1]=V[i,1]/2; else V[i-1,1]=(V[i,1]-1)/2;
   end;
   print V;

La seconde colonne de la matrice V contient bien mon vecteur colonne.

Il y a encore cependant un sérieux problème sur la fonction modulo. En effet, elle fonctionne sur les petits nombres mais est perturbée sur les gros. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
   X=exp(29*log(2));
   Y=mod(X,2);
   print X Y;

On obtient

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
        X         Y
 
536870912 3.5763E-7

Est-ce que quelqu'un aurait un moyen de contourner ce problème ?

[JeromeMATHIAS]

Bonjour,

tu utilise la fonction modulo...donc (à priori) tu compte l'utiliser plutôt sur des entiers....et tu sais que le résultat sera un entier.

Le modulo te donne 10E-7 à la place de 0, pourquoi n'arrondis tu pas directement ?

V[i,2]=ROUND(mod(V[i,1],2));

[enicnath]

Bonjour,
tu utilise la fonction modulo...donc (à priori) tu compte l'utiliser plutôt sur des entiers....et tu sais que le résultat sera un entier.
Le modulo te donne 10E-7 à la place de 0, pourquoi n'arrondis tu pas directement ?
V[i,2]=ROUND(mod(V[i,1],2));

Tu as raison.
Voici une solution simple et acceptable (mais je reste étonné de cette limite sur la fonction mod).
Merci