Rounding Numbers: Every Method and Rule Explained

Rounding is the process of replacing a number with a shorter, less precise one that’s still close to the original — and “which digit do I look at” is only half the problem. The other half is what to do at the exact halfway point, and there isn’t one universal answer: round half up, round half down, round half away from zero, round half toward zero, and round half to even (“banker’s rounding”) are all real, deliberately-used methods, and they don’t all agree. Add truncation, ceiling, and floor — which don’t do any “rounding” at the halfway point at all, they just always go one direction — and you have eight distinct methods in everyday use, each chosen for a reason.

Significant figures tell you how many digits to keep. Rounding is the mechanical operation you use to actually get there. Our Complete Guide to Significant Figures covers the “how many” question; this page covers the “by what method” question — which turns out to have real, non-obvious answers that different fields, tools, and standards genuinely disagree on. The single most useful thing on this page is probably the negative-number example in Case 3 below: it’s the one place where two methods that look identical for positive numbers quietly diverge, and it trips up more people than any other rounding question.

<!– BLOCK: B02 – Inline Mini-Calculator –> <!– DEV NOTE: Embed the Rounding Mode Comparator tool here (Tier 1 tool #6 in the site blueprint). Shortcode: [sfc_rounding_comparator default_input=”2.5″ show_all_methods=”true”]. This is the flagship differentiator tool for the whole silo — showing one input rounded eight different ways, side by side, is not something any competitor site currently offers. –>

[Live Rounding Mode Comparator embeds here] — Enter any number and see it rounded under all eight methods at once, side by side.

The 8 Rounding Methods

1. Round half up (toward positive infinity). Look at the first digit being dropped. 5 or more: round up. Less than 5: round down. At an exact tie, this method always moves toward positive infinity — which, for a positive number, means “up” in the everyday sense, but for a negative number means toward the less negative option. This is the method most people mean when they say “normal rounding,” though as Case 3 shows, it’s more precisely defined than that phrase suggests.

2. Round half down (toward negative infinity). The mirror image of half up: at an exact tie, always move toward negative infinity. Rare as a standalone method, but it’s the necessary reference point for understanding the next two.

3. Round half away from zero. At a tie, move to whichever neighbor has the larger absolute value. For positive numbers this behaves exactly like round half up. For negative numbers it does not — it behaves like round half down, because “away from zero” for a negative number means more negative. This is the method Excel and Google Sheets use by default.

4. Round half toward zero. The opposite: at a tie, move to whichever neighbor has the smaller absolute value. Positive numbers behave like round half down; negative numbers behave like round half up. Genuinely rare as a deliberate choice, but useful to know as the fourth point on this compass.

5. Round half to even (“banker’s rounding,” “statistician’s rounding,” “Gaussian rounding,” “Dutch rounding”). At a tie, round to whichever neighbor is an even number. 2.5 rounds to 2 (already even); 3.5 rounds to 4 (the even neighbor). This is the default in IEEE 754 floating-point arithmetic, in Python’s built-in round(), and in NIST’s own laboratory rounding guidance — not because it’s “more correct” in any single case, but because across many values it eliminates the systematic upward drift that half-up rounding introduces. See Example 4.

6. Truncation (round toward zero, unconditionally). Simply discard the extra digits — no evaluation of their value at all. 2.789 truncated to one decimal place is 2.7, not 2.8, even though 2.789 is closer to 2.8. Truncation isn’t really “rounding” in the precision-preserving sense; it’s a deliberate choice to always underestimate the magnitude, and it’s common in contexts like currency display (truncating sub-cent fractions) and low-level computing.

7. Ceiling (round toward positive infinity, unconditionally). Always round up to the next value, regardless of how close the original number is. Used where under-provisioning is the worse failure mode — billing systems that round usage up to the next full unit, for instance.

8. Floor (round toward negative infinity, unconditionally). Always round down. Used where over-provisioning is the worse failure mode, or as the standard method for integer division in many programming languages.

There’s also a ninth, rarer method worth knowing by name: stochastic rounding, which rounds up or down with a probability proportional to how close the number is to each neighbor (a number 70% of the way to the next integer rounds up 70% of the time, at random). It shows up in large-scale numerical computing and machine learning training, where it prevents rounding bias from accumulating across millions of operations — well outside the scope of a sig fig calculator, but worth recognizing the name if you encounter it.

Worked Examples

Example 1 — One number, eight methods

Number: 2.5, rounded to the nearest integer

Three methods give 3; five give 2. This is the single clearest illustration of why “just round it” isn’t a complete instruction.

Example 2 — A non-tie, for contrast

Number: 2.3, rounded to the nearest integer

Every method that evaluates the dropped digit agrees here: half up, half down, half away from zero, half toward zero, half to even, and truncation all give 2. Only ceiling gives 3, because ceiling always rounds up regardless of how close the number actually is. This is the useful baseline: methods only disagree with each other at exact ties (or, for ceiling/floor/truncation, essentially all the time relative to normal rounding) — Example 1’s split is the exception that matters, not the rule.

Example 3 — Negative numbers: where “half up” and “away from zero” split

Number: −2.5, rounded to the nearest integer

Notice that round half up and round half away from zero — which give identical results for every positive number — disagree here. This is the single most common source of “why did my spreadsheet give a different answer than my calculator” confusion. If a method matters for negative data, name it precisely, don’t just say “round half up.”

Example 4 — Why banker’s rounding exists

Numbers: 0.5, 1.5, 2.5, 3.5, 4.5, rounded to the nearest integer

Half up rounds every single tie upward — five out of five, unconditionally. Half to even alternates, because consecutive half-integers alternate between having an even lower neighbor and an even upper neighbor — three down, two up here, and it trends toward an even 50/50 split the longer the sequence runs. Averaged over a dataset with many exact-halfway values (common in currency and instrument readings that land on a clean 0.5 unit), half up’s one-directional rounding introduces a small but real upward drift; half to even’s alternation cancels almost all of it out. That’s the entire justification for banker’s rounding — not that any single answer is “more correct,” but that the aggregate behavior over many values is closer to unbiased.

Example 5 — Double rounding

Number: 0.149, rounded to 1 decimal place

Direct: the second decimal digit is 4, which is less than 5, so round down → 0.1

Two-step (round to 2 decimals, then round that result to 1): 0.149 → 0.15 (third decimal is 9, rounds up) → then 0.15 → 0.2 (second decimal is 5, rounds up)

Direct rounding gives 0.1. Rounding in two stages gives 0.2 — a different answer, from the same starting number, purely because of an intermediate rounding step that shouldn’t have happened. This is exactly why the guard-digit rule in our sig figs guide exists, and it applies to plain rounding just as much as it applies to significant figures.

Example 6 — Decimal places and significant figures are different targets

Number: 1234.567

Rounded to 2 decimal places: look at the third decimal (7), round up → 1234.57 Rounded to 2 significant figures: keep only the first two digits (1, 2); the next digit (3) rounds down → 1200 (better written 1.2 × 10³)

Same number, same instruction word (“round”), wildly different results — because “2 decimal places” and “2 significant figures” are counting entirely different things. See Rounding vs. Significant Figures for the full explanation.

Where the Methods Still Cause Problems

• “Round half up” is not always well-defined for negatives. Some sources use the phrase loosely to mean “round half away from zero.” As Example 3 shows, these genuinely diverge below zero — always name which one you mean if it matters.
• Your spreadsheet and your programming language don’t necessarily agree. Excel’s ROUND() uses half away from zero; Python’s built-in round() uses half to even. The exact same formula, run in two different tools, can give different answers at a tie — not a bug in either one, just a different documented default.
• Ceiling, floor, and truncation diverge from “normal” rounding on almost every number, not just at ties. It’s easy to assume all rounding methods only disagree at the exact halfway point; ceiling and floor actually disagree with round-to-nearest on the vast majority of inputs, since they ignore how close the number actually is.
• Rounding more than once compounds error in a way that’s easy to miss in a multi-stage spreadsheet or database pipeline, where an intermediate value gets displayed (and silently re-stored) at reduced precision before a later calculation uses it. See Example 5.
• Regulatory and contractual contexts sometimes mandate a specific method, removing the choice entirely — tax calculations, billing increments, and lab conformance testing (see below) often specify the rounding method in writing precisely because the “obvious” choice isn’t universal.

How Different Tools and Standards Round a Tie

The practical takeaway: if a rounded answer needs to be reproducible by someone else — a classmate, a colleague, an auditor — state which method you used. “Round half up” alone is ambiguous enough about negative numbers that professional guidance documents spell it out explicitly rather than assuming it’s understood.

Standards Note

It’s worth being precise about what the standards actually say, since it’s easy to assume a named standard mandates one “correct” method. Neither NIST’s GLP-9 nor ISO 80000-1 does this — both are structured as a menu of accepted methods with a requirement to document which one is in use, not a single universal rule. ASTM E29 is different in kind: it’s not primarily about tie-breaking at all, but about how a result gets compared to a written specification limit once its precision is already settled. The full comparison across all of these lives in Rounding Standards Compared: ASTM E29, ISO 80000-1, NIST, and Classroom Rules.

Common Mistakes

1. Treating “round half up” and “round half away from zero” as interchangeable. They agree for positive numbers and disagree for negative ones — see Example 3.
2. Assuming a spreadsheet or programming language rounds the way a textbook does. Excel and Python disagree with each other by default, and neither is “wrong.”
3. Rounding through multiple stages instead of once at the end, introducing double-rounding error (Example 5).
4. Confusing “round to N decimal places” with “round to N significant figures.” These are different operations that can give very different results on the same number (Example 6).
5. Truncating when asked to round, or rounding when asked to truncate. Near a boundary these can diverge by a full unit.
6. Assuming every method only disagrees at the exact halfway point. Ceiling, floor, and truncation diverge from ordinary rounding across most of the number line, not just at ties.

Practice Problems

Concept: Identifying methods

Q1. Which method always moves a tie toward positive infinity — so 4.5 rounds to 5, and −4.5 rounds to −4? A) Round half to even B) Round half up C) Round half away from zero D) Truncation Answer: B. By definition, round half up always moves toward positive infinity at a tie.

