Summary of JavaScript floating point number and Operation precision adjustment

JavaScript has only one numeric type Number, and all numbers in Javascript are represented in IEEE-754 standard format. The precision of floating point numbers is not unique to JavaScript, because some decimals represent infinite digits in binary format.

Decimal binary
0.1 0.0001 1001 1001 1001...
0.2 0.0011 0011 0011 0011...
0.3 0.0100 1100 1100 1100...
0.4 0.0110 0110 0110 0110...
0.5 0.1
0.6 0.1001 1001 1001 1001...
For example, if 1.1 is used, the program cannot really represent '1. 1 & prime; but can only be accurate to a certain extent. This is an unavoidable loss of precision: 1.09999999999999999.
The problem in JavaScript is more complicated. Here we only give some test data in Chrome:
Console. log (1.0-0.9 = 0.1) // false
Console. log (1.0-0.8 = 0.2) // false
Console. log (1.0-0.7 = 0.3) // false
Console. log (1.0-0.6 = 0.4) // true
Console. log (1.0-0.5 = 0.5) // true
Console. log (1.0-0.4 = 0.6) // true
Console. log (1.0-0.3 = 0.7) // true
Console. log (1.0-0.2 = 0.8) // true
Console. log (1.0-0.1 = 0.9) // true
How can we avoid this type of 1.0-0.9! = What happens to 0.1 of non-bug issues? The following provides a more widely used solution. The accuracy of the computing result is reduced before the floating point calculation result is judged, because the accuracy is automatically rounded down:
(1.0-0.9). toFixed (digits) // toFixed () the accuracy parameter digits must be between 0 and 20
Console. log (parseFloat (1.0-0.9). toFixed (10) === 0.1) // true
Console. log (parseFloat (1.0-0.8). toFixed (10) === 0.2) // true
Console. log (parseFloat (1.0-0.7). toFixed (10) === 0.3) // true
Console. log (parseFloat (11.0-11.8). toFixed (10) ===- 0.8) // true
Write a method:
// Use the isEqual tool to determine whether the values are equal
Function isEqual (number1, number2, digits ){
Digits = undefined? 10: digits; // The default precision is 10.
Return number1.toFixed (digits) === number2.toFixed (digits );
}
Console. log (isEqual (1.0-0.7, 0.3); // true
// Prototype extension method, prefer the object-oriented style
Number. prototype. isEqual = function (number, digits ){
Digits = undefined? 10: digits; // The default precision is 10.
Return this. toFixed (digits) === number. toFixed (digits );
}
Console. log (1.0-0.7). isEqual (0.3); // true
Next, let's try the floating point operation,
Console. log (1.79 + 0.12) // 1.9100000000000001
Console. log (2.01-0.12) // 1.8899999999999997
Console. log (1.01*1.3) // 1.3130000000000002
Console. log (0.69/10) // 0.06899999999999999
Solution:
// Addition function, used to obtain accurate addition results
// Note: The addition result of javascript has an error, which is obvious when two floating point numbers are added. This function returns a more accurate addition result.
// Call: accAdd (arg1, arg2)
// Return value: the exact result of adding arg2 to arg1
Function accAdd (arg1, arg2 ){
Var r1, r2, m;
Try {r1 = arg1.toString (). split (".") [1]. length} catch (e) {r1 = 0}
Try {r2 = arg2.toString (). split (".") [1]. length} catch (e) {r2 = 0}
M = Math. pow (10, Math. max (r1, r2 ))
Return (arg1 * m + arg2 * m)/m
}
// Add an add method to the Number type to facilitate calling.
Number. prototype. add = function (arg ){
Return accAdd (arg, this );
}
 
// Subtraction function, used to obtain the exact subtraction result
// Note: The addition result of javascript has an error, which is obvious when two floating point numbers are added. This function returns a more precise subtraction result.
// Call: accSub (arg1, arg2)
// Return value: the exact result of arg1 minus arg2
Function accSub (arg1, arg2 ){
Var r1, r2, m, n;
Try {r1 = arg1.toString (). split (".") [1]. length} catch (e) {r1 = 0}
Try {r2 = arg2.toString (). split (".") [1]. length} catch (e) {r2 = 0}
M = Math. pow (10, Math. max (r1, r2 ));
// Last modify by deeka
// Dynamically control the precision length
N = (r1> = r2 )? R1: r2;
Return (arg1 * m-arg2 * m)/m). toFixed (n );
}
// Division function, used to obtain accurate division results
// Note: The division result of javascript has an error, which is obvious when two floating point numbers are separated. This function returns a more precise division result.
// Call: accDiv (arg1, arg2)
// Return value: the exact result of dividing arg1 by arg2
Function accDiv (arg1, arg2 ){
Var t1 = 0, t2 = 0, r1, r2;
Try {t1 = arg1.toString (). split (".") [1]. length} catch (e ){}
Try {t2 = arg2.toString (). split (".") [1]. length} catch (e ){}
With (Math ){
R1 = Number (arg1.toString (). replace (".",""))
R2 = Number (arg2.toString (). replace (".",""))
Return (r1/r2) * pow (10, T2-T1 );
  }
}
// Add a div method to the Number type to facilitate calling.
Number. prototype. div = function (arg ){
Return accDiv (this, arg );
}
 
// Multiplication function, used to obtain accurate multiplication results
// Note: There is an error in the javascript multiplication result, which is obvious when two floating point numbers are multiplied. This function returns a more accurate multiplication result.
// Call: accMul (arg1, arg2)
// Return value: the exact result of multiplying arg1 by arg2
Function accMul (arg1, arg2 ){
Var m = 0, s1 = arg1.toString (), s2 = arg2.toString ();
Try {m + = s1.split (".") [1]. length} catch (e ){}
Try {m + = s2.split (".") [1]. length} catch (e ){}
Return Number (s1.replace (".", "") * Number (s2.replace (".", "")/Math. pow (10, m)
}
// Add a mul method to the Number type to facilitate calling.
Number. prototype. mul = function (arg ){
Return accMul (arg, this );
}
<Br> // verify the following:
Console. log (accAdd (1.79, 0.12); // 1.91
Console. log (accSub (2.01, 0.12); // 1.89
Console. log (accDiv (0.69, 10); // 0.069 <br> console. log (accMul (1.01, 1.3); // 1.313
After the transformation, you can happily perform the floating point addition, subtraction, multiplication, division operation ~