Précision de Math.Sin() et Math.Cos() dans C#

Question

Je suis terriblement contrarié par l'inexactitude des fonctions trigonométriques intrinsèques dans le CLR. Il est bien connu que

Math.Sin(Math.PI)=0.00000000000000012246063538223773 

au lieu de 0. Quelque chose de semblable se produit avec Math.Cos(Math.PI/2).

Mais quand je fais une longue série de calculs sur des cas particuliers à évaluer

Math.Sin(Math.PI/2+x)-Math.Cos(x) 

et le résultat est nul pour x = 0,2, mais pas zéro pour x = 0,1 (essayer). Un autre problème est lorsque l'argument est un grand nombre, l'inexactitude devient proportionnellement grande. Donc, je me demande si quelqu'un a codé une meilleure représentation des fonctions trig en C# pour le partager avec le monde. Est-ce que le CLR appelle une bibliothèque mathématique C standard implémentant CORDIC ou quelque chose de similaire? link: wikipedia CORDIC

Answer 1

Vous devez utiliser une bibliothèque décimale de précision arbitraire. (.Net 4.0 a un arbitrary integer class, mais pas un nombre décimal).

Quelques plus populaires sont disponibles:

• BigNum
• W3B.Sine

Answer 2

Cela n'a rien à voir avec la précision des fonctions trigonométriques mais plutôt avec le système de type CLS. Selon la documentation, un double a une précision de 15-16 chiffres (ce qui est exactement ce que vous obtenez) donc vous ne pouvez pas être plus précis avec ce type. Donc, si vous voulez plus de précision, vous devrez créer un nouveau type capable de le stocker.

Notez également que vous ne devriez jamais être en train d'écrire un code comme ceci:

double d = CalcFromSomewhere(); 
if (d == 0) 
{ 
    DoSomething(); 
} 

Vous devriez faire à la place:

double d = CalcFromSomewhere(); 
double epsilon = 1e-5; // define the precision you are working with 
if (Math.Abs(d) < epsilon) 
{ 
    DoSomething(); 
} 

Answer 3

Ceci est un résultat de précision à virgule flottante. Vous obtenez un certain nombre de chiffres significatifs, et tout ce qui ne peut pas être représenté exactement est approximé. Par exemple, pi n'est pas un nombre rationnel, et il est donc impossible d'obtenir une représentation exacte. Puisque vous ne pouvez pas obtenir la valeur exacte de pi, vous n'obtiendrez pas les sinus et les cosinus exacts des nombres, y compris pi (vous n'obtiendrez pas la plupart du temps les valeurs exactes des sinus et des cosinus).

La meilleure explication intermédiaire est "What Every Computer Scientist Should Know About Floating-Point Arithmetic". Si vous ne voulez pas entrer dans cela, rappelez-vous que les nombres à virgule flottante sont généralement des approximations, et que les calculs à virgule flottante sont comme des tas de sable en mouvement: avec tout ce que vous faites, vous perdez un peu de sable ramasser un peu de terre.

Si vous voulez une représentation exacte, vous devrez vous trouver un système d'algèbre symbolique.

Answer 4

Je vous entends. Je suis terriblement agacé par l'imprécision de la division. L'autre jour, je l'ai fait:

Console.WriteLine(1.0/3.0); 

et je suis ,333333333333333, au lieu de la bonne réponse qui est 0.3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333 3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333 3333333333333333 ...

Peut-être que vous voyez maintenant quel est le problème. Math.Pi n'est pas égal à pi tout plus de 1,0/3,0 est égal à un tiers. Les deux diffèrent de la vraie valeur par quelques centaines de quadrillionths, et donc tous les calculs que vous effectuez avec Math.Pi ou 1.0/3.0 vont également être décalés de quelques centaines de quadrillionths, y compris en prenant le sinus.

Si vous n'aimez pas cette approximation arithmétique est approximative alors ne pas utiliser l'arithmétique approximative. Utilisez l'arithmétique exacte. J'avais l'habitude d'utiliser Waterloo Maple quand j'avais besoin d'arithmétique exacte; peut-être devriez-vous acheter une copie de cela.

Answer 5

Je rejette l'idée des erreurs sont dues à l'arrondi. Que peut-on faire est de définir sin(x) comme suit, en utilisant l'expansion d'un Taylor avec 6 termes:

const double π=Math.PI; 
    const double π2=Math.PI/2; 
    const double π4=Math.PI/4; 

    public static double Sin(double x) 
    { 

     if (x==0) { return 0; } 
     if (x<0) { return -Sin(-x); } 
     if (x>π) { return -Sin(x-π); } 
     if (x>π4) { return Cos(π2-x); } 

     double x2=x*x; 

     return x*(x2/6*(x2/20*(x2/42*(x2/72*(x2/110*(x2/156-1)+1)-1)+1)-1)+1); 
    } 

    public static double Cos(double x) 
    { 
     if (x==0) { return 1; } 
     if (x<0) { return Cos(-x); } 
     if (x>π) { return -Cos(x-π); } 
     if (x>π4) { return Sin(π2-x); } 

     double x2=x*x; 

     return x2/2*(x2/12*(x2/30*(x2/56*(x2/90*(x2/132-1)+1)-1)+1)-1)+1; 
    } 

erreur typique est 1e-16 et pire des cas est 1e-11. C'est pire que le CLR, mais il est contrôlable en ajoutant plus de termes. Les bonnes nouvelles sont que pour les cas spéciaux dans le PO et pour Sin(45°) la réponse est exacte.