Salut,
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double. Il
ne me semble pas que ces calculs sont pris directement en charge par
le(s) processeur(s). Ma question est donc la suivante : la norme
impose-t-elle l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger qu'un
compilateur calcule de manière correcte sur les entiers (1+1 doit
toujours être égal à 2), ce qui est en soi une garantie
(extérieure) de l'identité des résultats. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi. Il
n'y a pas alors de "résultat juste" (ex. 1/3 n'a pas d'expression
décimale finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Salut,
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double. Il
ne me semble pas que ces calculs sont pris directement en charge par
le(s) processeur(s). Ma question est donc la suivante : la norme
impose-t-elle l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger qu'un
compilateur calcule de manière correcte sur les entiers (1+1 doit
toujours être égal à 2), ce qui est en soi une garantie
(extérieure) de l'identité des résultats. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi. Il
n'y a pas alors de "résultat juste" (ex. 1/3 n'a pas d'expression
décimale finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Salut,
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double. Il
ne me semble pas que ces calculs sont pris directement en charge par
le(s) processeur(s). Ma question est donc la suivante : la norme
impose-t-elle l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger qu'un
compilateur calcule de manière correcte sur les entiers (1+1 doit
toujours être égal à 2), ce qui est en soi une garantie
(extérieure) de l'identité des résultats. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi. Il
n'y a pas alors de "résultat juste" (ex. 1/3 n'a pas d'expression
décimale finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Je programme une application qui fait un fort usage des
calculs avec des valeurs décimales (à virgule) avec les types
float ou double.
Il ne me semble pas que ces calculs sont pris directement en
charge par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ?
Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger
qu'un compilateur calcule de manière correcte sur les entiers
(1+1 doit toujours être égal à 2), ce qui est en soi une
garantie (extérieure) de l'identité des résultats. Mais
lorsque le calcul a lieu sur des nombres décimaux, le résultat
est souvent arrondi. Il n'y a pas alors de "résultat juste"
(ex. 1/3 n'a pas d'expression décimale finie juste, même si
certaines sont meilleures que d'autres). Comment sait-on que
la manière de calculer et d'arrondir sera la même sur chaque
compilateur ?
Je programme une application qui fait un fort usage des
calculs avec des valeurs décimales (à virgule) avec les types
float ou double.
Il ne me semble pas que ces calculs sont pris directement en
charge par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ?
Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger
qu'un compilateur calcule de manière correcte sur les entiers
(1+1 doit toujours être égal à 2), ce qui est en soi une
garantie (extérieure) de l'identité des résultats. Mais
lorsque le calcul a lieu sur des nombres décimaux, le résultat
est souvent arrondi. Il n'y a pas alors de "résultat juste"
(ex. 1/3 n'a pas d'expression décimale finie juste, même si
certaines sont meilleures que d'autres). Comment sait-on que
la manière de calculer et d'arrondir sera la même sur chaque
compilateur ?
Je programme une application qui fait un fort usage des
calculs avec des valeurs décimales (à virgule) avec les types
float ou double.
Il ne me semble pas que ces calculs sont pris directement en
charge par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ?
Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger
qu'un compilateur calcule de manière correcte sur les entiers
(1+1 doit toujours être égal à 2), ce qui est en soi une
garantie (extérieure) de l'identité des résultats. Mais
lorsque le calcul a lieu sur des nombres décimaux, le résultat
est souvent arrondi. Il n'y a pas alors de "résultat juste"
(ex. 1/3 n'a pas d'expression décimale finie juste, même si
certaines sont meilleures que d'autres). Comment sait-on que
la manière de calculer et d'arrondir sera la même sur chaque
compilateur ?
jul wrote:Je programme une application qui fait un fort usage des
calculs avec des valeurs décimales (à virgule) avec les
types float ou double. Il ne me semble pas que ces calculs
sont pris directement en charge par le(s) processeur(s). Ma
question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger
qu'un compilateur calcule de manière correcte sur les
entiers (1+1 doit toujours être égal à 2), ce qui est en soi
une garantie (extérieure) de l'identité des résultats. Mais
lorsque le calcul a lieu sur des nombres décimaux, le
résultat est souvent arrondi. Il n'y a pas alors de
"résultat juste" (ex. 1/3 n'a pas d'expression décimale
finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et
d'arrondir sera la même sur chaque compilateur ?
Normalement, c'est la norme IEEE 754 (representation des
flottants) qui assure ca, mais rien a voir avec c++.
jul wrote:
Je programme une application qui fait un fort usage des
calculs avec des valeurs décimales (à virgule) avec les
types float ou double. Il ne me semble pas que ces calculs
sont pris directement en charge par le(s) processeur(s). Ma
question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger
qu'un compilateur calcule de manière correcte sur les
entiers (1+1 doit toujours être égal à 2), ce qui est en soi
une garantie (extérieure) de l'identité des résultats. Mais
lorsque le calcul a lieu sur des nombres décimaux, le
résultat est souvent arrondi. Il n'y a pas alors de
"résultat juste" (ex. 1/3 n'a pas d'expression décimale
finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et
d'arrondir sera la même sur chaque compilateur ?
Normalement, c'est la norme IEEE 754 (representation des
flottants) qui assure ca, mais rien a voir avec c++.
jul wrote:Je programme une application qui fait un fort usage des
calculs avec des valeurs décimales (à virgule) avec les
types float ou double. Il ne me semble pas que ces calculs
sont pris directement en charge par le(s) processeur(s). Ma
question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
Je précise pour bien me faire comprendre. Il facile d'exiger
qu'un compilateur calcule de manière correcte sur les
entiers (1+1 doit toujours être égal à 2), ce qui est en soi
une garantie (extérieure) de l'identité des résultats. Mais
lorsque le calcul a lieu sur des nombres décimaux, le
résultat est souvent arrondi. Il n'y a pas alors de
"résultat juste" (ex. 1/3 n'a pas d'expression décimale
finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et
d'arrondir sera la même sur chaque compilateur ?
Normalement, c'est la norme IEEE 754 (representation des
flottants) qui assure ca, mais rien a voir avec c++.
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double.
Il ne me semble pas que ces calculs sont pris directement en charge
par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle l'identité
des résultats de calculs entre différents compilateurs ?
Je précise pour bien me faire comprendre. Il facile d'exiger qu'un
compilateur calcule de manière correcte sur les entiers (1+1 doit
toujours être égal à 2), ce qui est en soi une garantie
(extérieure) de l'identité des résultats. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi. Il
n'y a pas alors de "résultat juste" (ex. 1/3 n'a pas d'expression
décimale finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double.
Il ne me semble pas que ces calculs sont pris directement en charge
par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle l'identité
des résultats de calculs entre différents compilateurs ?
Je précise pour bien me faire comprendre. Il facile d'exiger qu'un
compilateur calcule de manière correcte sur les entiers (1+1 doit
toujours être égal à 2), ce qui est en soi une garantie
(extérieure) de l'identité des résultats. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi. Il
n'y a pas alors de "résultat juste" (ex. 1/3 n'a pas d'expression
décimale finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double.
Il ne me semble pas que ces calculs sont pris directement en charge
par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle l'identité
des résultats de calculs entre différents compilateurs ?
Je précise pour bien me faire comprendre. Il facile d'exiger qu'un
compilateur calcule de manière correcte sur les entiers (1+1 doit
toujours être égal à 2), ce qui est en soi une garantie
(extérieure) de l'identité des résultats. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi. Il
n'y a pas alors de "résultat juste" (ex. 1/3 n'a pas d'expression
décimale finie juste, même si certaines sont meilleures que
d'autres). Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
la norme
impose-t-elle l'identité des résultats de calculs entre différents
compilateurs ?
la norme
impose-t-elle l'identité des résultats de calculs entre différents
compilateurs ?
la norme
impose-t-elle l'identité des résultats de calculs entre différents
compilateurs ?
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double.
Il ne me semble pas que ces calculs sont pris directement en charge
par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
[...] Il facile d'exiger qu'un compilateur calcule de manière
correcte sur les entiers [...]. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi.
Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double.
Il ne me semble pas que ces calculs sont pris directement en charge
par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
[...] Il facile d'exiger qu'un compilateur calcule de manière
correcte sur les entiers [...]. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi.
Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Je programme une application qui fait un fort usage des calculs avec
des valeurs décimales (à virgule) avec les types float ou double.
Il ne me semble pas que ces calculs sont pris directement en charge
par le(s) processeur(s).
Ma question est donc la suivante : la norme impose-t-elle
l'identité des résultats de calculs entre différents
compilateurs ? Si oui, au moyen de quel(s) critère(s) ?
[...] Il facile d'exiger qu'un compilateur calcule de manière
correcte sur les entiers [...]. Mais lorsque le calcul a
lieu sur des nombres décimaux, le résultat est souvent arrondi.
Comment sait-on que la manière de calculer et d'arrondir
sera la même sur chaque compilateur ?
Elle est loin d'être universale, et elle laisse un certain
nombre de libertés à l'implémentation aussi. Donc, des deux
processeurs que j'ai sous la main (un PC sous Linux et un Sun
Sparc sous Solaris), le programme :
#include <assert.h>
int
main()
{
double i = 1.0, j = 3.0 ;
double test = i / j ;
assert( test == i / j ) ;
return 0 ;
}
Elle est loin d'être universale, et elle laisse un certain
nombre de libertés à l'implémentation aussi. Donc, des deux
processeurs que j'ai sous la main (un PC sous Linux et un Sun
Sparc sous Solaris), le programme :
#include <assert.h>
int
main()
{
double i = 1.0, j = 3.0 ;
double test = i / j ;
assert( test == i / j ) ;
return 0 ;
}
Elle est loin d'être universale, et elle laisse un certain
nombre de libertés à l'implémentation aussi. Donc, des deux
processeurs que j'ai sous la main (un PC sous Linux et un Sun
Sparc sous Solaris), le programme :
#include <assert.h>
int
main()
{
double i = 1.0, j = 3.0 ;
double test = i / j ;
assert( test == i / j ) ;
return 0 ;
}
kanze wrote:Elle est loin d'être universale, et elle laisse un certain
nombre de libertés à l'implémentation aussi. Donc, des deux
processeurs que j'ai sous la main (un PC sous Linux et un Sun
Sparc sous Solaris), le programme :
#include <assert.h>
int
main()
{
double i = 1.0, j = 3.0 ;
double test = i / j ;
assert( test == i / j ) ;
return 0 ;
}
ah tiens, amusant. Je fais jamais ca (faire un calcul dans un
assert), mais c'est interessant.
Faudra que je regarde ce que donne le code assembleur, parce
qu'en faisant le calcul dans une variable avant, ca fonctionne
(j'ai pas dit portable, malgre ce que je pensais...).
kanze wrote:
Elle est loin d'être universale, et elle laisse un certain
nombre de libertés à l'implémentation aussi. Donc, des deux
processeurs que j'ai sous la main (un PC sous Linux et un Sun
Sparc sous Solaris), le programme :
#include <assert.h>
int
main()
{
double i = 1.0, j = 3.0 ;
double test = i / j ;
assert( test == i / j ) ;
return 0 ;
}
ah tiens, amusant. Je fais jamais ca (faire un calcul dans un
assert), mais c'est interessant.
Faudra que je regarde ce que donne le code assembleur, parce
qu'en faisant le calcul dans une variable avant, ca fonctionne
(j'ai pas dit portable, malgre ce que je pensais...).
kanze wrote:Elle est loin d'être universale, et elle laisse un certain
nombre de libertés à l'implémentation aussi. Donc, des deux
processeurs que j'ai sous la main (un PC sous Linux et un Sun
Sparc sous Solaris), le programme :
#include <assert.h>
int
main()
{
double i = 1.0, j = 3.0 ;
double test = i / j ;
assert( test == i / j ) ;
return 0 ;
}
ah tiens, amusant. Je fais jamais ca (faire un calcul dans un
assert), mais c'est interessant.
Faudra que je regarde ce que donne le code assembleur, parce
qu'en faisant le calcul dans une variable avant, ca fonctionne
(j'ai pas dit portable, malgre ce que je pensais...).
On 15 May 2006 05:28:51 -0700, "jul" :la norme
impose-t-elle l'identité des résultats de calculs entre
différents compilateurs ?
Non. Si tu as besoin de calculs fiables, les types double et
float sont à proscrire.
Il existe (je crois) des spécialistes qui savent effectuer des
calculs avec ces types, mais AMHA ils sont rares -- et a
priori, nous n'en faisons pas partie.
On 15 May 2006 05:28:51 -0700, "jul" <julien_ferard@yahoo.fr>:
la norme
impose-t-elle l'identité des résultats de calculs entre
différents compilateurs ?
Non. Si tu as besoin de calculs fiables, les types double et
float sont à proscrire.
Il existe (je crois) des spécialistes qui savent effectuer des
calculs avec ces types, mais AMHA ils sont rares -- et a
priori, nous n'en faisons pas partie.
On 15 May 2006 05:28:51 -0700, "jul" :la norme
impose-t-elle l'identité des résultats de calculs entre
différents compilateurs ?
Non. Si tu as besoin de calculs fiables, les types double et
float sont à proscrire.
Il existe (je crois) des spécialistes qui savent effectuer des
calculs avec ces types, mais AMHA ils sont rares -- et a
priori, nous n'en faisons pas partie.