mirror of
https://github.com/python/cpython.git
synced 2025-08-03 16:39:00 +00:00
Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60706,60708-60712,60714-60724 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk ........ r60701 | georg.brandl | 2008-02-09 22:36:15 +0100 (Sat, 09 Feb 2008) | 2 lines Needs only 2.4 now. ........ r60702 | georg.brandl | 2008-02-09 22:38:54 +0100 (Sat, 09 Feb 2008) | 2 lines Docs are rst now. ........ r60703 | georg.brandl | 2008-02-09 23:00:00 +0100 (Sat, 09 Feb 2008) | 2 lines Fix link. ........ r60704 | georg.brandl | 2008-02-10 00:09:25 +0100 (Sun, 10 Feb 2008) | 2 lines Fix for newest doctools. ........ r60709 | raymond.hettinger | 2008-02-10 08:21:09 +0100 (Sun, 10 Feb 2008) | 1 line Clarify that decimal also supports fixed-point arithmetic. ........ r60710 | nick.coghlan | 2008-02-10 08:32:52 +0100 (Sun, 10 Feb 2008) | 1 line Add missing NEWS entry for r60695 ........ r60712 | mark.dickinson | 2008-02-10 15:58:38 +0100 (Sun, 10 Feb 2008) | 3 lines Turn classmethods into staticmethods, and avoid calling the constructor of subclasses of Rational. (See discussion in issue #1682.) ........ r60715 | mark.dickinson | 2008-02-10 16:19:58 +0100 (Sun, 10 Feb 2008) | 2 lines Typos in decimal comment and documentation ........ r60716 | skip.montanaro | 2008-02-10 16:31:54 +0100 (Sun, 10 Feb 2008) | 2 lines Get the saying right. ;-) ........ r60717 | skip.montanaro | 2008-02-10 16:32:16 +0100 (Sun, 10 Feb 2008) | 2 lines whoops - revert ........ r60718 | mark.dickinson | 2008-02-10 20:23:36 +0100 (Sun, 10 Feb 2008) | 2 lines Remove reference to Rational ........ r60719 | raymond.hettinger | 2008-02-10 21:35:16 +0100 (Sun, 10 Feb 2008) | 1 line Complete an open todo on pickletools -- add a pickle optimizer. ........ r60721 | mark.dickinson | 2008-02-10 22:29:51 +0100 (Sun, 10 Feb 2008) | 3 lines Rename rational.Rational to fractions.Fraction, to avoid name clash with numbers.Rational. See issue #1682 for related discussion. ........ r60722 | christian.heimes | 2008-02-11 03:26:22 +0100 (Mon, 11 Feb 2008) | 1 line The test requires the network resource ........ r60723 | mark.dickinson | 2008-02-11 04:11:55 +0100 (Mon, 11 Feb 2008) | 3 lines Put an extra space into the repr of a Fraction: Fraction(1, 2) instead of Fraction(1,2). ........
This commit is contained in:
Christian Heimes
parent
ba99c58872
commit
3feef61742
15 changed files with 190 additions and 146 deletions
|
|
@ -1,6 +1,6 @@
|
|||
|
||||
:mod:`decimal` --- Decimal floating point arithmetic
|
||||
====================================================
|
||||
:mod:`decimal` --- Decimal fixed point and floating point arithmetic
|
||||
====================================================================
|
||||
|
||||
.. module:: decimal
|
||||
:synopsis: Implementation of the General Decimal Arithmetic Specification.
|
||||
|
|
@ -16,6 +16,11 @@
|
|||
The :mod:`decimal` module provides support for decimal floating point
|
||||
arithmetic. It offers several advantages over the :class:`float` datatype:
|
||||
|
||||
* Decimal "is based on a floating-point model which was designed with people
|
||||
in mind, and necessarily has a paramount guiding principle -- computers must
|
||||
provide an arithmetic that works in the same way as the arithmetic that
|
||||
people learn at school." -- excerpt from the decimal arithmetic specification.
|
||||
|
||||
* Decimal numbers can be represented exactly. In contrast, numbers like
|
||||
:const:`1.1` do not have an exact representation in binary floating point. End
|
||||
users typically would not expect :const:`1.1` to display as
|
||||
|
|
@ -25,7 +30,7 @@ arithmetic. It offers several advantages over the :class:`float` datatype:
|
|||
+ 0.1 + 0.1 - 0.3`` is exactly equal to zero. In binary floating point, the result
|
||||
is :const:`5.5511151231257827e-017`. While near to zero, the differences
|
||||
prevent reliable equality testing and differences can accumulate. For this
|
||||
reason, decimal would be preferred in accounting applications which have strict
|
||||
reason, decimal is preferred in accounting applications which have strict
|
||||
equality invariants.
|
||||
|
||||
* The decimal module incorporates a notion of significant places so that ``1.30
|
||||
|
|
@ -50,6 +55,13 @@ arithmetic. It offers several advantages over the :class:`float` datatype:
|
|||
standards. While the built-in float type exposes only a modest portion of its
|
||||
capabilities, the decimal module exposes all required parts of the standard.
|
||||
When needed, the programmer has full control over rounding and signal handling.
|
||||
This includes an option to enforce exact arithmetic by using exceptions
|
||||
to block any inexact operations.
|
||||
|
||||
* The decimal module was designed to support "without prejudice, both exact
|
||||
unrounded decimal arithmetic (sometimes called fixed-point arithmetic)
|
||||
and rounded floating-point arithmetic." -- excerpt from the decimal
|
||||
arithmetic specification.
|
||||
|
||||
The module design is centered around three concepts: the decimal number, the
|
||||
context for arithmetic, and signals.
|
||||
|
|
@ -832,7 +844,7 @@ described below. In addition, the module provides three pre-made contexts:
|
|||
:const:`ROUND_HALF_EVEN`. All flags are cleared. No traps are enabled (so that
|
||||
exceptions are not raised during computations).
|
||||
|
||||
Because the trapped are disabled, this context is useful for applications that
|
||||
Because the traps are disabled, this context is useful for applications that
|
||||
prefer to have result value of :const:`NaN` or :const:`Infinity` instead of
|
||||
raising exceptions. This allows an application to complete a run in the
|
||||
presence of conditions that would otherwise halt the program.
|
||||
|
|
@ -1245,7 +1257,7 @@ quiet or signaling :const:`NaN` always returns :const:`False` (even when doing
|
|||
:const:`True`. An attempt to compare two Decimals using any of the ``<``,
|
||||
``<=``, ``>`` or ``>=`` operators will raise the :exc:`InvalidOperation` signal
|
||||
if either operand is a :const:`NaN`, and return :const:`False` if this signal is
|
||||
trapped. Note that the General Decimal Arithmetic specification does not
|
||||
not trapped. Note that the General Decimal Arithmetic specification does not
|
||||
specify the behavior of direct comparisons; these rules for comparisons
|
||||
involving a :const:`NaN` were taken from the IEEE 854 standard (see Table 3 in
|
||||
section 5.7). To ensure strict standards-compliance, use the :meth:`compare`
|
||||
|
|
|
|||
|
|
@ -1,28 +1,28 @@
|
|||
|
||||
:mod:`rational` --- Rational numbers
|
||||
:mod:`fractions` --- Rational numbers
|
||||
====================================
|
||||
|
||||
.. module:: rational
|
||||
.. module:: fractions
|
||||
:synopsis: Rational numbers.
|
||||
.. moduleauthor:: Jeffrey Yasskin <jyasskin at gmail.com>
|
||||
.. sectionauthor:: Jeffrey Yasskin <jyasskin at gmail.com>
|
||||
.. versionadded:: 2.6
|
||||
|
||||
|
||||
The :mod:`rational` module defines an immutable, infinite-precision
|
||||
The :mod:`fractions` module defines an immutable, infinite-precision
|
||||
Rational number class.
|
||||
|
||||
|
||||
.. class:: Rational(numerator=0, denominator=1)
|
||||
Rational(other_rational)
|
||||
Rational(string)
|
||||
.. class:: Fraction(numerator=0, denominator=1)
|
||||
Fraction(other_fraction)
|
||||
Fraction(string)
|
||||
|
||||
The first version requires that *numerator* and *denominator* are
|
||||
instances of :class:`numbers.Integral` and returns a new
|
||||
``Rational`` representing ``numerator/denominator``. If
|
||||
``Fraction`` representing ``numerator/denominator``. If
|
||||
*denominator* is :const:`0`, raises a :exc:`ZeroDivisionError`. The
|
||||
second version requires that *other_rational* is an instance of
|
||||
:class:`numbers.Rational` and returns an instance of
|
||||
second version requires that *other_fraction* is an instance of
|
||||
:class:`numbers.Fraction` and returns an instance of
|
||||
:class:`Rational` with the same value. The third version expects a
|
||||
string of the form ``[-+]?[0-9]+(/[0-9]+)?``, optionally surrounded
|
||||
by spaces.
|
||||
|
|
@ -31,39 +31,39 @@ Rational number class.
|
|||
:class:`numbers.Rational` and is immutable and hashable.
|
||||
|
||||
|
||||
.. method:: Rational.from_float(flt)
|
||||
.. method:: Fraction.from_float(flt)
|
||||
|
||||
This classmethod constructs a :class:`Rational` representing the
|
||||
This classmethod constructs a :class:`Fraction` representing the
|
||||
exact value of *flt*, which must be a :class:`float`. Beware that
|
||||
``Rational.from_float(0.3)`` is not the same value as ``Rational(3,
|
||||
``Fraction.from_float(0.3)`` is not the same value as ``Rational(3,
|
||||
10)``
|
||||
|
||||
|
||||
.. method:: Rational.from_decimal(dec)
|
||||
.. method:: Fraction.from_decimal(dec)
|
||||
|
||||
This classmethod constructs a :class:`Rational` representing the
|
||||
This classmethod constructs a :class:`Fraction` representing the
|
||||
exact value of *dec*, which must be a
|
||||
:class:`decimal.Decimal`.
|
||||
|
||||
|
||||
.. method:: Rational.__floor__()
|
||||
.. method:: Fraction.__floor__()
|
||||
|
||||
Returns the greatest :class:`int` ``<= self``. Will be accessible
|
||||
through :func:`math.floor` in Py3k.
|
||||
|
||||
|
||||
.. method:: Rational.__ceil__()
|
||||
.. method:: Fraction.__ceil__()
|
||||
|
||||
Returns the least :class:`int` ``>= self``. Will be accessible
|
||||
through :func:`math.ceil` in Py3k.
|
||||
|
||||
|
||||
.. method:: Rational.__round__()
|
||||
Rational.__round__(ndigits)
|
||||
.. method:: Fraction.__round__()
|
||||
Fraction.__round__(ndigits)
|
||||
|
||||
The first version returns the nearest :class:`int` to ``self``,
|
||||
rounding half to even. The second version rounds ``self`` to the
|
||||
nearest multiple of ``Rational(1, 10**ndigits)`` (logically, if
|
||||
nearest multiple of ``Fraction(1, 10**ndigits)`` (logically, if
|
||||
``ndigits`` is negative), again rounding half toward even. Will be
|
||||
accessible through :func:`round` in Py3k.
|
||||
|
||||
|
|
@ -104,7 +104,7 @@ Notes for type implementors
|
|||
|
||||
Implementors should be careful to make equal numbers equal and hash
|
||||
them to the same values. This may be subtle if there are two different
|
||||
extensions of the real numbers. For example, :class:`rational.Rational`
|
||||
extensions of the real numbers. For example, :class:`fractions.Fraction`
|
||||
implements :func:`hash` as follows::
|
||||
|
||||
def __hash__(self):
|
||||
|
|
@ -199,11 +199,11 @@ in :class:`complex`, and both :meth:`__radd__` s land there, so ``a+b
|
|||
Because most of the operations on any given type will be very similar,
|
||||
it can be useful to define a helper function which generates the
|
||||
forward and reverse instances of any given operator. For example,
|
||||
:class:`rational.Rational` uses::
|
||||
:class:`fractions.Fraction` uses::
|
||||
|
||||
def _operator_fallbacks(monomorphic_operator, fallback_operator):
|
||||
def forward(a, b):
|
||||
if isinstance(b, (int, long, Rational)):
|
||||
if isinstance(b, (int, long, Fraction)):
|
||||
return monomorphic_operator(a, b)
|
||||
elif isinstance(b, float):
|
||||
return fallback_operator(float(a), b)
|
||||
|
|
@ -215,7 +215,7 @@ forward and reverse instances of any given operator. For example,
|
|||
forward.__doc__ = monomorphic_operator.__doc__
|
||||
|
||||
def reverse(b, a):
|
||||
if isinstance(a, RationalAbc):
|
||||
if isinstance(a, Rational):
|
||||
# Includes ints.
|
||||
return monomorphic_operator(a, b)
|
||||
elif isinstance(a, numbers.Real):
|
||||
|
|
@ -231,7 +231,7 @@ forward and reverse instances of any given operator. For example,
|
|||
|
||||
def _add(a, b):
|
||||
"""a + b"""
|
||||
return Rational(a.numerator * b.denominator +
|
||||
return Fraction(a.numerator * b.denominator +
|
||||
b.numerator * a.denominator,
|
||||
a.denominator * b.denominator)
|
||||
|
||||
|
|
|
|||
|
|
@ -33,3 +33,10 @@ probably won't find the :mod:`pickletools` module relevant.
|
|||
the opcode's argument; *pos* is the position at which this opcode is located.
|
||||
*pickle* can be a string or a file-like object.
|
||||
|
||||
.. function:: optimize(picklestring)
|
||||
|
||||
Returns a new equivalent pickle string after eliminating unused ``PUT``
|
||||
opcodes. The optimized pickle is shorter, takes less transmission time,
|
||||
requires less storage space, and unpickles more efficiently.
|
||||
|
||||
.. versionadded:: 2.6
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue