_pydecimal.py

# Copyright (c) 2004 Python Software Foundation.
# All rights reserved.

# Written by Eric Price <eprice at tjhsst.edu>
# and Facundo Batista <facundo at taniquetil.com.ar>
# and Raymond Hettinger <python at rcn.com>
# and Aahz <aahz at pobox.com>
# and Tim Peters

# This module should be kept in sync with the latest updates of the
# IBM specification as it evolves. Those updates will be treated
# as bug fixes (deviation from the spec is a compatibility, usability
# bug) and will be backported. At this point the spec is stabilizing
# and the updates are becoming fewer, smaller, and less significant.

"""
This is an implementation of decimal floating point arithmetic based on
the General Decimal Arithmetic Specification:

 http://speleotrove.com/decimal/decarith.html

and IEEE standard 854-1987:

 http://en.wikipedia.org/wiki/IEEE_854-1987

Decimal floating point has finite precision with arbitrarily large bounds.

The purpose of this module is to support arithmetic using familiar
"schoolhouse" rules and to avoid some of the tricky representation
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 0.0; Decimal('1.00') % Decimal('0.1') returns the expected
Decimal('0.00')).

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(123456)
Decimal('123456')
>>> Decimal('123.45e12345678')
Decimal('1.2345E+12345680')
>>> 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
>>> getcontext().prec = 18
>>> print(dig / Decimal(3))
0.333333333333333333
>>> print(dig.sqrt())
1
>>> print(Decimal(3).sqrt())
1.73205080756887729
>>> print(Decimal(3) ** 123)
4.85192780976896427E+58
>>> inf = Decimal(1) / Decimal(0)
>>> print(inf)
Infinity
>>> neginf = Decimal(-1) / Decimal(0)
>>> print(neginf)
-Infinity
>>> print(neginf + inf)
NaN
>>> print(neginf * inf)
-Infinity
>>> print(dig / 0)
Infinity
>>> getcontext().traps[DivisionByZero] = 1
>>> print(dig / 0)
Traceback (most recent call last):
 ...
 ...
 ...
decimal.DivisionByZero: x / 0
>>> c = Context()
>>> c.traps[InvalidOperation] = 0
>>> print(c.flags[InvalidOperation])
0
>>> c.divide(Decimal(0), Decimal(0))
Decimal('NaN')
>>> c.traps[InvalidOperation] = 1
>>> print(c.flags[InvalidOperation])
1
>>> c.flags[InvalidOperation] = 0
>>> print(c.flags[InvalidOperation])
0
>>> print(c.divide(Decimal(0), Decimal(0)))
Traceback (most recent call last):
 ...
 ...
 ...
decimal.InvalidOperation: 0 / 0
>>> print(c.flags[InvalidOperation])
1
>>> c.flags[InvalidOperation] = 0
>>> c.traps[InvalidOperation] = 0
>>> print(c.divide(Decimal(0), Decimal(0)))
NaN
>>> print(c.flags[InvalidOperation])
1
>>>
"""

__all__= [
# Two major classes
'Decimal', 'Context',

# Named tuple representation
'DecimalTuple',

# Contexts
'DefaultContext', 'BasicContext', 'ExtendedContext',

# Exceptions
'DecimalException', 'Clamped', 'InvalidOperation', 'DivisionByZero',
'Inexact', 'Rounded', 'Subnormal', 'Overflow', 'Underflow',
'FloatOperation',

# Exceptional conditions that trigger InvalidOperation
'DivisionImpossible', 'InvalidContext', 'ConversionSyntax', 'DivisionUndefined',

# Constants for use in setting up contexts
'ROUND_DOWN', 'ROUND_HALF_UP', 'ROUND_HALF_EVEN', 'ROUND_CEILING',
'ROUND_FLOOR', 'ROUND_UP', 'ROUND_HALF_DOWN', 'ROUND_05UP',

# Functions for manipulating contexts
'setcontext', 'getcontext', 'localcontext',

# Limits for the C version for compatibility
'MAX_PREC', 'MAX_EMAX', 'MIN_EMIN', 'MIN_ETINY',

# C version: compile time choice that enables the thread local context (deprecated, now always true)
'HAVE_THREADS',

# C version: compile time choice that enables the coroutine local context
'HAVE_CONTEXTVAR'
]

