# Banker's Rounding vs. Normal Rounding: What's the Difference and When Does It Matter?

Normal rounding sends every exact half up; banker's rounding sends it to the nearest even digit. That one difference adds $25 of drift to a column of 10,000 halved prices, and it is why Python, Excel and JavaScript can disagree about 2.5. Here are the rules, the bias math, what each language actually does, and when to use which.

---

- **Canonical URL:** https://dothecalculation.com/blog/math/bankers-rounding-vs-normal-rounding
- **Category:** Math
- **Author:** Do The Calculation Team
- **Published:** 2026-09-17
- **Last updated:** 2026-09-17
- **Reading time:** 22 min read
- **Publisher:** Do The Calculation (https://dothecalculation.com)
- **Methodology:** https://dothecalculation.com/methodology

---

Rounding looks like a solved problem. Everyone learns the rule in school, and for almost every number it works without a second thought. But there is one case where the rule you learned is not the only rule in use: a value that sits exactly halfway, like 2.5 or $0.125. School math rounds it up. A large amount of software, and some scientific and financial systems, round it to the nearest even digit instead. That rule is called banker's rounding.

The difference is invisible on a single number and very visible on a column of totals. If a report, a spreadsheet and a script each round the same data with a different rule, the totals will not match, and nobody will have made an arithmetic mistake. This guide explains both rules, shows exactly where the bias in normal rounding comes from, lists what common tools actually do, and covers the floating-point trap that is often blamed on banker's rounding but has nothing to do with it.

## Quick Answer

**Normal rounding and banker's rounding at a glance**
| Feature | Normal rounding | Banker's rounding |
| --- | --- | --- |
| Rule for an exact half | Round up (away from zero) | Round to the neighbor whose last digit is even |
| Examples | 2.5 → 3, 3.5 → 4 | 2.5 → 2, 3.5 → 4 |
| Anything not an exact half | Nearest value | Nearest value (identical to normal rounding) |
| Bias on many ties | Pushes totals upward | Balances out when odd and even neighbors are equally common |
| Also called | Standard rounding, round half up, half away from zero | Round half to even, convergent rounding, Gaussian rounding |
| Default in | School math, Excel ROUND, US tax whole-dollar rounding | Python round(), .NET Math.Round, IEEE 754 floating point |

**Five ties rounded to the nearest whole number**
| Number | Normal rounding | Banker's rounding |
| --- | --- | --- |
| 1.5 | 2 | 2 (2 is even) |
| 2.5 | 3 | 2 (2 is even) |
| 3.5 | 4 | 4 (4 is even) |
| 4.5 | 5 | 4 (4 is even) |
| 5.5 | 6 | 6 (6 is even) |

The key point: the two methods only disagree on exact halves, and only when the digit before the half is even. Everywhere else they give the same answer. Banker's rounding exists to stop exact halves from always moving the same way, which is what quietly inflates totals under normal rounding.

Tool: [Compare Both Rules on Any Number](https://dothecalculation.com/calculators/rounding-calculator) — The rounding calculator has Standard (half-up), Banker's (half-even), Ceiling and Floor modes, and a side-by-side chart of all four results for the number and precision you enter.

## What Is Normal Rounding?

Normal rounding, also called standard, half-up or arithmetic rounding, is the method most people learn in school. You look at the single digit immediately to the right of the place you are rounding to. If that digit is 5 or more, the kept digit goes up by one. If it is 4 or less, the kept digit stays as it is. The [complete rounding rules guide](/blog/math/rounding-rules-complete-guide) walks through that rule at every place value.

**Normal rounding to the nearest whole number**
| Number | Rounded | Why |
| --- | --- | --- |
| 1.4 | 1 | Deciding digit 4 is less than 5, so round down |
| 1.5 | 2 | Deciding digit is 5, so round up |
| 1.6 | 2 | Deciding digit 6 is more than 5, so round up |
| 2.5 | 3 | Deciding digit is 5, so round up |
| 3.5 | 4 | Deciding digit is 5, so round up |
| 4.5 | 5 | Deciding digit is 5, so round up |

### "Up" means two different things for negative numbers

For positive numbers, "round half up" is unambiguous. For negative numbers it splits into two rules. Round half away from zero sends −2.5 to −3, mirroring what happens to 2.5. That is what most people mean by normal rounding, and it is what Excel's ROUND function does. Round half toward positive infinity sends −2.5 to −2, because −2 is the larger number. That is what JavaScript's Math.round and Java's Math.round do. Both are called "half up" in casual use, so it is worth checking which one a system means before comparing results.

### Where the upward bias comes from

Take every number with one decimal place and look at how far rounding moves it. A deciding digit of 0 means no change. Digits 1 to 4 move the number down by 0.1 to 0.4. Digits 6 to 9 move it up by 0.4 to 0.1. Those eight cases cancel each other out exactly: the total downward movement is 1.0 and the total upward movement is 1.0. The only case left over is 5, which normal rounding always moves up by 0.5, with nothing on the other side to cancel it.

**Rounding error by deciding digit, rounding to the nearest whole number**
| Deciding digit | Normal rounding error | Banker's rounding error |
| --- | --- | --- |
| 0 | 0 | 0 |
| 1, 2, 3, 4 | −0.1, −0.2, −0.3, −0.4 | −0.1, −0.2, −0.3, −0.4 |
| 5 | +0.5 every time | +0.5 if the kept digit is odd, −0.5 if it is even |
| 6, 7, 8, 9 | +0.4, +0.3, +0.2, +0.1 | +0.4, +0.3, +0.2, +0.1 |
| Average over all ten digits | +0.05 per value | 0 when odd and even kept digits are equally common |

So normal rounding adds an average of +0.05 per value when the deciding digit is spread evenly. That is small for one number and systematic across many. Round the 100 values 0.0, 0.1, 0.2 and so on up to 9.9 to whole numbers: the true total is 495, normal rounding gives 500, and banker's rounding gives 495. If every value in a set ends in exactly .5, the effect is ten times stronger. Rounding 0.5, 1.5, 2.5 up to 9.5 gives a true total of 50, a normal-rounded total of 55 and a banker's-rounded total of 50. Round 100 values that all end in .5 and normal rounding adds 50 units, half a unit per value.

## What Is Banker's Rounding?

Banker's rounding, formally round half to even, changes exactly one case: the tie. When the part being dropped is exactly half a unit, the number goes to whichever neighbor has an even digit in the kept place. Every other number rounds to its nearest neighbor, just as in normal rounding.

**Round half to even**

```
If the dropped part is more than half → round up
If the dropped part is less than half → round down
If the dropped part is exactly half → keep or raise the last digit so it ends up even
```
- "Exactly half" means a 5 followed by nothing, or by zeros only. 2.5 is a tie; 2.51 is not a tie and rounds to 3 under either method.
- The even test applies to the last kept digit, not to the whole number. Rounding 1.25 to one decimal place gives 1.2 because 2 is even.

**Banker's rounding to the nearest whole number**
| Number | Banker's rounding | Direction |
| --- | --- | --- |
| 1.5 | 2 | Up, because 2 is even |
| 2.5 | 2 | Down, because 2 is even |
| 3.5 | 4 | Up, because 4 is even |
| 4.5 | 4 | Down, because 4 is even |
| 5.5 | 6 | Up, because 6 is even |
| 6.5 | 6 | Down, because 6 is even |

Ties alternate between rounding up and rounding down as you move through consecutive numbers, and that alternation is the whole point. When the digit before the tie is equally likely to be odd or even, half the ties go up by 0.5 and half go down by 0.5, and the error on ties averages out to zero.

> **A common misreading of the rule** — Banker's rounding is sometimes summarized as "if the next digit is 5, round to even." That shortcut is wrong whenever anything non-zero follows the 5. 2.501 is closer to 3 than to 2, so it rounds to 3 under both methods. The even rule only breaks genuine ties.

## The Key Difference, Side by Side

_[Figure: Same input, two tie-breaking rules — Both methods agree on everything except exact halves.]_

**Every tie from 0.5 to 9.5, rounded to the nearest whole number**
| Number | Normal rounding | Banker's rounding | Result |
| --- | --- | --- | --- |
| 0.5 | 1 | 0 | Banker's rounds down |
| 1.5 | 2 | 2 | Same |
| 2.5 | 3 | 2 | Banker's rounds down |
| 3.5 | 4 | 4 | Same |
| 4.5 | 5 | 4 | Banker's rounds down |
| 5.5 | 6 | 6 | Same |
| 6.5 | 7 | 6 | Banker's rounds down |
| 7.5 | 8 | 8 | Same |
| 8.5 | 9 | 8 | Banker's rounds down |
| 9.5 | 10 | 10 | Same |
| Total (true total 50) | 55 | 50 | Normal rounding is 5 too high |

### Worked example: rounding 2.5

Normal rounding looks at the deciding digit, sees a 5, and rounds up to 3. Banker's rounding recognizes that 2.5 is exactly halfway between 2 and 3, notes that 2 is even, and rounds down to 2. Normal rounding added 0.5 to the value; banker's rounding took 0.5 away. On the next tie, 3.5, banker's rounding goes up to 4 and adds 0.5 back, which is how the running total stays honest.

### Worked example: rounding 3.5

Normal rounding gives 4 because the deciding digit is 5. Banker's rounding also gives 4, because 4 is the even neighbor. Same result, different reasons, which is why the difference between the two methods is easy to miss in a quick spot check.

### Worked example: rounding to cents

The rule works identically at any decimal place. Rounding $0.125 to the nearest cent, the tie is between $0.12 and $0.13. Normal rounding gives $0.13. Banker's rounding gives $0.12, because the kept digit 2 is even. Rounding $12.345 to cents gives $12.35 under normal rounding and $12.34 under banker's rounding. Rounding $1.35 to one decimal place gives 1.4 under both, because 4 is already the even neighbor.

## Why Banker's Rounding Exists: The Bias in Real Numbers

Exact ties are rare in messy real-world data, so the bias in normal rounding only matters when ties are common. That happens more often than it sounds. Any time a whole-cent amount is halved, split or multiplied by a rate like 50% or 2.5%, a large share of results land exactly on a half cent.

Consider a price list with one item at every whole-cent price from $0.01 to $100.00, which is 10,000 items, and a half-price sale. Every odd-cent price produces a half-cent result: $0.01 becomes $0.005, $0.03 becomes $0.015, and so on. That is 5,000 exact ties. The true total of the halved prices is $250,025.00. Rounding each sale price to the cent with normal rounding gives $250,050.00, which is $25.00 too high, half a cent for every tie. Banker's rounding gives exactly $250,025.00, because the kept cent digit alternates between even and odd across consecutive prices.

_[Figure: Cumulative rounding drift on a half-price sale — Items priced $0.01 to $100.00 in one-cent steps, each halved and rounded to the cent. Drift is the rounded total minus the true total.]_

### The case where banker's rounding does not balance

Banker's rounding only cancels its errors when the digit before the tie is spread across odd and even values. If it is not, the bias simply changes direction. Suppose 1,000 accounts each accrue exactly $0.005 of interest. Normal rounding turns every one into $0.01, a total of $10.00 against a true $5.00, so $5.00 too much. Banker's rounding turns every one into $0.00, because 0 is even, a total of $0.00, so $5.00 too little. Neither rule fixes a dataset where every value is the same tie. The real fix in that situation is to keep full precision and round the total once.

> **What "unbiased" actually promises** — Banker's rounding is unbiased on average, across data where odd and even neighbors are equally likely. It is not a guarantee that any particular total will be exact, and it does not reduce the error on an individual value. Each tie is still off by half a unit under either rule.

### Where the name comes from, and what it does not mean

The name "banker's rounding" is traditional, and its origin is not well documented. It does not mean that banks are required to use it, or that accounting standards mandate it. Rounding rules in finance are set by the contract, the regulator or the system specification, and many of them specify half-up. US federal tax returns let you round to whole dollars by dropping amounts under 50 cents and raising amounts from 50 to 99 cents to the next dollar. When the euro was introduced, EU Council Regulation 1103/97 required currency conversions to be rounded to the nearest cent, with an exact half cent rounded up. If a figure has to match an external rule, follow that rule, not the name of the method.

## What Programming Languages and Spreadsheets Actually Do

The defaults vary widely, and some well-known functions use neither pure rule. These are the behaviors documented for common tools:

**Default rounding behavior of common functions**
| Tool | Function | Tie behavior | Examples |
| --- | --- | --- | --- |
| Python 3 | round() | Half to even | round(2.5) = 2, round(3.5) = 4, round(-2.5) = -2 |
| Python | decimal module | Choosable: ROUND_HALF_EVEN (the default context), ROUND_HALF_UP and others | Decimal("2.675") to 2 places: 2.68 under either rule |
| NumPy | numpy.round | Half to even | np.round(0.5) = 0.0, np.round(2.5) = 2.0 |
| C# / .NET | Math.Round | Half to even by default; MidpointRounding.AwayFromZero available | Math.Round(2.5) = 2 |
| Excel / Google Sheets | ROUND | Half away from zero | ROUND(2.5, 0) = 3, ROUND(-2.5, 0) = -3 |
| Excel VBA | Round | Half to even | Round(2.5) = 2 |
| JavaScript | Math.round | Half toward positive infinity | Math.round(2.5) = 3, Math.round(-2.5) = -2 |
| JavaScript | Number.toFixed | Rounds the stored binary value, so decimal ties can go either way | (1.005).toFixed(2) = "1.00" |
| Java | Math.round | Half toward positive infinity | Math.round(-2.5) = -2 |
| Java | BigDecimal with RoundingMode.HALF_EVEN | Half to even (you choose the mode) | new BigDecimal("2.5") to 0 places = 2 |
| IEEE 754 floating point | Default rounding mode | roundTiesToEven | Used for results of binary arithmetic that cannot be stored exactly |

The practical consequence: a spreadsheet built with ROUND and a Python script built with round() can produce different totals from identical inputs. So can an Excel worksheet formula and a VBA macro in the same workbook. JavaScript is the odd one out: Math.round is neither normal rounding nor banker's rounding for negative numbers, and the language has no built-in half-to-even function, so it has to be written by hand or taken from a decimal library.

## The Floating-Point Trap: Not Everything Is Banker's Rounding

Python's round(2.675, 2) returns 2.67. That looks like banker's rounding, since 7 is odd and the result went down, but banker's rounding would give 2.68, because 8 is the even neighbor. The real cause is that most programming languages store decimals in binary, and 2.675 has no exact binary representation. The nearest value a double-precision float can hold is 2.67499999999999982236431605997495353221893310546875, which is slightly below the tie, so it correctly rounds down. No tie-breaking rule was involved at all.

**Ties that are and are not real ties in binary**
| Expression | Result | What actually happened |
| --- | --- | --- |
| Python round(0.125, 2) | 0.12 | 0.125 is exact in binary, so this is a genuine tie broken to even |
| Python round(2.675, 2) | 2.67 | Stored value is just under 2.675, so no tie exists |
| JavaScript (2.675).toFixed(2) | "2.67" | Same stored value, same result |
| JavaScript (1.005).toFixed(2) | "1.00" | Stored value is just under 1.005 |
| Python Decimal("2.675") half-even to 2 places | 2.68 | Decimal stores 2.675 exactly, so it is a true tie and 8 is even |

Values like 0.5, 0.25 and 0.125 are exact in binary, so rounding them shows the real tie rule. Most two-decimal money values are not. For money and anything else that must match a decimal rule exactly, use a decimal type such as Python's decimal module, .NET's decimal, Java's BigDecimal or a decimal library in JavaScript, or work in integer cents. Binary floats are fine for measurement and analysis, where a difference in the fifteenth digit is noise.

> **How the rounding calculator handles this** — The [rounding calculator](/calculators/rounding-calculator) treats what you type as a decimal value, so 2.675 to two places counts as a true tie: Banker's mode returns 2.68 and Standard mode returns 2.68 too. Standard mode rounds halves away from zero (−2.5 → −3), Banker's mode rounds them to even (−2.5 → −2), and Ceiling and Floor always round toward positive or negative infinity.

## When to Use Each Method

_[Figure: Choosing a rounding rule — Work down the list and stop at the first step that applies.]_

**Typical choices by situation**
| Situation | Usual method | Why |
| --- | --- | --- |
| School math and tests | Normal rounding | It is the taught convention, and answer keys assume it |
| Everyday estimates | Normal rounding | Simple, and a single value has no bias to accumulate |
| US tax return whole-dollar rounding | Normal rounding | IRS instructions raise 50 to 99 cents to the next dollar |
| Euro currency conversion | Normal rounding | EU Regulation 1103/97 rounds an exact half cent up |
| Financial systems summing many rounded amounts | Often banker's rounding, if the spec allows | Stops ties from drifting totals upward |
| Statistical summaries of large datasets | Banker's rounding, or round only the final figure | Avoids a small systematic upward shift |
| Scientific and measurement reporting | Round to even on exact ties | Described in NIST SP 811 and ISO 80000-1 |
| Programming | Check the language | Python and .NET default to half even; Excel, JavaScript and Java Math.round do not |

A simple rule of thumb: if a number will be read on its own, normal rounding is fine. If thousands of rounded numbers will be added together, the tie rule starts to matter, and rounding once at the end matters even more. Significant-figure reporting has its own rules for which digit is being rounded, covered in the [significant figures guide](/blog/math/significant-figures-guide).

## Real-World Applications

### Finance and payments

Interest accruals, currency conversions, pro-rata splits and discounts all produce fractions of a cent that must be rounded to a payable amount. Where many of those amounts are summed, a half-even rule keeps the rounded total close to the true total. Where an external rule applies, as with euro conversions or tax forms, the external rule decides, and it is often half-up. The same problem shows up with tax: applying a rate per line and rounding each line gives a different total than rounding the tax on the invoice total, which is the subject of the [sales tax and VAT in Excel guide](/blog/templates/excel-sales-tax-and-vat). The [sales tax calculator](/calculators/sales-tax-calculator) is a quick way to see the unrounded figure before deciding where to round.

### Accounting and reporting

Financial statements are often presented in thousands or millions, so individual rounded lines no longer add to the rounded total. That is a presentation effect rather than a tie-breaking problem, and it happens under both methods. The documented approach matters more than the specific rule: pick one method, apply it consistently, and state where rounding differences are expected.

### Programming

Most rounding bugs in code are not about half-up versus half-even at all. They come from binary floating point, from rounding at every intermediate step, or from two services using different defaults. Choose a decimal type for money, set the rounding mode explicitly instead of relying on a default, and test with values like 0.5, 2.5, −2.5 and 1.005.

### Statistics and science

When raw measurements are recorded to one more digit than will be reported, ties are common, and always rounding them up nudges the mean upward. The round-to-even rule for exact ties is described in NIST's SI guide and in ISO 80000-1. In practice, the stronger habit is to compute averages and standard deviations from unrounded data and round only the result.

## Practice Problems

Round each number with both methods. The first five round to the nearest whole number; the rest use the place shown.

- Problem 1: 2.5. Normal rounding gives 3. Banker's rounding gives 2, because 2 is even.
- Problem 2: 7.5. Normal rounding gives 8. Banker's rounding also gives 8, because 8 is even.
- Problem 3: 4.5. Normal rounding gives 5. Banker's rounding gives 4, because 4 is even.
- Problem 4: 9.5. Normal rounding gives 10. Banker's rounding also gives 10, because the kept digit becomes 0, which is even.
- Problem 5: 6.5. Normal rounding gives 7. Banker's rounding gives 6, because 6 is even.
- Problem 6: 0.125 to the nearest hundredth. Normal rounding gives 0.13. Banker's rounding gives 0.12.
- Problem 7: 3.45 to the nearest tenth. Normal rounding gives 3.5. Banker's rounding gives 3.4.
- Problem 8: 2.51 to the nearest whole number. Both give 3, because 2.51 is not a tie.
- Problem 9: −3.5 to the nearest whole number. Normal rounding (away from zero) gives −4. Banker's rounding also gives −4, because 4 is even.

**Answer summary**
| Number | Rounded to | Normal | Banker's |
| --- | --- | --- | --- |
| 2.5 | Whole number | 3 | 2 |
| 7.5 | Whole number | 8 | 8 |
| 4.5 | Whole number | 5 | 4 |
| 9.5 | Whole number | 10 | 10 |
| 6.5 | Whole number | 7 | 6 |
| 0.125 | Hundredth | 0.13 | 0.12 |
| 3.45 | Tenth | 3.5 | 3.4 |
| 2.51 | Whole number | 3 | 3 |
| −3.5 | Whole number | −4 | −4 |

## Common Mistakes and How to Avoid Them

### Mistake 1: Assuming all rounding is the same

The problem is assuming the school rule applies everywhere. The fix is to check the context: spreadsheets, programming languages, tax forms and scientific guidance do not all agree on ties.

### Mistake 2: Using a different rule from the one specified

The problem is rounding ties up when a system or spec expects half-even, or the reverse. The fix is to treat the tie rule as part of the requirement and to reconcile against the system of record using its rule, not yours.

### Mistake 3: Confusing banker's rounding with truncation

The problem is thinking banker's rounding just cuts off decimals because it sometimes rounds down. The fix is to remember that it still rounds to the nearest value; 2.7 becomes 3 and 2.51 becomes 3. Only exact ties are treated differently. Truncation, by contrast, turns 2.7 into 2.

### Mistake 4: Applying the even rule to non-ties

The problem is rounding 2.501 or 3.4501 as if they were ties. The fix is to check every digit after the 5: if any of them is not zero, the value is past the midpoint and rounds up under both methods.

### Mistake 5: Not checking your language's default

The problem is assuming round() or Math.round() behaves like school rounding. The fix is to read the documentation and test with 2.5 and −2.5. Python and C# default to half even, JavaScript's Math.round sends −2.5 to −2, and Excel's ROUND sends it to −3.

### Mistake 6: Blaming the tie rule for floating-point results

The problem is reading round(2.675, 2) = 2.67 as banker's rounding. The fix is to recognize that the stored binary value is below the tie, and to use a decimal type or integer cents when exact decimal rounding matters.

### Mistake 7: Not documenting your rounding method

The problem is that different team members or systems use different methods and nobody can explain why totals differ. The fix is to state the rule, the precision and the point in the calculation where rounding happens, in the code or in the report notes.

### Mistake 8: Rounding too early

The problem is rounding every intermediate result, which compounds error under any rule. The fix is to keep full precision until the final step. In the half-price example above, adding the unrounded sale prices and rounding the total once gives the exact $250,025.00 no matter which tie rule you use.

## Sources to Verify or Cite

- Python documentation, built-in round(), including the note on round(2.675, 2): https://docs.python.org/3/library/functions.html#round
- Python documentation, decimal module rounding modes: https://docs.python.org/3/library/decimal.html
- Microsoft .NET API reference, Math.Round and MidpointRounding: https://learn.microsoft.com/en-us/dotnet/api/system.math.round
- Microsoft VBA reference, Round function: https://learn.microsoft.com/en-us/office/vba/language/reference/user-interface-help/round-function
- Microsoft Support, Excel ROUND function: https://support.microsoft.com/en-us/office/round-function-c018c5d8-40fb-4053-90b1-b3e7f61a213c
- MDN Web Docs, Math.round(): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round
- MDN Web Docs, Number.prototype.toFixed(): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed
- Oracle Java SE API, RoundingMode: https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/math/RoundingMode.html
- IEEE 754-2019, Standard for Floating-Point Arithmetic: https://standards.ieee.org/ieee/754/6210/
- NIST Special Publication 811, Guide for the Use of the International System of Units: https://www.nist.gov/pml/special-publication-811
- IRS, Instructions for Form 1040, rounding off to whole dollars: https://www.irs.gov/instructions/i1040gi
- Council Regulation (EC) No 1103/97 on the introduction of the euro, Article 5 on rounding: https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=CELEX:31997R1103

## Frequently Asked Questions

**What is banker's rounding?**

Banker's rounding, also called round half to even, rounds a value that is exactly halfway to the neighbor with an even last digit. 2.5 becomes 2, 3.5 becomes 4, and 0.125 to two decimal places becomes 0.12. Values that are not exact ties round to the nearest neighbor as usual.

**What is normal rounding?**

Normal rounding, or round half up, rounds a deciding digit of 5 or more up and 4 or less down. Every exact half goes up: 2.5 becomes 3 and 3.5 becomes 4. For negative numbers it usually means away from zero, so −2.5 becomes −3.

**What is the difference between banker's rounding and normal rounding?**

Only the handling of exact halves. Normal rounding always moves a tie up, away from zero. Banker's rounding moves it to the even neighbor, so ties go up about half the time and down about half the time. On every non-tie the two methods give identical results.

**Why is banker's rounding considered less biased?**

Under normal rounding, the errors from deciding digits 1 to 4 and 6 to 9 cancel, but a 5 always adds +0.5, so the average error is +0.05 per value. Banker's rounding adds +0.5 on some ties and −0.5 on others, which averages to zero when odd and even neighbors are equally common. Rounding 0.5, 1.5 up to 9.5 gives 55 under normal rounding and the true total of 50 under banker's rounding.

**Do banks and accountants have to use banker's rounding?**

No general rule requires it. The name is traditional. Rounding in finance is set by the contract, regulator or system, and many rules specify half-up, including US tax whole-dollar rounding and the EU rule for euro conversions. Banker's rounding is a common choice where many rounded amounts are summed and no external rule applies.

**Does Python use banker's rounding?**

Yes. Python 3's round() rounds exact ties to even, so round(2.5) is 2 and round(0.125, 2) is 0.12. Results can still look surprising because floats are binary: round(2.675, 2) is 2.67 because 2.675 is stored as a value slightly below 2.675. The decimal module avoids that.

**Does Excel use banker's rounding?**

The ROUND worksheet function does not. It rounds halves away from zero, so ROUND(2.5, 0) is 3 and ROUND(-2.5, 0) is -3. The Round function in VBA does use banker's rounding, so a macro and a formula in the same workbook can disagree.

**Does JavaScript use banker's rounding?**

No. Math.round rounds halves toward positive infinity, so Math.round(2.5) is 3 but Math.round(-2.5) is -2. toFixed works on the stored binary value, which is why (1.005).toFixed(2) returns "1.00". JavaScript has no built-in half-to-even function.

**What is round half away from zero?**

A rule that moves exact halves away from zero: 2.5 becomes 3 and −2.5 becomes −3. It is the usual meaning of normal rounding and the behavior of Excel's ROUND. It differs from round half toward positive infinity only on negative ties.

**Can rounding errors really cause problems?**

Yes, when ties are frequent and many rounded values are summed. Halving 10,000 prices from $0.01 to $100.00 and rounding each to the cent overstates the total by $25.00 under normal rounding. The simplest protection under either rule is to keep full precision and round the final total once.

**What does floating-point precision have to do with rounding?**

Most languages store decimals in binary, and many decimal values, including 2.675 and 1.005, cannot be stored exactly. The stored value lands slightly above or below the intended tie, so the result is decided by that tiny difference rather than by any tie-breaking rule. Decimal types and integer cents avoid the problem.

**Which rounding method is best?**

It depends on the job. Use whatever rule is specified by a form, regulation or existing system. Use banker's rounding when many values with frequent ties are rounded and then summed or averaged. Use normal rounding for everyday math, school work and single values people will check by hand.

## Final Summary

Banker's rounding and normal rounding differ in exactly one case: a value that sits precisely halfway. Normal rounding always sends it up, which adds a small, consistent upward bias whenever ties are common. Banker's rounding sends it to the even neighbor, which cancels that bias when odd and even neighbors appear equally often. Neither rule removes the need to round at the right moment, and neither explains results that come from binary floating point.

**Quick reference**
| Number | Normal rounding | Banker's rounding |
| --- | --- | --- |
| 1.5 | 2 | 2 |
| 2.5 | 3 | 2 |
| 3.5 | 4 | 4 |
| 4.5 | 5 | 4 |
| 5.5 | 6 | 6 |
| 6.5 | 7 | 6 |
| −2.5 | −3 | −2 |

- The methods only disagree on exact ties, and only when the kept digit would otherwise become odd
- On evenly spread one-decimal data, normal rounding averages +0.05 of error per value; banker's rounding averages zero
- Python round() and .NET Math.Round default to half even; Excel ROUND rounds halves away from zero; JavaScript Math.round sends halves toward positive infinity
- round(2.675, 2) = 2.67 is a floating-point effect, not banker's rounding
- Follow any external rule first: US tax whole-dollar rounding and euro conversions both round halves up
- Keep full precision and round once at the end, and document the rule you used

---

_Source: [Do The Calculation](https://dothecalculation.com/blog/math/bankers-rounding-vs-normal-rounding). Quote freely with attribution and a link to this page._