> My students and I are interested in knowing the rationale behind Python's
> choice of the Banker's rounding algorithm to be the default rounding
> algorithm in the third release of Python.
To be specific: your question is on the toplevel round() function.
https://docs.python.org/3/library/functions.html#round
The assumption implicit in the question is that Python is the only
system that does this.
However, it's not just Python: the general "IEEE 754" standard says to do this.
https://en.wikipedia.org/wiki/Rounding#Round_half_to_even
There's more background information here:
http://www.lahey.com/float.htm
---
The rest of this is very-deep diving: if you are a beginner to Python,
I strongly recommend skipping the rest of this.
Let me double check where the rounding is happening, just for my own
peace of mind.
According the source code, in Python 2:
https://github.com/python-git/python/blob/master/Python/bltinmodule.c#L2064
it does its own thing, and we can see in in terms of floor() and ceiling().
What about in Python 3?
If we look at the latest code,
http://svn.python.org/projects/python/trunk/Python/bltinmodule.c,
and look for "builtin_round", it tells us to look at the
'_Py_double_round' function defined in floatobject.c,
http://svn.python.org/projects/python/trunk/Objects/floatobject.c
which in fact does appear to have its own implementation of rounding,
with the internal comment C:
/* The basic idea is very simple: convert and round the double to a
decimal string using _Py_dg_dtoa, then convert that decimal string
back to a double with _Py_dg_strtod. There's one minor difficulty:
Python 2.x expects round to do round-half-away-from-zero, while
_Py_dg_dtoa does round-half-to-even. So we need some way to detect
and correct the halfway cases.
Detection: a halfway value has the form k * 0.5 * 10**-ndigits for
some odd integer k. Or in other words, a rational number x is
exactly halfway between two multiples of 10**-ndigits if its
2-valuation is exactly -ndigits-1 and its 5-valuation is at least
-ndigits. For ndigits >= 0 the latter condition is automatically
satisfied for a binary float x, since any such float has
nonnegative 5-valuation. For 0 > ndigits >= -22, x needs to be an
integral multiple of 5**-ndigits; we can check this using fmod.
For -22 > ndigits, there are no halfway cases: 5**23 takes 54 bits
to represent exactly, so any odd multiple of 0.5 * 10**n for n >=
23 takes at least 54 bits of precision to represent exactly.
Correction: a simple strategy for dealing with halfway cases is to
(for the halfway cases only) call _Py_dg_dtoa with an argument of
ndigits+1 instead of ndigits (thus doing an exact conversion to
decimal), round the resulting string manually, and then convert
back using _Py_dg_strtod.
*/
Suffice it to say, this is probably too much detail already.
_______________________________________________
Tutor maillist - Tutor@python.org
To unsubscribe or change subscription options:
https://mail.python.org/mailman/listinfo/tutor
