We Keep Coding

How to get floating value of numbers in javascript?

I'm trying to get a number to the nth decimal place without rounding off
The closest I could find was from this source
num = num.toString(); //If it's not already a String
num = num.slice(0, (num.indexOf("."))+3); //With 3 exposing the hundredths place
Number(num); //If you need it back as a Number
but it has it's limitations
this is what I'm trying to achieve:
if n=3
16 -> 16.000
16.000001 -> 16.000
16.12345 -> 16.123
4239.20902190 -> 4239.209
I'm trying to stay way from a mathematical approach and rather use a string approach as mathematical approaches sometimes become unpredictable, so is there any modern way of achieving the desired results?
I may have put an incorrect title to the problem so any edit is welcome

If you multiply a number by 10, then use Math.floor to remove everything after the decimal place, THEN divide by 10, you get the value of the original number to one decimal place with no rounding. If instead of 10 you use 100, it'll be 2 decimal places. 1000 makes 3, 10000-4, etc.
Then using number.prototype.ToFixed(n), we can get a string out that will always have n decimal places.
Combining these together you get something like:
function toDecimalPlaceWithoutRounding(number, precision) {
const factor = 10 ** precision; // "x ** y" means x to the power of y
const value = Math.floor(number * factor) / factor;
return value.toFixed(precision);
}
a quick test of this:
function toDecimalPlaceWithoutRounding(number, precision) {
const factor = 10 ** precision;
const value = Math.floor(number * factor) / factor;
return value.toFixed(precision);
}
for (let i = 0; i < 10; i++) {
const number = Math.random() * 20;
const result = toDecimalPlaceWithoutRounding(number, 3);
console.log(number,result);
}
NOTE you could just use .toFixed, but it will round. eg. (3.555).toFixed(2) will give "3.56".
EDIT negative support:
function toDecimalPlaceWithoutRounding(number, precision) {
const factor = 10 ** precision;
const roundFunc = number > 0 ? Math.floor : Math.ceil; // use floor for positive numbers, ceil for negative
const value = roundFunc(number * factor) / factor;
return value.toFixed(precision);
}
for (let i = 0; i < 10; i++) {
const number = Math.random() * 20 - 10;
const result = toDecimalPlaceWithoutRounding(number, 3);
console.log(number,result);
}

So I found the solution thanks to #Callum Morrisson
by using Math.trunc():
function toPrecision(num,precision)
{
num=Math.trunc(num*10**precision)/10**precision;
return num;
}
console.log(toPrecision(-21873212130.119281231231231,4))
jsfiddle here

This can be achieved by 10**n and Math.round()
function roundWithPrecision(num,n){
//return Math.round(num * 10 ** n)/(10**n)
return Math.floor(num * 10 ** n)/(10**n)
}
A test of the function:
a=roundWithPrecision(16.12345,4)
16.1234
b=roundWithPrecision(16.123456,5)
16.12346

How to format float?

I have float numbers:
var a = parseFloat("12.999");
var b = parseFloat("14");
And I want to display them as:
12.99
14.00 -> with zeros
But without round, only truncate. How to do it?

You use a combination of the Math.floor() and Number.prototype.toFixed() function, like this:
console.log((Math.floor(a * 100) * 0.01).toFixed(2));
console.log((Math.floor(b * 100) * 0.01).toFixed(2));
Math.floor() will truncate the value to the closest lower integer. That is why you need to first multiply by 100 and then multiply by 0.01.
Number.prototype.toFixed() will format your output using a set number of decimals.
Most languages do have functions called round, ceil, floor or similar ones, but almost all of them round to the nearest integer, so the multiply-round-divide chain (or divide-round-multiply for rounding to tens, hundreds, thousands...) is a good pattern to know.

You can first truncat the part, you do not need.
function c(x, p) {
return ((x * Math.pow(10, p) | 0) / Math.pow(10, p)).toFixed(p);
}
document.write(c(12.999, 2) + '<br>');
document.write(c(14, 2));

JavaScript math, round to two decimal places [duplicate]

This question already has answers here:
How to round to at most 2 decimal places, if necessary
(91 answers)
Closed 5 years ago.
I have the following JavaScript syntax:
var discount = Math.round(100 - (price / listprice) * 100);
This rounds up to the whole number. How can I return the result with two decimal places?

