Voici une courte liste d'implémentations et de langages que j'ai essayés. Il est trié par proximité de zéro :

• Schéma : (+ 1 (make-polar 1 (atan 0 -1)))
  • ⇒ 0.0+1.2246063538223773e-16i (Chez Scheme, MIT Scheme)
  • ⇒ 0.0+1.22460635382238e-16i (Ruse)
  • ⇒ 0.0+1.22464679914735e-16i (Poulet avec numbers oeuf)
  • ⇒ 0.0+1.2246467991473532e-16i (MzScheme, SISC, Gauche, Gambit)
  • ⇒ 0.0+1.2246467991473533e-16i (GDS)
• Lisp commun : (1+ (exp (complex 0 pi)))
  • ⇒ #C(0.0L0 -5.0165576136843360246L-20) (CLISP)
  • ⇒ #C(0.0d0 1.2246063538223773d-16) (CMUCL)
  • ⇒ #C(0.0d0 1.2246467991473532d-16) (SBCL)
• Perl : use Math::Complex; Math::Complex->emake(1, pi) + 1
  • ⇒ 1.22464679914735e-16i
• Python : from cmath import exp, pi; exp(complex(0, pi)) + 1
  • ⇒ 1.2246467991473532e-16j (CPython)
• Rubis : require 'complex'; Complex::polar(1, Math::PI) + 1
  • ⇒ Complex(0.0, 1.22464679914735e-16) (IRM)
  • ⇒ Complex(0.0, 1.2246467991473532e-16) (JRuby)
• R : complex(argument = pi) + 1
  • ⇒ 0+1.224606353822377e-16i

Je suis d'accord avec Ryan, vous auriez besoin de passer à un autre système de représentation des nombres. La solution est en dehors du domaine des mathématiques à virgule flottante car vous avez besoin de pi pour être représenté comme un nombre décimal infiniment long, donc tout schéma de précision limité ne fonctionnera tout simplement pas (du moins pas sans utiliser une sorte de facteur de fudge pour compenser le perdu précision).

Votre question me semble un peu étrange, car vous semblez suggérer que les mathématiques en virgule flottante sont implémentées par le langage. Ce n'est généralement pas vrai, car les calculs FP sont effectués à l'aide d'un processeur à virgule flottante dans le matériel. Mais logiciel ou matériel, la virgule flottante sera toujours imprécise. C'est comme ça que les flottants fonctionnent.

Si vous avez besoin d'une meilleure précision, vous devez utiliser une représentation numérique différente. Tout comme si vous faisiez des calculs entiers sur des nombres qui ne rentrent pas dans un entier ou un long. Certains langages ont des bibliothèques pour cela intégrées (je sais que Java a BigInteger et BigDecimal), mais vous devriez utiliser explicitement ces bibliothèques au lieu de types natifs, et les performances seraient (parfois significativement) pires que si vous utilisiez des flottants. /p>

Ce n'est pas que la plupart des implémentations en virgule flottante ne soient pas d'accord, c'est juste qu'elles ne peuvent pas obtenir la précision nécessaire pour obtenir une réponse à 100 %. Et la bonne réponse est qu'ils ne peuvent pas.

PI est une série infinie de chiffres que personne n'a été capable de désigner par autre chose qu'une représentation symbolique, et e^X est le même, et donc la seule façon d'obtenir une précision de 100 % est de devenir symbolique.< /p>