traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Fix decimal repr which should have used single quotes like other reprs.

This commit is contained in:
Raymond Hettinger 2008-02-14 02:41:22 +00:00
parent ddb164a651
commit abe3237187
3 changed files with 334 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
Doc/library/decimal.rst
View File

@ -51,10 +51,10 @@ arithmetic. It offers several advantages over the :class:`float` datatype:
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal("0.142857")
Decimal('0.142857')
>>> getcontext().prec = 28
>>> Decimal(1) / Decimal(7)
Decimal("0.1428571428571428571428571429")
Decimal('0.1428571428571428571428571429')
* Both binary and decimal floating point are implemented in terms of published
standards. While the built-in float type exposes only a modest portion of its
@ -133,19 +133,19 @@ representation error). Decimal numbers include special values such as
:const:`Infinity`, and :const:`-0`. ::
>>> Decimal(10)
Decimal("10")
>>> Decimal("3.14")
Decimal("3.14")
Decimal('10')
>>> Decimal('3.14')
Decimal('3.14')
>>> Decimal((0, (3, 1, 4), -2))
Decimal("3.14")
Decimal('3.14')
>>> Decimal(str(2.0 ** 0.5))
Decimal("1.41421356237")
>>> Decimal(2) ** Decimal("0.5")
Decimal("1.414213562373095048801688724")
>>> Decimal("NaN")
Decimal("NaN")
>>> Decimal("-Infinity")
Decimal("-Infinity")
Decimal('1.41421356237')
>>> Decimal(2) ** Decimal('0.5')
Decimal('1.414213562373095048801688724')
>>> Decimal('NaN')
Decimal('NaN')
>>> Decimal('-Infinity')
Decimal('-Infinity')
The significance of a new Decimal is determined solely by the number of digits
input. Context precision and rounding only come into play during arithmetic
@ -153,28 +153,28 @@ operations. ::
>>> getcontext().prec = 6
>>> Decimal('3.0')
Decimal("3.0")
Decimal('3.0')
>>> Decimal('3.1415926535')
Decimal("3.1415926535")
Decimal('3.1415926535')
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal("5.85987")
Decimal('5.85987')
>>> getcontext().rounding = ROUND_UP
>>> Decimal('3.1415926535') + Decimal('2.7182818285')
Decimal("5.85988")
Decimal('5.85988')
Decimals interact well with much of the rest of Python. Here is a small decimal
floating point flying circus::
>>> data = map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split())
>>> max(data)
Decimal("9.25")
Decimal('9.25')
>>> min(data)
Decimal("0.03")
Decimal('0.03')
>>> sorted(data)
[Decimal("0.03"), Decimal("1.00"), Decimal("1.34"), Decimal("1.87"),
Decimal("2.35"), Decimal("3.45"), Decimal("9.25")]
[Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'),
Decimal('2.35'), Decimal('3.45'), Decimal('9.25')]
>>> sum(data)
Decimal("19.29")
Decimal('19.29')
>>> a,b,c = data[:3]
>>> str(a)
'1.34'
@ -185,31 +185,31 @@ floating point flying circus::
>>> int(a)
1
>>> a * 5
Decimal("6.70")
Decimal('6.70')
>>> a * b
Decimal("2.5058")
Decimal('2.5058')
>>> c % a
Decimal("0.77")
Decimal('0.77')
And some mathematical functions are also available to Decimal::
>>> Decimal(2).sqrt()
Decimal("1.414213562373095048801688724")
Decimal('1.414213562373095048801688724')
>>> Decimal(1).exp()
Decimal("2.718281828459045235360287471")
>>> Decimal("10").ln()
Decimal("2.302585092994045684017991455")
>>> Decimal("10").log10()
Decimal("1")
Decimal('2.718281828459045235360287471')
>>> Decimal('10').ln()
Decimal('2.302585092994045684017991455')
>>> Decimal('10').log10()
Decimal('1')
The :meth:`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::
>>> Decimal('7.325').quantize(Decimal('.01'), rounding=ROUND_DOWN)
Decimal("7.32")
Decimal('7.32')
>>> Decimal('7.325').quantize(Decimal('1.'), rounding=ROUND_UP)
Decimal("8")
Decimal('8')
As shown above, the :func:`getcontext` function accesses the current context and
allows the settings to be changed. This approach meets the needs of most
@ -227,16 +227,16 @@ enabled::
>>> myothercontext = Context(prec=60, rounding=ROUND_HALF_DOWN)
>>> setcontext(myothercontext)
>>> Decimal(1) / Decimal(7)
Decimal("0.142857142857142857142857142857142857142857142857142857142857")
Decimal('0.142857142857142857142857142857142857142857142857142857142857')
>>> ExtendedContext
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
capitals=1, flags=[], traps=[])
>>> setcontext(ExtendedContext)
>>> Decimal(1) / Decimal(7)
Decimal("0.142857143")
Decimal('0.142857143')
>>> Decimal(42) / Decimal(0)
Decimal("Infinity")
Decimal('Infinity')
>>> setcontext(BasicContext)
>>> Decimal(42) / Decimal(0)
@ -253,7 +253,7 @@ using the :meth:`clear_flags` method. ::
>>> setcontext(ExtendedContext)
>>> getcontext().clear_flags()
>>> Decimal(355) / Decimal(113)
Decimal("3.14159292")
Decimal('3.14159292')
>>> getcontext()
Context(prec=9, rounding=ROUND_HALF_EVEN, Emin=-999999999, Emax=999999999,
capitals=1, flags=[Inexact, Rounded], traps=[])
@ -266,7 +266,7 @@ Individual traps are set using the dictionary in the :attr:`traps` field of a
context::
>>> Decimal(1) / Decimal(0)
Decimal("Infinity")
Decimal('Infinity')
>>> getcontext().traps[DivisionByZero] = 1
>>> Decimal(1) / Decimal(0)
Traceback (most recent call last):
@ -294,7 +294,7 @@ Decimal objects
Construct a new :class:`Decimal` object based from *value*.
*value* can be an integer, string, tuple, or another :class:`Decimal`
object. If no *value* is given, returns ``Decimal("0")``. If *value* is a
object. If no *value* is given, returns ``Decimal('0')``. If *value* is a
string, it should conform to the decimal numeric string syntax after leading
and trailing whitespace characters are removed::
@ -312,11 +312,11 @@ Decimal objects
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
digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))``
returns ``Decimal("1.414")``.
returns ``Decimal('1.414')``.
The *context* precision does not affect how many digits are stored. That is
determined exclusively by the number of digits in *value*. For example,
``Decimal("3.00000")`` records all five zeros even if the context precision is
``Decimal('3.00000')`` records all five zeros even if the context precision is
only three.
The purpose of the *context* argument is determining what to do if *value* is a
@ -343,7 +343,7 @@ also have a number of specialized methods:
.. method:: Decimal.adjusted()
Return the adjusted exponent after shifting out the coefficient's rightmost
digits until only the lead digit remains: ``Decimal("321e+5").adjusted()``
digits until only the lead digit remains: ``Decimal('321e+5').adjusted()``
returns seven. Used for determining the position of the most significant digit
with respect to the decimal point.
@ -373,10 +373,10 @@ also have a number of specialized methods:
instance rather than an integer, and if either operand is a NaN
then the result is a NaN::
a or b is a NaN ==> Decimal("NaN")
a < b ==> Decimal("-1")
a == b ==> Decimal("0")
a > b ==> Decimal("1")
a or b is a NaN ==> Decimal('NaN')
a < b ==> Decimal('-1')
a == b ==> Decimal('0')
a > b ==> Decimal('1')
.. method:: Decimal.compare_signal(other[, context])
@ -396,14 +396,14 @@ also have a number of specialized methods:
value but different representations compare unequal in this
ordering::
>>> Decimal("12.0").compare_total(Decimal("12"))
Decimal("-1")
>>> Decimal('12.0').compare_total(Decimal('12'))
Decimal('-1')
Quiet and signaling NaNs are also included in the total ordering.
The result of this function is ``Decimal("0")`` if both operands
have the same representation, ``Decimal("-1")`` if the first
The result of this function is ``Decimal('0')`` if both operands
have the same representation, ``Decimal('-1')`` if the first
operand is lower in the total order than the second, and
``Decimal("1")`` if the first operand is higher in the total order
``Decimal('1')`` if the first operand is higher in the total order
than the second operand. See the specification for details of the
total order.
@ -439,8 +439,8 @@ also have a number of specialized methods:
Return a copy of the first operand with the sign set to be the
same as the sign of the second operand. For example::
>>> Decimal("2.3").copy_sign(Decimal("-1.5"))
Decimal("-2.3")
>>> Decimal('2.3').copy_sign(Decimal('-1.5'))
Decimal('-2.3')
This operation is unaffected by the context and is quiet: no flags
are changed and no rounding is performed.
@ -454,9 +454,9 @@ also have a number of specialized methods:
:const:`ROUND_HALF_EVEN` rounding mode.
>>> Decimal(1).exp()
Decimal("2.718281828459045235360287471")
Decimal('2.718281828459045235360287471')
>>> Decimal(321).exp()
Decimal("2.561702493119680037517373933E+139")
Decimal('2.561702493119680037517373933E+139')
.. versionadded:: 2.6
@ -466,7 +466,7 @@ also have a number of specialized methods:
the intermediate product self*other.
>>> Decimal(2).fma(3, 5)
Decimal("11")
Decimal('11')
.. versionadded:: 2.6
@ -563,9 +563,9 @@ also have a number of specialized methods:
For a nonzero number, return the adjusted exponent of its operand
as a :class:`Decimal` instance. If the operand is a zero then
``Decimal("-Infinity")`` is returned and the
``Decimal('-Infinity')`` is returned and the
:const:`DivisionByZero` flag is raised. If the operand is an
infinity then ``Decimal("Infinity")`` is returned.
infinity then ``Decimal('Infinity')`` is returned.
.. versionadded:: 2.6
@ -655,10 +655,10 @@ also have a number of specialized methods:
.. method:: Decimal.normalize([context])
Normalize the number by stripping the rightmost trailing zeros and converting
any result equal to :const:`Decimal("0")` to :const:`Decimal("0e0")`. Used for
any result equal to :const:`Decimal('0')` to :const:`Decimal('0e0')`. Used for
producing canonical values for members of an equivalence class. For example,
``Decimal("32.100")`` and ``Decimal("0.321000e+2")`` both normalize to the
equivalent value ``Decimal("32.1")``.
``Decimal('32.100')`` and ``Decimal('0.321000e+2')`` both normalize to the
equivalent value ``Decimal('32.1')``.
.. method:: Decimal.number_class([context])
@ -683,8 +683,8 @@ also have a number of specialized methods:
Return a value equal to the first operand after rounding and
having the exponent of the second operand.
>>> Decimal("1.41421356").quantize(Decimal("1.000"))
Decimal("1.414")
>>> Decimal('1.41421356').quantize(Decimal('1.000'))
Decimal('1.414')
Unlike other operations, if the length of the coefficient after the
quantize operation would be greater than precision, then an
@ -716,7 +716,7 @@ also have a number of specialized methods:
Compute the modulo as either a positive or negative value depending on which is
closest to zero. For instance, ``Decimal(10).remainder_near(6)`` returns
``Decimal("-2")`` which is closer to zero than ``Decimal("4")``.
``Decimal('-2')`` which is closer to zero than ``Decimal('4')``.
If both are equally close, the one chosen will have the same sign as *self*.
@ -771,7 +771,7 @@ also have a number of specialized methods:
Engineering notation has an exponent which is a multiple of 3, so there are up
to 3 digits left of the decimal place. For example, converts
``Decimal('123E+1')`` to ``Decimal("1.23E+3")``
``Decimal('123E+1')`` to ``Decimal('1.23E+3')``
.. method:: Decimal.to_integral([rounding[, context]])
@ -985,10 +985,10 @@ method. For example, ``C.exp(x)`` is equivalent to
change the result::
>>> getcontext().prec = 3
>>> Decimal("3.4445") + Decimal("1.0023")
Decimal("4.45")
>>> Decimal("3.4445") + Decimal(0) + Decimal("1.0023")
Decimal("4.44")
>>> Decimal('3.4445') + Decimal('1.0023')
Decimal('4.45')
>>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')
Decimal('4.44')
This method implements the to-number operation of the IBM
specification. If the argument is a string, no leading or trailing
@ -1247,15 +1247,15 @@ properties of addition::
>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')
>>> (u + v) + w
Decimal("9.5111111")
Decimal('9.5111111')
>>> u + (v + w)
Decimal("10")
Decimal('10')
>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')
>>> (u*v) + (u*w)
Decimal("0.01")
Decimal('0.01')
>>> u * (v+w)
Decimal("0.0060000")
Decimal('0.0060000')
The :mod:`decimal` module makes it possible to restore the identities by
expanding the precision sufficiently to avoid loss of significance::
@ -1263,15 +1263,15 @@ expanding the precision sufficiently to avoid loss of significance::
>>> getcontext().prec = 20
>>> u, v, w = Decimal(11111113), Decimal(-11111111), Decimal('7.51111111')
>>> (u + v) + w
Decimal("9.51111111")
Decimal('9.51111111')
>>> u + (v + w)
Decimal("9.51111111")
Decimal('9.51111111')
>>>
>>> u, v, w = Decimal(20000), Decimal(-6), Decimal('6.0000003')
>>> (u*v) + (u*w)
Decimal("0.0060000")
Decimal('0.0060000')
>>> u * (v+w)
Decimal("0.0060000")
Decimal('0.0060000')
Special values
@ -1327,7 +1327,7 @@ normalized floating point representations, it is not immediately obvious that
the following calculation returns a value equal to zero::
>>> 1 / Decimal('Infinity')
Decimal("0E-1000000026")
Decimal('0E-1000000026')
.. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@ -1538,7 +1538,7 @@ minimize typing when using the interactive interpreter?
>>> D = decimal.Decimal
>>> D('1.23') + D('3.45')
Decimal("4.68")
Decimal('4.68')
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
@ -1550,14 +1550,14 @@ the :const:`Inexact` trap is set, it is also useful for validation::
>>> TWOPLACES = Decimal(10) ** -2 # same as Decimal('0.01')
>>> # Round to two places
>>> Decimal("3.214").quantize(TWOPLACES)
Decimal("3.21")
>>> Decimal('3.214').quantize(TWOPLACES)
Decimal('3.21')
>>> # Validate that a number does not exceed two places
>>> Decimal("3.21").quantize(TWOPLACES, context=Context(traps=[Inexact]))
Decimal("3.21")
>>> Decimal('3.21').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Decimal('3.21')
>>> Decimal("3.214").quantize(TWOPLACES, context=Context(traps=[Inexact]))
>>> Decimal('3.214').quantize(TWOPLACES, context=Context(traps=[Inexact]))
Traceback (most recent call last):
...
Inexact: Changed in rounding
@ -1579,7 +1579,7 @@ representative::
>>> values = map(Decimal, '200 200.000 2E2 .02E+4'.split())
>>> [v.normalize() for v in values]
[Decimal("2E+2"), Decimal("2E+2"), Decimal("2E+2"), Decimal("2E+2")]
[Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2'), Decimal('2E+2')]
Q. Some decimal values always print with exponential notation. Is there a way
to get a non-exponential representation?
@ -1607,7 +1607,7 @@ suggest, so we trap :const:`Inexact` to signal a need for more precision::
ctx.prec += 1
>>> float_to_decimal(math.pi)
Decimal("3.141592653589793115997963468544185161590576171875")
Decimal('3.141592653589793115997963468544185161590576171875')
Q. Why isn't the :func:`float_to_decimal` routine included in the module?
@ -1616,7 +1616,7 @@ decimal floating point. Also, its use requires some care to avoid the
representation issues associated with binary floating point::
>>> float_to_decimal(1.1)
Decimal("1.100000000000000088817841970012523233890533447265625")
Decimal('1.100000000000000088817841970012523233890533447265625')
Q. Within a complex calculation, how can I make sure that I haven't gotten a
spurious result because of insufficient precision or rounding anomalies.
@ -1637,20 +1637,20 @@ results can look odd if you forget that the inputs haven't been rounded::
>>> getcontext().prec = 3
>>> Decimal('3.104') + D('2.104')
Decimal("5.21")
Decimal('5.21')
>>> Decimal('3.104') + D('0.000') + D('2.104')
Decimal("5.20")
Decimal('5.20')
The solution is either to increase precision or to force rounding of inputs
using the unary plus operation::
>>> getcontext().prec = 3
>>> +Decimal('1.23456789') # unary plus triggers rounding
Decimal("1.23")
Decimal('1.23')
Alternatively, inputs can be rounded upon creation using the
:meth:`Context.create_decimal` method::
>>> Context(prec=5, rounding=ROUND_DOWN).create_decimal('1.2345678')
Decimal("1.2345")
Decimal('1.2345')

484
Lib/decimal.py
View File

@ -35,26 +35,26 @@ issues associated with binary floating point. The package is especially
useful for financial applications or for contexts where users have
expectations that are at odds with binary floating point (for instance,
in binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead
of the expected Decimal("0.00") returned by decimal floating point).
of the expected Decimal('0.00') returned by decimal floating point).
Here are some examples of using the decimal module:
>>> from decimal import *
>>> setcontext(ExtendedContext)
>>> Decimal(0)
Decimal("0")
>>> Decimal("1")
Decimal("1")
>>> Decimal("-.0123")
Decimal("-0.0123")
Decimal('0')
>>> Decimal('1')
Decimal('1')
>>> Decimal('-.0123')
Decimal('-0.0123')
>>> Decimal(123456)
Decimal("123456")
>>> Decimal("123.45e12345678901234567890")
Decimal("1.2345E+12345678901234567892")
>>> Decimal("1.33") + Decimal("1.27")
Decimal("2.60")
>>> Decimal("12.34") + Decimal("3.87") - Decimal("18.41")
Decimal("-2.20")
Decimal('123456')
>>> Decimal('123.45e12345678901234567890')
Decimal('1.2345E+12345678901234567892')
>>> Decimal('1.33') + Decimal('1.27')
Decimal('2.60')
>>> Decimal('12.34') + Decimal('3.87') - Decimal('18.41')
Decimal('-2.20')
>>> dig = Decimal(1)
>>> print dig / Decimal(3)
0.333333333
@ -91,7 +91,7 @@ DivisionByZero: x / 0
>>> print c.flags[InvalidOperation]
0
>>> c.divide(Decimal(0), Decimal(0))
Decimal("NaN")
Decimal('NaN')
>>> c.traps[InvalidOperation] = 1
>>> print c.flags[InvalidOperation]
1
@ -516,15 +516,15 @@ class Decimal(object):
"""Create a decimal point instance.
>>> Decimal('3.14') # string input
Decimal("3.14")
Decimal('3.14')
>>> Decimal((0, (3, 1, 4), -2)) # tuple (sign, digit_tuple, exponent)
Decimal("3.14")
Decimal('3.14')
>>> Decimal(314) # int or long
Decimal("314")
Decimal('314')
>>> Decimal(Decimal(314)) # another decimal instance
Decimal("314")
Decimal('314')
>>> Decimal(' 3.14 \\n') # leading and trailing whitespace okay
Decimal("3.14")
Decimal('3.14')
"""
# Note that the coefficient, self._int, is actually stored as
@ -883,7 +883,7 @@ class Decimal(object):
#
# The hash of a nonspecial noninteger Decimal must depend only
# on the value of that Decimal, and not on its representation.
# For example: hash(Decimal("100E-1")) == hash(Decimal("10")).
# For example: hash(Decimal('100E-1')) == hash(Decimal('10')).
if self._is_special:
if self._isnan():
raise TypeError('Cannot hash a NaN value.')
@ -917,7 +917,7 @@ class Decimal(object):
def __repr__(self):
"""Represents the number as an instance of Decimal."""
# Invariant: eval(repr(d)) == d
return 'Decimal("%s")' % str(self)
return "Decimal('%s')" % str(self)
def __str__(self, eng=False, context=None):
"""Return string representation of the number in scientific notation.
@ -3647,13 +3647,13 @@ class Context(object):
the plus operation on the operand.
>>> ExtendedContext.abs(Decimal('2.1'))
Decimal("2.1")
Decimal('2.1')
>>> ExtendedContext.abs(Decimal('-100'))
Decimal("100")
Decimal('100')
>>> ExtendedContext.abs(Decimal('101.5'))
Decimal("101.5")
Decimal('101.5')
>>> ExtendedContext.abs(Decimal('-101.5'))
Decimal("101.5")
Decimal('101.5')
"""
return a.__abs__(context=self)
@ -3661,9 +3661,9 @@ class Context(object):
"""Return the sum of the two operands.
>>> ExtendedContext.add(Decimal('12'), Decimal('7.00'))
Decimal("19.00")
Decimal('19.00')
>>> ExtendedContext.add(Decimal('1E+2'), Decimal('1.01E+4'))
Decimal("1.02E+4")
Decimal('1.02E+4')
"""
return a.__add__(b, context=self)
@ -3677,7 +3677,7 @@ class Context(object):
received object already is in its canonical form.
>>> ExtendedContext.canonical(Decimal('2.50'))
Decimal("2.50")
Decimal('2.50')
"""
return a.canonical(context=self)
@ -3696,17 +3696,17 @@ class Context(object):
zero or negative zero, or '1' if the result is greater than zero.
>>> ExtendedContext.compare(Decimal('2.1'), Decimal('3'))
Decimal("-1")
Decimal('-1')
>>> ExtendedContext.compare(Decimal('2.1'), Decimal('2.1'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.compare(Decimal('2.1'), Decimal('2.10'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.compare(Decimal('3'), Decimal('2.1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.compare(Decimal('2.1'), Decimal('-3'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.compare(Decimal('-3'), Decimal('2.1'))
Decimal("-1")
Decimal('-1')
"""
return a.compare(b, context=self)
@ -3718,21 +3718,21 @@ class Context(object):
>>> c = ExtendedContext
>>> c.compare_signal(Decimal('2.1'), Decimal('3'))
Decimal("-1")
Decimal('-1')
>>> c.compare_signal(Decimal('2.1'), Decimal('2.1'))
Decimal("0")
Decimal('0')
>>> c.flags[InvalidOperation] = 0
>>> print c.flags[InvalidOperation]
0
>>> c.compare_signal(Decimal('NaN'), Decimal('2.1'))
Decimal("NaN")
Decimal('NaN')
>>> print c.flags[InvalidOperation]
1
>>> c.flags[InvalidOperation] = 0
>>> print c.flags[InvalidOperation]
0
>>> c.compare_signal(Decimal('sNaN'), Decimal('2.1'))
Decimal("NaN")
Decimal('NaN')
>>> print c.flags[InvalidOperation]
1
"""
@ -3746,17 +3746,17 @@ class Context(object):
representations.
>>> ExtendedContext.compare_total(Decimal('12.73'), Decimal('127.9'))
Decimal("-1")
Decimal('-1')
>>> ExtendedContext.compare_total(Decimal('-127'), Decimal('12'))
Decimal("-1")
Decimal('-1')
>>> ExtendedContext.compare_total(Decimal('12.30'), Decimal('12.3'))
Decimal("-1")
Decimal('-1')
>>> ExtendedContext.compare_total(Decimal('12.30'), Decimal('12.30'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.compare_total(Decimal('12.3'), Decimal('12.300'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.compare_total(Decimal('12.3'), Decimal('NaN'))
Decimal("-1")
Decimal('-1')
"""
return a.compare_total(b)
@ -3771,9 +3771,9 @@ class Context(object):
"""Returns a copy of the operand with the sign set to 0.
>>> ExtendedContext.copy_abs(Decimal('2.1'))
Decimal("2.1")
Decimal('2.1')
>>> ExtendedContext.copy_abs(Decimal('-100'))
Decimal("100")
Decimal('100')
"""
return a.copy_abs()
@ -3781,9 +3781,9 @@ class Context(object):
"""Returns a copy of the decimal objet.
>>> ExtendedContext.copy_decimal(Decimal('2.1'))
Decimal("2.1")
Decimal('2.1')
>>> ExtendedContext.copy_decimal(Decimal('-1.00'))
Decimal("-1.00")
Decimal('-1.00')
"""
return Decimal(a)
@ -3791,9 +3791,9 @@ class Context(object):
"""Returns a copy of the operand with the sign inverted.
>>> ExtendedContext.copy_negate(Decimal('101.5'))
Decimal("-101.5")
Decimal('-101.5')
>>> ExtendedContext.copy_negate(Decimal('-101.5'))
Decimal("101.5")
Decimal('101.5')
"""
return a.copy_negate()
@ -3804,13 +3804,13 @@ class Context(object):
equal to the sign of the second operand.
>>> ExtendedContext.copy_sign(Decimal( '1.50'), Decimal('7.33'))
Decimal("1.50")
Decimal('1.50')
>>> ExtendedContext.copy_sign(Decimal('-1.50'), Decimal('7.33'))
Decimal("1.50")
Decimal('1.50')
>>> ExtendedContext.copy_sign(Decimal( '1.50'), Decimal('-7.33'))
Decimal("-1.50")
Decimal('-1.50')
>>> ExtendedContext.copy_sign(Decimal('-1.50'), Decimal('-7.33'))
Decimal("-1.50")
Decimal('-1.50')
"""
return a.copy_sign(b)
@ -3818,25 +3818,25 @@ class Context(object):
"""Decimal division in a specified context.
>>> ExtendedContext.divide(Decimal('1'), Decimal('3'))
Decimal("0.333333333")
Decimal('0.333333333')
>>> ExtendedContext.divide(Decimal('2'), Decimal('3'))
Decimal("0.666666667")
Decimal('0.666666667')
>>> ExtendedContext.divide(Decimal('5'), Decimal('2'))
Decimal("2.5")
Decimal('2.5')
>>> ExtendedContext.divide(Decimal('1'), Decimal('10'))
Decimal("0.1")
Decimal('0.1')
>>> ExtendedContext.divide(Decimal('12'), Decimal('12'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.divide(Decimal('8.00'), Decimal('2'))
Decimal("4.00")
Decimal('4.00')
>>> ExtendedContext.divide(Decimal('2.400'), Decimal('2.0'))
Decimal("1.20")
Decimal('1.20')
>>> ExtendedContext.divide(Decimal('1000'), Decimal('100'))
Decimal("10")
Decimal('10')
>>> ExtendedContext.divide(Decimal('1000'), Decimal('1'))
Decimal("1000")
Decimal('1000')
>>> ExtendedContext.divide(Decimal('2.40E+6'), Decimal('2'))
Decimal("1.20E+6")
Decimal('1.20E+6')
"""
return a.__div__(b, context=self)
@ -3844,11 +3844,11 @@ class Context(object):
"""Divides two numbers and returns the integer part of the result.
>>> ExtendedContext.divide_int(Decimal('2'), Decimal('3'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.divide_int(Decimal('10'), Decimal('3'))
Decimal("3")
Decimal('3')
>>> ExtendedContext.divide_int(Decimal('1'), Decimal('0.3'))
Decimal("3")
Decimal('3')
"""
return a.__floordiv__(b, context=self)
@ -3862,17 +3862,17 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> c.exp(Decimal('-Infinity'))
Decimal("0")
Decimal('0')
>>> c.exp(Decimal('-1'))
Decimal("0.367879441")
Decimal('0.367879441')
>>> c.exp(Decimal('0'))
Decimal("1")
Decimal('1')
>>> c.exp(Decimal('1'))
Decimal("2.71828183")
Decimal('2.71828183')
>>> c.exp(Decimal('0.693147181'))
Decimal("2.00000000")
Decimal('2.00000000')
>>> c.exp(Decimal('+Infinity'))
Decimal("Infinity")
Decimal('Infinity')
"""
return a.exp(context=self)
@ -3884,11 +3884,11 @@ class Context(object):
multiplication, using add, all with only one final rounding.
>>> ExtendedContext.fma(Decimal('3'), Decimal('5'), Decimal('7'))
Decimal("22")
Decimal('22')
>>> ExtendedContext.fma(Decimal('3'), Decimal('-5'), Decimal('7'))
Decimal("-8")
Decimal('-8')
>>> ExtendedContext.fma(Decimal('888565290'), Decimal('1557.96930'), Decimal('-86087.7578'))
Decimal("1.38435736E+12")
Decimal('1.38435736E+12')
"""
return a.fma(b, c, context=self)
@ -4042,15 +4042,15 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> c.ln(Decimal('0'))
Decimal("-Infinity")
Decimal('-Infinity')
>>> c.ln(Decimal('1.000'))
Decimal("0")
Decimal('0')
>>> c.ln(Decimal('2.71828183'))
Decimal("1.00000000")
Decimal('1.00000000')
>>> c.ln(Decimal('10'))
Decimal("2.30258509")
Decimal('2.30258509')
>>> c.ln(Decimal('+Infinity'))
Decimal("Infinity")
Decimal('Infinity')
"""
return a.ln(context=self)
@ -4061,19 +4061,19 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> c.log10(Decimal('0'))
Decimal("-Infinity")
Decimal('-Infinity')
>>> c.log10(Decimal('0.001'))
Decimal("-3")
Decimal('-3')
>>> c.log10(Decimal('1.000'))
Decimal("0")
Decimal('0')
>>> c.log10(Decimal('2'))
Decimal("0.301029996")
Decimal('0.301029996')
>>> c.log10(Decimal('10'))
Decimal("1")
Decimal('1')
>>> c.log10(Decimal('70'))
Decimal("1.84509804")
Decimal('1.84509804')
>>> c.log10(Decimal('+Infinity'))
Decimal("Infinity")
Decimal('Infinity')
"""
return a.log10(context=self)
@ -4086,13 +4086,13 @@ class Context(object):
value of that digit and without limiting the resulting exponent).
>>> ExtendedContext.logb(Decimal('250'))
Decimal("2")
Decimal('2')
>>> ExtendedContext.logb(Decimal('2.50'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logb(Decimal('0.03'))
Decimal("-2")
Decimal('-2')
>>> ExtendedContext.logb(Decimal('0'))
Decimal("-Infinity")
Decimal('-Infinity')
"""
return a.logb(context=self)
@ -4102,17 +4102,17 @@ class Context(object):
The operands must be both logical numbers.
>>> ExtendedContext.logical_and(Decimal('0'), Decimal('0'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('0'), Decimal('1'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('1'), Decimal('0'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_and(Decimal('1'), Decimal('1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.logical_and(Decimal('1100'), Decimal('1010'))
Decimal("1000")
Decimal('1000')
>>> ExtendedContext.logical_and(Decimal('1111'), Decimal('10'))
Decimal("10")
Decimal('10')
"""
return a.logical_and(b, context=self)
@ -4122,13 +4122,13 @@ class Context(object):
The operand must be a logical number.
>>> ExtendedContext.logical_invert(Decimal('0'))
Decimal("111111111")
Decimal('111111111')
>>> ExtendedContext.logical_invert(Decimal('1'))
Decimal("111111110")
Decimal('111111110')
>>> ExtendedContext.logical_invert(Decimal('111111111'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_invert(Decimal('101010101'))
Decimal("10101010")
Decimal('10101010')
"""
return a.logical_invert(context=self)
@ -4138,17 +4138,17 @@ class Context(object):
The operands must be both logical numbers.
>>> ExtendedContext.logical_or(Decimal('0'), Decimal('0'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_or(Decimal('0'), Decimal('1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.logical_or(Decimal('1'), Decimal('0'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.logical_or(Decimal('1'), Decimal('1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.logical_or(Decimal('1100'), Decimal('1010'))
Decimal("1110")
Decimal('1110')
>>> ExtendedContext.logical_or(Decimal('1110'), Decimal('10'))
Decimal("1110")
Decimal('1110')
"""
return a.logical_or(b, context=self)
@ -4158,17 +4158,17 @@ class Context(object):
The operands must be both logical numbers.
>>> ExtendedContext.logical_xor(Decimal('0'), Decimal('0'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_xor(Decimal('0'), Decimal('1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.logical_xor(Decimal('1'), Decimal('0'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.logical_xor(Decimal('1'), Decimal('1'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.logical_xor(Decimal('1100'), Decimal('1010'))
Decimal("110")
Decimal('110')
>>> ExtendedContext.logical_xor(Decimal('1111'), Decimal('10'))
Decimal("1101")
Decimal('1101')
"""
return a.logical_xor(b, context=self)
@ -4182,13 +4182,13 @@ class Context(object):
infinity) of the two operands is chosen as the result.
>>> ExtendedContext.max(Decimal('3'), Decimal('2'))
Decimal("3")
Decimal('3')
>>> ExtendedContext.max(Decimal('-10'), Decimal('3'))
Decimal("3")
Decimal('3')
>>> ExtendedContext.max(Decimal('1.0'), Decimal('1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.max(Decimal('7'), Decimal('NaN'))
Decimal("7")
Decimal('7')
"""
return a.max(b, context=self)
@ -4206,13 +4206,13 @@ class Context(object):
infinity) of the two operands is chosen as the result.
>>> ExtendedContext.min(Decimal('3'), Decimal('2'))
Decimal("2")
Decimal('2')
>>> ExtendedContext.min(Decimal('-10'), Decimal('3'))
Decimal("-10")
Decimal('-10')
>>> ExtendedContext.min(Decimal('1.0'), Decimal('1'))
Decimal("1.0")
Decimal('1.0')
>>> ExtendedContext.min(Decimal('7'), Decimal('NaN'))
Decimal("7")
Decimal('7')
"""
return a.min(b, context=self)
@ -4228,9 +4228,9 @@ class Context(object):
has the same exponent as the operand.
>>> ExtendedContext.minus(Decimal('1.3'))
Decimal("-1.3")
Decimal('-1.3')
>>> ExtendedContext.minus(Decimal('-1.3'))
Decimal("1.3")
Decimal('1.3')
"""
return a.__neg__(context=self)
@ -4243,15 +4243,15 @@ class Context(object):
of the two operands.
>>> ExtendedContext.multiply(Decimal('1.20'), Decimal('3'))
Decimal("3.60")
Decimal('3.60')
>>> ExtendedContext.multiply(Decimal('7'), Decimal('3'))
Decimal("21")
Decimal('21')
>>> ExtendedContext.multiply(Decimal('0.9'), Decimal('0.8'))
Decimal("0.72")
Decimal('0.72')
>>> ExtendedContext.multiply(Decimal('0.9'), Decimal('-0'))
Decimal("-0.0")
Decimal('-0.0')
>>> ExtendedContext.multiply(Decimal('654321'), Decimal('654321'))
Decimal("4.28135971E+11")
Decimal('4.28135971E+11')
"""
return a.__mul__(b, context=self)
@ -4262,13 +4262,13 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> ExtendedContext.next_minus(Decimal('1'))
Decimal("0.999999999")
Decimal('0.999999999')
>>> c.next_minus(Decimal('1E-1007'))
Decimal("0E-1007")
Decimal('0E-1007')
>>> ExtendedContext.next_minus(Decimal('-1.00000003'))
Decimal("-1.00000004")
Decimal('-1.00000004')
>>> c.next_minus(Decimal('Infinity'))
Decimal("9.99999999E+999")
Decimal('9.99999999E+999')
"""
return a.next_minus(context=self)
@ -4279,13 +4279,13 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> ExtendedContext.next_plus(Decimal('1'))
Decimal("1.00000001")
Decimal('1.00000001')
>>> c.next_plus(Decimal('-1E-1007'))
Decimal("-0E-1007")
Decimal('-0E-1007')
>>> ExtendedContext.next_plus(Decimal('-1.00000003'))
Decimal("-1.00000002")
Decimal('-1.00000002')
>>> c.next_plus(Decimal('-Infinity'))
Decimal("-9.99999999E+999")
Decimal('-9.99999999E+999')
"""
return a.next_plus(context=self)
@ -4301,19 +4301,19 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> c.next_toward(Decimal('1'), Decimal('2'))
Decimal("1.00000001")
Decimal('1.00000001')
>>> c.next_toward(Decimal('-1E-1007'), Decimal('1'))
Decimal("-0E-1007")
Decimal('-0E-1007')
>>> c.next_toward(Decimal('-1.00000003'), Decimal('0'))
Decimal("-1.00000002")
Decimal('-1.00000002')
>>> c.next_toward(Decimal('1'), Decimal('0'))
Decimal("0.999999999")
Decimal('0.999999999')
>>> c.next_toward(Decimal('1E-1007'), Decimal('-100'))
Decimal("0E-1007")
Decimal('0E-1007')
>>> c.next_toward(Decimal('-1.00000003'), Decimal('-10'))
Decimal("-1.00000004")
Decimal('-1.00000004')
>>> c.next_toward(Decimal('0.00'), Decimal('-0.0000'))
Decimal("-0.00")
Decimal('-0.00')
"""
return a.next_toward(b, context=self)
@ -4324,17 +4324,17 @@ class Context(object):
result.
>>> ExtendedContext.normalize(Decimal('2.1'))
Decimal("2.1")
Decimal('2.1')
>>> ExtendedContext.normalize(Decimal('-2.0'))
Decimal("-2")
Decimal('-2')
>>> ExtendedContext.normalize(Decimal('1.200'))
Decimal("1.2")
Decimal('1.2')
>>> ExtendedContext.normalize(Decimal('-120'))
Decimal("-1.2E+2")
Decimal('-1.2E+2')
>>> ExtendedContext.normalize(Decimal('120.00'))
Decimal("1.2E+2")
Decimal('1.2E+2')
>>> ExtendedContext.normalize(Decimal('0.00'))
Decimal("0")
Decimal('0')
"""
return a.normalize(context=self)
@ -4393,9 +4393,9 @@ class Context(object):
has the same exponent as the operand.
>>> ExtendedContext.plus(Decimal('1.3'))
Decimal("1.3")
Decimal('1.3')
>>> ExtendedContext.plus(Decimal('-1.3'))
Decimal("-1.3")
Decimal('-1.3')
"""
return a.__pos__(context=self)
@ -4425,46 +4425,46 @@ class Context(object):
>>> c.Emin = -999
>>> c.Emax = 999
>>> c.power(Decimal('2'), Decimal('3'))
Decimal("8")
Decimal('8')
>>> c.power(Decimal('-2'), Decimal('3'))
Decimal("-8")
Decimal('-8')
>>> c.power(Decimal('2'), Decimal('-3'))
Decimal("0.125")
Decimal('0.125')
>>> c.power(Decimal('1.7'), Decimal('8'))
Decimal("69.7575744")
Decimal('69.7575744')
>>> c.power(Decimal('10'), Decimal('0.301029996'))
Decimal("2.00000000")
Decimal('2.00000000')
>>> c.power(Decimal('Infinity'), Decimal('-1'))
Decimal("0")
Decimal('0')
>>> c.power(Decimal('Infinity'), Decimal('0'))
Decimal("1")
Decimal('1')
>>> c.power(Decimal('Infinity'), Decimal('1'))
Decimal("Infinity")
Decimal('Infinity')
>>> c.power(Decimal('-Infinity'), Decimal('-1'))
Decimal("-0")
Decimal('-0')
>>> c.power(Decimal('-Infinity'), Decimal('0'))
Decimal("1")
Decimal('1')
>>> c.power(Decimal('-Infinity'), Decimal('1'))
Decimal("-Infinity")
Decimal('-Infinity')
>>> c.power(Decimal('-Infinity'), Decimal('2'))
Decimal("Infinity")
Decimal('Infinity')
>>> c.power(Decimal('0'), Decimal('0'))
Decimal("NaN")
Decimal('NaN')
>>> c.power(Decimal('3'), Decimal('7'), Decimal('16'))
Decimal("11")
Decimal('11')
>>> c.power(Decimal('-3'), Decimal('7'), Decimal('16'))
Decimal("-11")
Decimal('-11')
>>> c.power(Decimal('-3'), Decimal('8'), Decimal('16'))
Decimal("1")
Decimal('1')
>>> c.power(Decimal('3'), Decimal('7'), Decimal('-16'))
Decimal("11")
Decimal('11')
>>> c.power(Decimal('23E12345'), Decimal('67E189'), Decimal('123456789'))
Decimal("11729830")
Decimal('11729830')
>>> c.power(Decimal('-0'), Decimal('17'), Decimal('1729'))
Decimal("-0")
Decimal('-0')
>>> c.power(Decimal('-23'), Decimal('0'), Decimal('65537'))
Decimal("1")
Decimal('1')
"""
return a.__pow__(b, modulo, context=self)
@ -4487,35 +4487,35 @@ class Context(object):
if the result is subnormal and inexact.
>>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.001'))
Decimal("2.170")
Decimal('2.170')
>>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.01'))
Decimal("2.17")
Decimal('2.17')
>>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.1'))
Decimal("2.2")
Decimal('2.2')
>>> ExtendedContext.quantize(Decimal('2.17'), Decimal('1e+0'))
Decimal("2")
Decimal('2')
>>> ExtendedContext.quantize(Decimal('2.17'), Decimal('1e+1'))
Decimal("0E+1")
Decimal('0E+1')
>>> ExtendedContext.quantize(Decimal('-Inf'), Decimal('Infinity'))
Decimal("-Infinity")
Decimal('-Infinity')
>>> ExtendedContext.quantize(Decimal('2'), Decimal('Infinity'))
Decimal("NaN")
Decimal('NaN')
>>> ExtendedContext.quantize(Decimal('-0.1'), Decimal('1'))
Decimal("-0")
Decimal('-0')
>>> ExtendedContext.quantize(Decimal('-0'), Decimal('1e+5'))
Decimal("-0E+5")
Decimal('-0E+5')
>>> ExtendedContext.quantize(Decimal('+35236450.6'), Decimal('1e-2'))
Decimal("NaN")
Decimal('NaN')
>>> ExtendedContext.quantize(Decimal('-35236450.6'), Decimal('1e-2'))
Decimal("NaN")
Decimal('NaN')
>>> ExtendedContext.quantize(Decimal('217'), Decimal('1e-1'))
Decimal("217.0")
Decimal('217.0')
>>> ExtendedContext.quantize(Decimal('217'), Decimal('1e-0'))
Decimal("217")
Decimal('217')
>>> ExtendedContext.quantize(Decimal('217'), Decimal('1e+1'))
Decimal("2.2E+2")
Decimal('2.2E+2')
>>> ExtendedContext.quantize(Decimal('217'), Decimal('1e+2'))
Decimal("2E+2")
Decimal('2E+2')
"""
return a.quantize(b, context=self)
@ -4523,7 +4523,7 @@ class Context(object):
"""Just returns 10, as this is Decimal, :)
>>> ExtendedContext.radix()
Decimal("10")
Decimal('10')
"""
return Decimal(10)
@ -4540,17 +4540,17 @@ class Context(object):
remainder cannot be calculated).
>>> ExtendedContext.remainder(Decimal('2.1'), Decimal('3'))
Decimal("2.1")
Decimal('2.1')
>>> ExtendedContext.remainder(Decimal('10'), Decimal('3'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.remainder(Decimal('-10'), Decimal('3'))
Decimal("-1")
Decimal('-1')
>>> ExtendedContext.remainder(Decimal('10.2'), Decimal('1'))
Decimal("0.2")
Decimal('0.2')
>>> ExtendedContext.remainder(Decimal('10'), Decimal('0.3'))
Decimal("0.1")
Decimal('0.1')
>>> ExtendedContext.remainder(Decimal('3.6'), Decimal('1.3'))
Decimal("1.0")
Decimal('1.0')
"""
return a.__mod__(b, context=self)
@ -4565,19 +4565,19 @@ class Context(object):
remainder cannot be calculated).
>>> ExtendedContext.remainder_near(Decimal('2.1'), Decimal('3'))
Decimal("-0.9")
Decimal('-0.9')
>>> ExtendedContext.remainder_near(Decimal('10'), Decimal('6'))
Decimal("-2")
Decimal('-2')
>>> ExtendedContext.remainder_near(Decimal('10'), Decimal('3'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.remainder_near(Decimal('-10'), Decimal('3'))
Decimal("-1")
Decimal('-1')
>>> ExtendedContext.remainder_near(Decimal('10.2'), Decimal('1'))
Decimal("0.2")
Decimal('0.2')
>>> ExtendedContext.remainder_near(Decimal('10'), Decimal('0.3'))
Decimal("0.1")
Decimal('0.1')
>>> ExtendedContext.remainder_near(Decimal('3.6'), Decimal('1.3'))
Decimal("-0.3")
Decimal('-0.3')
"""
return a.remainder_near(b, context=self)
@ -4591,15 +4591,15 @@ class Context(object):
positive or to the right otherwise.
>>> ExtendedContext.rotate(Decimal('34'), Decimal('8'))
Decimal("400000003")
Decimal('400000003')
>>> ExtendedContext.rotate(Decimal('12'), Decimal('9'))
Decimal("12")
Decimal('12')
>>> ExtendedContext.rotate(Decimal('123456789'), Decimal('-2'))
Decimal("891234567")
Decimal('891234567')
>>> ExtendedContext.rotate(Decimal('123456789'), Decimal('0'))
Decimal("123456789")
Decimal('123456789')
>>> ExtendedContext.rotate(Decimal('123456789'), Decimal('+2'))
Decimal("345678912")
Decimal('345678912')
"""
return a.rotate(b, context=self)
@ -4624,11 +4624,11 @@ class Context(object):
"""Returns the first operand after adding the second value its exp.
>>> ExtendedContext.scaleb(Decimal('7.50'), Decimal('-2'))
Decimal("0.0750")
Decimal('0.0750')
>>> ExtendedContext.scaleb(Decimal('7.50'), Decimal('0'))
Decimal("7.50")
Decimal('7.50')
>>> ExtendedContext.scaleb(Decimal('7.50'), Decimal('3'))
Decimal("7.50E+3")
Decimal('7.50E+3')
"""
return a.scaleb (b, context=self)
@ -4643,15 +4643,15 @@ class Context(object):
coefficient are zeros.
>>> ExtendedContext.shift(Decimal('34'), Decimal('8'))
Decimal("400000000")
Decimal('400000000')
>>> ExtendedContext.shift(Decimal('12'), Decimal('9'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.shift(Decimal('123456789'), Decimal('-2'))
Decimal("1234567")
Decimal('1234567')
>>> ExtendedContext.shift(Decimal('123456789'), Decimal('0'))
Decimal("123456789")
Decimal('123456789')
>>> ExtendedContext.shift(Decimal('123456789'), Decimal('+2'))
Decimal("345678900")
Decimal('345678900')
"""
return a.shift(b, context=self)
@ -4662,23 +4662,23 @@ class Context(object):
algorithm.
>>> ExtendedContext.sqrt(Decimal('0'))
Decimal("0")
Decimal('0')
>>> ExtendedContext.sqrt(Decimal('-0'))
Decimal("-0")
Decimal('-0')
>>> ExtendedContext.sqrt(Decimal('0.39'))
Decimal("0.624499800")
Decimal('0.624499800')
>>> ExtendedContext.sqrt(Decimal('100'))
Decimal("10")
Decimal('10')
>>> ExtendedContext.sqrt(Decimal('1'))
Decimal("1")
Decimal('1')
>>> ExtendedContext.sqrt(Decimal('1.0'))
Decimal("1.0")
Decimal('1.0')
>>> ExtendedContext.sqrt(Decimal('1.00'))
Decimal("1.0")
Decimal('1.0')
>>> ExtendedContext.sqrt(Decimal('7'))
Decimal("2.64575131")
Decimal('2.64575131')
>>> ExtendedContext.sqrt(Decimal('10'))
Decimal("3.16227766")
Decimal('3.16227766')
>>> ExtendedContext.prec
9
"""
@ -4688,11 +4688,11 @@ class Context(object):
"""Return the difference between the two operands.
>>> ExtendedContext.subtract(Decimal('1.3'), Decimal('1.07'))
Decimal("0.23")
Decimal('0.23')
>>> ExtendedContext.subtract(Decimal('1.3'), Decimal('1.30'))
Decimal("0.00")
Decimal('0.00')
>>> ExtendedContext.subtract(Decimal('1.3'), Decimal('2.07'))
Decimal("-0.77")
Decimal('-0.77')
"""
return a.__sub__(b, context=self)
@ -4721,21 +4721,21 @@ class Context(object):
context.
>>> ExtendedContext.to_integral_exact(Decimal('2.1'))
Decimal("2")
Decimal('2')
>>> ExtendedContext.to_integral_exact(Decimal('100'))
Decimal("100")
Decimal('100')
>>> ExtendedContext.to_integral_exact(Decimal('100.0'))
Decimal("100")
Decimal('100')
>>> ExtendedContext.to_integral_exact(Decimal('101.5'))
Decimal("102")
Decimal('102')
>>> ExtendedContext.to_integral_exact(Decimal('-101.5'))
Decimal("-102")
Decimal('-102')
>>> ExtendedContext.to_integral_exact(Decimal('10E+5'))
Decimal("1.0E+6")
Decimal('1.0E+6')
>>> ExtendedContext.to_integral_exact(Decimal('7.89E+77'))
Decimal("7.89E+77")
Decimal('7.89E+77')
>>> ExtendedContext.to_integral_exact(Decimal('-Inf'))
Decimal("-Infinity")
Decimal('-Infinity')
"""
return a.to_integral_exact(context=self)
@ -4749,21 +4749,21 @@ class Context(object):
be set. The rounding mode is taken from the context.
>>> ExtendedContext.to_integral_value(Decimal('2.1'))
Decimal("2")
Decimal('2')
>>> ExtendedContext.to_integral_value(Decimal('100'))
Decimal("100")
Decimal('100')
>>> ExtendedContext.to_integral_value(Decimal('100.0'))
Decimal("100")
Decimal('100')
>>> ExtendedContext.to_integral_value(Decimal('101.5'))
Decimal("102")
Decimal('102')
>>> ExtendedContext.to_integral_value(Decimal('-101.5'))
Decimal("-102")
Decimal('-102')
>>> ExtendedContext.to_integral_value(Decimal('10E+5'))
Decimal("1.0E+6")
Decimal('1.0E+6')
>>> ExtendedContext.to_integral_value(Decimal('7.89E+77'))
Decimal("7.89E+77")
Decimal('7.89E+77')
>>> ExtendedContext.to_integral_value(Decimal('-Inf'))
Decimal("-Infinity")
Decimal('-Infinity')
"""
return a.to_integral_value(context=self)

2
Lib/test/test_decimal.py
View File

@ -1049,7 +1049,7 @@ class DecimalUsabilityTest(unittest.TestCase):
d = Decimal('15.32')
self.assertEqual(str(d), '15.32') # str
self.assertEqual(repr(d), 'Decimal("15.32")') # repr
self.assertEqual(repr(d), "Decimal('15.32')") # repr
def test_tonum_methods(self):
#Test float, int and long methods.