4
\$\begingroup\$

JavaScript has some inaccurate rounding behavior so I've been looking for a reliable solution without success. There are many answers in this SO post but none cover all the edge cases as far as I can tell. I wrote the following which handles all the edge cases presented. Will it be reliable with edge cases I haven't tested?

If this is a viable solution, any enhancements to make it more efficient would be appreciated. It's not fast (time to run function 1000000 times: 778ms) but doesn't seem to be terrible either. If there is a better solution, please post.

The edge cases that seemed to give the most problem were the first two:

console.log(round(1.005, 2)); // 1.01
console.log(round(1234.00000254495, 10)); //1234.000002545
console.log(round(1835.665, 2)); // 1835.67))
console.log(round(-1835.665, 2)); // -1835.67))
console.log(round(10.8034, 2)); // 10.8
console.log(round(1.275, 2)); // 1.28
console.log(round(1.27499, 2)); // 1.27
console.log(round(1.2345678e+2, 2)); // 123.46
console.log(round(1234.5678, -1)); // 1230
console.log(round(1235.5678, -1)); // 1240
console.log(round(1234.5678, -2)); // 1200
console.log(round(1254.5678, -2)); // 1300
console.log(round(1254, 2)); // 1254
console.log(round("123.45")); // 123
console.log(round("123.55")); // 124

function round(number, precision) {
  precision = precision ? precision : 0;

  var sNumber = "" + number;
  var a = sNumber.split(".");
  if (a.length == 1 || precision < 0) {
    // from MDN https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
    var factor = Math.pow(10, precision);
    var tempNumber = number * factor;
    var roundedTempNumber = Math.round(tempNumber);
    return roundedTempNumber / factor;
  }
  // use one decimal place beyond the precision
  var factor = Math.pow(10, precision + 1);
  // separate out decimals and trim or pad as necessary
  var sDec = a[1].substr(0, precision + 1);
  if (sDec.length < precision + 1) {
    for (var i = 0; i < (precision - sDec.length); i++)
      sDec = sDec.concat("0");
  }
  // put the number back together
  var sNumber = a[0] + "." + sDec;
  var number = parseFloat(sNumber);
  // test the last digit
  var last = sDec.substr(sDec.length - 1);
  if (last >= 5) {
    // round up by correcting float error
    // UPDATED - for negative numbers will round away from 0 
    // e.g. round(-2.5, 0) == -3        
    number += 1/(factor) * (+number < 0 ? -1 : 1);
  }
  number = +number.toFixed(precision);
  return number;
};

\$\endgroup\$
6
  • \$\begingroup\$ Reminds me of a really old blog post I wrote a while back: fundamentaldisaster.blogspot.com/2007/11/…. I too created a round function as well. \$\endgroup\$ Commented Mar 25, 2017 at 18:17
  • \$\begingroup\$ @GregBurghardt - Yes - I'm 10 years late to this question. I changed careers and only recently took it up again. Base 10 rounding seems like a pretty basic need. I'm surprised that in 10 +years, they couldn't have added something native to the language. \$\endgroup\$ Commented Mar 25, 2017 at 18:27
  • \$\begingroup\$ "Note that it will round negatives toward zero (e.g. round(-1835.665, 2)) ==> -1835.66). It will not round for negative precision (e.g round(1234.5678, -1)) will give NaN." This does not go against your specification? What is your specification? \$\endgroup\$ Commented Mar 25, 2017 at 18:52
  • \$\begingroup\$ @Mast - My logic says that rounding should be symmetrical and go away from 0. For negative numbers that means -1.5 rounds to 2. Because there is no widely accepted practice on this, I mentioned it so that anyone using the above code would be aware of the resulting behavior. I also wanted a function that rounded for "negative precision" (e.g. round(1254, -2)) => 1300 ) so I mentioned that as well. \$\endgroup\$ Commented Mar 25, 2017 at 19:01
  • \$\begingroup\$ You could always look at the MDN, that has an example function that does the same. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… \$\endgroup\$ Commented Mar 25, 2017 at 19:21

4 Answers 4

Reset to default
1
\$\begingroup\$

