Analysis of floating point computing problems in js

Analysis of floating point computing problems in js

This article mainly introduces the problem of floating point operations in js. If you need it, please refer to it and hope to help you.

How is the floating point calculation in js?

 

For example, var a = 0.69;

 

I want to get 6.9 to write var c = a * 10 directly like this;

 

Alert (c); the result is 6.8999999999999995.

 

After a search on the Internet, some netizens said this was a JS floating point number calculation Bug and found a solution:

 

Method 1: javascript UDF

The Code is as follows:

<Script>

 

// 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 );

}

 

// 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 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 );

}

 

Var a = 0.69;

Var B = 10;

Alert (a * B); // 6.8999999999999995

Alert (a * 100)/10 );

</Script>

 

 

You can call a function directly.

 

Method 2: If you know the number of decimal places, you can consider extending the floating point number to an integer (and then dividing it by the corresponding multiples) Before performing operations, in this way, we can get the correct result.

 

Alert (11*22.9); // get 251.89999999999998

Alert (11 * (22.9*10)/10); // get 251.9