négatif zéro en python

J'ai rencontré négatif zéro en sortie de python; il est créé par exemple comme suit:

k = 0.0
print(-k)

La sortie sera -0.0.

Cependant, quand je compare le -k à 0.0 pour l'égalité, il donne de Vrai. Quelle est la différence entre 0.0 et -0.0 (je n'ai pas de soins sans doute qu'ils ont différents représentation interne; je ne se soucient que de leur comportement dans un programme.) Est-il caché des pièges, je devrais être au courant?

  • Il ne donne pas de valeur négative avec python 2.5.4
  • Le réel caché piège, c'est quand vous commencez les essais de l'égalité avec les valeurs à virgule flottante. Ils sont imprécises et sujettes à bizarre arrondi divergences.
  • Mais il n'a imprimer de valeur négatif sur Python 2.7.1.
  • Ce problème est venu dans la vie réelle application gps; longitude légèrement à l'ouest du méridien a été rapporté que des zéro degrés et les x minutes, alors qu'il devrait avoir moins de zéro degré et les x minutes. Mais python ne peut pas représenter les entiers négatifs zéro.
InformationsquelleAutor max | 2010-11-03
  1. 31

    Découvrez -0 (nombre) dans Wikipedia

    Essentiellement de l'IEEE en fait de définir un négatif zéro.

    Et par cette définition pour tous les usages:

    -0.0 == +0.0 == 0

    Je suis d'accord avec aaronasterling que -0.0 et +0.0 sont des objets différents. Faisant d'eux les égaux (opérateur d'égalité) permet de s'assurer que les bogues ne sont pas introduites dans le code.

    Pensez à a * b == c * d

    >>> a = 3.4
>>> b =4.4
>>> c = -0.0
>>> d = +0.0
>>> a*c
-0.0
>>> b*d
0.0
>>> a*c == b*d
True
>>>

    [Edit: Plus d'infos sur la base des observations]

    Quand j'ai dit à toutes fins pratiques, j'avais choisi le mot plutôt à la hâte. Je voulais standard de comparaison d'égalité.

    Comme la référence dit, la norme IEEE définit comparaison de telle sorte que +0 = -0, plutôt que de -0 < +0. Bien qu'il soit toujours possible d'ignorer le signe de zéro, la norme IEEE ne pas le faire. Lorsqu'une multiplication ou la division implique un signé zéro, l'habitude de signer les règles s'appliquent dans le calcul du signe de la réponse.

    Opérations comme divmod et atan2 présentent ce comportement. En fait, atan2 conforme avec la norme IEEE définition que ne le sous-jacent "C" lib.

    >>> divmod(-0.0,100)
(-0.0, 0.0)
>>> divmod(+0.0,100)
(0.0, 0.0)

>>> math.atan2(0.0, 0.0) == math.atan2(-0.0, 0.0)
True 
>>> math.atan2(0.0, -0.0) == math.atan2(-0.0, -0.0)
False

    Une façon est de trouver par le biais de la documentation, si la mise en œuvre est conforme à la norme IEEE comportement . Il semble également de la discussion qu'il y a de subtiles plate-forme de variations trop.

    Cependant cet aspect (IEEE définition de la conformité) n'a pas été respectée partout. Voir le rejet de PEP 754 en raison de l'indifférence! Je ne sais pas si cela a été repris plus tard.

    Voir aussi Ce Que Tout Informaticien Devez Savoir À Propos De L'Arithmétique À Virgule Flottante.

    • Pourquoi avez-vous retiré de votre réponse? C'est est un ajout précieux à l'information ici. Je viens de upvoted il.
    • parce que je me suis trompé sur la dernière partie, et le reste n'est pas vraiment unique à mon poste.
    • Si c'est "l'égalité pour toutes les fins" comment peut-il expliquer la différence dans atan2 dans Craig McQueen réponse? Je suis d'accord qu'il renvoie True lorsque comparés pour l'égalité, mais si les deux numéros de comportement peut varier, je voudrais savoir quand.
    • Notez que la fonction arctangente est essentiellement la recherche de la pente (et la direction) des arguments fournis, donc en interne, c'est la division par zéro conduisant à des discontinuités qui ne devrait pas être surprenant. En outre, la fonction de sortie est cyclique avec une période 2π, +π et π sont les "mêmes".
    InformationsquelleAutor pyfunc
  2. 16

    Cela fait une différence dans la atan2() fonction (au moins, dans certaines implémentations). Dans mon Python 3.1 et 3.2 sur Windows (qui est basé sur le C sous-jacente de la mise en œuvre, en fonction de la note Disponible détail de l'implémentation près de la bas de l'Python math documentation du module):

    >>> import math
>>> math.atan2(0.0, 0.0)
0.0
>>> math.atan2(-0.0, 0.0)
-0.0
>>> math.atan2(0.0, -0.0)
3.141592653589793
>>> math.atan2(-0.0, -0.0)
-3.141592653589793
    InformationsquelleAutor Craig McQueen
  3. 13

    math.copysign() traite -0.0 et +0.0 différemment, sauf si vous utilisez Python sur un drôle de plate-forme:

    math.copysign(x, y)

         Retour x avec le signe de y. Sur une plate-forme qui prend en charge signé zéros, copysign(1.0, -0.0) retourne -1.0.

    >>> import math
>>> math.copysign(1, -0.0)
-1.0
>>> math.copysign(1, 0.0)
1.0
    • numpy a aussi un copysign. Yay!!!
    InformationsquelleAutor Alex Trebek
  4. 11

    Oui, il y a une différence entre 0.0 et -0.0 (bien que Python ne me permet pas de reproduire :-P). Si vous divisez un nombre positif par 0.0, vous obtenez l'infini positif; si vous divisez ce même nombre par -0.0 vous obtenez l'infini négatif.

    Au-delà de cela, cependant, il n'y a pas de différence pratique entre les deux valeurs.

    • Vous ne pouvez pas diviser par 0. Si vous êtes à la parler de parler de limites, -0 encore moins de sens.
    • -1 Vous ne pouvez pas diviser un nombre de 0 puisque vous obtenez un ZeroDivisonError. Cela signifie qu'il n'y a pas de différence.
    • En Python, vous ne pouvez pas; en d'autres langues, vous avez très bien peuvent. Je m'adressais la distinction entre 0.0 et -0.0 en général le traitement à virgule flottante sens.
    • Cependant, cette question est à propos de Python. Presque toutes les langues jeter une erreur, de toute façon.
    • toutes les langues? Vous avez sûrement plaisanterie. Essayez les expressions suivantes en JavaScript et Ruby: 1/0.0, 1/-0.0.
    • +1 pour annuler la downvotes. Chris est exact que, par exemple, en C, point flottant division par 0.0 est défini pour produire de l'infini, avec le signe de (numérateur et le dénominateur sont de même signe) ? positif : négatif.
    • Ceux-ci sont seulement deux langues. Permettez-moi de stand en C# et Python.
    • Le point de mon post est ceci: soutien à l'infini est intégré dans la plupart des virgule flottante processeurs. Refusant la division par zéro n'est pas venu "pour", mais doit être conçue dans la langue. Donc, pour le meilleur ou pour le pire, de nombreuses langues, il suffit de ne pas les déranger. Aussi, dieu merci, C# et Python ne sont pas "presque toutes les langues", ni même près de lui.
    • Je ne dis pas que l'infini n'est pas intégré dans la plupart des processeur en virgule flottante, mais plutôt, beaucoup de langues ont tendance à jeter une exception, car il n'y a vraiment pas de tout point d'1)Diviser par zéro et 2)à l'Aide de positif/négatif de l'infini, de toute façon. Et dieu merci, Javascript en particulier n'est pas une représentation de toutes les langues. Je certainement ne sera pas de la programmation, si elle l'était.
    • Vous êtes en oubliant que ** a une priorité plus élevée que -. (-0.0) ** 0 donne 1.0.
    • Point. (+1) je vais revenir à mon post, puis, et laissez-les infinités se tenir debout sur leur propre infini pieds. 😉
    • Je suppose que je parlais mathamatically, pas quelles langues avec des nombres à virgule flottante. Je undownvote, mais vous avez +4 de sorte qu'il égalise
    • La norme pour la virgule flottante permet à ces choses. "il n'y a vraiment pas de tout point" ne veut rien dire, puisqu'ils sont définis et normalisés. en.wikipedia.org/wiki-0_(nombre) La norme existe, est mis en œuvre et définit ces choses clairement et complètement.
    • Merci de m'indiquer une utilisation pratique de diviser par zéro
    • Comme je l'ai dit dans mon précédent, précédent commentaire, je comprends qu'il est intégré dans. De nombreuses langues décider de jeter l'exception, car il n'y a aucune utilisation pratique de la division par zéro et est probablement une faute. Merci de lire mon commentaire à nouveau.
    • Comme je l'ai dit dans mon commentaire précédent, je l'ai dit, j'ai compris que c'est construit (et donc en existe un). Donc, je n'ai jamais nié qu'il existe. En fait, je pense que vous êtes d'argumenter à propos d'une question entièrement différente. Mon argument était que de nombreuses langues lever une exception sur la division par zéro, même si c'est possible parce qu'il n'est pas ce que vous souhaitiez. Il semble que vous vous êtes hors sujet.
    • ne peut pas diviser un nombre de 0 puisque vous obtenez un ZeroDivisonError. Cela signifie qu'il n'y a pas de différence". Vrai. Puisque vous ne pouvez pas diviser par zéro, il n'y a pas de différence visible. "il n'y a vraiment pas de tout point d'1)Diviser par zéro et 2)à l'Aide de positif/négatif de l'infini". Vrai. S'il vous plaît écrire une pièce utile de code pour moi qui divise par zéro et utilise l'infini positif. Vous ne serez pas. Norme définie ou non, ils sont tout simplement pas utile. C'est tout.
    • La compréhension après la troisième fois, est utile aussi bien.
    • Je comprends aussi que le standard définit le positif/négatif de l'infini. Je ne comprends juste pas pourquoi c'est important.
    • Il est important que (un) et (b) il y a une mise en œuvre. (Même si elle est partielle.) Parce que vous (et moi) de ne pas voir la mathématique complexe subtilités ne veut rien dire. Ils existent encore. Je ne comprends pas équations aux dérivées partielles, et ne vois pas de valeur pratique. Certaines personnes le font. J'ai peu de valeur pratique dans la norme. Ce n'est pas le point. Mon humble avis sur "pratique" n'a aucun mérite. Il existe toujours, et il a encore un sens, et c'est encore que partiellement mises en œuvre.
    • Je ne comprends pas ce que vous obtenez en.
    • Merci pour les précisions. Puisque c'est arriver à être une assez longue ligne de commentaires, je vais juste dire que je vais garder mon point de vue, et vous pouvez garder le vôtre.
    • Vous voulez de la division de ±0.0 parce que le flotteur +0.0 ne représentent pas les mathématiques de 0. Il représente une plage de numéros proche de 0. Dépassement de capacité arithmétique est une façon vous pouvez obtenir la valeur +0.0 sans mathématiquement à atteindre 0.
    • Il m'est arrivé d'avoir un message non lu onglet ouvert sur le but de l'signé zéros: softwareengineering.stackexchange.com/questions/280648/...

    InformationsquelleAutor Chris Jester-Young
  5. 1

    Mêmes valeurs, mais un nombre différent 

    >>> Decimal('0').compare(Decimal('-0'))        # Compare value
Decimal('0')                                   # Represents equality

>>> Decimal('0').compare_total(Decimal('-0'))  # Compare using abstract representation
Decimal('1')                                   # Represents a > b

    Référence :

    http://docs.python.org/2/library/decimal.html#decimal.Decimal.compare
    http://docs.python.org/2/library/decimal.html#decimal.Decimal.compare_total

    InformationsquelleAutor user