# Two major classes

'Decimal', 'Context',

# Contexts

'DefaultContext', 'BasicContext', 'ExtendedContext',

# Exceptions

'DecimalException', 'Clamped', 'InvalidOperation', 'DivisionByZero',

'Inexact', 'Rounded', 'Subnormal', 'Overflow', 'Underflow',

'FloatOperation',

# 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

'HAVE_THREADS'

"""Base exception class.

def handle(self, context, *args):

"""Exponent of a 0 changed to fit bounds.

"""An invalid operation was performed.

def handle(self, context, *args):

if args:

ans = _dec_from_triple(args[0]._sign, args[0]._int, 'n', True)

return ans._fix_nan(context)

"""Trying to convert badly formed string.

def handle(self, context, *args):

"""Division by 0.

def handle(self, context, sign, *args):

"""Cannot perform the division adequately.

def handle(self, context, *args):

"""Undefined result of division.

def handle(self, context, *args):

"""Had to round, losing information.

"""Invalid context. Unknown rounding, for example.

def handle(self, context, *args):

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

"""Exponent < Emin before rounding.

"""Numerical overflow.

def handle(self, context, sign, *args):

if context.rounding in (ROUND_HALF_UP, ROUND_HALF_EVEN,

ROUND_HALF_DOWN, ROUND_UP):

return _SignedInfinity[sign]

if sign == 0:

if context.rounding == ROUND_CEILING:

return _SignedInfinity[sign]

return _dec_from_triple(sign, '9'*context.prec,

context.Emax-context.prec+1)

if sign == 1:

if context.rounding == ROUND_FLOOR:

return _SignedInfinity[sign]

return _dec_from_triple(sign, '9'*context.prec,

"""Numerical underflow with result rounded to 0.

"""Enable stricter semantics for mixing floats and Decimals.

"""Set this thread's context to context."""

if context in (DefaultContext, BasicContext, ExtendedContext):

context = context.copy()

context.clear_flags()

"""Returns this thread's context.

try:

return threading.current_thread().__decimal_context__

except AttributeError:

context = Context()

threading.current_thread().__decimal_context__ = context

"""Returns this thread's context.

try:

return _local.__decimal_context__

except AttributeError:

context = Context()

_local.__decimal_context__ = context

"""Set this thread's context to context."""

if context in (DefaultContext, BasicContext, ExtendedContext):

context = context.copy()

context.clear_flags()

"""Return a context manager for a copy of the supplied context

if ctx is None: ctx = getcontext()

"""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.

# 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.

if isinstance(value, str):

m = _parser(value.strip())

if m is None:

if context is None:

context = getcontext()

return context._raise_error(ConversionSyntax,

"Invalid literal for Decimal: %r" % value)

if m.group('sign') == "-":

self._sign = 1

else:

self._sign = 0

intpart = m.group('int')

if intpart is not None:

# 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')

if diag is not None:

# NaN

self._int = str(int(diag or '0')).lstrip('0')

if m.group('signal'):

self._exp = 'N'

else:

self._exp = 'n'

else:

# infinity

self._int = '0'

self._exp = 'F'

self._is_special = True

return self

# From an integer

if isinstance(value, int):

if value >= 0:

self._sign = 0

else:

self._sign = 1

self._exp = 0

self._int = str(abs(value))

self._is_special = False

return self

# From another decimal

if isinstance(value, Decimal):

self._exp = value._exp

self._sign = value._sign

self._int = value._int

self._is_special = value._is_special

return self

# From an internal working value

if isinstance(value, _WorkRep):

self._sign = value.sign

self._int = str(value.int)

self._exp = int(value.exp)

self._is_special = False

return self

# tuple/list conversion (possibly from as_tuple())

if isinstance(value, (list,tuple)):

if len(value) != 3:

