Convertir un nombre décimal en binaire

Résolu/Fermé
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013 - 2 juil. 2013 à 12:24
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013 - 3 juil. 2013 à 11:43
Bonjour à toutes et à tous,

J'ai utilisé la fonction A pour convertir un tel nombre entier en forme binaire.

A) String xx=Integer.ToBinaryString(valeur_entière_à_convertir);

Hélas, cette fonction n'est accessible que pour convertir des valeurs entières en binaire.
Comment je peux alors avoir une autre fonction pour la conversion d'un nombre décimal en binaire?
Merci d'avance.

Amicalement,

7 réponses

KX Messages postés 16643 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 6 décembre 2022 2 984
2 juil. 2013 à 18:57
Avec ton exemple je me rends compte qu'il y a une petite erreur, en effet tu devrais avoir 64 bits dans ta représentation, or tu n'en as que 62, à cause des premiers 0 qui n'apparaissent pas au moment de la transformation Long.toBinaryString.

Le résultat correct est :
0011111111110000000000000000000000000000000000000000000000000000

Tu devrais regarder sur Wikipedia pour comprendre le fonctionnement de l'IEEE 754 : https://fr.wikipedia.org/wiki/IEEE_754

Voici une explication pour ton exemple 1.0

On "découpe" la chaîne de caractères en 3 morceaux :

s = "0"
e = "01111111111"
m = "0000000000000000000000000000000000000000000000000000"

Le calcul à faire étant x = (-1)^s * 2^(127-e) * (1,m)
Ici : x = (-1)^0 * 2^(127-127) * (1,0) = 1 * 1 * 1 = 1

Remarque : pour avoir les 64 bits en entier tu peux faire comme ça :

private static final String ZEROS = String.format("%064d", 0);

public static void main(String[] args)
{
	double d = 1;
	String s = Long.toBinaryString(Double.doubleToLongBits(d));
	
	s = ZEROS.substring(s.length()) + s;
	
	System.out.println(s);		
}

En ce qui concerne les autres formats de données, il n'y en a vraiment qu'un qui pourrait être utile de connaître c'est le binaire virgule fixe. Dans ce cas on considère que le nombre de "décimales" est constant (par exemple N), et on multiplie par 2^N la valeur qu'il faut pour récupérer un entier que l'on traite alors en complément à deux avec Long.toBinaryString par exemple.

Exemple : 1.4 en virgule fixe à 3 "décimales", ça donne --> 1.4 * 2^3 = 11.2
On ne garde que la partie entière (donc 11) qui se représente 1011, on rajoute la virgule après 3 chiffres et ça donne : "1,011"

Mais en Java et dans la plupart des langages, c'est surtout l'IEEE 754 qui est utilisé pour les calculs de nombres décimaux.
2
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013
2 juil. 2013 à 19:15
mes vifs remerciements pour cette réponse que je l'apprécie beaucoup!! :)

Une seule question: la fonction Long.toBinaryString(Double.doubleToLongBits(d)) nous donne que 64 bits ?

amicalement,
1
KX Messages postés 16643 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 6 décembre 2022 2 984
Modifié par KX le 2/07/2013 à 19:25
Les "double" sont codés sur 4 octets (64 bits), donc on les transforme en "long" qui sont eux aussi sur 4 octets, et ensuite on récupère une String de 64 caractères.
Il n'y a rien de plus à récupérer si ce n'est les "0" de départs qui sont oubliés lors du passage en String.

Remarque : pour les "float" qui sont sur 2 octets (32 bits) on les transforme en "int" qui sont eux aussi sur 2 octets, la String à récupérer sera donc de 32 caractères.

En IEEE 754 c'est ce qu'on appelle la précision simple pour les "float" et la précision double pour les "double" (d'où le nom)
0
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013
2 juil. 2013 à 19:34
ah ok mercii beaucoupp :))

est ce que les caractères (les char) sont toujours codés sue 8 bits ?

amicalement
1
KX Messages postés 16643 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 6 décembre 2022 2 984
2 juil. 2013 à 20:12
Non parce que Java supporte l'Unicode donc la plupart des caractères sont sur 16 bits.
0
KX Messages postés 16643 Date d'inscription samedi 31 mai 2008 Statut Modérateur Dernière intervention 6 décembre 2022 2 984
2 juil. 2013 à 14:04
Il y a plusieurs manières de représenter un nombre décimal, pour la représentation en virgule flottante IEEE 754 tu peux faire comme ça :

double d = 123.456;
String s = Long.toBinaryString(Double.doubleToLongBits(d));
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013
2 juil. 2013 à 16:48
J'ai essayé d'utiliser ton code sur NetBeans et il marche très bien. J'ai aussi tenté de changer la valeur de d.
par exemple:
double d=1.0.

j'ai eu 11111111110000000000000000000000000000000000000000000000000000
comme forme binaire.

est-ce que c'est juste ?
est-ce que les autres méthodes (autres que la virgule flottante) conduisent toujours au même résultat ?

Merci du fond de mon coeur.
0
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013
2 juil. 2013 à 18:23
moi j'interesse à convertir un double (un float) en binaire,,est ce que ta réponse répond à mon besoin ?

amicalement,
0
BittarAhmad Messages postés 12 Date d'inscription mardi 21 mai 2013 Statut Membre Dernière intervention 25 juillet 2013
3 juil. 2013 à 11:43
ah ok donc c'est plus mieux est de representer toujours les caracteres su 16 bits en java.
Merci beaucoup!
0