Rounding Calculator

Readers arrive assuming that rounding 1.5 always gives 2, because that is what grade school taught. But the result depends on the method you pick, and no single method is correct. The common school rule, half up, is one of seven methods here. For 1.5, half up gives 2, but half to even (banker's rounding) gives 2 as well; the difference shows up at 2.5, where half up gives 3 and half to even gives 2. The real problem is that floating-point numbers in IEEE 754 binary64 cannot represent most decimals exactly, 0.1 plus 0.2 equals 0.30000000000000004, not 0.3, so a rounding calculator that uses binary floats will produce the wrong result for 1.005, 2.675, or 1.255. This calculator works on exact decimal arithmetic, never on binary floats, so 1.005 rounds to 1.01 under half up, which is what you expect.

Enter the number you want to round in the "Number to Round" field. The calculator accepts numbers with or without a decimal point, negative numbers, and numbers with thousands separators (1,234,567.8). Then select one of three rounding types.

Decimal Places

Pick "Decimal Places" and choose how many digits you want after the decimal point, from 0 (whole number) up to 15. The calculator rounds to that number of decimal places using the method you select. For example, rounding 3.14159 to 2 decimal places under half up gives 3.14. The scale is automatically set to 10^−d.

Significant Figures

Pick "Significant Figures" and enter a number from 1 to 15. The calculator identifies the first non-zero digit and rounds to the requested number of significant figures. For example, 12345 with 3 significant figures becomes 12300. The input's own significant figures are shown: if you type 2.0, the calculator tells you it has 2 significant figures; if you type 200, it tells you it has 1 to 3 (trailing zeros in a whole number are ambiguous).

Nearest Value

Pick "Nearest Value" and choose a preset like 10, 5, 0.5, 0.25, or enter a custom multiple. The calculator divides your number by that multiple, rounds the quotient using your chosen method, and multiplies back. For example, rounding 37 to the nearest 10 using half up gives 40. This is how Excel's MROUND works, but note that MROUND uses half away from zero, not half up, a distinction that matters for ties.

The calculator shows all seven methods side by side when you check "Show all rounding methods." Here is how each method handles 2.5 rounded to the nearest whole number:

• Half Up (ties toward +∞): 2.5 → 3. An exact tie goes toward positive infinity, so −2.5 → −2.
• Half Away from Zero (school rule, Excel ROUND): 2.5 → 3. For negative numbers, −2.5 → −3 (away from zero). This is identical to half up for positive numbers but differs for negative ties.
• Half Down (ties toward −∞): 2.5 → 2. An exact tie goes toward negative infinity, so −2.5 → −3.
• Half to Even (Banker's): 2.5 → 2 (even), 3.5 → 4 (even). This reduces cumulative bias in datasets and is the default in IEEE 754-2019 (roundTiesToEven) and Python's round().
• Round Up (Ceiling): 2.5 → 3. Always goes to the higher multiple, toward +∞. Excel's CEILING.MATH works this way.
• Round Down (Floor): 2.5 → 2. Always goes to the lower multiple, toward −∞. Excel's FLOOR.MATH works this way.
• Truncate (Towards Zero): 2.5 → 2. Simply drops digits after the rounding position. Excel's TRUNC works this way.

After rounding, the calculator shows the absolute difference between the original number and the rounded value, plus the percentage error. For example, rounding 123.456789 to 2 decimal places gives 123.46. The difference is 0.003211, and the percentage error is 0.0026%. That percentage error is the absolute difference divided by the absolute original value, expressed as a percent. A percentage error near zero means the rounded value is very close to the original; a larger percentage error (for example, rounding 0.00149 to 2 decimal places gives 0.00, a difference of 0.00149 and a 100% error) tells you the rounding has lost nearly all precision. The calculator also shows the calculation steps: the original number, the rounding unit, the neighbouring multiples, the remainder relative to half the unit, and which direction the method chose.

The most common rounding tasks are to the nearest tenth, hundredth, whole number, and ten. Here is how the calculator handles them under the default half-up method:

• Nearest tenth: 3.14159 → 3.1 (the hundredths digit is 4, so the tenths digit stays). 1.99 → 2.0 (the hundredths digit is 9, so the tenths digit rounds up to 10, carrying to the integer part).
• Nearest hundredth: 3.14159 → 3.14 (the thousandths digit is 1, so the hundredths digit stays).
• Nearest whole number: 3.14159 → 3 (the tenths digit is 1, so the integer part stays).5 → 2 under half to even. 9.999 → 10 (the tenths digit is 9, so the integer part rounds up to 10).
• Nearest ten: 37 → 40 (the ones digit is 7, so the tens digit rounds up).99 → 100 (the ones digit is 9, so the tens digit rounds up to 100).

The single thing that goes wrong most often with rounding is the half-up assumption: assuming every tool uses the school rule. Python's round() uses half to even. JavaScript's Math.round() uses half away from zero. Excel's ROUND uses half away from zero. IEEE 754-2019 defaults to roundTiesToEven. If you plug 2.5 into a spreadsheet expecting 3 and get 2, or into Python expecting 3 and get 2, you have hit the tie-breaking wall. The same number can round differently depending on which tool you use, and the only way to be sure is to know which method that tool implements. For negative numbers the divergence is worse: Excel's ROUND(-1.5, 0) gives −2 (away from zero), while a half-up rule would give −1 (toward positive infinity). Always check the documentation for the specific function you are using.