__xname__=__name__# sys.modules lookup (--without-threads)
__name__='decimal'# For pickling
__version__='1.70'# Highest version of the spec this complies with
# See http://speleotrove.com/decimal/
__libmpdec_version__="2.4.2"# compatible libmpdec version

importmathas_math
importnumbersas_numbers
importsys

try:
fromcollectionsimportnamedtupleas_namedtuple
DecimalTuple=_namedtuple('DecimalTuple', 'sign digits exponent')
exceptImportError:
DecimalTuple=lambda*args: args

# Rounding
ROUND_DOWN='ROUND_DOWN'
ROUND_HALF_UP='ROUND_HALF_UP'
ROUND_HALF_EVEN='ROUND_HALF_EVEN'
ROUND_CEILING='ROUND_CEILING'
ROUND_FLOOR='ROUND_FLOOR'
ROUND_UP='ROUND_UP'
ROUND_HALF_DOWN='ROUND_HALF_DOWN'
ROUND_05UP='ROUND_05UP'

# Compatibility with the C version
HAVE_THREADS=True
HAVE_CONTEXTVAR=True
ifsys.maxsize==2**63-1:
MAX_PREC=999999999999999999
MAX_EMAX=999999999999999999
MIN_EMIN=-999999999999999999
else:
MAX_PREC=425000000
MAX_EMAX=425000000
MIN_EMIN=-425000000

MIN_ETINY=MIN_EMIN- (MAX_PREC-1)

# Errors

classDecimalException(ArithmeticError):
"""Base exception class.

 Used exceptions derive from this.
 If an exception derives from another exception besides this (such as
 Underflow (Inexact, Rounded, Subnormal) that indicates that it is only
 called if the others are present. This isn't actually used for
 anything, though.

 handle -- Called when context._raise_error is called and the
 trap_enabler is not set. First argument is self, second is the
 context. More arguments can be given, those being after
 the explanation in _raise_error (For example,
 context._raise_error(NewError, '(-x)!', self._sign) would
 call NewError().handle(context, self._sign).)

 To define a new exception, it should be sufficient to have it derive
 from DecimalException.
 """
defhandle(self, context, *args):
pass


classClamped(DecimalException):
"""Exponent of a 0 changed to fit bounds.

 This occurs and signals clamped if the exponent of a result has been
 altered in order to fit the constraints of a specific concrete
 representation. This may occur when the exponent of a zero result would
 be outside the bounds of a representation, or when a large normal
 number would have an encoded exponent that cannot be represented. In
 this latter case, the exponent is reduced to fit and the corresponding
 number of zero digits are appended to the coefficient ("fold-down").
 """

classInvalidOperation(DecimalException):
"""An invalid operation was performed.

 Various bad things cause this:

 Something creates a signaling NaN
 -INF + INF
 0 * (+-)INF
 (+-)INF / (+-)INF
 x % 0
 (+-)INF % x
 x._rescale( non-integer )
 sqrt(-x) , x > 0
 0 ** 0
 x ** (non-integer)
 x ** (+-)INF
 An operand is invalid

 The result of the operation after these is a quiet positive NaN,
 except when the cause is a signaling NaN, in which case the result is
 also a quiet NaN, but with the original sign, and an optional
 diagnostic information.
 """
defhandle(self, context, *args):
ifargs:
ans=_dec_from_triple(args[0]._sign, args[0]._int, 'n', True)
returnans._fix_nan(context)
return_NaN

classConversionSyntax(InvalidOperation):
"""Trying to convert badly formed string.

 This occurs and signals invalid-operation if a string is being
 converted to a number and it does not conform to the numeric string
 syntax. The result is [0,qNaN].
 """
defhandle(self, context, *args):
return_NaN

classDivisionByZero(DecimalException, ZeroDivisionError):
"""Division by 0.

 This occurs and signals division-by-zero if division of a finite number
 by zero was attempted (during a divide-integer or divide operation, or a
 power operation with negative right-hand operand), and the dividend was
 not zero.

 The result of the operation is [sign,inf], where sign is the exclusive
 or of the signs of the operands for divide, or is 1 for an odd power of
 -0, for power.
 """

defhandle(self, context, sign, *args):
return_SignedInfinity[sign]

classDivisionImpossible(InvalidOperation):
"""Cannot perform the division adequately.

 This occurs and signals invalid-operation if the integer result of a
 divide-integer or remainder operation had too many digits (would be
 longer than precision). The result is [0,qNaN].
 """

defhandle(self, context, *args):
return_NaN

classDivisionUndefined(InvalidOperation, ZeroDivisionError):
"""Undefined result of division.

 This occurs and signals invalid-operation if division by zero was
 attempted (during a divide-integer, divide, or remainder operation), and
 the dividend is also zero. The result is [0,qNaN].
 """

defhandle(self, context, *args):
return_NaN

classInexact(DecimalException):
"""Had to round, losing information.

 This occurs and signals inexact whenever the result of an operation is
 not exact (that is, it needed to be rounded and any discarded digits
 were non-zero), or if an overflow or underflow condition occurs. The
 result in all cases is unchanged.

 The inexact signal may be tested (or trapped) to determine if a given
 operation (or sequence of operations) was inexact.
 """

classInvalidContext(InvalidOperation):
"""Invalid context. Unknown rounding, for example.

 This occurs and signals invalid-operation if an invalid context was
 detected during an operation. This can occur if contexts are not checked
 on creation and either the precision exceeds the capability of the
 underlying concrete representation or an unknown or unsupported rounding
 was specified. These aspects of the context need only be checked when
 the values are required to be used. The result is [0,qNaN].
 """

defhandle(self, context, *args):
return_NaN

classRounded(DecimalException):
"""Number got rounded (not necessarily changed during rounding).

 This occurs and signals rounded whenever the result of an operation is
 rounded (that is, some zero or non-zero digits were discarded from the
 coefficient), or if an overflow or underflow condition occurs. The
 result in all cases is unchanged.

 The rounded signal may be tested (or trapped) to determine if a given
 operation (or sequence of operations) caused a loss of precision.
 """

classSubnormal(DecimalException):
"""Exponent < Emin before rounding.

 This occurs and signals subnormal whenever the result of a conversion or
 operation is subnormal (that is, its adjusted exponent is less than
 Emin, before any rounding). The result in all cases is unchanged.

 The subnormal signal may be tested (or trapped) to determine if a given
 or operation (or sequence of operations) yielded a subnormal result.
 """

classOverflow(Inexact, Rounded):
"""Numerical overflow.

 This occurs and signals overflow if the adjusted exponent of a result
 (from a conversion or from an operation that is not an attempt to divide
 by zero), after rounding, would be greater than the largest value that
 can be handled by the implementation (the value Emax).

 The result depends on the rounding mode:

 For round-half-up and round-half-even (and for round-half-down and
 round-up, if implemented), the result of the operation is [sign,inf],
 where sign is the sign of the intermediate result. For round-down, the
 result is the largest finite number that can be represented in the
 current precision, with the sign of the intermediate result. For
 round-ceiling, the result is the same as for round-down if the sign of
 the intermediate result is 1, or is [0,inf] otherwise. For round-floor,
 the result is the same as for round-down if the sign of the intermediate
 result is 0, or is [1,inf] otherwise. In all cases, Inexact and Rounded
 will also be raised.
 """

defhandle(self, context, sign, *args):
ifcontext.roundingin (ROUND_HALF_UP, ROUND_HALF_EVEN,
ROUND_HALF_DOWN, ROUND_UP):
return_SignedInfinity[sign]
ifsign==0:
ifcontext.rounding==ROUND_CEILING:
return_SignedInfinity[sign]
return_dec_from_triple(sign, '9'*context.prec,
context.Emax-context.prec+1)
ifsign==1:
ifcontext.rounding==ROUND_FLOOR:
return_SignedInfinity[sign]
return_dec_from_triple(sign, '9'*context.prec,
context.Emax-context.prec+1)


classUnderflow(Inexact, Rounded, Subnormal):
"""Numerical underflow with result rounded to 0.

 This occurs and signals underflow if a result is inexact and the
 adjusted exponent of the result would be smaller (more negative) than
 the smallest value that can be handled by the implementation (the value
 Emin). That is, the result is both inexact and subnormal.

 The result after an underflow will be a subnormal number rounded, if
 necessary, so that its exponent is not less than Etiny. This may result
 in 0 with the sign of the intermediate result and an exponent of Etiny.

 In all cases, Inexact, Rounded, and Subnormal will also be raised.
 """

