The precision of digital computing in JS

The problem is this:
37.5*5.5=206.08 (JS figure out is such a result, I rounded to take two decimal places)
I first suspect is rounding the problem, directly with JS calculate a result is: 206.08499999999998
How can this, two numbers only one decimal number multiplied, how can more such a decimal point out.
I googled it and found that it was a bug in JavaScript floating-point arithmetic.
For example: 7*0.8 JavaScript figure out is: 5.6000000000000005
Some solutions have been found on the Internet, that is, the functions of some floating-point operations have been written back.
Here's an excerpt of these methods for a friend who encounters the same problem:

Program code


The Division function, which is used to get the exact division result
Description: JavaScript division results will be error, the two floating-point numbers are more obvious when dividing. This function returns a more precise division result.
Call: Accdiv (ARG1,ARG2)
Return value: Arg1 divided by Arg2 's exact result

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);
}
}
Adding a Div method to the number type is more convenient to call.
Number.prototype.div = function (ARG) {
Return Accdiv (this, ARG);
}
multiplication function to get the exact result of the multiplication
Description: JavaScript multiplication results will be error, in two floating-point numbers are more obvious when multiplying. This function returns a more accurate result of the multiplication.
Call: Accmul (ARG1,ARG2)
return value: Arg1 times Arg2 's exact result
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)
}
Adding a Mul method to the number type is more convenient to call.
Number.prototype.mul = function (ARG) {
Return Accmul (ARG, this);
}
The addition function, which is used to get the exact addition result.
Description: JavaScript addition results will be error, in two floating-point number added when it is more obvious. This function returns a more precise addition result.
Call: Accadd (ARG1,ARG2)
return value: Arg1 plus arg2 's exact result
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
}
Adding an Add method to the number type is more convenient to call.
Number.prototype.add = function (ARG) {
Return Accadd (Arg,this);
}


It is OK to include these functions in the place you want to use and then call it to compute.
For example you want to calculate: 7*0.8, then change to (7). Mul (8)
Other operations are similar, you can get more accurate results.

--------------------------------------------------------------------------------------------------------------- ---------------------------------------------
The above is on the Internet a JS cow on the blog reprinted, but the above mentioned only the addition, multiplication and division solutions.
At this time, many people may think, with addition, subtraction is not easy. I almost let this idea suffer.
The rest is not much to say,
To post a subtraction code:



function Subtr (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
Dynamic Control Precision Length
N= (R1>=R2) r1:r2;
Return ((arg1*m-arg2*m)/m). ToFixed (n);
}