Q2. Which method always increases the magnitude at a tie — so 4.5 rounds to 5, and −4.5 rounds to −5? A) Round half up B) Round half away from zero C) Round half toward zero D) Round half to even Answer: B. “Away from zero” means larger absolute value in both directions.

Concept: Banker’s rounding

Q3. Under round half to even, what does 2.5 round to? A) 2 B) 3 C) 2.5 D) It’s undefined Answer: A) 2 — because 2 is the even neighbor.

Q4. Under round half to even, what does 3.5 round to? A) 3 B) 4 C) 3.5 D) It’s undefined Answer: B) 4 — because 4 is the even neighbor.

Concept: Negative numbers

Q5. Under strict round half up (toward positive infinity), what does −2.5 round to? A) −3 B) −2 C) −2.5 D) 0 Answer: B) −2. Toward positive infinity means the less negative option.

Q6. Under round half away from zero, what does −2.5 round to? A) −3 B) −2 C) −2.5 D) 0 Answer: A) −3. Away from zero means the larger-magnitude, more negative option.

Concept: Decimal places vs. significant figures

Q7. Rounding 1234.567 to 2 decimal places gives: A) 1200 B) 1234.57 C) 1230 D) 1234.6 Answer: B) 1234.57.

Q8. Rounding 1234.567 to 2 significant figures gives: A) 1234.57 B) 12 C) 1200 D) 1234.6 Answer: C) 1200 (best written 1.2 × 10³) — a completely different operation from decimal-place rounding.