NOTE - See Edit 4 if 3 digit precision is important
var discount = (price / listprice).toFixed(2);
toFixed will round up or down for you depending on the values beyond 2 decimals.
Example: http://jsfiddle.net/calder12/tv9HY/
Documentation: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed
Edit - As mentioned by others this converts the result to a string. To avoid this:
var discount = +((price / listprice).toFixed(2));
Edit 2- As also mentioned in the comments this function fails in some precision, in the case of 1.005 for example it will return 1.00 instead of 1.01. If accuracy to this degree is important I've found this answer: https://stackoverflow.com/a/32605063/1726511 Which seems to work well with all the tests I've tried.
There is one minor modification required though, the function in the answer linked above returns whole numbers when it rounds to one, so for example 99.004 will return 99 instead of 99.00 which isn't ideal for displaying prices.
Edit 3 - Seems having the toFixed on the actual return was STILL screwing up some numbers, this final edit appears to work. Geez so many reworks!
var discount = roundTo((price / listprice), 2);
function roundTo(n, digits) {
if (digits === undefined) {
digits = 0;
}
var multiplicator = Math.pow(10, digits);
n = parseFloat((n * multiplicator).toFixed(11));
var test =(Math.round(n) / multiplicator);
return +(test.toFixed(digits));
}
See Fiddle example here: https://jsfiddle.net/calder12/3Lbhfy5s/
Edit 4 - You guys are killing me. Edit 3 fails on negative numbers, without digging into why it's just easier to deal with turning a negative number positive before doing the rounding, then turning it back before returning the result.
function roundTo(n, digits) {
var negative = false;
if (digits === undefined) {
digits = 0;
}
if (n < 0) {
negative = true;
n = n * -1;
}
var multiplicator = Math.pow(10, digits);
n = parseFloat((n * multiplicator).toFixed(11));
n = (Math.round(n) / multiplicator).toFixed(digits);
if (negative) {
n = (n * -1).toFixed(digits);
}
return n;
}
Fiddle: https://jsfiddle.net/3Lbhfy5s/79/

If you use a unary plus to convert a string to a number as documented on MDN.
For example:+discount.toFixed(2)

The functions Math.round() and .toFixed() is meant to round to the nearest integer. You'll get incorrect results when dealing with decimals and using the "multiply and divide" method for Math.round() or parameter for .toFixed(). For example, if you try to round 1.005 using Math.round(1.005 * 100) / 100 then you'll get the result of 1, and 1.00 using .toFixed(2) instead of getting the correct answer of 1.01.
You can use following to solve this issue:
Number(Math.round(100 - (price / listprice) * 100 + 'e2') + 'e-2');
Add .toFixed(2) to get the two decimal places you wanted.
Number(Math.round(100 - (price / listprice) * 100 + 'e2') + 'e-2').toFixed(2);
You could make a function that will handle the rounding for you:
function round(value, decimals) {
return Number(Math.round(value + 'e' + decimals) + 'e-' + decimals);
}
Example:
https://jsfiddle.net/k5tpq3pd/36/
Alternative
You can add a round function to Number using prototype. I would not suggest adding .toFixed() here as it would return a string instead of number.
Number.prototype.round = function(decimals) {
return Number((Math.round(this + "e" + decimals) + "e-" + decimals));
}
and use it like this:
var numberToRound = 100 - (price / listprice) * 100;
numberToRound.round(2);
numberToRound.round(2).toFixed(2); //Converts it to string with two decimals
Example
https://jsfiddle.net/k5tpq3pd/35/
Source: http://www.jacklmoore.com/notes/rounding-in-javascript/

To get the result with two decimals, you can do like this :
var discount = Math.round((100 - (price / listprice) * 100) * 100) / 100;
The value to be rounded is multiplied by 100 to keep the first two digits, then we divide by 100 to get the actual result.

The best and simple solution I found is
function round(value, decimals) {
return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}
round(1.005, 2); // 1.01

try using discount.toFixed(2);

I think the best way I've seen it done is multiplying by 10 to the power of the number of digits, then doing a Math.round, then finally dividing by 10 to the power of digits. Here is a simple function I use in typescript:
function roundToXDigits(value: number, digits: number) {
value = value * Math.pow(10, digits);
value = Math.round(value);
value = value / Math.pow(10, digits);
return value;
}
Or plain javascript:
function roundToXDigits(value, digits) {
if(!digits){
digits = 2;
}
value = value * Math.pow(10, digits);
value = Math.round(value);
value = value / Math.pow(10, digits);
return value;
}

A small variation on the accepted answer.
toFixed(2) returns a string, and you will always get two decimal places. These might be zeros. If you would like to suppress final zero(s), simply do this:
var discount = + ((price / listprice).toFixed(2));
Edited:
I've just discovered what seems to be a bug in Firefox 35.0.1, which means that the above may give NaN with some values.
I've changed my code to
var discount = Math.round(price / listprice * 100) / 100;
This gives a number with up to two decimal places. If you wanted three, you would multiply and divide by 1000, and so on.
The OP wants two decimal places always, but if toFixed() is broken in Firefox it needs fixing first.
See https://bugzilla.mozilla.org/show_bug.cgi?id=1134388

Fastest Way - faster than toFixed():
TWO DECIMALS
x = .123456
result = Math.round(x * 100) / 100 // result .12
THREE DECIMALS
x = .123456
result = Math.round(x * 1000) / 1000 // result .123

function round(num,dec)
{
num = Math.round(num+'e'+dec)
return Number(num+'e-'+dec)
}
//Round to a decimal of your choosing:
round(1.3453,2)

