mirrors
/
cpython
mirror of https://github.com/python/cpython.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

gh-101100: Fix Sphinx warnings in `decimal` module (GH-102125) 

(cherry picked from commit b7c1126447)

Co-authored-by: Hugo van Kemenade <hugovk@users.noreply.github.com>
Co-authored-by: C.A.M. Gerlach <CAM.Gerlach@Gerlach.CAM>
This commit is contained in:
Miss Islington (bot) 2023-02-25 01:51:36 -08:00 committed by GitHub
parent 9f472f81bc
commit 9563cf47bc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 84 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

168
Doc/library/decimal.rst
View File

@ -40,23 +40,23 @@ decimal floating point arithmetic. It offers several advantages over the
people learn at school." -- excerpt from the decimal arithmetic specification.
* Decimal numbers can be represented exactly. In contrast, numbers like
:const:`1.1` and :const:`2.2` do not have exact representations in binary
``1.1`` and ``2.2`` do not have exact representations in binary
floating point. End users typically would not expect ``1.1 + 2.2`` to display
as :const:`3.3000000000000003` as it does with binary floating point.
as ``3.3000000000000003`` as it does with binary floating point.
* The exactness carries over into arithmetic. In decimal floating point, ``0.1
+ 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
is ``5.5511151231257827e-017``. While near to zero, the differences
prevent reliable equality testing and differences can accumulate. For this
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
+ 1.20`` is :const:`2.50`. The trailing zero is kept to indicate significance.
+ 1.20`` is ``2.50``. The trailing zero is kept to indicate significance.
This is the customary presentation for monetary applications. For
multiplication, the "schoolbook" approach uses all the figures in the
multiplicands. For instance, ``1.3 * 1.2`` gives :const:`1.56` while ``1.30 *
1.20`` gives :const:`1.5600`.
multiplicands. For instance, ``1.3 * 1.2`` gives ``1.56`` while ``1.30 *
1.20`` gives ``1.5600``.
* Unlike hardware based binary floating point, the decimal module has a user
alterable precision (defaulting to 28 places) which can be as large as needed for
@ -88,8 +88,8 @@ context for arithmetic, and signals.
A decimal number is immutable. It has a sign, coefficient digits, and an
exponent. To preserve significance, the coefficient digits do not truncate
trailing zeros. Decimals also include special values such as
:const:`Infinity`, :const:`-Infinity`, and :const:`NaN`. The standard also
differentiates :const:`-0` from :const:`+0`.
``Infinity``, ``-Infinity``, and ``NaN``. The standard also
differentiates ``-0`` from ``+0``.
The context for arithmetic is an environment specifying precision, rounding
rules, limits on exponents, flags indicating the results of operations, and trap
@ -139,8 +139,8 @@ precision, rounding, or enabled traps::
Decimal instances can be constructed from integers, strings, floats, or tuples.
Construction from an integer or a float performs an exact conversion of the
value of that integer or float. Decimal numbers include special values such as
:const:`NaN` which stands for "Not a number", positive and negative
:const:`Infinity`, and :const:`-0`::
``NaN`` which stands for "Not a number", positive and negative
``Infinity``, and ``-0``::
>>> getcontext().prec = 28
>>> Decimal(10)
@ -250,7 +250,7 @@ And some mathematical functions are also available to Decimal:
>>> Decimal('10').log10()
Decimal('1')
The :meth:`quantize` method rounds a number to a fixed exponent. This method is
The :meth:`~Decimal.quantize` method rounds a number to a fixed exponent. This method is
useful for monetary applications that often round results to a fixed number of
places:
@ -299,7 +299,7 @@ enabled:
Contexts also have signal flags for monitoring exceptional conditions
encountered during computations. The flags remain set until explicitly cleared,
so it is best to clear the flags before each set of monitored computations by
using the :meth:`clear_flags` method. ::
using the :meth:`~Context.clear_flags` method. ::
>>> setcontext(ExtendedContext)
>>> getcontext().clear_flags()
@ -309,12 +309,12 @@ using the :meth:`clear_flags` method. ::
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999,
capitals=1, clamp=0, flags=[Inexact, Rounded], traps=[])
The *flags* entry shows that the rational approximation to :const:`Pi` was
The *flags* entry shows that the rational approximation to pi was
rounded (digits beyond the context precision were thrown away) and that the
result is inexact (some of the discarded digits were non-zero).
Individual traps are set using the dictionary in the :attr:`traps` field of a
context:
Individual traps are set using the dictionary in the :attr:`~Context.traps`
attribute of a context:
.. doctest:: newcontext
@ -369,7 +369,7 @@ Decimal objects
with the fullwidth digits ``'\uff10'`` through ``'\uff19'``.
If *value* is a :class:`tuple`, it should have three components, a sign
(:const:`0` for positive or :const:`1` for negative), a :class:`tuple` of
(``0`` for positive or ``1`` for negative), a :class:`tuple` of
digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))``
returns ``Decimal('1.414')``.
@ -387,7 +387,7 @@ Decimal objects
The purpose of the *context* argument is determining what to do if *value* is a
malformed string. If the context traps :const:`InvalidOperation`, an exception
is raised; otherwise, the constructor returns a new Decimal with the value of
:const:`NaN`.
``NaN``.
Once constructed, :class:`Decimal` objects are immutable.
@ -701,7 +701,7 @@ Decimal objects
.. method:: max(other, context=None)
Like ``max(self, other)`` except that the context rounding rule is applied
before returning and that :const:`NaN` values are either signaled or
before returning and that ``NaN`` values are either signaled or
ignored (depending on the context and whether they are signaling or
quiet).
@ -713,7 +713,7 @@ Decimal objects
.. method:: min(other, context=None)
Like ``min(self, other)`` except that the context rounding rule is applied
before returning and that :const:`NaN` values are either signaled or
before returning and that ``NaN`` values are either signaled or
ignored (depending on the context and whether they are signaling or
quiet).
@ -744,8 +744,8 @@ Decimal objects
.. method:: normalize(context=None)
Normalize the number by stripping the rightmost trailing zeros and
converting any result equal to :const:`Decimal('0')` to
:const:`Decimal('0e0')`. Used for producing canonical values for attributes
converting any result equal to ``Decimal('0')`` to
``Decimal('0e0')``. Used for producing canonical values for attributes
of an equivalence class. For example, ``Decimal('32.100')`` and
``Decimal('0.321000e+2')`` both normalize to the equivalent value
``Decimal('32.1')``.
@ -790,7 +790,7 @@ Decimal objects
the current thread's context is used.
An error is returned whenever the resulting exponent is greater than
:attr:`Emax` or less than :attr:`Etiny`.
:attr:`~Context.Emax` or less than :meth:`~Context.Etiny`.
.. method:: radix()
@ -830,7 +830,7 @@ Decimal objects
.. method:: same_quantum(other, context=None)
Test whether self and other have the same exponent or whether both are
:const:`NaN`.
``NaN``.
This operation is unaffected by context and is quiet: no flags are changed
and no rounding is performed. As an exception, the C version may raise
@ -892,11 +892,11 @@ Decimal objects
Logical operands
^^^^^^^^^^^^^^^^
The :meth:`logical_and`, :meth:`logical_invert`, :meth:`logical_or`,
and :meth:`logical_xor` methods expect their arguments to be *logical
The :meth:`~Decimal.logical_and`, :meth:`~Decimal.logical_invert`, :meth:`~Decimal.logical_or`,
and :meth:`~Decimal.logical_xor` methods expect their arguments to be *logical
operands*. A *logical operand* is a :class:`Decimal` instance whose
exponent and sign are both zero, and whose digits are all either
:const:`0` or :const:`1`.
``0`` or ``1``.
.. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -966,7 +966,7 @@ described below. In addition, the module provides three pre-made contexts:
exceptions are not raised during computations).
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
prefer to have result value of ``NaN`` or ``Infinity`` instead of
raising exceptions. This allows an application to complete a run in the
presence of conditions that would otherwise halt the program.
@ -985,8 +985,8 @@ described below. In addition, the module provides three pre-made contexts:
In single threaded environments, it is preferable to not use this context at
all. Instead, simply create contexts explicitly as described below.
The default values are :attr:`prec`\ =\ :const:`28`,
:attr:`rounding`\ =\ :const:`ROUND_HALF_EVEN`,
The default values are :attr:`Context.prec`\ =\ ``28``,
:attr:`Context.rounding`\ =\ :const:`ROUND_HALF_EVEN`,
and enabled traps for :class:`Overflow`, :class:`InvalidOperation`, and
:class:`DivisionByZero`.
@ -1000,7 +1000,7 @@ In addition to the three supplied contexts, new contexts can be created with the
default values are copied from the :const:`DefaultContext`. If the *flags*
field is not specified or is :const:`None`, all flags are cleared.
*prec* is an integer in the range [:const:`1`, :const:`MAX_PREC`] that sets
*prec* is an integer in the range [``1``, :const:`MAX_PREC`] that sets
the precision for arithmetic operations in the context.
The *rounding* option is one of the constants listed in the section
@ -1010,20 +1010,20 @@ In addition to the three supplied contexts, new contexts can be created with the
contexts should only set traps and leave the flags clear.
The *Emin* and *Emax* fields are integers specifying the outer limits allowable
for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, :const:`0`],
*Emax* in the range [:const:`0`, :const:`MAX_EMAX`].
for exponents. *Emin* must be in the range [:const:`MIN_EMIN`, ``0``],
*Emax* in the range [``0``, :const:`MAX_EMAX`].
The *capitals* field is either :const:`0` or :const:`1` (the default). If set to
:const:`1`, exponents are printed with a capital :const:`E`; otherwise, a
lowercase :const:`e` is used: :const:`Decimal('6.02e+23')`.
The *capitals* field is either ``0`` or ``1`` (the default). If set to
``1``, exponents are printed with a capital ``E``; otherwise, a
lowercase ``e`` is used: ``Decimal('6.02e+23')``.
The *clamp* field is either :const:`0` (the default) or :const:`1`.
If set to :const:`1`, the exponent ``e`` of a :class:`Decimal`
The *clamp* field is either ``0`` (the default) or ``1``.
If set to ``1``, the exponent ``e`` of a :class:`Decimal`
instance representable in this context is strictly limited to the
range ``Emin - prec + 1 <= e <= Emax - prec + 1``. If *clamp* is
:const:`0` then a weaker condition holds: the adjusted exponent of
the :class:`Decimal` instance is at most ``Emax``. When *clamp* is
:const:`1`, a large normal number will, where possible, have its
``0`` then a weaker condition holds: the adjusted exponent of
the :class:`Decimal` instance is at most :attr:`~Context.Emax`. When *clamp* is
``1``, a large normal number will, where possible, have its
exponent reduced and a corresponding number of zeros added to its
coefficient, in order to fit the exponent constraints; this
preserves the value of the number but loses information about
@ -1032,13 +1032,13 @@ In addition to the three supplied contexts, new contexts can be created with the
>>> Context(prec=6, Emax=999, clamp=1).create_decimal('1.23e999')
Decimal('1.23000E+999')
A *clamp* value of :const:`1` allows compatibility with the
A *clamp* value of ``1`` allows compatibility with the
fixed-width decimal interchange formats specified in IEEE 754.
The :class:`Context` class defines several general purpose methods as well as
a large number of methods for doing arithmetic directly in a given context.
In addition, for each of the :class:`Decimal` methods described above (with
the exception of the :meth:`adjusted` and :meth:`as_tuple` methods) there is
the exception of the :meth:`~Decimal.adjusted` and :meth:`~Decimal.as_tuple` methods) there is
a corresponding :class:`Context` method. For example, for a :class:`Context`
instance ``C`` and :class:`Decimal` instance ``x``, ``C.exp(x)`` is
equivalent to ``x.exp(context=C)``. Each :class:`Context` method accepts a
@ -1048,11 +1048,11 @@ In addition to the three supplied contexts, new contexts can be created with the
.. method:: clear_flags()
Resets all of the flags to :const:`0`.
Resets all of the flags to ``0``.
.. method:: clear_traps()
Resets all of the traps to :const:`0`.
Resets all of the traps to ``0``.
.. versionadded:: 3.3
@ -1467,13 +1467,13 @@ are also included in the pure Python version for compatibility.
+---------------------+---------------------+-------------------------------+
| | 32-bit | 64-bit |
+=====================+=====================+===============================+
| .. data:: MAX_PREC | :const:`425000000` | :const:`999999999999999999` |
| .. data:: MAX_PREC | ``425000000`` | ``999999999999999999`` |
+---------------------+---------------------+-------------------------------+
| .. data:: MAX_EMAX | :const:`425000000` | :const:`999999999999999999` |
| .. data:: MAX_EMAX | ``425000000`` | ``999999999999999999`` |
+---------------------+---------------------+-------------------------------+
| .. data:: MIN_EMIN | :const:`-425000000` | :const:`-999999999999999999` |
| .. data:: MIN_EMIN | ``-425000000`` | ``-999999999999999999`` |
+---------------------+---------------------+-------------------------------+
| .. data:: MIN_ETINY | :const:`-849999999` | :const:`-1999999999999999997` |
| .. data:: MIN_ETINY | ``-849999999`` | ``-1999999999999999997`` |
+---------------------+---------------------+-------------------------------+
@ -1498,7 +1498,7 @@ Rounding modes
.. data:: ROUND_CEILING
Round towards :const:`Infinity`.
Round towards ``Infinity``.
.. data:: ROUND_DOWN
@ -1506,7 +1506,7 @@ Rounding modes
.. data:: ROUND_FLOOR
Round towards :const:`-Infinity`.
Round towards ``-Infinity``.
.. data:: ROUND_HALF_DOWN
@ -1554,7 +1554,7 @@ condition.
Altered an exponent to fit representation constraints.
Typically, clamping occurs when an exponent falls outside the context's
:attr:`Emin` and :attr:`Emax` limits. If possible, the exponent is reduced to
:attr:`~Context.Emin` and :attr:`~Context.Emax` limits. If possible, the exponent is reduced to
fit by adding zeros to the coefficient.
@ -1568,8 +1568,8 @@ condition.
Signals the division of a non-infinite number by zero.
Can occur with division, modulo division, or when raising a number to a negative
power. If this signal is not trapped, returns :const:`Infinity` or
:const:`-Infinity` with the sign determined by the inputs to the calculation.
power. If this signal is not trapped, returns ``Infinity`` or
``-Infinity`` with the sign determined by the inputs to the calculation.
.. class:: Inexact
@ -1586,7 +1586,7 @@ condition.
An invalid operation was performed.
Indicates that an operation was requested that does not make sense. If not
trapped, returns :const:`NaN`. Possible causes include::
trapped, returns ``NaN``. Possible causes include::
Infinity - Infinity
0 * Infinity
@ -1603,10 +1603,10 @@ condition.
Numerical overflow.
Indicates the exponent is larger than :attr:`Emax` after rounding has
Indicates the exponent is larger than :attr:`Context.Emax` after rounding has
occurred. If not trapped, the result depends on the rounding mode, either
pulling inward to the largest representable finite number or rounding outward
to :const:`Infinity`. In either case, :class:`Inexact` and :class:`Rounded`
to ``Infinity``. In either case, :class:`Inexact` and :class:`Rounded`
are also signaled.
@ -1615,14 +1615,14 @@ condition.
Rounding occurred though possibly no information was lost.
Signaled whenever rounding discards digits; even if those digits are zero
(such as rounding :const:`5.00` to :const:`5.0`). If not trapped, returns
(such as rounding ``5.00`` to ``5.0``). If not trapped, returns
the result unchanged. This signal is used to detect loss of significant
digits.
.. class:: Subnormal
Exponent was lower than :attr:`Emin` prior to rounding.
Exponent was lower than :attr:`~Context.Emin` prior to rounding.
Occurs when an operation result is subnormal (the exponent is too small). If
not trapped, returns the result unchanged.
@ -1680,7 +1680,7 @@ Mitigating round-off error with increased precision
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The use of decimal floating point eliminates decimal representation error
(making it possible to represent :const:`0.1` exactly); however, some operations
(making it possible to represent ``0.1`` exactly); however, some operations
can still incur round-off error when non-zero digits exceed the fixed precision.
The effects of round-off error can be amplified by the addition or subtraction
@ -1730,8 +1730,8 @@ Special values
^^^^^^^^^^^^^^
The number system for the :mod:`decimal` module provides special values
including :const:`NaN`, :const:`sNaN`, :const:`-Infinity`, :const:`Infinity`,
and two zeros, :const:`+0` and :const:`-0`.
including ``NaN``, ``sNaN``, ``-Infinity``, ``Infinity``,
and two zeros, ``+0`` and ``-0``.
Infinities can be constructed directly with: ``Decimal('Infinity')``. Also,
they can arise from dividing by zero when the :exc:`DivisionByZero` signal is
@ -1742,30 +1742,30 @@ The infinities are signed (affine) and can be used in arithmetic operations
where they get treated as very large, indeterminate numbers. For instance,
adding a constant to infinity gives another infinite result.
Some operations are indeterminate and return :const:`NaN`, or if the
Some operations are indeterminate and return ``NaN``, or if the
:exc:`InvalidOperation` signal is trapped, raise an exception. For example,
``0/0`` returns :const:`NaN` which means "not a number". This variety of
:const:`NaN` is quiet and, once created, will flow through other computations
always resulting in another :const:`NaN`. This behavior can be useful for a
``0/0`` returns ``NaN`` which means "not a number". This variety of
``NaN`` is quiet and, once created, will flow through other computations
always resulting in another ``NaN``. This behavior can be useful for a
series of computations that occasionally have missing inputs --- it allows the
calculation to proceed while flagging specific results as invalid.
A variant is :const:`sNaN` which signals rather than remaining quiet after every
A variant is ``sNaN`` which signals rather than remaining quiet after every
operation. This is a useful return value when an invalid result needs to
interrupt a calculation for special handling.
The behavior of Python's comparison operators can be a little surprising where a
:const:`NaN` is involved. A test for equality where one of the operands is a
quiet or signaling :const:`NaN` always returns :const:`False` (even when doing
``NaN`` is involved. A test for equality where one of the operands is a
quiet or signaling ``NaN`` always returns :const:`False` (even when doing
``Decimal('NaN')==Decimal('NaN')``), while a test for inequality always returns
: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
if either operand is a ``NaN``, and return :const:`False` if this signal is
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`
and :meth:`compare-signal` methods instead.
involving a ``NaN`` were taken from the IEEE 854 standard (see Table 3 in
section 5.7). To ensure strict standards-compliance, use the :meth:`~Decimal.compare`
and :meth:`~Decimal.compare_signal` methods instead.
The signed zeros can result from calculations that underflow. They keep the sign
that would have resulted if the calculation had been carried out to greater
@ -1997,7 +1997,7 @@ Q. In a fixed-point application with two decimal places, some inputs have many
places and need to be rounded. Others are not supposed to have excess digits
and need to be validated. What methods should be used?
A. The :meth:`quantize` method rounds to a fixed number of decimal places. If
A. The :meth:`~Decimal.quantize` method rounds to a fixed number of decimal places. If
the :const:`Inexact` trap is set, it is also useful for validation:
>>> TWOPLACES = Decimal(10) ** -2 # same as Decimal('0.01')
@ -2021,7 +2021,7 @@ throughout an application?
A. Some operations like addition, subtraction, and multiplication by an integer
will automatically preserve fixed point. Others operations, like division and
non-integer multiplication, will change the number of decimal places and need to
be followed-up with a :meth:`quantize` step:
be followed-up with a :meth:`~Decimal.quantize` step:
>>> a = Decimal('102.72') # Initial fixed-point values
>>> b = Decimal('3.17')
@ -2037,7 +2037,7 @@ be followed-up with a :meth:`quantize` step:
Decimal('0.03')
In developing fixed-point applications, it is convenient to define functions
to handle the :meth:`quantize` step:
to handle the :meth:`~Decimal.quantize` step:
>>> def mul(x, y, fp=TWOPLACES):
... return (x * y).quantize(fp)
@ -2049,12 +2049,12 @@ to handle the :meth:`quantize` step:
>>> div(b, a)
Decimal('0.03')
Q. There are many ways to express the same value. The numbers :const:`200`,
:const:`200.000`, :const:`2E2`, and :const:`.02E+4` all have the same value at
Q. There are many ways to express the same value. The numbers ``200``,
``200.000``, ``2E2``, and ``.02E+4`` all have the same value at
various precisions. Is there a way to transform them to a single recognizable
canonical value?
A. The :meth:`normalize` method maps all equivalent values to a single
A. The :meth:`~Decimal.normalize` method maps all equivalent values to a single
representative:
>>> values = map(Decimal, '200 200.000 2E2 .02E+4'.split())
@ -2066,7 +2066,7 @@ to get a non-exponential representation?
A. For some values, exponential notation is the only way to express the number
of significant places in the coefficient. For example, expressing
:const:`5.0E+3` as :const:`5000` keeps the value constant but cannot show the
``5.0E+3`` as ``5000`` keeps the value constant but cannot show the
original's two-place significance.
If an application does not care about tracking significance, it is easy to
@ -2142,12 +2142,12 @@ for medium-sized numbers and the `Number Theoretic Transform
<https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general)#Number-theoretic_transform>`_
for very large numbers.
The context must be adapted for exact arbitrary precision arithmetic. :attr:`Emin`
and :attr:`Emax` should always be set to the maximum values, :attr:`clamp`
should always be 0 (the default). Setting :attr:`prec` requires some care.
The context must be adapted for exact arbitrary precision arithmetic. :attr:`~Context.Emin`
and :attr:`~Context.Emax` should always be set to the maximum values, :attr:`~Context.clamp`
should always be 0 (the default). Setting :attr:`~Context.prec` requires some care.
The easiest approach for trying out bignum arithmetic is to use the maximum
value for :attr:`prec` as well [#]_::
value for :attr:`~Context.prec` as well [#]_::
>>> setcontext(Context(prec=MAX_PREC, Emax=MAX_EMAX, Emin=MIN_EMIN))
>>> x = Decimal(2) ** 256
@ -2164,7 +2164,7 @@ the available memory will be insufficient::
MemoryError
On systems with overallocation (e.g. Linux), a more sophisticated approach is to
adjust :attr:`prec` to the amount of available RAM. Suppose that you have 8GB of
adjust :attr:`~Context.prec` to the amount of available RAM. Suppose that you have 8GB of
RAM and expect 10 simultaneous operands using a maximum of 500MB each::
>>> import sys