检查十进制浮点数

Question

Normally we expect 0.1+0.2===0.3 to be true. But it is not what javascript will result. As javascript displays decimal floating point number but stores binary floating point number internally. So this returns false.

If we use chrome developer tool console, we'll get the following result:

0.1+0.2;//0.30000000000000004

0.1+1-1;//0.10000000000000009


0.1 + 0.2 === 0.3 ;// returns false but we expect to be true.
0.1+1-1===0.1;//returns false

Due to rounding errors, as a best practice we should not compare non-integers directly. Instead, take an upper bound for rounding errors into consideration. Such an upper bound is called a machine epsilon.

And here is the epsilon method:

var eps = Math.pow(2,-53);
function checkEq(x,y){
    return Math.abs(x - y) <  eps;
}

Now, if we check it returns true.

checkEq(0.1+0.2,0.3);// returns true
checkEq(0.1+1-1,0.1);//returns true

It's okay and fine. But if I check this:

checkEq(0.3+0.6,0.9);// returns false

Which is not okay and not as what we expect.

So, how should we do to return the correct results?

---

What I've tried to solve this is like this:

var lx,ly,lxi,lyi;
function isFloating(x){
   return x.toString().indexOf('.');
}
function checkEq(x,y){
   lxi = x.toString().length - x.toString().indexOf('.') - 1;
   lyi = y.toString().length - y.toString().indexOf('.') - 1;
   lx = isFloating(x) > -1 ? lxi : 0;
   ly = isFloating(y) > -1 ? lyi : 0;
   return x.toFixed(lx) - y.toFixed(ly)===0;
}

Now, fixed. And it results fine if I check like this:

checkEq(0.3,0.3); //returns true

But the following returns false

checkEq(0.3+0.6,0.9)

As here first it's value is stored in binaray floating point number and then returning decimal floating point number after calculating.

So now, how can I set toFixed() method for each input like in checkEq(0.3+0.6,0.9) 0.3.toFixed(lx) and 0.6.toFixed(lx) and then only add:

    var lx,ly,lxi,lyi;
    function isFloating(x){
    return x.toString().indexOf('.');
    }
    function checkEq(x,y){
    x = x.toString().split(/\+ | \- | \/ | \ | \\ */);
    y = x.toString().split(/\+ | \- | \/ | \ | \\*/);

    for(var i=0;i<x.length,y.length;i++){
    //here too I may be wrong...
       lxi = x[i].toString().length - x[i].toString().indexOf('.') - 1;
       lyi = y[i].toString().length - y[i].toString().indexOf('.') - 1;
    // particularly after this would wrong...
       lx = isFloating(x[i]) > -1 ? lxi : 0; 
       ly = isFloating(y[i]) > -1 ? lyi : 0;

    //And, here I'm stucked too badly...
    //take splitted operators to calculate:
    //Ex- '0.3 + 1 - 1' 
    // Number('0.3').toFixed(1) + Number('1').toFixed(0) - Number('1').toFixed(0)
    //But careful, we may not know how many input will be there....


    }

//return x.toFixed(lx) - y.toFixed(ly)===0;
}

Other answers are also welcome but helping me with my code is greatly appreciated.

Answer 1

Perhaps you should try out some existing JS Math library such as bignumber.js , which supports arbitrary-precision arithmetic. Implementing everything from scratch will be rather time consuming and tedious.

Example

0.3+0.6    //0.8999999999999999
x = new BigNumber('0.3')    // "0.3"
y = new BigNumber('0.6')    // "0.6"
z = new BigNumber('0.9')    // "0.9"
z.equals(x.plus(y))    // true

Answer 2

I think you should take a little larger value for epsilon.

You can also have a look at math.js : the comparison functions of math.js also check for near equality. Comparison is explained here:

http://mathjs.org/docs/datatypes/numbers.html#comparison

So you can do:

math.equal(0.1 + 0.2, 0.3); // true
math.equal(0.3 + 0.6, 0.9); // true

even better, math.js has support for bignumbers ( see docs ), so you can do:

math.equal(math.bignumber(0.1) + math.bignumber(0.2), math.bignumber(0.3);

or using the expression parser:

math.config({number: 'bignumber'});

math.eval('0.1 + 0.2');        // returns BigNumber 0.3, not 0.30000000000000004
math.eval('0.1 + 0.2 == 0.3'); // returns true

Answer 3

Discontinuous functions such as equality (but also floor and ceil) are badly affected by rounding errors, and taking an epsilon into account may work in some cases, but may also give an incorrect answer (eg abs(xy) < eps may return true while the exact value of x and y are really different); you should do an error analysis to make sure that it is OK. There is no general way to solve the problem in floating point: this depends on your application. If your inputs are decimal numbers and you just use addition, subtraction and multiplication, a decimal floating-point arithmetic may be OK if the precision is large enough so that all your data can be represented exactly. You can also use a rational arithmetic, such as big-rational (not tried).