Differentiating +0 and -0

Question

It turns out +0 === -0 evaluates to true despite +0 and -0 being different entities. So, how do you differentiate +0 from -0?

There is a hack:

if (1 / myZero > 0) {
   // myZero is +0
} else {
   // myZero is -0
}

Can I do better?

Why do you need to know this? (Not condescending... I am really curious!) — Jason Gennaro, Aug 28 '11 at 20:35
your solution seems reasonable. (+0 === -0) being true seems like an oversight in the language so I don't know how else you'll resolve it. I wouldn't expect it to come up frequently. — evan, Aug 28 '11 at 20:35
You don't need a function, just do this check: `if ( 1 / x > 0 ) { ...` — Šime Vidas, Aug 28 '11 at 20:44
@Jason: I'm just playing around with the specs, and considering a bunch of thought experiments. These kind of bizarre things could potentially lead to difficult-to-find bugs. See one of my fears here: http://stackoverflow.com/questions/7223517/function-given-strictly-equal-arguments-yielding-non-strictly-equal-results — Randomblue, Aug 28 '11 at 21:02
@JasonGennaro - right now I'm writing my own `printf` in javascript and `%+f` specifier must distinguish between `+0` and `-0` — csharpfolk, Aug 07 '15 at 17:02

Randomblue · Accepted Answer · 2016-05-08T13:47:17.053

26

In ECMAScript 6 Object.is behaves like === except that it distinguishes positive and negative zeroes, and Object.is(NaN, NaN) evaluates to true. (See here for a writeup.)

Chrome 24 supports Object.is.

edited May 08 '16 at 13:47

answered Nov 24 '12 at 08:53

Randomblue

105,985
138
338
537

there's also an alternative version for ECMAScript 5 at the end of [this documentation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is) if you need it for old browsers – Gerard Brull Aug 16 '16 at 01:43

score 14 · Answer 2 · answered Aug 28 '11 at 20:42

14

This is still some kind of hack, but a look at the specs suggests this:

Math.atan2(0, -0) === Math.PI // true
Math.atan2(0,  0) === 0       // true

answered Aug 28 '11 at 20:42

pimvdb

146,912
75
297
349

Which specs are you referring to? ECMAScript? (Not doubting, I just want to know...) – Jared Farrish Aug 28 '11 at 20:43
@Jared Farrish: Yes, the part of `atan2`. – pimvdb Aug 28 '11 at 20:44
Do you have a link by chance? – Jared Farrish Aug 28 '11 at 20:44
Ok, thanks guys. :) It's for my own edification. (Note, pimvdb's reference is found at http://bclary.com/2004/11/07/#a-15.8.2.5) – Jared Farrish Aug 28 '11 at 20:47
1

It works but is x10 times slower on my chrome than `1/zero` test – csharpfolk Aug 07 '15 at 17:09
This doesn't work with every number: `Math.atan2(0, -5e-324) === Math.PI` is true, yet `-5e-324 === -0` is false. – Timothy Gu Dec 08 '17 at 02:37

Matt Fenwick · Answer 3 · 2012-07-12T12:27:47.843

9

According to David Flanagan's book, p. 34, dividing 1 by your zero will produce the corresponding infinity, which can then be used in an equality check:

1 / 0
> Infinity
1 / -0
> -Infinity

And here's the behavior of the equality comparisons of infinities:

Infinity === -Infinity
> false
Infinity === Infinity
> true
-Infinity === Infinity
> false
-Infinity === -Infinity
> true

edited Jul 12 '12 at 12:27

answered Jul 11 '12 at 12:53

Matt Fenwick

46,727
21
123
189

This doesn't work with every number: `1 / -5e-324` results in `-Infinity`, yet `-5e-324 === -0` is false. – Timothy Gu Dec 08 '17 at 02:38
@TimothyGu What's your point? The question specifically asks about +0 and -0, not about "every number". – Matt Fenwick Dec 08 '17 at 11:25
Certainly true. My bad for forgetting the original question – Timothy Gu Dec 09 '17 at 18:49

score 4 · Answer 4 · answered Aug 28 '11 at 21:10

4

This returns +0:

-0 + 0

This doesn't help to differenciate -0 and +0, but this helps in ensuring that some value is not -0.

1 / -0       => -Infinity  
1 / (-0 + 0) => Infinity

answered Aug 28 '11 at 21:10

Arnaud Le Blanc

95,062
22
198
192

4

or you could use `Math.abs(-0)`. – evan Aug 28 '11 at 21:12
5

This is very useful for me because I needed to specifically ensure positive zero but leave other signed numbers alone. – Semicolon Mar 23 '14 at 04:00

Roy Prins · Answer 5 · 2019-08-09T07:44:39.180

3

As people seem stumped as to what the practical need for this would be: here is my use case...

I needed a solution to sort the columns of a table by their index. Click the <th> and invoke the sorter with [ordinal] for ascending and -[ordinal] for descending. The first column would give -0 for descending or 0 for ascending.

So I need to differentiate between +0 and -0 and ended up here. The solution that worked for me is in the comment by @Šime Vidas, but is hidden away somewhat.

[ section removed - see comments below ]

edited Aug 09 '19 at 07:44

answered Jan 16 '15 at 17:24

Roy Prins

2,510
1
24
40

1

Very nice use case. One small thing I don't get yet: the expressions you provide also state that `-0 > 0` would result in `true`. I was stunned when I read it, and of course, I immediately tried it in the browser's developer tools. Seems it returns `false` instead (as I expected). Am I perhaps misunderstanding something here? – Bart Hofland Aug 09 '19 at 06:44
I honestly do not remember writing this and I see your observation is correct. Excuse my brainfart and I will add a comment to designate it as such. – Roy Prins Aug 09 '19 at 07:43

score 3 · Answer 6 · answered Dec 25 '15 at 09:33

3

To check the negative zero, here is one simple solution.

function isNegativeZero(n) {
    n = Number( n );
    return (n === 0) && (1 / n === -Infinity);
}

answered Dec 25 '15 at 09:33

zangw

37,361
17
142
172

score 1 · Answer 7 · answered Aug 02 '15 at 07:28

1

One straight option in Node.js is to use Buffer.

var negZero = Buffer('8000000000000000', 'hex')

var buf = Buffer(8);
buf.writeDoubleBE(myZero);

if (buf.equals(negZero)) {
    // myZero is -0
} else {
    // myZero is +0
}

Also, you can easily browserify them by buffer module.

answered Aug 02 '15 at 07:28

hakatashi

7,447
2
19
21

1

Same idea by using TypedArray: `isPosZero = x => !(new Uint8Array(new Float64Array([x]).buffer).some(Boolean))` – tsh Jan 09 '18 at 07:37

score 0 · Answer 8 · answered Jul 05 '16 at 02:49

0

As hinted at by Matt Fenwick, you could just do (using the var zero):

if(1/zero===Infinity) {
  // zero is +0
} else {
  // zero is -0
}

answered Jul 05 '16 at 02:49

user31415

436
7
16

Sean Morris · Answer 9 · 2021-10-22T07:34:44.777

0

Use Math.sign()

console.log(Math.sign( 1 / +0 ));
console.log(Math.sign( 1 / -0 ));

edited Oct 22 '21 at 07:34

answered Jan 20 '21 at 07:27

Sean Morris

254
2
8

Differentiating +0 and -0

9 Answers9

Linked

Related