Here is my solution that I came up with by starting off from your own code, which as I was tracing the logic I realized was a bit bloated, through quite efficient. What's more, when I was adding a few more test cases I discovered 2 bugs in it. I also did benchmark of your, @mseifert and mine code.

But first, few comments about your code:

  • You have quite numerous unnecessary (in my opinion) variables,
  • The loop and surrounding conditional statement is completely unnecessary as well,
  • Variables' names could be more descriptive, especially a's,
  • sDec += '0' is shorter and faster than sDec = sDec.concat("0"),
  • Why to assign +number.toFixed(precision) to variable number, if in the very next line you just return number? Go with return +number.toFixed(precision) instead.

Test cases

Just one note: this is definitely not the elegant way of writing tests, but test cases themselves weren't in the scope of this question, so I allowed myself to do it this way.

Two lines with comments next to them are those which revealed bugs in your original code to me.

console.clear();
console.log(round(1.0e-5, 5) === 0.00001);
console.log(round(1.0e-20, 20) === 1e-20);
console.log(round(1.0e20, 2) === 100000000000000000000);
console.log(round(1.005, 2) === 1.01);
console.log(round(1234.00000254495, 10) === 1234.000002545);
console.log(round(1835.665, 2) === 1835.67);
console.log(round(-1835.665, 2) === -1835.67);
console.log(round(1.27499, 2) === 1.27);
console.log(round(1.2345678e+2, 2) === 123.46);
console.log(round(1234.5678, -1) === 1230);
console.log(round(1234.5678, -2) === 1200);
console.log(round(1254.5678, -2) === 1300);
console.log(round(1254, 2) === 1254);
console.log(round(1254) === 1254);
console.log(round('1254') === 1254);
console.log(round('123.55') === 124);
console.log(round('123.55', 1) === 123.6);
console.log(round('123.55', '1') === 123.6);
console.log(round(123.55, '1') === 123.6);
console.log(round('-1835.665', 2) === -1835.67);
console.log(round('-1835.665', '2') === -1835.67); // Made me turn precision into +precision
console.log(round(-1835.665, '2') === -1835.67);
console.log(round('1.0e-5', 5) === 0.00001); // Made me add number = +number;
console.log(round('1.0e-5', '5') === 0.00001);
console.log(round(1.0e-5, '5') === 0.00001);
console.log(round('1.0e-20', 20) === 1e-20);
console.log(round('1.0e-20', '20') === 1e-20);
console.log(round(1.0e-20, '20') === 1e-20);
console.log(round('1.0e20', 2) === 100000000000000000000);
console.log(round('1.0e20', '2') === 100000000000000000000);
console.log(round(1.0e20, '2') === 100000000000000000000);

Benchmark

Notice that my code is not much faster than yours.

(made with JSBench.Me and using Chrome 57)

Benchmark

Complete code

You can change the only var keyword to const from ES6 if you want to use it, since the variables that this keyword applies to are indeed constant.

function round(number, precision) {
    'use strict';
    precision = precision ? +precision : 0;

    var sNumber     = number + '',
        periodIndex = sNumber.indexOf('.'),
        factor      = Math.pow(10, precision);

    if (periodIndex === -1 || precision < 0) {
        return Math.round(number * factor) / factor;
    }

    number = +number;

    // sNumber[periodIndex + precision + 1] is the last digit
    if (sNumber[periodIndex + precision + 1] >= 5) {
        // Correcting float error
        // factor * 10 to use one decimal place beyond the precision
        number += (number < 0 ? -1 : 1) / (factor * 10);
    }

    return +number.toFixed(precision);
}
\$\endgroup\$
2
  • 1
    \$\begingroup\$ Excellent. I am not sure if you noticed my separate answer where I fixed the bugs and more. But your answer is significantly faster than mine final one. I especially like how you've avoided split() which seems to slow things down. \$\endgroup\$ Commented Mar 27, 2017 at 3:29
  • \$\begingroup\$ @mseifert: Yes, I did notice it but I found your shifting code a bit harder to follow and I wanted to optimize it, as well. Also, as you have mentioned I tried to avoid string operations. Actually, I wanted to remove sNumber whatsoever, but replacing sNumber[periodIndex + precision + 1] would introduce a lot of burden, making it counterproductive. \$\endgroup\$ Commented Mar 27, 2017 at 11:25
