Dans les primitives signées est 0 positif ou négatif (ou les deux)?

Question

Je lisais cette page sur le "Code Ranch" qui parle de variables.

Il était question de "primitives signées", et disait que 0 est compté comme négatif ???

J'ai toujours pensé que 0 était positif dans ces cas?

Tous ces types entiers sont SIGNÉS. Le bit le plus à gauche représente le signe (positif ou négatif) et NE fait PAS partie de la valeur. Donc, avec un octet, par exemple, vous n'avez pas les 8 bits entiers pour représenter votre valeur. Vous obtenez 7. Cela vous donne une plage, pour les octets, de: (-2 à la 7e) à (2 à la 7e) -1. Pourquoi ce petit -1 sur la fin? Parce que zéro est là, et zéro compte comme négatif. Fonctionne de la même manière avec les autres.

http://www.javaranch.com/campfire/StoryCups.jsp

Mais quand on regarde ce poste Why is the range of bytes -128 to 127 in Java?

Un commentaire mentionne "0 est positif par défaut." Il parle aussi de "Compliments de deux" et mentionne tout "1" dans le bit le plus à gauche serait "négatif", ce qui n'a pas 0.

Aussi, si 0 était négatif -128 à 0 est de 129 négatifs, avec 127 positifs, ce qui n'a pas de sens ....

Donc je suis curieux de savoir si c'est une erreur, ou si 0 est négatif, et pourquoi?

Aussi, je lisais ce fil How can a primitive float value be -0.0? What does that mean?

qui parlait d'un flotteur avec une valeur de -0,0, et en ajoutant une « 0.0 » à elle afin d'en faire un « neutre/positif » 0.0 .. Donc, je suis curieux de savoir si les zéros à la fois positifs et négatifs existent dans les flottants, ou existe-t-il à la fois dans les primitives virgule flottante et les entiers ????? De même, quand j'ai été Google réponses pour cela, mention de "Zéro n'étant ni positif-négatif/étant à la fois positif-négatif ...." Curieux si/quand cela s'applique dans nos langues?

Merci

Answer 1

C'est une question complexe avec plusieurs facettes donc je vais essayer de le décomposer mieux que je peux. D'abord, il y a le concept mathématique de zéro et si c'est positif ou négatif. Malheureusement, la réponse à cela, essentiellement, est que cela dépend du contexte et il est parfois raisonnable d'inclure zéro dans un ensemble de nombres positifs ou de nombres négatifs. Les mathématiciens reconnaissent l'ambiguïté et ont un terme spécial pour savoir quand ils doivent savoir si le zéro est dans un ensemble particulier de nombres ou non - "non négatif" et "non positif" incluent tous les deux zéro. Certaines définitions du «bon sens» de positif et négatif permet une comparaison exclusive avec zéro, ce qui met zéro dans le cas particulier de ne pas être positif ou négatif. D'autres ont une notion inclusive de positif ou négatif, qui peut rendre nul à la fois positif et négatif. https://math.stackexchange.com/questions/26705/is-zero-positive-or-negative

Alors qu'est-ce que cela signifie pour le langage Java?Encore une fois, il y a un certain nombre de cas différents à considérer - les types intégrales primitifs, les types à virgule flottante primitive, les primitives encadrées, les classes de précision arbitraires BigDecimal et BigInteger, et, surtout, quels effets sont visibles?

Java représente les types intégrales primitifs utilisant le système 2s complement et n'a donc qu'une seule représentation pour zéro. Dans le sens où 0 n'a pas le bit de signe défini, il peut être raisonnable de dire que 0 est positif. Cependant, c'est vraiment un point discutable car il n'y a vraiment rien d'autre dans le langage qui se préoccupe de savoir si le zéro est positif ou négatif et donc cela n'a vraiment pas d'effet pratique. Les versions encadrées de ces types ont le même comportement.

