Rounding Calculator

Number to round:

Use decimal text such as 1.005, -12.5, or 6.022e23; the calculator rounds from the typed decimal string.

Target type:

Pick the precision target before choosing the rounding rule.

Decimal places:

Use 0 through 12 decimal places for copy-ready fixed precision.

Significant figures:

Use 1 through 16 significant figures; leading zeros before the first nonzero digit do not count.

Place value:

Choose the digit position that should be kept.

Increment:

Use decimal steps or simple fractions for currency, measurement, or pack-size rounding.

Rounding rule:

Choose standard 5-up, banker's half-even, JavaScript-style ties, ceiling, floor, truncation, or away-from-zero rounding.

Check rounding inputs

{{ error }}

Keep trailing zeros for the selected precision

Use this when the output precision itself matters, such as 15.50 or 1.2300.

Show thousands separators in displayed values

Separators affect display and copied summary values, not the exported numeric payload.

Step	Value	Precision note	Copy
{{ row.step }}	{{ row.value }}	{{ row.note }}

Check	Status	Detail	Copy
{{ row.check }}	{{ row.status }}	{{ row.detail }}

No finite comparison points are available for this precision target.

{{ jsonPayload }}

Export to PDF Fullscreen

Embed:

Customize

Include current inputs

Size

Advanced

Width

Height

Aspect ratio

Max height

Collapsible embed

Allow fullscreen

Referrer policy

Sandbox tokens

Rounding turns a detailed number into a value that fits a chosen precision. The precision may be a fixed number of decimal places, a count of significant figures, a named place value, or a practical step such as 0.05 or 1/8. The rounded value is easier to compare, copy, or report, but it is no longer the exact original value.

The rule matters most when a number lands exactly halfway between two possible targets. Values such as 1.005, -12.5, and 2.375 can move in different directions depending on whether the rule is half-up, half-even, toward zero, away from zero, ceiling, floor, or ties toward positive infinity. Negative numbers make casual words like "up" and "down" especially easy to misread, so the direction should be named before the result is trusted.

A number line showing 1.005 halfway between 1.00 and 1.01, with a tie rule choosing a target.

Good rounding practice keeps the original value, the precision target, and the tie rule separate in your notes. That is the only way another person can reproduce the same result later, especially when the value is being used in a price list, measurement table, dataset summary, engineering estimate, or classroom answer key.

Technical Details:

A rounded number sits on a target grid. The gap between adjacent grid points is the target quantum: 0.01 for two decimal places, 1000 for thousands, or 0.125 for an eighth-unit increment. Rounding compares the input with the two neighboring grid points and then applies the selected rule to choose one of them.

For a nonzero input, the magnitude can be divided into whole quanta plus a remainder. The remainder decides whether the kept magnitude stays at the lower grid point or moves to the next one.

Formula Core:

| x | = n q + r, 0 \leq r < q rounded magnitude = n q or (n + 1) q

Here x is the input, q is the target quantum, n is the lower whole-quantum count, and r is the discarded amount. If r is zero, the input already lands on the selected target. If r is exactly half of q, tie handling controls the result.

Precision targets available in the rounding calculator
Precision target	Target quantum	Current bounds
`Decimal places`	A power of ten after the decimal point, such as `0.01` for two places.	0 to 12 decimal places.
`Significant figures`	A power of ten chosen from the first nonzero digit and the requested figure count.	1 to 16 significant figures.
`Named place value`	A named power of ten, from millions through millionths.	Millions, hundred thousands, ten thousands, thousands, hundreds, tens, ones, tenths, hundredths, thousandths, ten-thousandths, hundred-thousandths, and millionths.
`Custom increment`	A positive decimal step or a terminating fraction such as `0.05`, `0.125`, or `1/8`.	Up to 12 decimal places after the fraction is converted to decimal form.

The directional rules are easiest to audit when they are written as actions on the magnitude. The sign is restored after the magnitude decision, except that a rounded zero is displayed without a negative sign.