classFloatOperation(DecimalException, TypeError):
"""Enable stricter semantics for mixing floats and Decimals.

 If the signal is not trapped (default), mixing floats and Decimals is
 permitted in the Decimal() constructor, context.create_decimal() and
 all comparison operators. Both conversion and comparisons are exact.
 Any occurrence of a mixed operation is silently recorded by setting
 FloatOperation in the context flags. Explicit conversions with
 Decimal.from_float() or context.create_decimal_from_float() do not
 set the flag.

 Otherwise (the signal is trapped), only equality comparisons and explicit
 conversions are silent. All other mixed operations raise FloatOperation.
 """

# List of public traps and flags
_signals= [Clamped, DivisionByZero, Inexact, Overflow, Rounded,
Underflow, InvalidOperation, Subnormal, FloatOperation]

# Map conditions (per the spec) to signals
_condition_map= {ConversionSyntax:InvalidOperation,
DivisionImpossible:InvalidOperation,
DivisionUndefined:InvalidOperation,
InvalidContext:InvalidOperation}

# Valid rounding modes
_rounding_modes= (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_CEILING,
ROUND_FLOOR, ROUND_UP, ROUND_HALF_DOWN, ROUND_05UP)

##### Context Functions ##################################################

# The getcontext() and setcontext() function manage access to a thread-local
# current context.

importcontextvars

_current_context_var=contextvars.ContextVar('decimal_context')

defgetcontext():
"""Returns this thread's context.

 If this thread does not yet have a context, returns
 a new context and sets this thread's context.
 New contexts are copies of DefaultContext.
 """
try:
return_current_context_var.get()
exceptLookupError:
context=Context()
_current_context_var.set(context)
returncontext

defsetcontext(context):
"""Set this thread's context to context."""
ifcontextin (DefaultContext, BasicContext, ExtendedContext):
context=context.copy()
context.clear_flags()
_current_context_var.set(context)

delcontextvars# Don't contaminate the namespace

deflocalcontext(ctx=None):
"""Return a context manager for a copy of the supplied context

 Uses a copy of the current context if no context is specified
 The returned context manager creates a local decimal context
 in a with statement:
 def sin(x):
 with localcontext() as ctx:
 ctx.prec += 2
 # Rest of sin calculation algorithm
 # uses a precision 2 greater than normal
 return +s # Convert result to normal precision

 def sin(x):
 with localcontext(ExtendedContext):
 # Rest of sin calculation algorithm
 # uses the Extended Context from the
 # General Decimal Arithmetic Specification
 return +s # Convert result to normal context

 >>> setcontext(DefaultContext)
 >>> print(getcontext().prec)
 28
 >>> with localcontext():
 ... ctx = getcontext()
 ... ctx.prec += 2
 ... print(ctx.prec)
 ...
 30
 >>> with localcontext(ExtendedContext):
 ... print(getcontext().prec)
 ...
 9
 >>> print(getcontext().prec)
 28
 """
ifctxisNone: ctx=getcontext()
return_ContextManager(ctx)


##### Decimal class #######################################################

# Do not subclass Decimal from numbers.Real and do not register it as such
# (because Decimals are not interoperable with floats). See the notes in
# numbers.py for more detail.

classDecimal(object):
"""Floating point class for decimal arithmetic."""

__slots__= ('_exp','_int','_sign', '_is_special')
# Generally, the value of the Decimal instance is given by
# (-1)**_sign * _int * 10**_exp
# Special values are signified by _is_special == True

# We're immutable, so use __new__ not __init__
def__new__(cls, value="0", context=None):
"""Create a decimal point instance.

 >>> Decimal('3.14') # string input
 Decimal('3.14')
 >>> Decimal((0, (3, 1, 4), -2)) # tuple (sign, digit_tuple, exponent)
 Decimal('3.14')
 >>> Decimal(314) # int
 Decimal('314')
 >>> Decimal(Decimal(314)) # another decimal instance
 Decimal('314')
 >>> Decimal(' 3.14 \\n') # leading and trailing whitespace okay
 Decimal('3.14')
 """

# Note that the coefficient, self._int, is actually stored as
# a string rather than as a tuple of digits. This speeds up
# the "digits to integer" and "integer to digits" conversions
# that are used in almost every arithmetic operation on
# Decimals. This is an internal detail: the as_tuple function
# and the Decimal constructor still deal with tuples of
# digits.

self=object.__new__(cls)

# From a string
# REs insist on real strings, so we can too.
ifisinstance(value, str):
m=_parser(value.strip().replace("_", ""))
ifmisNone:
ifcontextisNone:
context=getcontext()
returncontext._raise_error(ConversionSyntax,
"Invalid literal for Decimal: %r"%value)

ifm.group('sign') =="-":
self._sign=1
else:
self._sign=0
intpart=m.group('int')
ifintpartisnotNone:
# finite number
fracpart=m.group('frac') or''
exp=int(m.group('exp') or'0')
self._int=str(int(intpart+fracpart))
self._exp=exp-len(fracpart)
self._is_special=False
else:
diag=m.group('diag')
ifdiagisnotNone:
# NaN
self._int=str(int(diagor'0')).lstrip('0')
ifm.group('signal'):
self._exp='N'
else:
self._exp='n'
else:
# infinity
self._int='0'
self._exp='F'
self._is_special=True
returnself

# From an integer
ifisinstance(value, int):
ifvalue>=0:
self._sign=0
else:
self._sign=1
self._exp=0
self._int=str(abs(value))
self._is_special=False
returnself

# From another decimal
ifisinstance(value, Decimal):
self._exp=value._exp
self._sign=value._sign
self._int=value._int
self._is_special=value._is_special
returnself

# From an internal working value
ifisinstance(value, _WorkRep):
self._sign=value.sign
self._int=str(value.int)
self._exp=int(value.exp)
self._is_special=False
returnself

# tuple/list conversion (possibly from as_tuple())
ifisinstance(value, (list,tuple)):
iflen(value) !=3:
raiseValueError('Invalid tuple size in creation of Decimal '
'from list or tuple. The list or tuple '
'should have exactly three elements.')
# process sign. The isinstance test rejects floats
ifnot (isinstance(value[0], int) andvalue[0] in (0,1)):
raiseValueError("Invalid sign. The first value in the tuple "
"should be an integer; either 0 for a "
"positive number or 1 for a negative number.")
self._sign=value[0]
ifvalue[2] =='F':
# infinity: value[1] is ignored
self._int='0'
self._exp=value[2]
self._is_special=True
else:
# process and validate the digits in value[1]
digits= []
fordigitinvalue[1]:
ifisinstance(digit, int) and0<=digit<=9:
# skip leading zeros
ifdigitsordigit!=0:
digits.append(digit)
else:
raiseValueError("The second value in the tuple must "
"be composed of integers in the range "
"0 through 9.")
ifvalue[2] in ('n', 'N'):
# NaN: digits form the diagnostic
self._int=''.join(map(str, digits))
self._exp=value[2]
self._is_special=True
elifisinstance(value[2], int):
# finite number: digits give the coefficient
self._int=''.join(map(str, digitsor [0]))
self._exp=value[2]
self._is_special=False
else:
raiseValueError("The third value in the tuple must "
"be an integer, or one of the "
"strings 'F', 'n', 'N'.")
returnself

ifisinstance(value, float):
ifcontextisNone:
context=getcontext()
context._raise_error(FloatOperation,
"strict semantics for mixing floats and Decimals are "
"enabled")
value=Decimal.from_float(value)
self._exp=value._exp
self._sign=value._sign
self._int=value._int
self._is_special=value._is_special
returnself

raiseTypeError("Cannot convert %r to Decimal"%value)

@classmethod
deffrom_float(cls, f):
"""Converts a float to a decimal number, exactly.

 Note that Decimal.from_float(0.1) is not the same as Decimal('0.1').
 Since 0.1 is not exactly representable in binary floating point, the
 value is stored as the nearest representable value which is
 0x1.999999999999ap-4. The exact equivalent of the value in decimal
 is 0.1000000000000000055511151231257827021181583404541015625.

 >>> Decimal.from_float(0.1)
 Decimal('0.1000000000000000055511151231257827021181583404541015625')
 >>> Decimal.from_float(float('nan'))
 Decimal('NaN')
 >>> Decimal.from_float(float('inf'))
 Decimal('Infinity')
 >>> Decimal.from_float(-float('inf'))
 Decimal('-Infinity')
 >>> Decimal.from_float(-0.0)
 Decimal('-0')

 """
