big.js

Griffin: a citation (and more ... decimal point to the right to get it out of the way (my addition: for each number)" so, # shifts for x plus # shifts for y. 2016-03-03T02:50:58.79Z+00:00 ... @NateZaugg you can't truncate the the overflowing decimals, you have to round the amount, because 2090.5 * 8.61 is 17999.205 but in float it's 17999.204999999998 2017-05-12T06:13:16.493Z+00:00 ... I'm finding BigNumber.js meets my needs. A JavaScript library for arbitrary-precision decimal and ... More on stackoverflow.com

Pretty much the same advice. Our application uses feet-inch data up to 1/64” precision. We use exclusively integers. More on reddit.com

Single floats are around 7 decimal digits (24 bits) and exponents from -126 to 127: that's certainly not always good enough, but in some sense that's the easy part. It's the rare bit of science where your measurement setups aren't introducing at least that much variation, and once you start using doubles you get even more. The bigger problems, to me at least, are compounding errors and different logic problems. Errors can be much larger than the simple rounding error in long calculations. If you're computing the sum of many numbers with very different magnitudes, the order will affect the output, and it's easy to get huge errors. Very roughly, if you have 2^40 + 1 + 1 + 1 + ..., the single float closest to 2^40 + 1 is actually just 2^40, and so you can add as many 1s as you like and nothing will change in the output. Many linear algebra routines and other workhorses of numerical computing aren't accurate to anything close to the last digit of the output: in larger mathematical models I've used, you can get differences up to 0.1% just from different numerical routines. That's not nothing, even if it is a testament to how good floating-point numbers are that such things work at all. The other problem is logic. Comparing floating-point numbers is famously tricky to do well for testing, and it's easy to assume that something like while x < 2^50: x = x + 1 will eventually finish when it won't for the roundoff error introduced above. From my point of view, the problem isn't necessarily when you have clearly defined precision requirements and floats aren't good enough, although of course that does happen. The problem is that errors in large programs can compound or confound your reasoning in complex ways that are difficult to understand and debug, so your actual results can be off by way more than the precision of the underlying data type. More on reddit.com

JavaScript numbers are double-precision floating-point values, also known as a double in other languages like C. This covers the "float" side of things. Now, a double-precision floating-point value can perfectly represent integers up to 52 bits, which is a lot bigger than the 32 bits an int can typically store in other languages. JavaScript bitwise operators such as & or | or ^ also convert their values to 32-bit integers before doing their work. So, just use regular JavaScript numbers to perform your integer arithmetic, and then throw in a few | 0 operations if you want the rounding / clamping behavior found in other language's 32-bit int types. In other words, everything you want is already present. More on reddit.com