Concept: Double rounding and truncation

Q9. Rounding 0.149 directly to 1 decimal place gives 0.1. What does rounding it to 2 decimal places first, then to 1, give instead? A) 0.1 B) 0.15 C) 0.2 D) 0.14 Answer: C) 0.2 — a genuine double-rounding error from the intermediate step.

Q10. What’s the key difference between rounding and truncating? A) They’re the same operation B) Truncation only applies to negative numbers C) Truncation discards extra digits regardless of their value; rounding adjusts based on what’s discarded D) Rounding only applies in scientific contexts Answer: C.

One Number, Eight Outcomes

Input: 2.5

• → 3: round half up · round half away from zero · ceiling
• → 2: round half down · round half toward zero · round half to even · truncation · floor

Input: −2.5

• → −2: round half up (toward +∞) · round half toward zero · round half to even
• → −3: round half down (toward −∞) · round half away from zero

Quick Reference

Continue Learning

Related fundamentals:

• Significant Figures: The Complete Guide
• Rounding vs. Significant Figures: Not the Same Thing

Go deeper on one method at a time:

• Round Half Up vs. Round Half Even: Which Does Your Class Use?
• Banker’s Rounding Explained (and Why Excel and Python Disagree)
• Truncation vs. Rounding: When Cutting Digits Is Correct
• Rounding Rules for Negative Numbers
• Round Half Away From Zero vs. Round Half Toward Zero
• The Double Rounding Error That Changes Your Final Answer
• Why Different Calculators Give Different Rounded Answers
• Rounding Standards Compared: ASTM E29, ISO 80000-1, NIST

Tools:

• Rounding Mode Comparator — see all eight methods on one input at once
• Round to N Decimal Places
• Round to N Significant Figures

Sources and Further Reading

• NIST GLP 9 (2019), Rounding — NIST’s laboratory guidance defining three accepted rounding options (even/odd, standard spreadsheet, and always-round-up) and requiring documentation of which is used. (nist.gov)
• ISOBudgets, How to Round Uncertainty to 2 Significant Digits (ISO 17025) — a practitioner explainer cross-referencing how ISO 80000-1, ASTM E29, NIST GLP-9, and the GUM each define conventional and banker’s rounding. (isobudgets.com)
• note.nkmk.me, Round Numbers in Python — technical reference confirming Python’s round() implements round-half-to-even by default, consistent with IEEE 754. (note.nkmk.me)

Review and Methodology

Reviewed by: [Pending — reviewer assignment required before publication] Last reviewed: [Pending] Methodology: Every method definition and worked example above is cross-checked against the primary standards and software documentation listed in Sources. Calculator results referenced on this page use an arbitrary-precision decimal engine, not native floating-point math, validated against the site’s versioned regression fixture set.

Changelog

v1.0 — Initial draft completed, 2026-08-10.