You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Original bug ID: 1427 Reporter: administrator Status: closed Resolution: not a bug Priority: normal Severity: minor Category: ~DO NOT USE (was: OCaml general)
Bug description
Bonjour,
J'observe une différence de résultats entre ocamlc et ocamlopt sur des
calculs flottants. Vu que la doc dit à la fin du chapitre 11 << Except
on those points, the two compilers should generate code that behave
identically. >> et qu'il ne s'agit pas de l'un des points en question,
je m'étonne.
Voici le code :
======================================================================
let x =
let jj = 2443825.5 in
let t = (jj -. 2415020.) /. 36525. (* 0.788651608487 *) in
let th0 = 6.6460656 +. 2400.051262 *. t +. 0.00002581 *. t *. t in
let ts = th0 -. 24. *. floor (th0 /. 24.) in
let h = floor ts in
let ts' = (ts -. h) *. 60. in
let m = floor ts' in
(ts' -. m) *. 60.
let _ =
Printf.printf "%E\n" (x -. 1.33157320077)
(désolé, je ne suis pas parvenu à réduire plus) et voici ce que cela
donne :
J'observe une différence de résultats entre ocamlc et ocamlopt sur des
calculs flottants. Vu que la doc dit à la fin du chapitre 11 << Except
on those points, the two compilers should generate code that behave
identically. >> et qu'il ne s'agit pas de l'un des points en question,
je m'étonne.
Je parie que c'est sur Pentium... En effet, le Pentium fait ses
calculs flottants en précision étendue (80 bits), et tronque en double
précision (64 bits) lorsqu'on stocke un résultat en mémoire.
En bytecode, tous les résultats intermédiaires de calculs flottants
sont stockés en mémoire et donc tronqués à 64 bits. En revanche,
ocamlopt peut garder des résultats intermédiaires dans les registres
du processeur. Ainsi, dans l'expression "a *. b -. c", le produit
a * b va être en précision étendue. Cela peut changer notablement le
résultat si a * b est très proche de c.
Le supplément de précision est généralement une bonne chose, d'un
point de vue d'analyse numérique, mais peut mener à des résultats
très différents entre ocamlc et ocamlopt si l'algorithme est mal
conditionné.
il faudrait aussi savoir combien de chiffres sont réellement
significatifs dans le résultat de ton calcul. (Étant donné la
précision des constantes et des entrées.) Il est fort possible que
les résultats ci-dessus soient tous deux numériquement corrects...
IA32 issue with extended precision (intermediate results in 80 bits). While the
ocamlc/ocamlopt difference can be surprising, the extra precision should never
hurt in well-written numerical code, and can even help.
Original bug ID: 1427
Reporter: administrator
Status: closed
Resolution: not a bug
Priority: normal
Severity: minor
Category: ~DO NOT USE (was: OCaml general)
Bug description
Bonjour,
J'observe une différence de résultats entre ocamlc et ocamlopt sur des
calculs flottants. Vu que la doc dit à la fin du chapitre 11 << Except
on those points, the two compilers should generate code that behave
identically. >> et qu'il ne s'agit pas de l'un des points en question,
je m'étonne.
Voici le code :
======================================================================
let x =
let jj = 2443825.5 in
let t = (jj -. 2415020.) /. 36525. (* 0.788651608487 *) in
let th0 = 6.6460656 +. 2400.051262 *. t +. 0.00002581 *. t *. t in
let ts = th0 -. 24. *. floor (th0 /. 24.) in
let h = floor ts in
let ts' = (ts -. h) *. 60. in
let m = floor ts' in
(ts' -. m) *. 60.
let _ =
Printf.printf "%E\n" (x -. 1.33157320077)
(désolé, je ne suis pas parvenu à réduire plus) et voici ce que cela
donne :
======================================================================
ocamlopt bug.ml; ./a.out; ocaml bug.ml
8.171617E-10
-1.383560E-12
Cordialement,
Jean-Christophe
The text was updated successfully, but these errors were encountered: