# [Python-checkins] r71671 - python/branches/py3k/Doc/whatsnew/3.1.rst

raymond.hettinger python-checkins at python.org
Fri Apr 17 11:45:20 CEST 2009

```Author: raymond.hettinger
Date: Fri Apr 17 11:45:19 2009
New Revision: 71671

Log:
Nits.

Modified:
python/branches/py3k/Doc/whatsnew/3.1.rst

Modified: python/branches/py3k/Doc/whatsnew/3.1.rst
==============================================================================
--- python/branches/py3k/Doc/whatsnew/3.1.rst	(original)
+++ python/branches/py3k/Doc/whatsnew/3.1.rst	Fri Apr 17 11:45:19 2009
@@ -155,7 +155,7 @@

The significance is easily seen with a number like ``1.1`` which does not
have an exact equivalent in binary floating point.  Since there is no exact
-  equivalent, an expression like ``float("1.1")`` evaluates to the nearest
+  equivalent, an expression like ``float('1.1')`` evaluates to the nearest
representable value which is ``0x1.199999999999ap+0`` in hex or
``1.100000000000000088817841970012523233890533447265625`` in decimal. That
nearest value was and still is used in subsequent floating point
@@ -163,16 +163,16 @@

What is new is how the number gets displayed.  Formerly, Python used a
simple approach.  The value of ``repr(1.1)`` was computed as ``format(1.1,
-  '.17g')`` which evaluates to ``'1.1000000000000001'``. The advantage of
+  '.17g')`` which evaluated to ``'1.1000000000000001'``. The advantage of
using 17 digits was that it relied on IEEE-754 guarantees to assure that
``eval(repr(1.1))`` would round-trip exactly to its original value.  The
disadvantage is that many people found the output to be confusing (mistaking
intrinsic limitations of binary floating point representation as being a
problem with Python itself).

-  The new algorithm for ``repr(1.1)`` is smarter and returns ``1.1``.
+  The new algorithm for ``repr(1.1)`` is smarter and returns ``'1.1'``.
Effectively, it searches all equivalent string representations (ones that
-  get stored as the same underlying float value) and returns the shortest
+  get stored with the same underlying float value) and returns the shortest
representation.

The new algorithm tends to emit cleaner representations when possible, but
```