Why the result is like this [duplicate] - javascript

This question already has answers here:
Is floating point math broken?
(31 answers)
Closed 4 years ago.
var tm=110;
var fm=200;
var pr=Math.ceil(tm/fm*100);
console.log(pr);
The result is showing 56.
But it should be 55
Note that
tm/fm*100 is resulting 55.0000001
But
When tm=100 and all fm=200 then the result is 50
I've solved that problem concedering upto 2 decimal places after point, I could not understand where from 1 is comming after some 0s!

Math.ceil() returns the smallest integer greater than or equal to a given number. See MDN Documentation.
Remove Math.ceil()
parseFloat() pr variable
Call Float's precision method toPrecision(8)
The extra 1 you are seeing is a result of binary floating point math. JavaScript does this. Source
<script>
var tm=110;
var fm=200;
var pr= parseFloat(tm/fm*100);
alert(pr.toPrecision(8)); // output: 55.00000000
</script>

Related

What's the deal with big number faulty arithematic in JS? [duplicate]

This question already has answers here:
What is JavaScript's highest integer value that a number can go to without losing precision?
(21 answers)
Large numbers erroneously rounded in JavaScript
(6 answers)
javascript large integer round because precision? (why?)
(2 answers)
Closed 1 year ago.
So, I found something I couldn't understand and can't find any internet resource that explains it.
Please see the code below:
var num = 35422484817926290
// subtract 5 from num
console.log(num-5)
Output (Wrong) : 35422484817926284
I checked it in Node, Opera, and Chrome, all of them give the wrong answers.
I do understand the fact that arithmetic with unsafe Integers in JS is faulty, for example:
console.log(100000000000000005-1)
Output (Wrong) : 100000000000000000
So what's the deal with big number arithmetic in JS?
When I run this code:
var num = 35422484817926290
// subtract 5 from num
console.log(num-5)
in Visual Studio Code, i get the following warning:
"Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."
So the correct way to make this calculation would be like this:
var num = 35422484817926290n
// subtract 5 from num
console.log(num-5n)
JavaScript is not faulty, this is how the Floating point arithmetic works. Looks duplicate to this post. For better calculation involving floating-point numbers you should use BigNumber API.

Javascript: Subtracting a whole integer from a integer with a decimal alters the decimal value? [duplicate]

This question already has answers here:
Is floating point math broken?
(31 answers)
Get decimal portion of a number with JavaScript
(29 answers)
Closed 3 years ago.
The goal is to isolate the decimal value (with simply turning the integer into a string and splitting it).
To that affect I have:
var x = 1001.1;
var roundedDown = Math.floor(x); // Produces 1001
var decimal = x - roundedDown;
The expected value of decimal should be 0.1 (1001.1 - 1001). But instead I get 0.0999999 recurring.
I have tried with Math.trunc as well but get the same results.
Would anyone know why this is?

"For" loop index not incrementing correctly [duplicate]

This question already has answers here:
Is floating point math broken?
(31 answers)
How to deal with floating point number precision in JavaScript?
(47 answers)
Closed 3 years ago.
When I run a “For” loop and I log the index used in it with increments of 0.1 , starting from 1, the outcome is not a number with a single decimal digit, but something with multiple decimal digits (code and results are shown here below).
for (let i = 1; i <= 2; i += 0.1) {
console.log(i);
};
What I expected is to see the following series:
1
1.1
1.2
1.3
...
instead what I actually get is:
1
1.1
1.2000000000000002
1.3000000000000003
1.4000000000000004
1.5000000000000004
1.6000000000000005
1.7000000000000006
1.8000000000000007
1.9000000000000008
This happens in every browser, in the same way either I compile the loop directly in the Console DOM or I code within Visual Studio Code.
Does anyone have an explanation about it?
Have you tried incrementing by 0.100000000000000?
Or using i = i.toFixed(1)? This will round the number to one decimal place. May not be what you need as toFixed will convert the number to a string

Rounding problems with calculate numbers in Javascript [duplicate]

This question already has answers here:
Is floating point math broken?
(31 answers)
Closed 8 years ago.
I've got the following problem when i'm counting in javascript.
var processAmount = parseFloat(166.98) - parseFloat(61.58);
The result is: 105.39999999999999
Doesnt matter if I use parseFloat() or not.
How can I solve this?
Sometimes floats numbers cannot be represented exactly in binary.
Try this:
var processAmount = parseFloat(166.98) - parseFloat(61.58);
processAmount.toFixed(2);
FROM: Javascript float subtract

How to get 12.6 with a=10.3 and b=2.3? [duplicate]

This question already has answers here:
How to deal with floating point number precision in JavaScript?
(47 answers)
Closed 8 years ago.
Tried :
var a=10.3;
var b=2.3;
alert(a+b);
but I get 12.600000000000001. I know JavaScript is loosely typed, but I hope I can do a sum :)
you can use toFixed() method also
var a=10.3;
var b=2.3;
alert((a+b).toFixed(1));​
Works in chrome
Multiply to the precision you want then round and divide by whatever you multiplied by:
var a=10.3;
var b=2.3;
alert(Math.round((a+b) * 10) / 10);
http://jsfiddle.net/DYKJB/3/
It's not about the typing but about the precision of floating point types. You need to round for presentation.
Floating point types are not a good choice if you need exact values. If you want to express currency values express them as cents or use an appropriate library for this.

Categories