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
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
A voir également:
- Algorithme convertir un nombre décimal en binaire python
- Codage binaire - Guide
- Convertir youtube en mp3 avec audacity - Guide
- Convertir une note sur 20 ✓ - Forum Bureautique
- En raison d'un nombre important d'échec de connexion snapchat - Forum Snapchat
- Convertir cda en mp3 ✓ - Forum Logiciels
7 réponses
KX
Messages postés
16733
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
31 janvier 2024
3 015
2 juil. 2013 à 18:57
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 :
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.
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.
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
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,
Une seule question: la fonction Long.toBinaryString(Double.doubleToLongBits(d)) nous donne que 64 bits ?
amicalement,
KX
Messages postés
16733
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
31 janvier 2024
3 015
Modifié par KX le 2/07/2013 à 19:25
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)
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)
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
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
est ce que les caractères (les char) sont toujours codés sue 8 bits ?
amicalement
KX
Messages postés
16733
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
31 janvier 2024
3 015
2 juil. 2013 à 20:12
2 juil. 2013 à 20:12
Non parce que Java supporte l'Unicode donc la plupart des caractères sont sur 16 bits.
KX
Messages postés
16733
Date d'inscription
samedi 31 mai 2008
Statut
Modérateur
Dernière intervention
31 janvier 2024
3 015
2 juil. 2013 à 14:04
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));
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
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.
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.
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
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,
amicalement,
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
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!
Merci beaucoup!
