Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
James Kanze
On Feb 19, 6:18 pm, JBB wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
On Feb 19, 6:18 pm, JBB <nos...@nospam.com> wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100;
unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000
alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que
fait le compilateur est correct. (À vrai dire, je me serais
attendu à un SIGFPE, ou quelque chose du genre.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
JBB
On Feb 19, 6:18 pm, JBB wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier. je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64). Il n'y a pas des flottants avec plus de précisions? j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
On Feb 19, 6:18 pm, JBB <nos...@nospam.com> wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100;
unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000
alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que
fait le compilateur est correct. (À vrai dire, je me serais
attendu à un SIGFPE, ou quelque chose du genre.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier.
je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64).
Il n'y a pas des flottants avec plus de précisions?
j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier. je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64). Il n'y a pas des flottants avec plus de précisions? j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
Michael DOUBEZ
On Feb 19, 6:18 pm, JBB wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier. je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64). Il n'y a pas des flottants avec plus de précisions? j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
Si tu veux vraiment cette précision, je pense que tu devrais passer à une lib de nombre mutliprecision. Les plus connues étant: - GMP : GNU Multiple Precision Arithmetic Library http://gmplib.org/ - MIRACL : Multiprecision Integer and Rational Arithmetic C/C++ Library http://www.shamus.ie/
Michael
On Feb 19, 6:18 pm, JBB <nos...@nospam.com> wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100;
unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000
alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que
fait le compilateur est correct. (À vrai dire, je me serais
attendu à un SIGFPE, ou quelque chose du genre.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
en fait je cherchait un type flottant qui englobe le type unsigned
__int64 tout en gardant la précision au niveau de l'entier.
je me doute bien que ça marche pas avec 'double' qui n'est que sur 8
octets ( tout comme __int64).
Il n'y a pas des flottants avec plus de précisions?
j'ai l'impression que 'long double' n'est pas différent de double (
sizeof(long double) = 8)
Si tu veux vraiment cette précision, je pense que tu devrais passer à
une lib de nombre mutliprecision. Les plus connues étant:
- GMP : GNU Multiple Precision Arithmetic Library
http://gmplib.org/
- MIRACL : Multiprecision Integer and Rational Arithmetic C/C++ Library
http://www.shamus.ie/
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
-- James Kanze (GABI Software) email: Conseils en informatique orientée objet/ Beratung in objektorientierter Datenverarbeitung 9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier. je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64). Il n'y a pas des flottants avec plus de précisions? j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
Si tu veux vraiment cette précision, je pense que tu devrais passer à une lib de nombre mutliprecision. Les plus connues étant: - GMP : GNU Multiple Precision Arithmetic Library http://gmplib.org/ - MIRACL : Multiprecision Integer and Rational Arithmetic C/C++ Library http://www.shamus.ie/
Michael
Marc Boyer
On 2008-02-20, JBB wrote:
On Feb 19, 6:18 pm, JBB wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier. je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64).
Donc un flottant avec une mantisse sur plus de 64bits. AMHA, sur des processeurs 64 bits, il va falloir passer à une émulation logicielle.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
On 2008-02-20, JBB <nospam@nospam.com> wrote:
On Feb 19, 6:18 pm, JBB <nos...@nospam.com> wrote:
voici un code compilé VisualStudio2005, windows XP
double f = 1e100;
unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000
alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que
fait le compilateur est correct. (À vrai dire, je me serais
attendu à un SIGFPE, ou quelque chose du genre.)
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier.
je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64).
Donc un flottant avec une mantisse sur plus de 64bits.
AMHA, sur des processeurs 64 bits, il va falloir passer à
une émulation logicielle.
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
voici un code compilé VisualStudio2005, windows XP
double f = 1e100; unsigned __int64 y = f;
dans y je trouve : 0x8000000000000000 alors que je m'attendais plutot à 0xFFFFFFFFFFFFFFFF
c'est normal? c'est un bug?
Le code a un comportement indéfini. C-à-d que n'importe ce que fait le compilateur est correct. (À vrai dire, je me serais attendu à un SIGFPE, ou quelque chose du genre.)
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier. je me doute bien que ça marche pas avec 'double' qui n'est que sur 8 octets ( tout comme __int64).
Donc un flottant avec une mantisse sur plus de 64bits. AMHA, sur des processeurs 64 bits, il va falloir passer à une émulation logicielle.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Sylvain Togni
j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
La taille de long double dépend du compilateur. Les tailles les plus courantes sont : - 64 bits (mantisse 52 bits) - 80 bits (mantisse 64 bits) - 128 bits (mantisse 112 bits)
-- Sylvain Togni
j'ai l'impression que 'long double' n'est pas différent de double (
sizeof(long double) = 8)
La taille de long double dépend du compilateur. Les tailles les
plus courantes sont :
- 64 bits (mantisse 52 bits)
- 80 bits (mantisse 64 bits)
- 128 bits (mantisse 112 bits)
j'ai l'impression que 'long double' n'est pas différent de double ( sizeof(long double) = 8)
La taille de long double dépend du compilateur. Les tailles les plus courantes sont : - 64 bits (mantisse 52 bits) - 80 bits (mantisse 64 bits) - 128 bits (mantisse 112 bits)
-- Sylvain Togni
Fabien LE LEZ
On Wed, 20 Feb 2008 10:46:09 +0100, JBB :
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier.
T'es sûr de vouloir un flottant ? Ces machins-là sont passablement imprévisibles, dans le meilleur des cas. Un type entier très long (333 bits minimum) ne serait-il pas plus adapté ?
On Wed, 20 Feb 2008 10:46:09 +0100, JBB <nospam@nospam.com>:
en fait je cherchait un type flottant qui englobe le type
unsigned __int64 tout en gardant la précision au niveau de l'entier.
T'es sûr de vouloir un flottant ? Ces machins-là sont passablement
imprévisibles, dans le meilleur des cas.
Un type entier très long (333 bits minimum) ne serait-il pas plus
adapté ?
en fait je cherchait un type flottant qui englobe le type unsigned __int64 tout en gardant la précision au niveau de l'entier.
T'es sûr de vouloir un flottant ? Ces machins-là sont passablement imprévisibles, dans le meilleur des cas. Un type entier très long (333 bits minimum) ne serait-il pas plus adapté ?