Rounding rule behavior for halfway and directional cases
Rule	Halfway or remainder behavior	Negative-number cue
`Nearest, 5 rounds away from zero`	Less than half stays lower; more than half moves up; exactly half increases magnitude.	`-12.5` to ones becomes `-13`.
`Nearest, banker's half-even`	Exactly half chooses the rounded value whose kept digit is even.	`-12.5` to ones becomes `-12` because 12 is even.
`Nearest, ties toward +infinity`	Exactly half chooses the result closer to positive infinity.	`-12.5` to ones becomes `-12`, matching JavaScript-style tie behavior.
`Ceiling`	Any nonzero discarded amount moves the result toward positive infinity.	A negative value with discarded digits moves closer to zero.
`Floor`	Any nonzero discarded amount moves the result toward negative infinity.	A negative value with discarded digits becomes more negative.
`Truncate, toward zero`	Discarded digits never increase magnitude.	A negative value with discarded digits moves closer to zero.
`Away from zero`	Any nonzero discarded amount increases magnitude.	A negative value with discarded digits becomes more negative.

The source number is parsed from decimal text before rounding. Decimal strings, integers, and scientific notation are accepted; commas and underscores are ignored. This matters for values such as 1.005, where binary floating-point storage can surprise people in ordinary programming shortcuts. The rounded value, signed difference, absolute error, and audit rows come from scaled decimal arithmetic rather than from a direct binary floating-point round.

Input validation bounds for the rounding calculator
Input area	Accepted behavior	Why it matters
`Number to round`	Finite decimal, integer, or scientific-notation text.	Non-finite values and malformed text are blocked before results appear.
`Input size`	Up to 90 significant input digits.	Very long numeric text is rejected before it can make the trace hard to read.
`Scientific notation`	Exponent from `-120` to `120`.	Keeps very large and very small values inside the decimal arithmetic bounds.
`Custom fraction`	Only terminating positive fractions are accepted.	`1/8` works; `1/3` is rejected because it cannot become a finite decimal step.

Everyday Use & Decision Guide:

Start with the target type that matches the job. Use Decimal places for currency-style or fixed-format reporting, Significant figures for measurements that should keep the same meaningful digit count across different magnitudes, Named place value for estimates such as nearest thousand or nearest tenth, and Custom increment for pack sizes, tick sizes, measurement marks, or cash steps.

Leave Rounding rule on Nearest, 5 rounds away from zero only when that is the convention you actually need. Choose Nearest, banker's half-even for reports that ask for half-even behavior. Use Nearest, ties toward +infinity when matching JavaScript-style integer rounding. Directional rules such as Ceiling, Floor, Truncate, toward zero, and Away from zero should be reserved for policies where the direction has a real meaning, such as conservative estimates or minimum pack counts.

Turn on Keep trailing zeros when the displayed precision is part of the answer, such as 15.50 or 1.2300.
Use Show thousands separators when large displayed values need to scan cleanly. Separators affect the visible values, not the numeric meaning.
Check Signed difference before copying a rounded value into a report. A small-looking change can matter when the original number is close to zero.
Open Rule Audit when a halfway value or negative value produces a result that feels surprising.
Use Rounding Error Curve to compare nearby precision targets before deciding how much precision to keep.

The rounded value is the copy-ready answer, but the trace explains why it changed. If the input is rejected, fix the number text or custom increment first; later tabs only appear after the source value and target precision pass validation.

Step-by-Step Guide:

Use this order when the rounded value needs to be reproducible.

Enter Number to round. The field accepts values such as 1.005, -12.5, or 6.022e23. If the alert says to use a finite decimal, integer, or scientific-notation number, replace the source text before adjusting precision.
Choose Target type. The next visible field changes to Decimal places, Significant figures, Place value, or Increment.
Set the precision field. For custom increments, use a positive decimal or a terminating fraction such as 1/8. If a fraction is rejected, choose a denominator that converts to a finite decimal.
Choose Rounding rule. For negative halfway cases, compare half-up, half-even, and ties toward positive infinity if the rule is not already specified by the assignment or report.
Open Advanced if display precision matters. Keep trailing zeros preserves zeros implied by the target, while grouping only changes displayed separators.
Read Rounded value in the summary, then review Rounding Trace and Rule Audit. The trace shows the input number, target quantum, rule, rounded value, signed difference, absolute error, and relative error when it can be calculated.
Use Rounding Error Curve when you need to compare the selected precision against nearby decimal-place, significant-figure, place-value, or increment targets. Use JSON when another workflow needs the rounded value and audit details as structured data.

