Je ne comprends pas pourquoi nous nous soucions de différentes représentations pour un zéro positif et un zéro négatif.

Je me souviens vaguement de la lecture des affirmations selon lesquelles la représentation négative égale à zéro est extrêmement importante dans les programmes impliquant des nombres complexes. Je n'ai jamais eu l'occasion d'écrire du code impliquant des nombres complexes, alors je suis un peu déconcerté de savoir pourquoi.

L'article de Wikipedia sur le concept n'est pas particulièrement utile. il ne fait que de vagues affirmations sur le zéro signé, rendant certaines opérations mathématiques plus simples en virgule flottante, si je comprends bien. Cette réponse répertorie quelques fonctions qui se comportent différemment. Vous pouvez peut-être en déduire quelque chose à partir des exemples si vous savez comment les utiliser. (Bien que, l'exemple particulier des racines carrées complexes semble plat fausse, puisque les deux nombres sont mathématiquement équivalents, à moins que je n’aie un malentendu.) Mais j’ai été incapable de trouver une déclaration claire du genre de problème que vous auriez eu si cela n’était pas là. Les ressources les plus mathématiques que j'ai pu trouver indiquent qu'il n'y a pas de distinction mathématique entre les deux, et l'article de Wikipedia semble suggérer que cela est rarement vu en dehors de l'informatique en dehors de la description des limites.

Alors, pourquoi un zéro négatif est-il précieux en informatique? Je suis sûr que je manque juste quelque chose.

Vous devez garder à l'esprit que dans l'arithmétique FPU, 0 ne doit pas nécessairement signifier exactement zéro, mais aussi une valeur trop petite pour être représentée à l'aide d'un type de données donné, par exemple

a = -1 / 1000000000000000000.0

a est trop petit pour être représenté correctement par float (32 bits), il est donc "arrondi" à -0.

Maintenant, supposons que notre calcul continue:

b = 1 / a

Parce que a est float, il en résultera -infinity qui est assez loin de la réponse correcte de -1000000000000000000.0

Calculons maintenant b s'il n'y a pas -0 (donc a est arrondi à +0):

b = 1 / +0
b = +infinity

Le résultat est encore faux à cause des arrondis, mais maintenant, il est "plus faux" - non seulement numériquement, mais surtout à cause du signe différent (le résultat du calcul est + infini, le résultat correct est -1000000000000000000.0).

Vous pouvez toujours dire que cela n'a pas vraiment d'importance, car les deux ont tort. L'important est qu'il existe de nombreuses applications numériques dans lesquelles le résultat le plus important du calcul est le signe. Par exemple, lorsque vous décidez de tourner à gauche ou à droite au croisement à l'aide d'un algorithme d'apprentissage automatique, vous pouvez interpréter une valeur positive => tourner gauche, valeur négative => tourner à droite, la "magnitude" réelle de la valeur est simplement un "coefficient de confiance".

Premièrement, comment créez-vous un -0? Il existe deux manières: (1) d'effectuer une opération en virgule flottante dans laquelle le résultat mathématique est négatif, mais si proche de zéro qu'il est arrondi à zéro et non à un nombre non nul. Ce calcul donnera un -0. (b) Certaines opérations impliquant des zéros: multiplier un zéro positif par un nombre négatif ou diviser un zéro positif par un nombre négatif ou annuler un zéro positif.

Avoir un zéro négatif simplifie un peu la multiplication et la division, le signe de x * y ou x / y est toujours le signe de x, exclusif ou le signe de y. Sans zéro négatif, il faudrait une vérification supplémentaire pour remplacer -0 par +0.

Il existe de très rares situations où cela est utile. Vous pouvez vérifier si le résultat d'une multiplication ou d'une division est mathématiquement supérieur ou inférieur à zéro, même en cas de dépassement négatif (tant que vous savez que le résultat n'est pas un zéro mathématique). Je ne me souviens pas avoir jamais écrit du code où cela fait une différence.

Optimiser les compilateurs déteste -0. Par exemple, vous ne pouvez pas remplacer x + 0.0 par x, car le résultat ne devrait pas être x si x est -0.0. Vous ne pouvez pas remplacer x * 0.0 par 0.0 car le résultat devrait être -0.0 si x <0 ou x est -0.0.

C # Double conforme à IEEE 754

    double a = 3.0;
    double b = 0.0;
    double c = -0.0;

    Console.WriteLine(a / b);
    Console.WriteLine(a / c);

impressions:

Infinity
-Infinity

en fait pour expliquer un peu ...

Double d = -0.0; 

Cela signifie quelque chose de beaucoup plus proche de d = The Limit of x as x approaches 0-ou The Limit of x as x approaches 0 from the negatives.

Pour répondre au commentaire de Philipp ...

Fondamentalement, zéro négatif signifie un débordement.

Il y a très peu d'utilisation pratique pour le zéro négatif, le cas échéant ...

par exemple, ce code (encore C #):

double a = -0.0;
double b = 0.0;

Console.WriteLine(a.Equals(b));
Console.WriteLine(a==b);
Console.WriteLine(Math.Sign(a));

donne ce résultat:

True
True
0

Pour expliquer de manière informelle, toutes les valeurs spéciales qu'une virgule flottante IEEE 754 peut avoir (infini positif, infini négatif, NAN, -0,0) n'ont aucune signification au sens pratique. Ils ne peuvent représenter aucune valeur physique, ni aucune valeur ayant un sens dans le calcul "réel". Ce qu'ils veulent dire est fondamentalement ceci:

• l'infini positif signifie un débordement à l'extrémité positive, une virgule flottante peut représenter
• l'infini négatif signifie un débordement à l'extrémité positive, une virgule flottante peut représenter
• un zéro négatif signifie un débordement et les opérandes avaient des signes opposés
• un zéro positif peut signifier un débordement et les opérandes avaient le même signe
• NAN signifie que votre calcul est compliment non défini, comme sqrt(-7), ou qu'il n'a pas de limite comme 0/0ou commePositiveInfinity/PositiveInfinity

La question de savoir comment cela se rapporte aux calculs de nombres complexes montre clairement pourquoi les deux valeurs +0 et -0 existent en virgule flottante. Si vous étudiez l’analyse complexe, vous découvrez rapidement que les fonctions continues de complexe à complexe ne peuvent généralement pas être traitées comme des «valeurs uniques», à moins d’adopter la «fiction polie» selon laquelle les sorties forment ce qu’on appelle une «surface de Riemann». Par exemple, le logarithme complexe attribue à chaque entrée un nombre infini de sorties. Lorsque vous les connectez pour former une sortie continue, vous obtenez toutes les parties réelles formant une surface de tire-bouchon infinie autour de l'origine. Une courbe continue qui traverse l'axe réel "du côté de l'imaginaire positif" vers le bas et une autre courbe qui "entoure le pôle" et traverse l'axe réel "

Appliquez maintenant cela à un programme numérique qui calcule en utilisant une virgule flottante complexe. L'action entreprise après un calcul donné peut être très différente selon la "feuille" sur laquelle le programme est actuellement "activé", et le signe du dernier résultat calculé vous indique probablement quelle "feuille". Supposons maintenant que le résultat était nul? Rappelez-vous qu'ici, «zéro» signifie vraiment «trop petit pour être correctement représenté». Mais si le calcul peut permettre de conserver le signe (c.-à-d. Mémoriser quelle feuille) lorsque le résultat est égal à zéro, le code peut alors vérifier le signe et effectuer la bonne action, même dans cette situation.

La raison est plus simple que d'habitude

Bien sûr, il y a beaucoup de hacks qui ont l'air vraiment sympa et qui sont utiles (comme arrondir à -0.0ou +0.0mais supposons que nous ayons une représentation de int signé avec un signe moins / plus au début (je sais que cela est résolu par le code binaire U2 en nombres entiers généralement mais supposons une représentation moins complexe de double):

0 111 = 7
^ sign

Et s'il y a un nombre négatif?

1 111 = -7

Ok, c'est simple. Alors représentons 0:

0 000 = 0

C'est bien aussi. Mais qu'en est-il 1 000? Est-ce que ce doit être un numéro interdit? Mieux vaut non.

Supposons donc qu'il existe deux types de zéro:

0 000 = +0
1 000 = -0

Eh bien, cela simplifiera nos calculs et fournira fort heureusement quelques fonctionnalités additionnelles. Donc, les +0et -0viennent seulement de problèmes de représentation binaire.