Vincent Lefevre a écrit :
>> Sans doute. Mais si tu as des exemples concrets ca m'interresse
>
> Le cas classique:
>
> if (x != y)
> a = b / (x - y);
> else
> ...
Perso je fais pas confiance au x!=y pour la division, car si ca diffère
d'un pouieme sensiblement égal à la précision, le résultat de la
division contient une erreur énorme sur la valeur de "a" (plusieurs
ordres de grandeurs au dessus).
> Aussi après un appel de rint...
pour savoir si un nombre est un entier ou pas?
>> car en fait je me dit que si on veut une équalité stricte, alors il
>> est plus simple de passer par un union et comparer (bit à bits) les
>> entiers correspondants.
>
> Non! D'une part c'est incorrect, car les représentations ne sont pas
> forcément identiques
Pourquoi donc? tous les doubles sont sérialisés en mémoire de la même
façon au format IEEE.
> (encore plus s'il y a des bytes de padding, comme avec un long
> double en 80 bits dans une union). D'autre part, ce serait plus
> lent.
Ca n'est pas le propos. Le propos était de voir si les deux "double"s
sont identiques (sous entendu en mémoire).
Vincent Lefevre a écrit :
>> Sans doute. Mais si tu as des exemples concrets ca m'interresse
>
> Le cas classique:
>
> if (x != y)
> a = b / (x - y);
> else
> ...
Perso je fais pas confiance au x!=y pour la division, car si ca diffère
d'un pouieme sensiblement égal à la précision, le résultat de la
division contient une erreur énorme sur la valeur de "a" (plusieurs
ordres de grandeurs au dessus).
> Aussi après un appel de rint...
pour savoir si un nombre est un entier ou pas?
>> car en fait je me dit que si on veut une équalité stricte, alors il
>> est plus simple de passer par un union et comparer (bit à bits) les
>> entiers correspondants.
>
> Non! D'une part c'est incorrect, car les représentations ne sont pas
> forcément identiques
Pourquoi donc? tous les doubles sont sérialisés en mémoire de la même
façon au format IEEE.
> (encore plus s'il y a des bytes de padding, comme avec un long
> double en 80 bits dans une union). D'autre part, ce serait plus
> lent.
Ca n'est pas le propos. Le propos était de voir si les deux "double"s
sont identiques (sous entendu en mémoire).
Vincent Lefevre a écrit :
>> Sans doute. Mais si tu as des exemples concrets ca m'interresse
>
> Le cas classique:
>
> if (x != y)
> a = b / (x - y);
> else
> ...
Perso je fais pas confiance au x!=y pour la division, car si ca diffère
d'un pouieme sensiblement égal à la précision, le résultat de la
division contient une erreur énorme sur la valeur de "a" (plusieurs
ordres de grandeurs au dessus).
> Aussi après un appel de rint...
pour savoir si un nombre est un entier ou pas?
>> car en fait je me dit que si on veut une équalité stricte, alors il
>> est plus simple de passer par un union et comparer (bit à bits) les
>> entiers correspondants.
>
> Non! D'une part c'est incorrect, car les représentations ne sont pas
> forcément identiques
Pourquoi donc? tous les doubles sont sérialisés en mémoire de la même
façon au format IEEE.
> (encore plus s'il y a des bytes de padding, comme avec un long
> double en 80 bits dans une union). D'autre part, ce serait plus
> lent.
Ca n'est pas le propos. Le propos était de voir si les deux "double"s
sont identiques (sous entendu en mémoire).
Bonjour,
Si j'ai bien compris %a est le spécificateur format de printf pour afficher
un float en base 16.
Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
Question 1 : pour les doubles c'est %la ?
Question 2 : quelle est la lettre pour l'exposant en hexa
(e comme en décimal?)
Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
ingénérie (%f, %e et %g)
Question 4 : Comment écrit-on une constante immédiates float en hexa
Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
0.0625?
Question 5 : En C++ (pas en C) un ostream de gcc formate -0.0
(0.0 avec un bit de signe = 1) en `-0.0', alors que
VisualC++ le formate en `0.0'. Je ne sais pas ce que fait
printf, mais comment ça devrait être ? Et en général,
est-ce qu'un 0.0 avec un bit de signe à 1 est une valeur
valide ?
Bonjour,
Si j'ai bien compris %a est le spécificateur format de printf pour afficher
un float en base 16.
Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
Question 1 : pour les doubles c'est %la ?
Question 2 : quelle est la lettre pour l'exposant en hexa
(e comme en décimal?)
Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
ingénérie (%f, %e et %g)
Question 4 : Comment écrit-on une constante immédiates float en hexa
Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
0.0625?
Question 5 : En C++ (pas en C) un ostream de gcc formate -0.0
(0.0 avec un bit de signe = 1) en `-0.0', alors que
VisualC++ le formate en `0.0'. Je ne sais pas ce que fait
printf, mais comment ça devrait être ? Et en général,
est-ce qu'un 0.0 avec un bit de signe à 1 est une valeur
valide ?
Bonjour,
Si j'ai bien compris %a est le spécificateur format de printf pour afficher
un float en base 16.
Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
Question 1 : pour les doubles c'est %la ?
Question 2 : quelle est la lettre pour l'exposant en hexa
(e comme en décimal?)
Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
ingénérie (%f, %e et %g)
Question 4 : Comment écrit-on une constante immédiates float en hexa
Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
0.0625?
Question 5 : En C++ (pas en C) un ostream de gcc formate -0.0
(0.0 avec un bit de signe = 1) en `-0.0', alors que
VisualC++ le formate en `0.0'. Je ne sais pas ce que fait
printf, mais comment ça devrait être ? Et en général,
est-ce qu'un 0.0 avec un bit de signe à 1 est une valeur
valide ?
Peut-etre.. qu'est il préconisé à la place? Parce que les codes pour
parser la partie fractionnaire où l'on trouve:
double b = 0.1;
while(..) {
x += ((*s++) - '0') * b;
b /= 10;
}
sont légions et contiennent tous le même bug.
> Le code est tout de même faux sur la plupart des machines actuelles
> (avec des long sur 64 bits)!
Hum? Je ne vois pas. D'un coté tu as 2 long int à 32 bits chacun, et de
l'autre 64bits. Ca doit rentrer.
Peut-etre.. qu'est il préconisé à la place? Parce que les codes pour
parser la partie fractionnaire où l'on trouve:
double b = 0.1;
while(..) {
x += ((*s++) - '0') * b;
b /= 10;
}
sont légions et contiennent tous le même bug.
> Le code est tout de même faux sur la plupart des machines actuelles
> (avec des long sur 64 bits)!
Hum? Je ne vois pas. D'un coté tu as 2 long int à 32 bits chacun, et de
l'autre 64bits. Ca doit rentrer.
Peut-etre.. qu'est il préconisé à la place? Parce que les codes pour
parser la partie fractionnaire où l'on trouve:
double b = 0.1;
while(..) {
x += ((*s++) - '0') * b;
b /= 10;
}
sont légions et contiennent tous le même bug.
> Le code est tout de même faux sur la plupart des machines actuelles
> (avec des long sur 64 bits)!
Hum? Je ne vois pas. D'un coté tu as 2 long int à 32 bits chacun, et de
l'autre 64bits. Ca doit rentrer.
Samuel DEVULDER a écrit :
> long *ptr = &d;
Pour les amateurs de trétacapillotomie[*], on peut écrire:
long *ptr = (void*)&d;
Samuel DEVULDER a écrit :
> long *ptr = &d;
Pour les amateurs de trétacapillotomie[*], on peut écrire:
long *ptr = (void*)&d;
Samuel DEVULDER a écrit :
> long *ptr = &d;
Pour les amateurs de trétacapillotomie[*], on peut écrire:
long *ptr = (void*)&d;
Vincent Belaïche a écrit :
> Bonjour,
> Si j'ai bien compris %a est le spécificateur format de printf pour
> afficher un float en base 16.
Je peux pas te répondre sur tout. Le fait est que le format %a n'est pas
référencé partout. Trop récent peut être.
> Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
> Question 1 : pour les doubles c'est %la ?
Je sais pas. J'arrive pas à trouver de truc clair la dessus. Un approche
empirique a l'air de dire que gcc accepte double et float sans soucis. Le
code asm montre cependant que le float est converti en double avant d'être
envoyé sur la pile pour le printf. Ca relativise l'intérêt de "%a" pour
regarder ce qu'on a *exactement* en mémoire car une conversion a lieu.
Apparemment il faut toujours le 'p'.
Vincent Belaïche a écrit :
> Bonjour,
> Si j'ai bien compris %a est le spécificateur format de printf pour
> afficher un float en base 16.
Je peux pas te répondre sur tout. Le fait est que le format %a n'est pas
référencé partout. Trop récent peut être.
> Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
> Question 1 : pour les doubles c'est %la ?
Je sais pas. J'arrive pas à trouver de truc clair la dessus. Un approche
empirique a l'air de dire que gcc accepte double et float sans soucis. Le
code asm montre cependant que le float est converti en double avant d'être
envoyé sur la pile pour le printf. Ca relativise l'intérêt de "%a" pour
regarder ce qu'on a *exactement* en mémoire car une conversion a lieu.
Apparemment il faut toujours le 'p'.
Vincent Belaïche a écrit :
> Bonjour,
> Si j'ai bien compris %a est le spécificateur format de printf pour
> afficher un float en base 16.
Je peux pas te répondre sur tout. Le fait est que le format %a n'est pas
référencé partout. Trop récent peut être.
> Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
> Question 1 : pour les doubles c'est %la ?
Je sais pas. J'arrive pas à trouver de truc clair la dessus. Un approche
empirique a l'air de dire que gcc accepte double et float sans soucis. Le
code asm montre cependant que le float est converti en double avant d'être
envoyé sur la pile pour le printf. Ca relativise l'intérêt de "%a" pour
regarder ce qu'on a *exactement* en mémoire car une conversion a lieu.
Apparemment il faut toujours le 'p'.
- on ne lit pas le dernier membre écrit dans l'union, à nouveau non
conforme.
- on ne lit pas le dernier membre écrit dans l'union, à nouveau non
conforme.
- on ne lit pas le dernier membre écrit dans l'union, à nouveau non
conforme.
Je sais pas. J'arrive pas à trouver de truc clair la dessus. Un approche
empirique a l'air de dire que gcc accepte double et float sans soucis.
Le code asm montre cependant que le float est converti en double avant
d'être envoyé sur la pile pour le printf. Ca relativise l'intérêt de
"%a" pour regarder ce qu'on a *exactement* en mémoire car une conversion
a lieu.
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les zero
terminaux.
> Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
> ingénérie (%f, %e et %g)
Je sais pas.
> Question 4 : Comment écrit-on une constante immédiates float en hexa
> Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
> 0.0625?
Apparemment il faut toujours le 'p'. Le format ne semble pas super
libre. La partie entière est 0 (pour 0.0 exclusivement) ou 1 (pour les
autres nombres), suivi de la partie fractionnaire précédée par un '.'
(si non nulle).
Il faut croire que VC++ estime que -0.0 est 0.0 c'est pareil (ce qui
n'est pas faux) et l'affiche de façon normalisée.
Je sais pas. J'arrive pas à trouver de truc clair la dessus. Un approche
empirique a l'air de dire que gcc accepte double et float sans soucis.
Le code asm montre cependant que le float est converti en double avant
d'être envoyé sur la pile pour le printf. Ca relativise l'intérêt de
"%a" pour regarder ce qu'on a *exactement* en mémoire car une conversion
a lieu.
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les zero
terminaux.
> Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
> ingénérie (%f, %e et %g)
Je sais pas.
> Question 4 : Comment écrit-on une constante immédiates float en hexa
> Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
> 0.0625?
Apparemment il faut toujours le 'p'. Le format ne semble pas super
libre. La partie entière est 0 (pour 0.0 exclusivement) ou 1 (pour les
autres nombres), suivi de la partie fractionnaire précédée par un '.'
(si non nulle).
Il faut croire que VC++ estime que -0.0 est 0.0 c'est pareil (ce qui
n'est pas faux) et l'affiche de façon normalisée.
Je sais pas. J'arrive pas à trouver de truc clair la dessus. Un approche
empirique a l'air de dire que gcc accepte double et float sans soucis.
Le code asm montre cependant que le float est converti en double avant
d'être envoyé sur la pile pour le printf. Ca relativise l'intérêt de
"%a" pour regarder ce qu'on a *exactement* en mémoire car une conversion
a lieu.
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les zero
terminaux.
> Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
> ingénérie (%f, %e et %g)
Je sais pas.
> Question 4 : Comment écrit-on une constante immédiates float en hexa
> Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
> 0.0625?
Apparemment il faut toujours le 'p'. Le format ne semble pas super
libre. La partie entière est 0 (pour 0.0 exclusivement) ou 1 (pour les
autres nombres), suivi de la partie fractionnaire précédée par un '.'
(si non nulle).
Il faut croire que VC++ estime que -0.0 est 0.0 c'est pareil (ce qui
n'est pas faux) et l'affiche de façon normalisée.
Si j'ai bien compris %a est le spécificateur format de printf pour
afficher un float en base 16.
Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
Question 1 : pour les doubles c'est %la ?
Question 2 : quelle est la lettre pour l'exposant en hexa
(e comme en décimal?)
Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
ingénérie (%f, %e et %g)
Question 4 : Comment écrit-on une constante immédiates float en hexa
Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
0.0625?
Question 5 : En C++ (pas en C)
Si j'ai bien compris %a est le spécificateur format de printf pour
afficher un float en base 16.
Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
Question 1 : pour les doubles c'est %la ?
Question 2 : quelle est la lettre pour l'exposant en hexa
(e comme en décimal?)
Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
ingénérie (%f, %e et %g)
Question 4 : Comment écrit-on une constante immédiates float en hexa
Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
0.0625?
Question 5 : En C++ (pas en C)
Si j'ai bien compris %a est le spécificateur format de printf pour
afficher un float en base 16.
Y a-t-il un site où on peut trouver les réponses aux questions suivantes:
Question 1 : pour les doubles c'est %la ?
Question 2 : quelle est la lettre pour l'exposant en hexa
(e comme en décimal?)
Question 3 : y a-t-il un équivalent des notations fixe, scientifique, et
ingénérie (%f, %e et %g)
Question 4 : Comment écrit-on une constante immédiates float en hexa
Est-ce que 0x0.1f est équivalent à 0.0625f, 0x0.1 à
0.0625?
Question 5 : En C++ (pas en C)
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les zero
terminaux.
Pas exactement, au sens où le premier quartet peut avoir 4 valeurs
possibles, suivant que l'on considère qu'il y a 0, 1, 2 ou 3 zéros
en tête (les implémentations diffèrent). En effet, l'exposant est
binaire, i.e. on a:
signe * significande_en_hexa * 2^exposant
À l'affichage, la partie "entière" peut aller de 0 à 15 (0 à F en
hexa).
1 à chaque fois (sauf pour zéro). Je rappelle que l'exposant est
binaire.
Il faut croire que VC++ estime que -0.0 est 0.0 c'est pareil (ce qui
n'est pas faux) et l'affiche de façon normalisée.
Ce n'est pas pareil (si la norme IEEE 754 est suivie), mais les
valeurs sont égales.
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les zero
terminaux.
Pas exactement, au sens où le premier quartet peut avoir 4 valeurs
possibles, suivant que l'on considère qu'il y a 0, 1, 2 ou 3 zéros
en tête (les implémentations diffèrent). En effet, l'exposant est
binaire, i.e. on a:
signe * significande_en_hexa * 2^exposant
À l'affichage, la partie "entière" peut aller de 0 à 15 (0 à F en
hexa).
1 à chaque fois (sauf pour zéro). Je rappelle que l'exposant est
binaire.
Il faut croire que VC++ estime que -0.0 est 0.0 c'est pareil (ce qui
n'est pas faux) et l'affiche de façon normalisée.
Ce n'est pas pareil (si la norme IEEE 754 est suivie), mais les
valeurs sont égales.
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les zero
terminaux.
Pas exactement, au sens où le premier quartet peut avoir 4 valeurs
possibles, suivant que l'on considère qu'il y a 0, 1, 2 ou 3 zéros
en tête (les implémentations diffèrent). En effet, l'exposant est
binaire, i.e. on a:
signe * significande_en_hexa * 2^exposant
À l'affichage, la partie "entière" peut aller de 0 à 15 (0 à F en
hexa).
1 à chaque fois (sauf pour zéro). Je rappelle que l'exposant est
binaire.
Il faut croire que VC++ estime que -0.0 est 0.0 c'est pareil (ce qui
n'est pas faux) et l'affiche de façon normalisée.
Ce n'est pas pareil (si la norme IEEE 754 est suivie), mais les
valeurs sont égales.
Vincent Lefevre a écrit :On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les
zero terminaux.
Pas exactement, au sens où le premier quartet peut avoir 4 valeurs
possibles, suivant que l'on considère qu'il y a 0, 1, 2 ou 3 zéros
en tête (les implémentations diffèrent). En effet, l'exposant est
heu? je ne pige pas. Tu veux dire qu'on peut avoir 0x100p0 pour
représenter 256.0 ?
C'est quoi ces zéros de têtes..
Vincent Lefevre a écrit :
On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les
zero terminaux.
Pas exactement, au sens où le premier quartet peut avoir 4 valeurs
possibles, suivant que l'on considère qu'il y a 0, 1, 2 ou 3 zéros
en tête (les implémentations diffèrent). En effet, l'exposant est
heu? je ne pige pas. Tu veux dire qu'on peut avoir 0x100p0 pour
représenter 256.0 ?
C'est quoi ces zéros de têtes..
Vincent Lefevre a écrit :On dirait que "%a" affiche tous les quartets (tranche de 4bits) du
double sauf ceux de poids faibles ne contenant que du zero. C'est
l'équivalent d'une représentation décimale où l'on affiche pas les
zero terminaux.
Pas exactement, au sens où le premier quartet peut avoir 4 valeurs
possibles, suivant que l'on considère qu'il y a 0, 1, 2 ou 3 zéros
en tête (les implémentations diffèrent). En effet, l'exposant est
heu? je ne pige pas. Tu veux dire qu'on peut avoir 0x100p0 pour
représenter 256.0 ?
C'est quoi ces zéros de têtes..