Les mathématiques.Cos & Mathématiques.Le péché en C#

Je suis en train d'essayer quelque chose que je pensais que devrait être assez simple. J'ai un angle, d'une position et d'une distance et je veux trouver X,Y coordonnées à partir de cette information.

Avec un exemple d'entrée de 90 degrés-je convertir la valeur en radians avec le code suivant:

public double DegreeToRadian(float angle)
{
  return Math.PI * angle / 180.0;
}

Cela me donne 1.5707963267949 radians
Puis, quand j'utilise

Math.Cos(radians)

Je me retrouve avec une réponse de: 6.12303176911189 E-17

Ce que le diable se passe? Le cosinus de 90 degrés doit être de 0, alors pourquoi suis-je en obtenir une telle déviance... et surtout comment puis-je l'arrêter?

Sans aucun doute, des tours à 0. L'utilisation d'un spécificateur de format lors de la conversion de la valeur en chaîne de sorte que l'utilisateur voit la façon dont ils attendent.
Ok, je prends le point que le manque de précision est due au manque de précision en virgule flottante, les types, mais comment fait quelque chose comme Calculatrice de Windows à gérer pour obtenir la réponse morts, est-il juste de tricher et d'utiliser une table de recherche?
qui a dit que la Calculatrice de Windows .Net doubles (n'est pas), ou de tout type à virgule flottante (n'est pas). Et qui dit que c'est de la transmission de la précision des résultats d'un calcul plutôt que d'appliquer sane règles d'arrondi?
La calculatrice a été totalement réécrit il y a quelques années pour l'utilisation en précision arbitraire de l'arithmétique en réponse à précisément de tels bugs.
Votre valeur de pi est désactivée par quelques parties 10 à 17, donc il ne devrait pas être une surprise que le résultat est aussi par quelques parties de 10 à 17. Pi est arrondi à 16 chiffres.

OriginalL'auteur elaverick | 2011-05-21

  1. 14

    Permettez-moi de répondre à votre question par une autre: dans Quelle mesure pensez-vous 6.12303176911189 E-17 est de 0? Ce que vous appelez déviance est en fait dû à la manière dont les nombres à virgule flottante sont enregistrés en interne. Je vous recommande la lecture de la la suite de l'article. Dans .NET ils sont stockés à l'aide de la La norme IEEE 754.

    L'application de certaines de base de la trigonométrie, de la distance entre les deux particules se déplaçant d'une année-lumière avec cette erreur dans l'angle est de 6,1 E-17 * 9.4E15 ~= 0.57 = 57cm. Je ne pense pas que cela vaut la peine de trop se préoccuper.

    OriginalL'auteur Darin Dimitrov

  2. 6

    Voir les réponses ci-dessus. Rappelez-vous que 6.12303176911189 E-17 est 0.00000000000000006 (j'ai peut-être même manqué un zéro!) c'est donc un très, très petit écart.

    OriginalL'auteur Edwin Groenendaal

  3. 2

    Lire sur arithmétique à virgule flottante. Il n'est jamais et ne peut jamais être exact. Ne comparez jamais exactement à quoi que ce soit, mais de vérifier si les chiffres diffèrent par un (petit) epsilon.

    Il est parfois exact. Pas tout le temps.
    C'est exactement comme exactement comme toute autre chose dans un ordinateur qui n'est pas à l'aide de l'aléatoire. Le problème, c'est le général de la fixation de la plupart des gens (y compris les programmeurs informatiques) avec décimale représentations.
    Complètement et totalement faux. C'est inexact car l'ensemble des nombres réels ne peuvent pas être représentés de manière précise par le biais de aucun des moyens physiques; il n'a rien à voir avec le nombre de base. D'autres choses dans un ordinateur peut être représenté exactement ... des nombres entiers et des nombres rationnels, par exemple. Même ici, le problème peut être exprimé exactement à travers symbolique plutôt que de la représentation numérique, mais qui ne peut vous prendre jusqu'à présent.

    OriginalL'auteur Pontus Gagge

  4. 1

    Depuis le résultat du calcul est vraiment très proche de 0 (zéro), vous pouvez simplement utiliser l'arrondissement:

    Math.Round(result, 4): //4 decimals, e.g.: 2.1234

    Donc, calcul de sin/cos d'radian:

    const double Deg = Math.PI / 180;
double sin = Math.Round(Math.Sin(yourRadianValue * Deg), 4);
double cos = Math.Round(Math.Cos(yourRadianValue * Deg), 4); //0.0000...06 becomes 0

    Qui, si yourRadianValue = 90, renvoie sin = 1 et cos = 0.

    OriginalL'auteur KAI

  5. 1

    Les autres postes sont correctes au sujet de la question pratique de travail avec virgule flottante implémentations qui retournent des résultats avec de petites erreurs. Cependant, il serait bien si à virgule flottante de la bibliothèque implémentations permettrait de préserver l'identité de base de bien-fonctions connues:

    Math.Sin(Math.PI) doit de l'égalité 0,

    Math.Cos(Math.PI) doit de l'égalité -1,

    Math.Sin(Math.PI/2) doit de l'égalité 1,

    Math.Cos(Math.PI/2) doit de l'égalité 0, etc.

    Vous attendez qu'un flottant de la bibliothèque de respecter ces et d'autres les identités trigonométriques, quelles que soient les erreurs mineures dans ses valeurs constantes (par exemple les Mathématiques.PI).

    Le fait que vous êtes l'obtention d'une petite erreur de Math.Cos(Math.PI/2) indique que la mise en œuvre est en train de calculer le résultat, plutôt que de tirer à partir d'un tableau. Une meilleure mise en œuvre de Math.Cos et les autres fonctions transcendantes pourrait être plus précise pour les identités spécifiques.

    Je suis sûr que dans le cas de C#, ce comportement est normal, et si Microsoft ne pouvait pas le changer sans affecter le code existant. Si l'obtention du résultat précis pour certaines identités trigonométriques questions à vous, vous pouvez envelopper le natif de fonctions en virgule flottante avec un peu de code qui vérifie le bien-connu entrées.

    OriginalL'auteur b1tw153

  6. 0

    vous devez utiliser l'arrondissement

    var radians = Math.PI * degres / 180.0;
var cos = Math.Round(Math.Cos(radians), 2);
var sin = Math.Round(Math.Sin(radians), 2);

    le résultat serait:
    le péché: 1
    cos: 0

    OriginalL'auteur Xhevo Ibraimi

  7. 0

    Comme remarqué par @b1tw153, ce serait super si les valeurs exactes ont été retournés pour les multiples de PI/2.
    Et c'est exactement ce que Microsoft fait dans leur System.Numerics bibliothèque; si vous examinez le code source pour Matrix3x2.CreateRotation, vous remarquerez qu'ils manipulent n * PI/2 cas manuellement: https://github.com/Microsoft/referencesource/blob/master/System.Numerics/System/Numerics/Matrix3x2.cs#L325

    OriginalL'auteur odalet