Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

différence ocamlc / ocamlopt #4293

Closed
vicuna opened this issue Oct 11, 2002 · 2 comments
Closed

différence ocamlc / ocamlopt #4293

vicuna opened this issue Oct 11, 2002 · 2 comments
Labels

Comments

@vicuna
Copy link

vicuna commented Oct 11, 2002

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

@vicuna
Copy link
Author

vicuna commented Oct 11, 2002

Comment author: administrator

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é.

Dans ton cas:

ocamlopt bug.ml; ./a.out; ocaml bug.ml
8.171617E-10
-1.383560E-12

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...

Bienvenu dans le monde merveilleux des flottants!

Amicalement,

  • Xavier

@vicuna
Copy link
Author

vicuna commented Jul 3, 2004

Comment author: administrator

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.

@vicuna vicuna closed this as completed Jul 3, 2004
@vicuna vicuna added the bug label Mar 19, 2019
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
Projects
None yet
Development

No branches or pull requests

1 participant