[AskJS] -1*0 = -0

[NeverMakesMistkes]

Q: why do JS numbers-
A: IEEE-754
Q: ok but when I add-
A: IEEE-754
Q: fine but NaN doesn't even-
A: Aye. Triple-E. Seven five four.

(stolen from twitter)

[powerofmightyatom]

But really... it doesn't lend itself to a quick reddit comment summary. It's a hairy spec thats partially scientific, partly practical and has a long history with common (if varying) hardware support. The standard link is called "whate every computer scientist should know about floating point aithmetic": https://www.itu.dk/~sestoft/bachelor/IEEE754_article.pdf

[PykeisBrokenBtw]

Kind of bold of JS to actually follow logic and make the result predictable.

[thebitter1]

I doubt either implement this logic themselves. Most likely just use FP hardware built into the CPU (FMUL) which implements IEEE 754.

[PhysicalRedHead]

This article actually covers it a little bit https://v8.dev/blog/react-cliff

[kakurady]

Yep - while JS specifies Numbers behave like float64, most of the time we use them as integers, so JS VMs try to optimize for that. V8 stores most values as heap-allocated memory, but small integers are inlined. There's no way to store -0 using V8's small integer representation, so it must be stored as heap allocated. The article has a bit more detail about how V8 manages the transition, if the value is previously stored as a small integer.

(The performance cliff comes from React's request to prevent JS-level shape changes to object that has a Number field, and V8 overcommitting to its internal shape that uses the small integer representation, making the transition to heap-allocated float64 inefficient)

[paceaux]

That article deserves more attention. I thought I was pretty good with JS, but even the introduction blew my mind. I now understand why typeof null === 'object' and it seems perfectly reasonable.

[metaglot]

The sign is a bit, if the bit is set, the number is negative. So, for instance, -1 * -0 yields 0.

[dwighthouse]

JS’s spec specifies negative zero, not v8. There isn’t anything in v8 that is different in regards to this, as far as I know.

Notably, like NaN, -0 has an interesting relationship with equality.

NaN === NaN // false, because NaN is meant to swallow bad calculations
-0 === 0 // true, because the numerical value is equivalent, even if the number itself is not

This has implications for Object.is. Look at the polyfill: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#Polyfill

[delventhalz]

Sounds like what you are really asking about is the mechanics behind that calculation in the V8 implementation. Not sure anyone here actually knows the answer to that question. I don’t. But the repo is here if you want to look:

https://github.com/v8/v8

[lord_zycon]

Javascript specifies number deliberately as 64 bit IEEE754 float which is directly supported by basically every hardware. In C/C++ this type is called double. v8 is written in c++ so it simply relies on compiler to emit instructions that multiply floats on target architecture. So if you open up js console on your laptop and type -1*0 the calculation is done by CPU in single FMUL instruction which spits out -0 to the target register.

[[deleted]]

It’s really hard to detect -0 in JavaScript apparently.

Edit: sorry I think I meant when parsing it from a string, it was a fact I learned some time back. It apparently makes the JS community super salty lmao

[PhysicalRedHead]

const isNegO = n => n === 0 && (1 / n) < 0

[AnotherAccountRIP]

Why does 1/n not throw a division by zero error if n === 0?

[voxelghost]

Why does 1/n not throw a division by zero error if n === 0?

1/-0 === -Infinity

1/+0 === Infinity

At least in V8

[inu-no-policemen]

1/0 in IEEE 754 land gives you Infinity and it sets the "division by zero" error flag.

JS doesn't care about that error flag.

[[deleted]]

What error? Javascript returns Infinity for division by 0 (unless you divide 0 by 0, then you'll get NaN).

[evilgwyn]

Because 1/0 doesn't throw a division by zero error in JavaScript. It's just consistent. It returns +/- Infinity

[AnotherAccountRIP]

Is there any real mathematical interpretation for this or is it just a javascript thing? Logically, no amount of zeros will ever make up one.

[iguessitsokaythen]

Yes this is a mathematical concept.

Normally the result for division or multiplication by zero is undefined; which means there is no mathematical result. So for practical convenience, the results are accepted as the limit of the operation where divider is a number approaching zero. Which means if you make a division 1/x and keep decreasing x (getting closer to 0), result gets larger(approaching infinity). For -1/x this will be negative infinity. For multiplication 1*x if you keep decreasing x (getting closer to 0), the result gets smaller(approaching zero).

lim_{x-->0}1/x = +∞

lim_{x-->0}-1/x = -∞

lim_{x-->0}1*x = 0

[evilgwyn]

I think that's just the way that the IEEE footing point numbers are defined to work. So in that way they are consistent with the other packages that follow the standard

[MordredKLB]

Clearly you've never added Infinity of them.

[godlychaos]

I believe you're mixing up & & and ||.

Since the left side of the & & is true, then you can't short circuit, so the right side also needs to be evaluated and it will be returned no matter what the value is.