Ce que le complément de 2 signifie cependant, c'est que toute plage donnée de nombres est inégalement équilibrée autour de zéro. Donc, si vous prenez une valeur de 8 bits, vous pouvez représenter 256 valeurs avec. L'un d'eux est 0, ce qui vous laisse avec 255 valeurs non nulles. Cependant, vous divisez le reste, vous obtenez un côté légèrement plus grand que l'autre. Le complément 2 rend -128 une valeur négative valide et 127 la plus grande valeur positive que vous pouvez représenter avec 8 bits. La même chose est vraie pour les plus grands types intégraux int et long - ils peuvent représenter un entier négatif non nul de plus que l'entier positif non nul. Ce n'est ni un bug ni une erreur, c'est un fait simple.

Pour les types primitifs à virgule flottante, double et float, Java utilise IEEE 754 pour les représenter. Cela permet deux façons différentes de représenter 0,0 et donc, techniquement, chaque zéro est soit -0,0 ou +0,0. La norme IEEE, cependant, est claire que ces deux valeurs sont pratiquement indiscernables - elles sont égales et donc -0.0 == +0.0 évalue à vrai. Pour la plupart des opérations mathématiques, -0,0 et +0,0 ont le même effet. C'est jusqu'à ce que vous essayez quelque chose qui génère Inf. Donc, en divisant par -0.0 vous obtiendrez -Inf et en divisant par +0.0 obtiendrez + inf. De toute façon, votre calcul est entré dans un trou noir. Heureusement, tous les NaN sont les mêmes, donc -0.0/0.0 vous obtiendrez Nan exactement comme 0.0/0.0. Pour les autres opérations mathématiques, -0,0 agit de manière cohérente. Ainsi, Math.sqrt(-0.0) est -0,0 et Math.sqrt(0.0) est 0,0. Math.abs(-0.0) renverra 0.0. Mais il y a vraiment très peu de différence entre -0,0 et 0,0.

Ce qui peut être important est que lorsque vous affichez les nombres dans une chaîne formatée, le signe reste. Si vous y tenez vraiment, vous pouvez utiliser Math.abs() pour transformer un zéro négatif en un zéro positif, mais ce n'est généralement pas un problème qui mérite d'être étudié.

Il y a un effet curieux quand il s'agit des types encadrés pour les nombres à virgule flottante et ceux liés à la méthode 'equals()'. Les types primitifs ont -0.0 == +0.0 évaluant à true. Cependant Double.valueOf(-0.0).equals(Double.valueOf(+0.0)) évalue à false, ce qui est documented mais contre-intuitif et potentiellement potentiellement confus. Lorsqu'il est combiné avec l'auto-boxing et l'auto-déballage, cela peut avoir des effets secondaires déroutants - par ex. Double.valueOf(-0.0) == Double.valueOf(+0.0) est faux mais -0.0 == +0.0 est true. Pendant ce temps, Double.valueOf(-0.0) == +0.0d est vrai. Comme toujours avec Java - méfiez-vous un peu des primitives en boîte et faites toujours attention à ne pas mélanger des primitives en boîte et sans boîte.

BigDecimal jette une autre clé dans les travaux en ayant une implémentation légèrement différente de equals(). Donc, BigDecimal.valueOf(-0.0).equals(BigDecimal.valueOf(0.0)) est évalué à vrai, mais BigDecimal.valueOf(-0.0).equals(BigDecimal.ZERO) est faux. C'est parce que l'échelle est considérée avec la valeur. BigDecimal.ZERO est en fait 0, ce qui est considéré comme une valeur différente de 0.0, ce qui est encore différent de 0.00 - new BigDecimal("-0.0").equals(new BigDecimal("-0.00")) est évalué à false.

Une autre chose que nous pouvons regarder est la fonction Math.signum(), qui est définie comme retournant -1, 0 ou 1 selon que l'argument est négatif, zéro ou positif.La même chose est vraie pour la méthode signum sur les classes BigInteger et BigDecimal dans le package java.math. Malheureusement la fonction Math.signum() renvoie un double, et ainsi vous obtenez -0.0 pour -0.0 et 0.0 pour 0.0, alors que BigDecimal.signum() renvoie un int. Mais ce que cela implique est que, bien que vous définissiez zéro, ce n'est pas vraiment positif ou négatif.