Summary of JavaScript floating-point number and operation precision Adjustment

Summary of JavaScript floating-point number and operation precision Adjustment

JavaScript has only one numeric type number, and all the numbers in JavaScript are represented in the IEEE-754 standard format. The accuracy of floating-point numbers is not specific to JavaScript, because some decimals are in binary notation and the number of bits is infinite.

Source: thewalker|2015-12-02 10:21

Mobile collection Sharing

"Technology salon" AI developer Combat Camp-7 minutes to build 1 custom skills. July 22, we wait for you together!

JavaScript has only one numeric type number, and all the numbers in JavaScript are represented in the IEEE-754 standard format. the accuracy of floating-point numbers is not specific to JavaScript, because some decimals are in binary notation and the number of bits is infinite .

2. Decimal binary binary
4. 0.1 0.0001 1001 1001 1001 ...
6. 0.2 0.0011 0011 0011 0011 ...
8. 0.3 0.0100 1100 1100 1100 ...
10. 0.4 0.0110 0110 0110 0110 ...
12. 0.5 0.1
14. 0.6 0.1001 1001 1001 1001 ...

So for example, 1.1, its program actually can not really represent ' 1.1′, but only to a certain degree of accuracy, which is unavoidable loss of precision: 1.09999999999999999

The problem in JavaScript is even more complicated, and here are just a few things to test in chrome:

2. Console.log (1.0-0.9 = = 0.1) //false
4. Console.log (1.0-0.8 = = 0.2) //false
6. Console.log (1.0-0.7 = = 0.3) //false
8. Console.log (1.0-0.6 = = 0.4) //true
10. Console.log (1.0-0.5 = = 0.5) //true
12. Console.log (1.0-0.4 = = 0.6) //true
14. Console.log (1.0-0.3 = = 0.7) //true
16. Console.log (1.0-0.2 = = 0.8) //true
18. Console.log (1.0-0.1 = = 0.9) //true

So how to avoid this kind of 1.0-0.9! = 0.1 Non-bug problem occurs? Here is a more current solution, before judging the results of floating-point calculations to reduce the accuracy of the results, because in the process of precision reduction will always automatically rounded:

2. (1.0-0.9). toFixed (digits) //toFixed () precision parameter digits must be between 0 and 20
4. Console.log (parsefloat (1.0-0.9) toFixed ()= = = 0.1 ) //true
6. Console.log (parsefloat (1.0-0.8) toFixed ()= = = 0.2 ) //true
8. Console.log (parsefloat (1.0-0.7) toFixed ()= = = 0.3 ) //true
10. Console.log (parsefloat (11.0-11.8) toFixed ()= = =-0.8) //true

Write a method:

2. Determine if the values are equal by using the IsEqual tool method
4. function IsEqual (number1, number2, digits) {
6. digits = digits = = undefined? 10:digits; //default accuracy is ten
8. return number1.tofixed (digits) = = = Number2.tofixed (digits);
10. }
12. Console.log (isequal (1.0-0.7, 0.3)); //true
14. Prototype extension mode, prefer object-oriented style
16. Number.prototype.isEqual = function (number, digits) {
18. digits = digits = = undefined? 10:digits; //default accuracy is ten
20. return this.tofixed (digits) = = = Number.tofixed (digits);
22. }
24. Console.log ((1.0-0.7). IsEqual (0.3)); //true

Next, try floating-point arithmetic,

1. Console.log (1.79+0.12) //1.9100000000000001
2. Console.log (2.01-0.12) //1.8899999999999997
3. Console.log (1.01*1.3) //1.3130000000000002
4. Console.log (0.69/) //0.06899999999999999

Solution:

2. An addition function that is used to obtain accurate addition results
4. Note: the addition of JavaScript will have an error, and it will be more obvious when the two floating-point numbers are added. This function returns a more accurate addition result.
6. Call: Accadd (ARG1,ARG2)
8. return value: Arg1 plus arg2 's exact result
10. function Accadd (ARG1,ARG2) {
12. var r1,r2,m;
14. try{r1=arg1.tostring (). Split (".") [1].length} catch (E) {r1=0}
16. try{r2=arg2.tostring (). Split (".") [1].length} catch (E) {r2=0}
18. M=math.pow (10,math.max (R1,R2))
20. return (arg1*m+arg2*m)/M
22. }
24. Adding an Add method to the number type makes it more convenient to call.
26. Number.prototype.add = function (ARG) {
28. return Accadd (ARG, this);
30. }
34. Subtraction function, which is used to get the exact subtraction result
36. Note: the addition of JavaScript will have an error, and it will be more obvious when the two floating-point numbers are added. This function returns a more accurate subtraction result.
38. Call: Accsub (ARG1,ARG2)
40. return value: Arg1 minus arg2 's exact result
42. function Accsub (ARG1,ARG2) {
44. var r1,r2,m,n;
46. try{r1=arg1.tostring (). Split (".") [1].length} catch (E) {r1=0}
48. try{r2=arg2.tostring (). Split (".") [1].length} catch (E) {r2=0}
50. M=math.pow (10,math.max (R1,R2));
52. //last Modify by Deeka
54. //Dynamic control accuracy length
56. N= (R1>=R2) r1:r2;
58. return ((arg1*m-arg2*m)/m). ToFixed (n);
60. }

2. The Division function, which is used to get accurate division results.
4. Description: The result of the division of JavaScript will be error, which will be obvious when dividing two floating-point numbers. This function returns a more accurate division result.
6. Call: Accdiv (ARG1,ARG2)
8. Return value: Arg1 divided by the exact result of arg2
10. function Accdiv (ARG1,ARG2) {
12. var t1=0,t2=0,r1,r2;
14. try{t1=arg1.tostring (). Split (".") [1].length} catch (e) {}
16. try{t2=arg2.tostring (). Split (".") [1].length} catch (e) {}
18. With (Math) {
20. R1=number (Arg1.tostring (). Replace (".",""))
22. R2=number (Arg2.tostring (). Replace (".",""))
24. return (R1/R2) *pow (10,t2-t1);
26. }
28. }
30. Adding a Div method to the number type makes it easier to call.
32. Number.prototype.div = function (ARG) {
34. return Accdiv (this, arg);
36. }
40. multiplication function to get the exact multiplication result
42. Description: JavaScript multiplication results are error-evident when multiplying two floating-point numbers. This function returns a more accurate multiplication result.
44. Call: Accmul (ARG1,ARG2)
46. return value: Arg1 times the exact result of arg2
48. function Accmul (ARG1,ARG2) {
50. var m=0,s1=arg1.tostring (), s2=arg2.tostring ();
52. try{m+=s1.split (".") [1].length} catch (e) {}
54. try{m+=s2.split (".") [1].length} catch (e) {}
56. return Number (S1.replace (".", "")) *number (s2.replace (".", ""))/math.pow (10,m)
58. }
60. Adding a Mul method to the number type makes it more convenient to call.
62. Number.prototype.mul = function (ARG) {
64. return Accmul (ARG, this );
66. }
68. <br>//verify:
70. Console.log (Accadd (1.79, 0.12)); //1.91
72. Console.log (Accsub (2.01, 0.12)); //1.89
74. Console.log (Accdiv (0.69, 10));   //0.069<br>console.log (Accmul (1.01, 1.3)); 1.313

After the transformation, you can happily carry out the floating point subtraction operation ~

"Editor's recommendation"

1. 25 free resources that are useful to JavaScript novice programmers
2. JavaScript modularization and Seajs source analysis
3. JavaScript design pattern Theory and actual combat: Observer pattern
4. The problem of JavaScript prototype chain and scope during interview
5. WordPress.com Open source, discard PHP instead of JavaScript

Summary of JavaScript floating-point number and operation precision Adjustment