Interpreting Results:

The summary gives the rounded value and badges for the selected target, rule, and delta. A badge such as exact target means the source number already sat on the selected grid. A delta badge means rounding changed the value, and the sign tells whether the rounded value is above or below the original.

How to read key output areas in the rounding calculator
Output cue	What to check	Common misread
`Rounded value`	The value after the selected target and rule are applied.	It is not the original value unless the trace says the input was already exact.
`Target quantum`	The grid size, such as `0.01`, `1000`, or `0.125`.	A smaller quantum keeps more detail, but it does not make the source measurement more accurate.
`Signed difference`	Rounded value minus original input.	A positive signed difference means the rounded result increased, not that the input was positive.
`Relative error`	Signed difference divided by the original input when the original input is not zero.	It is unavailable for zero because division by zero has no finite percentage meaning.
`Rule Audit`	Parse status, target quantum, tie handling, signed behavior, displayed precision, and decimal arithmetic guard.	A correct rounded value can still be the wrong reporting choice if the selected rule does not match the required convention.

The chart compares rounding error across nearby targets. Use it to choose a sensible precision, not to prove that one rounded value is more truthful than another. The source value and the required reporting convention still decide which precision is appropriate.

Worked Examples:

Decimal-place rounding with a familiar tie

Enter 1.005, choose Decimal places, set Decimal places to 2, and use Nearest, 5 rounds away from zero. The summary returns 1.01. Rounding Trace shows target quantum 0.01, signed difference +0.005, absolute error 0.005, and a halfway decision that increased the kept magnitude.

Negative halfway value with two different tie rules

With -12.5 rounded to the Ones place, Nearest, ties toward +infinity returns -12. Switching to Nearest, 5 rounds away from zero returns -13. Both results are internally consistent; they answer different tie rules, so the selected rule must match the convention you need.

Custom increment for measurement marks

Enter 2.37, set Target type to Custom increment, use 1/8, and keep the half-up rule. The increment converts to a 0.125 quantum, and the nearest multiple is 2.375. The trace reports signed difference +0.005, which is small in absolute terms but may matter if the measurement tolerance is tight.

Rejected non-terminating increment

If Increment is 1/3, the result area shows an input review instead of a rounded value. Use a terminating fraction such as 1/8, 1/16, 1/20, or 3/25, or enter a decimal step with no more than 12 decimal places.

FAQ:

Why does 1.005 round to 1.01 here?

The source value is parsed from the typed decimal string before rounding. With a 0.01 target and the half-up rule, 1.005 is exactly halfway between 1.00 and 1.01, so the kept magnitude increases.

When should I use significant figures instead of decimal places?

Use significant figures when the meaningful digit count should stay consistent across magnitudes. For example, four significant figures treats 60220 and 0.006022 by their first nonzero digit, while decimal places always count digits after the decimal point.

Why is relative error sometimes unavailable?

Relative error is signed difference divided by the original input. When the original input is 0, that percentage is undefined, so the trace reports that it is not available.

Why was my fraction increment rejected?

Fractions must convert to a terminating decimal with 12 decimal places or fewer. Denominators built only from factors of 2 and 5 after reduction work, so 1/8 and 3/25 are accepted while 1/3 is rejected.

Are the numbers sent to a server for rounding?

After the page loads, the number text, rounding trace, audit table, chart, and exports are produced in the browser. There is no helper endpoint for the number text in this calculator.

Glossary:

Target quantum: The grid size used for rounding, such as 0.01, 1000, or 0.125.
Significant figures: The meaningful digits counted from the first nonzero digit.
Halfway case: A value exactly halfway between two adjacent rounding targets.
Half-even: A tie rule that chooses the rounded value whose kept digit is even.
Signed difference: The rounded value minus the original input, preserving whether the result moved up or down.
Terminating fraction: A fraction that converts to a finite decimal step, such as 1/8 or 3/25.

References:

NIST Guide to the SI, Chapter 7, National Institute of Standards and Technology.
RoundingMode, Oracle Java SE 21 API documentation.
Math.round, ECMAScript Language Specification.
Rounding Modes, Unicode ICU Documentation.