Here is a working example
var value=200.2365455;
result=Math.round(value*100)/100 //result will be 200.24

To handle rounding to any number of decimal places, a function with 2 lines of code will suffice for most needs. Here's some sample code to play with.
var testNum = 134.9567654;
var decPl = 2;
var testRes = roundDec(testNum,decPl);
alert (testNum + ' rounded to ' + decPl + ' decimal places is ' + testRes);
function roundDec(nbr,dec_places){
var mult = Math.pow(10,dec_places);
return Math.round(nbr * mult) / mult;
}

JavaScript math calculation

I need to perform a math calculation in JavaScript that I am unsure how to do so.
The formula is as follows:
result = (scale * weighting) / 2
where the result I will need to two decimal places.
Example formula that I need to do in JavaScript might be:
result = ((3 * 2) + (2 * 1.5)) / 2
I am also unsure if I have to also convert this to int.

toFixed:
function algorithm(scale, weighting) {
var result = (scale * weighting) / 2;
return result.toFixed(2);
}
Or if you need an integer, parseInt:
parseInt(result, 10);

Not entirely sure what you want, but this might help:
result = Math.round(((scale * weighting) / 2) * 100) / 100;
http://jsfiddle.net/kQpma/

In JavaScript everything number is a floating point number. No explicit type conversion needed.
ref : http://oreilly.com/javascript/excerpts/learning-javascript/javascript-datatypes-variables.html ( search for "The Number Data Type" )

javascript: calculate x% of a number

I am wondering how in javascript if i was given a number (say 10000) and then was given a percentage (say 35.8%)
how would I work out how much that is (eg 3580)

var result = (35.8 / 100) * 10000;
(Thank you jball for this change of order of operations. I didn't consider it).

This is what I would do:
// num is your number
// amount is your percentage
function per(num, amount){
return num*amount/100;
}
...
<html goes here>
...
alert(per(10000, 35.8));

Your percentage divided by 100 (to get the percentage between 0 and 1) times by the number
35.8/100*10000

Best thing is to memorize balance equation in natural way.
Amount / Whole = Percentage / 100
usually You have one variable missing, in this case it is Amount
Amount / 10000 = 35.8 / 100
then you have high school math (proportion) to multiple outer from both sides and inner from both sides.
Amount * 100 = 358 000
Amount = 3580
It works the same in all languages and on paper. JavaScript is no exception.

I use two very useful JS functions:
http://blog.bassta.bg/2013/05/rangetopercent-and-percenttorange/
function rangeToPercent(number, min, max){
return ((number - min) / (max - min));
}
and
function percentToRange(percent, min, max) {
return((max - min) * percent + min);
}

If you want to pass the % as part of your function you should use the following alternative:
<script>
function fpercentStr(quantity, percentString)
{
var percent = new Number(percentString.replace("%", ""));
return fpercent(quantity, percent);
}
function fpercent(quantity, percent)
{
return quantity * percent / 100;
}
document.write("test 1: " + fpercent(10000, 35.873))
document.write("test 2: " + fpercentStr(10000, "35.873%"))
</script>

In order to fully avoid floating point issues, the amount whose percent is being calculated and the percent itself need to be converted to integers. Here's how I resolved this:
function calculatePercent(amount, percent) {
const amountDecimals = getNumberOfDecimals(amount);
const percentDecimals = getNumberOfDecimals(percent);
const amountAsInteger = Math.round(amount + `e${amountDecimals}`);
const percentAsInteger = Math.round(percent + `e${percentDecimals}`);
const precisionCorrection = `e-${amountDecimals + percentDecimals + 2}`; // add 2 to scale by an additional 100 since the percentage supplied is 100x the actual multiple (e.g. 35.8% is passed as 35.8, but as a proper multiple is 0.358)
return Number((amountAsInteger * percentAsInteger) + precisionCorrection);
}
function getNumberOfDecimals(number) {
const decimals = parseFloat(number).toString().split('.')[1];
if (decimals) {
return decimals.length;
}
return 0;
}
calculatePercent(20.05, 10); // 2.005
As you can see, I:
Count the number of decimals in both the amount and the percent
Convert both amount and percent to integers using exponential notation
Calculate the exponential notation needed to determine the proper end value
Calculate the end value
The usage of exponential notation was inspired by Jack Moore's blog post. I'm sure my syntax could be shorter, but I wanted to be as explicit as possible in my usage of variable names and explaining each step.

It may be a bit pedantic / redundant with its numeric casting, but here's a safe function to calculate percentage of a given number:
function getPerc(num, percent) {
return Number(num) - ((Number(percent) / 100) * Number(num));
}
// Usage: getPerc(10000, 25);

var number = 10000;
var result = .358 * number;

Harder Way (learning purpose) :
var number = 150
var percent= 10
var result = 0
for (var index = 0; index < number; index++) {
const calculate = index / number * 100
if (calculate == percent) result += index
}
return result