# Two major classes

'Decimal', 'Context',

# Contexts

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

# Exceptions

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

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

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

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

"""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.currentThread().__decimal_context__

except AttributeError:

context = Context()

threading.currentThread().__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, basestring):

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

exp = int(m.group('exp') or '0')

if fracpart is not None:

self._int = str((intpart+fracpart).lstrip('0') or '0')

self._exp = exp - len(fracpart)

else:

self._int = str(intpart.lstrip('0') or '0')

self._exp = exp

self._is_special = False

else:

diag = m.group('diag')

if diag is not None:

# NaN

self._int = str(diag.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,long)):

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, long)) 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, long)) 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, long)):

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

raise TypeError("Cannot convert float to Decimal. " +

"First convert the float to a string")

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

# @classmethod, but @decorator is not valid Python 2.3 syntax, so

# don't use it (see notes on Py2.3 compatibility at top of file)

def from_float(cls, f):

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

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

return cls(f)

if _math.isinf(f) or _math.isnan(f): # raises TypeError if not a float

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)

from_float = classmethod(from_float)

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 __nonzero__(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 NaN always return False

# != comparisons involving a NaN always return True

# <, >, <= 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):

other = _convert_other(other)

if other is NotImplemented:

return other

if self.is_nan() or other.is_nan():

return False

return self._cmp(other) == 0

def __ne__(self, other):

other = _convert_other(other)

if other is NotImplemented:

return other

if self.is_nan() or other.is_nan():

return True

return self._cmp(other) != 0

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

other = _convert_other(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):

other = _convert_other(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):

other = _convert_other(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):

other = _convert_other(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)"""

# Decimal integers must hash the same as the ints

#

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

if self._is_special:

if self._isnan():

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

return hash(str(self))

if not self:

return 0

if self._isinteger():

op = _WorkRep(self.to_integral_value())

# to make computation feasible for Decimals with large

# exponent, we use the fact that hash(n) == hash(m) for

# any two nonzero integers n and m such that (i) n and m

# have the same sign, and (ii) n is congruent to m modulo

# 2**64-1. So we can replace hash((-1)**s*c*10**e) with

# hash((-1)**s*c*pow(10, e, 2**64-1).

return hash((-1)**op.sign*op.int*pow(10, op.exp, 2**64-1))

# The value of a nonzero nonspecial Decimal instance is

# faithfully represented by the triple consisting of its sign,

# its adjusted exponent, and its coefficient with trailing

# zeros removed.

return hash((self._sign,

self._exp+len(self._int),

self._int.rstrip('0')))

def as_tuple(self):

"""Represents the number as a triple tuple.

return DecimalTuple(self._sign, tuple(map(int, self._int)), self._exp)

def __repr__(self):

"""Represents the number as an instance of Decimal."""

# Invariant: eval(repr(d)) == d

return "Decimal('%s')" % str(self)

def __str__(self, eng=False, context=None):

"""Return string representation of the number in scientific notation.

sign = ['', '-'][self._sign]

if self._is_special:

if self._exp == 'F':

return sign + 'Infinity'

elif self._exp == 'n':

return sign + 'NaN' + self._int

else: # self._exp == 'N'

return sign + 'sNaN' + self._int

# number of digits of self._int to left of decimal point

leftdigits = self._exp + len(self._int)

# dotplace is number of digits of self._int to the left of the

# decimal point in the mantissa of the output string (that is,

# after adjusting the exponent)

if self._exp <= 0 and leftdigits > -6:

# no exponent required

dotplace = leftdigits

elif not eng:

# usual scientific notation: 1 digit on left of the point

dotplace = 1

elif self._int == '0':

# engineering notation, zero