Adding float values in javascript

Question

I have had problems with the conditional 0.1 + 0.2 !== 0.3. I tried 0.0001 + 0.0002 and this not equal 0.03. As I know, we can use toFixed to solve this problem. But is there any solution to resolve this problem dynamically? Because with 0.1 + 0.2 we use toFixed(2) and 0.0001 + 0.0002 uses toFixed(4).

Answer 1

You could extend Math to include a function to do the math. The below takes two floats, determines the greatest number of decimal places and then based on that does the math then does a toFixed using the greatest number of decimal places.

Math.addFloats = function (f1,f2){
   //Helper function to find the number of decimal places
   function findDec(dec){
     var count = 0;
     while(dec%1){
       dec*=10;
       count++;
     }
     return count;
   }
   //Determine the greatest number of decimal places
   var dec1 = findDec(f1);
   var dec2 = findDec(f2);
   var fixed = dec1>dec2 ? dec1 : dec2;

   //do the math then do a toFixed, could do a toPrecision also
   var n = (f1+f2).toFixed(fixed);
   return +n;
}
console.log( Math.addFloats(0.1,0.2) == 0.3 ); //evaluates to true
console.log( Math.addFloats(1/3,1/7) ); //prints 0.47619047619047616
console.log( 1/3 + 1/7 ); //prints 0.47619047619047616

Havent fully tested it but doing some preliminary tests shows it works dynamically, could probably modify it to do other maths, but would probably have to change the decimal count check when doing divides/multiples etc

NOTE: this does not seem to count decimal places well for e notation, ie 2e-14 results in like 30, when it should be 14

EDIT: changing the findDec function to this answers version of finding decimals places seems to be better at determining the correct number of decimal places for different types of numbers

   function findDec(f1){
      function isInt(n){
         return typeof n === 'number' && 
            parseFloat(n) == parseInt(n, 10) && !isNaN(n);
      }
      var a = Math.abs(f1);
      f1 = a, count = 1;
      while(!isInt(f1) && isFinite(f1)){
         f1 = a * Math.pow(10,count++);
      }
      return count-1;
    }

Answer 2

(a) if you are dealing with (say) dollars, the best sol'n is to do everything in cents, using ints. (This only works if you never deal with fractions of a penny.)

(b) in any language, treat doubles/floats as "a good approximation of the actual value", and never compare with ==. Instead write a helper

double nearlyEqual(x,y,tolerance=0.00001) { return abs(x-y) < tolerance*max(abs(x),abs(y)); }

(warning: untested code).

Answer 3

Thank @Patrick so much. I have create a new code to add multiple float numbers based on your code. It's:

/**
 * Find the number of decimal places
 * @method findDec
 * @param {Float|Number} dec
 * @return {Number}
 */
var findDec = function (dec) {
    var count = 0;
    while (dec % 1) {
        dec *= 10;
        count++;
    }

    return count;
};

/**
 * Find the greatest number of decimal places
 * @method findFixed
 * @param {Float|Number} dec
 * @return {Number}
 */
var findFixed = function () {
    var fixed = [];
    for (var i = 0, arg; arg = arguments[i]; i++) {
        fixed.push(findDec(arg));
    }

    return Math.max.apply(this, fixed)
};

/**
 * Calculate total
 * @method findFixed
 * @param {Float|Number}
 * @return {Float|Number}
 */
var calculate = function () {
    var total = 0;

    for (var i = 0, arg; arg = arguments[i]; i++) {
        total += arg;
    }

    return total;
}

/**
 * Add float number
 * @method addNumber
 * @param {Float|Number}
 * @return {Float|Number}
 */
Math.addNumber = function() {
    //Determine the greatest number of decimal places
    var fixed = findFixed.apply(this, arguments);
    var total = calculate.apply(this, arguments);

    //do the math then do a toFixed, could do a toPrecision also
    return +total.toFixed(fixed);
}

Answer 4

use Number.prototype with custom like this :

Number.prototype.lenDecimalPoint = function(val){
            var decStr = val.toString().match(/\.\d*/);
            if(decStr && decStr.length > 0) {
                return decStr[0].replace().replace('.','').length;
            } else {
                return 0;
            }
        }

    Number.prototype.getVal = function(val, stdDec10Val){
            var dec10ValLog = Math.log10(stdDec10Val);
            var thisValDecPoint = this.lenDecimalPoint(val);
            var thisValStr = val.toString();
            thisValStr = thisValStr.replace('/^0\./','');
            thisValStr = thisValStr.replace('.','');
            thisValStr += Math.pow(10 ,dec10ValLog - thisValDecPoint).toString().replace('1','');
            return Number(thisValStr);
        }

    Number.prototype.getDec10Val = function(val1, val2){
            var thisDecPoint = this.lenDecimalPoint(val1);
            var newNumValDecPoint = this.lenDecimalPoint(val2);
            var decPoint = thisDecPoint > newNumValDecPoint ? thisDecPoint : newNumValDecPoint;
            return Math.pow(10,decPoint);
        }

    Number.prototype.add = function(newVal) {

            newVal = Number(newVal)

            var dec10Val = this.getDec10Val(this, newVal);
            var thisIntVal = this.getVal(this, dec10Val);
            var newIntVal = this.getVal(newVal,dec10Val);

            return Number(((thisIntVal) + (newIntVal))/dec10Val);
        }
    Number.prototype.sub = function(newVal) {

            newVal = Number(newVal)

            var dec10Val = this.getDec10Val(this, newVal);
            var thisIntVal = this.getVal(this, dec10Val);
            var newIntVal = this.getVal(newVal,dec10Val);

            return Number(((thisIntVal) - (newIntVal))/dec10Val);
        }
    Number.prototype.div = function(newVal) {

            newVal = Number(newVal)

            var dec10Val = this.getDec10Val(this, newVal);
            var thisIntVal = this.getVal(this, dec10Val);
            var newIntVal = this.getVal(newVal,dec10Val);

            return Number(((thisIntVal) / (newIntVal)));
        }
    Number.prototype.mul = function(newVal) {

            newVal = Number(newVal)

            var dec10Val = this.getDec10Val(this, newVal);
            var thisIntVal = this.getVal(this, dec10Val);
            var newIntVal = this.getVal(newVal,dec10Val);


            return Number((thisIntVal * newIntVal)/Math.pow(dec10Val,2));
        }

usage:

(0.1).add(0.3)