raise ValueError('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

if not (isinstance(value[0], int) and value[0] in (0,1)):

raise ValueError("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]

if value[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 = []

for digit in value[1]:

if isinstance(digit, int) and 0 <= digit <= 9:

# skip leading zeros

if digits or digit != 0:

digits.append(digit)

else:

raise ValueError("The second value in the tuple must "

"be composed of integers in the range "

"0 through 9.")

if value[2] in ('n', 'N'):

# NaN: digits form the diagnostic

self._int = ''.join(map(str, digits))

self._exp = value[2]

self._is_special = True

elif isinstance(value[2], int):

# finite number: digits give the coefficient

self._int = ''.join(map(str, digits or [0]))

self._exp = value[2]

self._is_special = False

else:

raise ValueError("The third value in the tuple must "

"be an integer, or one of the "

"strings 'F', 'n', 'N'.")

return self

if isinstance(value, float):

if context is None:

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

return self

raise TypeError("Cannot convert %r to Decimal" % value)

@classmethod

def from_float(cls, f):

"""Converts a float to a decimal number, exactly.

if isinstance(f, int): # handle integer inputs

return cls(f)

if not isinstance(f, float):

raise TypeError("argument must be int or float.")

if _math.isinf(f) or _math.isnan(f):

return cls(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

result = _dec_from_triple(sign, str(n*5**k), -k)

if cls is Decimal:

return result

else:

return cls(result)

def _isnan(self):

"""Returns whether the number is not actually one.

if self._is_special:

exp = self._exp

if exp == 'n':

return 1

elif exp == 'N':

return 2

return 0

def _isinfinity(self):

"""Returns whether the number is infinite

if self._exp == 'F':

if self._sign:

return -1

return 1

return 0

def _check_nans(self, other=None, context=None):

"""Returns whether the number is not actually one.

self_is_nan = self._isnan()

if other is None:

other_is_nan = False

else:

other_is_nan = other._isnan()

if self_is_nan or other_is_nan:

if context is None:

context = getcontext()

if self_is_nan == 2:

return context._raise_error(InvalidOperation, 'sNaN',

self)

if other_is_nan == 2:

return context._raise_error(InvalidOperation, 'sNaN',

other)

if self_is_nan:

return self._fix_nan(context)

return other._fix_nan(context)

return 0

def _compare_check_nans(self, other, context):

"""Version of _check_nans used for the signaling comparisons

if context is None:

context = getcontext()

if self._is_special or other._is_special:

if self.is_snan():

return context._raise_error(InvalidOperation,

'comparison involving sNaN',

self)

elif other.is_snan():

return context._raise_error(InvalidOperation,

'comparison involving sNaN',

other)

elif self.is_qnan():

return context._raise_error(InvalidOperation,

'comparison involving NaN',

self)

elif other.is_qnan():

return context._raise_error(InvalidOperation,

'comparison involving NaN',

other)

return 0

def __bool__(self):

"""Return True if self is nonzero; otherwise return False.

return self._is_special or self._int != '0'

def _cmp(self, other):

"""Compare the two non-NaN decimal instances self and other.

if self._is_special or other._is_special:

self_inf = self._isinfinity()

other_inf = other._isinfinity()

if self_inf == other_inf:

return 0

elif self_inf < other_inf:

return -1

else:

return 1

# check for zeros; Decimal('0') == Decimal('-0')

if not self:

if not other:

return 0

else:

return -((-1)**other._sign)

if not other:

return (-1)**self._sign

# If different signs, neg one is less

if other._sign < self._sign:

return -1

if self._sign < other._sign:

return 1

self_adjusted = self.adjusted()

other_adjusted = other.adjusted()

if self_adjusted == other_adjusted:

self_padded = self._int + '0'*(self._exp - other._exp)

other_padded = other._int + '0'*(other._exp - self._exp)

if self_padded == other_padded:

return 0

elif self_padded < other_padded:

return -(-1)**self._sign

else:

return (-1)**self._sign

elif self_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)

if other is NotImplemented:

return other

if self._check_nans(other, context):

return False

return self._cmp(other) == 0

def __ne__(self, other, context=None):

self, other = _convert_for_comparison(self, other, equality_op=True)

if other is NotImplemented:

return other

if self._check_nans(other, context):

return True

return self._cmp(other) != 0

def __lt__(self, other, context=None):

self, other = _convert_for_comparison(self, other)

if other is NotImplemented:

return other

ans = self._compare_check_nans(other, context)

if ans:

return False

return self._cmp(other) < 0

def __le__(self, other, context=None):

self, other = _convert_for_comparison(self, other)

if other is NotImplemented:

return other

ans = self._compare_check_nans(other, context)

if ans:

return False

return self._cmp(other) <= 0

def __gt__(self, other, context=None):

self, other = _convert_for_comparison(self, other)

if other is NotImplemented:

return other

ans = self._compare_check_nans(other, context)

if ans:

return False

return self._cmp(other) > 0

def __ge__(self, other, context=None):

self, other = _convert_for_comparison(self, other)

if other is NotImplemented:

return other

ans = self._compare_check_nans(other, context)

if ans:

return False

return self._cmp(other) >= 0

def compare(self, other, context=None):

"""Compares one to another.

other = _convert_other(other, raiseit=True)

# Compare(NaN, NaN) = NaN

if (self._is_special or other and other._is_special):

ans = self._check_nans(other, context)

if ans:

return ans

return Decimal(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').

if self._is_special:

if self.is_snan():

raise TypeError('Cannot hash a signaling NaN value.')

elif self.is_nan():

return _PyHASH_NAN

else:

if self._sign:

return -_PyHASH_INF

else:

return _PyHASH_INF