1
\$\begingroup\$

You should automate your test cases by comparing the actual with the expected result and only logging it when these differ. This will tell you immediately whether everything worked (no logging at all).

Your test doesn't cover numbers whose string representation contains an e.

\$\endgroup\$
3
  • \$\begingroup\$ I noticed this as well with the first case and addednumber = +number to handle when a string with an 'e' was passed. The below answer will now handle cases with an e in the string. For example console.log(round("1.2345678e+2", 2)); // ==> 123.46 and console.log(round(1.2345678e+2, 2)); // ==> 123.46. \$\endgroup\$ Commented Mar 25, 2017 at 20:27
  • \$\begingroup\$ No, I mean 1.0e-20 and 1.0e20, which have an e in their natural string representation. \$\endgroup\$ Commented Mar 25, 2017 at 20:30
  • \$\begingroup\$ Thanks for pointing this out. I've fixed the answer to handle those cases. Now I understand why MDN did it the way they did. \$\endgroup\$ Commented Mar 25, 2017 at 22:03
1
\$\begingroup\$

Here is a solution which is quick and handles all cases - negative number and negative precision. It was adapted from MDN - the main differences are

  1. I pass positive numbers to specify decimal places where it is the opposite on MDN.
  2. I took it out of the prototype and limited it to just the round function (removed ceil and floor)
  3. it is significantly faster

function round(number, precision) {
  number = +number;
  precision = precision ? +precision : 0;
  if (precision == 0) {
    return Math.round(number);
  }
  var sign = 1;
  if (number < 0) {
    sign = -1;
    number = Math.abs(number);
  }

  // Shift
  number = number.toString().split('e');
  number = Math.round(+(number[0] + 'e' + (number[1] ? (+number[1] + precision) : precision)));
  // Shift back
  number = number.toString().split('e');
  return +(number[0] + 'e' + (number[1] ? (+number[1] - precision) : -precision)) * sign;
}

console.log(round(1.0e-5, 5)); // 0.00001
console.log(round(1.0e-20, 20)); // 1e-20
console.log(round(1.0e20, 2)); // 100000000000000000000
console.log(round(1.005, 2)); // 1.01
console.log(round(1234.00000254495, 10)); //1234.000002545
console.log(round(1835.665, 2)); // 1835.67))
console.log(round(-1835.665, 2)); // -1835.67))
console.log(round(1.27499, 2)); // 1.27
console.log(round(1.2345678e+2, 2)); // 123.46
console.log(round(1234.5678, -1)); // 1230
console.log(round(1234.5678, -2)); // 1200
console.log(round(1254.5678, -2)); // 1300
console.log(round(1254, 2)); // 1254
console.log(round("123.55")); // 124

\$\endgroup\$
2
  • \$\begingroup\$ Shouldn't round(1.0e-20, 20) still be 1.0e-20? If not, round(1.0e-1, 1) would have to be 0 then, also, just by analogy. \$\endgroup\$ Commented Mar 26, 2017 at 0:46
  • \$\begingroup\$ @RolandIllig Yes thanks. It is fixed now. I needed to convert the stringnumber[1] to a numeric using+number[1] \$\endgroup\$ Commented Mar 26, 2017 at 3:57
-6
\$\begingroup\$

Use this function to round the given number

Number((6.688689).toFixed(1));
\$\endgroup\$
2
  • 2
    \$\begingroup\$ Can you expand on why that function would be an improvement? \$\endgroup\$ Commented Mar 25, 2017 at 9:08
  • 5
    \$\begingroup\$ This suggestion does not do the same thing as what the OP's code does. THis always rounds to an integer value, but the OP code rounds to a supplied precision. Also, assuming the 1 is a variable, this suggestion would not support negative precisions like -2. \$\endgroup\$ Commented Mar 25, 2017 at 11:05

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.