ifisinstance(f, int): # handle integer inputs
sign=0iff>=0else1
k=0
coeff=str(abs(f))
elifisinstance(f, float):
if_math.isinf(f) or_math.isnan(f):
returncls(repr(f))
if_math.copysign(1.0, f) ==1.0:
sign=0
else:
sign=1
n, d=abs(f).as_integer_ratio()
k=d.bit_length() -1
coeff=str(n*5**k)
else:
raiseTypeError("argument must be int or float.")

result=_dec_from_triple(sign, coeff, -k)
ifclsisDecimal:
returnresult
else:
returncls(result)

def_isnan(self):
"""Returns whether the number is not actually one.

 0 if a number
 1 if NaN
 2 if sNaN
 """
ifself._is_special:
exp=self._exp
ifexp=='n':
return1
elifexp=='N':
return2
return0

def_isinfinity(self):
"""Returns whether the number is infinite

 0 if finite or not a number
 1 if +INF
 -1 if -INF
 """
ifself._exp=='F':
ifself._sign:
return-1
return1
return0

def_check_nans(self, other=None, context=None):
"""Returns whether the number is not actually one.

 if self, other are sNaN, signal
 if self, other are NaN return nan
 return 0

 Done before operations.
 """

self_is_nan=self._isnan()
ifotherisNone:
other_is_nan=False
else:
other_is_nan=other._isnan()

ifself_is_nanorother_is_nan:
ifcontextisNone:
context=getcontext()

ifself_is_nan==2:
returncontext._raise_error(InvalidOperation, 'sNaN',
self)
ifother_is_nan==2:
returncontext._raise_error(InvalidOperation, 'sNaN',
other)
ifself_is_nan:
returnself._fix_nan(context)

returnother._fix_nan(context)
return0

def_compare_check_nans(self, other, context):
"""Version of _check_nans used for the signaling comparisons
 compare_signal, __le__, __lt__, __ge__, __gt__.

 Signal InvalidOperation if either self or other is a (quiet
 or signaling) NaN. Signaling NaNs take precedence over quiet
 NaNs.

 Return 0 if neither operand is a NaN.

 """
ifcontextisNone:
context=getcontext()

ifself._is_specialorother._is_special:
ifself.is_snan():
returncontext._raise_error(InvalidOperation,
'comparison involving sNaN',
self)
elifother.is_snan():
returncontext._raise_error(InvalidOperation,
'comparison involving sNaN',
other)
elifself.is_qnan():
returncontext._raise_error(InvalidOperation,
'comparison involving NaN',
self)
elifother.is_qnan():
returncontext._raise_error(InvalidOperation,
'comparison involving NaN',
other)
return0

def__bool__(self):
"""Return True if self is nonzero; otherwise return False.

 NaNs and infinities are considered nonzero.
 """
returnself._is_specialorself._int!='0'

def_cmp(self, other):
"""Compare the two non-NaN decimal instances self and other.

 Returns -1 if self < other, 0 if self == other and 1
 if self > other. This routine is for internal use only."""

ifself._is_specialorother._is_special:
self_inf=self._isinfinity()
other_inf=other._isinfinity()
ifself_inf==other_inf:
return0
elifself_inf<other_inf:
return-1
else:
return1

# check for zeros; Decimal('0') == Decimal('-0')
ifnotself:
ifnotother:
return0
else:
return-((-1)**other._sign)
ifnotother:
return (-1)**self._sign

# If different signs, neg one is less
ifother._sign<self._sign:
return-1
ifself._sign<other._sign:
return1

self_adjusted=self.adjusted()
other_adjusted=other.adjusted()
ifself_adjusted==other_adjusted:
self_padded=self._int+'0'*(self._exp-other._exp)
other_padded=other._int+'0'*(other._exp-self._exp)
ifself_padded==other_padded:
return0
elifself_padded<other_padded:
return-(-1)**self._sign
else:
return (-1)**self._sign
elifself_adjusted>other_adjusted:
return (-1)**self._sign
else: # self_adjusted < other_adjusted
return-((-1)**self._sign)

