Javascript float subtract

Question

I was wondering how can I subtract two negative Floating-Point numbers in javascript. I tried:

alert(-0.2-0.1);

and the result is -0.30000000000000004. Am I doing something wrong? What do I have to do to get -0.3 ?

Answer 1

No, nothing wrong with your code, most decimal fractions cannot be represented exactly in binary, use

number.toFixed(x)

Where x is the number of decimals you want and number is the result of the subtraction.

Answer 2

Another possible solution might be this:

Number((-0.2-0.1).toFixed(x))

Where x should be the tolerance in decimals you'd like.

Running this with an x of 16, gives me an output of -0.3.

-0.3 === Number((-0.2-0.1).toFixed(16)) // true, and also with every 0 < x < 16

Let me know.

Answer 3

The reason of your problem is explained here: Why does modulus operator return fractional number in javascript?

A possible solution could be:

<script type="text/javascript">
var result = (-20-10)/100;
alert("My result is "+result);
</script>

Answer 4

You are doing nothing wrong, what you are seeing is the side effect of computers storing numbers in base 2. In base 10, 1/3 can't be precisely represented: .33333333 (with a bar over the 3). The same is true for 1/10 and 1/5 in base 2 or binary. The answer you see is merely the result of a rounding error. If you are working with money, it is often advised to just store values as cents to avoid some floating point errors.

As far as fixing the result you can do something like:

var SIGDIG= 100000000;
alert( Math.floor((-0.2-0.1)*SIGDIG)/SIGDIG );

Answer 5

toFixed() is what you must be looking for.

E.g

number.toFixed(x); 

where x is the number of digits after the decimal point. It is optional with default value of 0.

More here : Javascript Number.toFixed() Method

Answer 6

Javascript uses IEEE 754 that is designed to balance the need for accuracy and limitations of computer hardware.

it's still subject to limitations and can lead to rounding errors and imprecise calculations in some cases.

a simplified example will be

> 0.05 - 0.02
< 0.030000000000000002 // this is the result!!!

the result is unexpected and this I call bug and makes arithmetic operations on floating-point useless.

you can work around the problem as suggested with toFixed but this will require you to know the number of digits after decimal point in advance and toFixed returns a string.

if you dont know the number of digits after decimal point in advance, here how the problem can be solved:

const getLongestDecimalLength = ( ...numbers ) => numbers.reduce( ( previousLength, number ) => {
  const numberParts = number.toString().split( '.' );
  if ( numberParts.length <= 1 ) return previousLength;
  return numberParts[ 1 ].length > previousLength ? numberParts[ 1 ].length : previousLength;
    }, 0 );

const price = 0.05;
const tax = 0.02;
const decimalLength = getLongestDecimalLength(price, tax);
const cost = parseFloat((price - tax).toFixed(decimalLength)); // 0.03