# Note: The Decimal standard doesn't cover rich comparisons for
# Decimals. In particular, the specification is silent on the
# subject of what should happen for a comparison involving a NaN.
# We take the following approach:
#
# == comparisons involving a quiet NaN always return False
# != comparisons involving a quiet NaN always return True
# == or != comparisons involving a signaling NaN signal
# InvalidOperation, and return False or True as above if the
# InvalidOperation is not trapped.
# <, >, <= and >= comparisons involving a (quiet or signaling)
# NaN signal InvalidOperation, and return False if the
# InvalidOperation is not trapped.
#
# This behavior is designed to conform as closely as possible to
# that specified by IEEE 754.

def__eq__(self, other, context=None):
self, other=_convert_for_comparison(self, other, equality_op=True)
ifotherisNotImplemented:
returnother
ifself._check_nans(other, context):
returnFalse
returnself._cmp(other) ==0

def__lt__(self, other, context=None):
self, other=_convert_for_comparison(self, other)
ifotherisNotImplemented:
returnother
ans=self._compare_check_nans(other, context)
ifans:
returnFalse
returnself._cmp(other) <0

def__le__(self, other, context=None):
self, other=_convert_for_comparison(self, other)
ifotherisNotImplemented:
returnother
ans=self._compare_check_nans(other, context)
ifans:
returnFalse
returnself._cmp(other) <=0

def__gt__(self, other, context=None):
self, other=_convert_for_comparison(self, other)
ifotherisNotImplemented:
returnother
ans=self._compare_check_nans(other, context)
ifans:
returnFalse
returnself._cmp(other) >0

def__ge__(self, other, context=None):
self, other=_convert_for_comparison(self, other)
ifotherisNotImplemented:
returnother
ans=self._compare_check_nans(other, context)
ifans:
returnFalse
returnself._cmp(other) >=0

defcompare(self, other, context=None):
"""Compare self to other. Return a decimal value:

 a or b is a NaN ==> Decimal('NaN')
 a < b ==> Decimal('-1')
 a == b ==> Decimal('0')
 a > b ==> Decimal('1')
 """
other=_convert_other(other, raiseit=True)

# Compare(NaN, NaN) = NaN
if (self._is_specialorotherandother._is_special):
ans=self._check_nans(other, context)
ifans:
returnans

returnDecimal(self._cmp(other))

def__hash__(self):
"""x.__hash__() <==> hash(x)"""

# In order to make sure that the hash of a Decimal instance
# agrees with the hash of a numerically equal integer, float
# or Fraction, we follow the rules for numeric hashes outlined
# in the documentation. (See library docs, 'Built-in Types').
ifself._is_special:
ifself.is_snan():
raiseTypeError('Cannot hash a signaling NaN value.')
elifself.is_nan():
return_PyHASH_NAN
else:
ifself._sign:
return-_PyHASH_INF
else:
return_PyHASH_INF

ifself._exp>=0:
exp_hash=pow(10, self._exp, _PyHASH_MODULUS)
else:
exp_hash=pow(_PyHASH_10INV, -self._exp, _PyHASH_MODULUS)
hash_=int(self._int) *exp_hash%_PyHASH_MODULUS
ans=hash_ifself>=0else-hash_
return-2ifans==-1elseans

defas_tuple(self):
"""Represents the number as a triple tuple.

 To show the internals exactly as they are.
 """
returnDecimalTuple(self._sign, tuple(map(int, self._int)), self._exp)

defas_integer_ratio(self):
"""Express a finite Decimal instance in the form n / d.

 Returns a pair (n, d) of integers. When called on an infinity
 or NaN, raises OverflowError or ValueError respectively.

 >>> Decimal('3.14').as_integer_ratio()
 (157, 50)
 >>> Decimal('-123e5').as_integer_ratio()
 (-12300000, 1)
 >>> Decimal('0.00').as_integer_ratio()
 (0, 1)

 """
ifself._is_special:
ifself.is_nan():
raiseValueError("cannot convert NaN to integer ratio")
else:
raiseOverflowError("cannot convert Infinity to integer ratio")

ifnotself:
return0, 1

# Find n, d in lowest terms such that abs(self) == n / d;
# we'll deal with the sign later.