--- /dev/null
+# Brownian motion -- an example of a NON multi-threaded Tkinter program ;)
+# By Michele Simoniato, inspired by brownian.py
+
+from Tkinter import *
+import random
+import sys
+
+WIDTH = 400
+HEIGHT = 300
+SIGMA = 10
+BUZZ = 2
+RADIUS = 2
+LAMBDA = 10
+FILL = 'red'
+
+stop = 0 # Set when main loop exits
+root = None # main window
+
+def particle(canvas): # particle = iterator over the moves
+ r = RADIUS
+ x = random.gauss(WIDTH/2.0, SIGMA)
+ y = random.gauss(HEIGHT/2.0, SIGMA)
+ p = canvas.create_oval(x-r, y-r, x+r, y+r, fill=FILL)
+ while not stop:
+ dx = random.gauss(0, BUZZ)
+ dy = random.gauss(0, BUZZ)
+ try:
+ canvas.move(p, dx, dy)
+ except TclError:
+ break
+ else:
+ yield None
+
+def move(particle): # move the particle at random time
+ particle.next()
+ dt = random.expovariate(LAMBDA)
+ root.after(int(dt*1000), move, particle)
+
+def main():
+ global root, stop
+ root = Tk()
+ canvas = Canvas(root, width=WIDTH, height=HEIGHT)
+ canvas.pack(fill='both', expand=1)
+ np = 30
+ if sys.argv[1:]:
+ np = int(sys.argv[1])
+ for i in range(np): # start the dance
+ move(particle(canvas))
+ try:
+ root.mainloop()
+ finally:
+ stop = 1
+
+if __name__ == '__main__':
+ main()
.. data:: O_BINARY
-
- Option for the *flag* argument to the :func:`open` function. This can be
- bit-wise OR'd together with those listed above. Availability: Windows.
-
- .. % XXX need to check on the availability of this one.
-
-
-.. data:: O_NOINHERIT
+ O_NOINHERIT
O_SHORT_LIVED
O_TEMPORARY
O_RANDOM
bit-wise OR'd together. Availability: Windows.
+.. data:: O_DIRECT
+ O_DIRECTORY
+ O_NOFOLLOW
+ O_NOATIME
+
+ Options for the *flag* argument to the :func:`open` function. These are
+ GNU extensions and not present if they are not defined by the C library.
+
+
.. data:: SEEK_SET
SEEK_CUR
SEEK_END
communicate() returns a tuple (stdout, stderr).
- .. note::
+ Note that if you want to send data to the process's stdin, you need to create
+ the Popen object with ``stdin=PIPE``. Similarly, to get anything other than
+ ``None`` in the result tuple, you need to give ``stdout=PIPE`` and/or
+ ``stderr=PIPE`` too.
+
+.. note::
The data read is buffered in memory, so do not use this method if the data size
is large or unlimited.
Called when the test case *test* raises an unexpected exception *err* is a tuple
of the form returned by :func:`sys.exc_info`: ``(type, value, traceback)``.
- The default implementation appends ``(test, err)`` to the instance's ``errors``
- attribute.
+ The default implementation appends a tuple ``(test, formatted_err)`` to the
+ instance's ``errors`` attribute, where *formatted_err* is a formatted
+ traceback derived from *err*.
.. method:: TestResult.addFailure(test, err)
Called when the test case *test* signals a failure. *err* is a tuple of the form
returned by :func:`sys.exc_info`: ``(type, value, traceback)``.
- The default implementation appends ``(test, err)`` to the instance's
- ``failures`` attribute.
+ The default implementation appends a tuple ``(test, formatted_err)`` to the
+ instance's ``failures`` attribute, where *formatted_err* is a formatted
+ traceback derived from *err*.
.. method:: TestResult.addSuccess(test)
The Document Object Model is being defined by the W3C in stages, or "levels" in
their terminology. The Python mapping of the API is substantially based on the
-DOM Level 2 recommendation. The mapping of the Level 3 specification, currently
-only available in draft form, is being developed by the `Python XML Special
-Interest Group <http://www.python.org/sigs/xml-sig/>`_ as part of the `PyXML
-package <http://pyxml.sourceforge.net/>`_. Refer to the documentation bundled
-with that package for information on the current state of DOM Level 3 support.
+DOM Level 2 recommendation.
+
+.. XXX PyXML is dead...
+.. The mapping of the Level 3 specification, currently
+ only available in draft form, is being developed by the `Python XML Special
+ Interest Group <http://www.python.org/sigs/xml-sig/>`_ as part of the `PyXML
+ package <http://pyxml.sourceforge.net/>`_. Refer to the documentation bundled
+ with that package for information on the current state of DOM Level 3 support.
.. % What if your needs are somewhere between SAX and the DOM? Perhaps
.. % you cannot afford to load the entire tree in memory but you find the
`Document Object Model (DOM) Level 1 Specification <http://www.w3.org/TR/REC-DOM-Level-1/>`_
The W3C recommendation for the DOM supported by :mod:`xml.dom.minidom`.
- `PyXML <http://pyxml.sourceforge.net>`_
- Users that require a full-featured implementation of DOM should use the PyXML
- package.
-
`Python Language Mapping Specification <http://www.omg.org/docs/formal/02-11-05.pdf>`_
This specifies the mapping from OMG IDL to Python.
.. method:: Node.appendChild(newChild)
- Add a new child node to this node at the end of the list of children, returning
- *newChild*.
+ Add a new child node to this node at the end of the list of
+ children, returning *newChild*. If the node was already in
+ in the tree, it is removed first.
.. method:: Node.insertBefore(newChild, refChild)
Changes to Python's build process and to the C API include:
+* Python 2.6 can be built with Microsoft Visual Studio 2008.
+ See the :file:`PCbuild9` directory for the build files.
+ (Implemented by Christian Heimes.)
+
* The BerkeleyDB module now has a C API object, available as
``bsddb.db.api``. This object can be used by other C extensions
that wish to use the :mod:`bsddb` module for their own purposes.
def handle(self, context, *args):
if args:
if args[0] == 1: # sNaN, must drop 's' but keep diagnostics
- ans = Decimal((args[1]._sign, args[1]._int, 'n'))
+ ans = _dec_from_triple(args[1]._sign, args[1]._int, 'n', True)
return ans._fix_nan(context)
elif args[0] == 2:
- return Decimal( (args[1], args[2], 'n') )
+ return _dec_from_triple(args[1], args[2], 'n', True)
return NaN
if sign == 0:
if context.rounding == ROUND_CEILING:
return Infsign[sign]
- return Decimal((sign, (9,)*context.prec,
- context.Emax-context.prec+1))
+ return _dec_from_triple(sign, '9'*context.prec,
+ context.Emax-context.prec+1)
if sign == 1:
if context.rounding == ROUND_FLOOR:
return Infsign[sign]
- return Decimal( (sign, (9,)*context.prec,
- context.Emax-context.prec+1))
+ return _dec_from_triple(sign, '9'*context.prec,
+ context.Emax-context.prec+1)
class Underflow(Inexact, Rounded, Subnormal):
Decimal("314")
"""
+ # 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)
self._is_special = False
# From an internal working value
if isinstance(value, _WorkRep):
self._sign = value.sign
- self._int = tuple(map(int, str(value.int)))
+ self._int = str(value.int)
self._exp = int(value.exp)
return self
else:
self._sign = 1
self._exp = 0
- self._int = tuple(map(int, str(abs(value))))
+ self._int = str(abs(value))
return self
# tuple/list conversion (possibly from as_tuple())
self._sign = value[0]
if value[2] == 'F':
# infinity: value[1] is ignored
- self._int = (0,)
+ self._int = '0'
self._exp = value[2]
self._is_special = True
else:
"0 through 9.")
if value[2] in ('n', 'N'):
# NaN: digits form the diagnostic
- self._int = tuple(digits)
+ 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 = tuple(digits or [0])
+ self._int = ''.join(map(str, digits or [0]))
self._exp = value[2]
self._is_special = False
else:
raise TypeError("Cannot convert float to Decimal. " +
"First convert the float to a string")
- # Other argument types may require the context during interpretation
- if context is None:
- context = getcontext()
-
# From a string
# REs insist on real strings, so we can too.
if isinstance(value, str):
- if _isinfinity(value):
- self._exp = 'F'
- self._int = (0,)
- self._is_special = True
- if _isinfinity(value) == 1:
- self._sign = 0
+ m = _parser(value)
+ 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 = (intpart+fracpart).lstrip('0') or '0'
+ self._exp = exp - len(fracpart)
else:
- self._sign = 1
- return self
- if _isnan(value):
- sig, sign, diag = _isnan(value)
- self._is_special = True
- if sig == 1:
- self._exp = 'n' # qNaN
- else: # sig == 2
- self._exp = 'N' # sNaN
- self._sign = sign
- self._int = tuple(map(int, diag)) # Diagnostic info
- return self
- try:
- self._sign, self._int, self._exp = _string2exact(value)
- except ValueError:
+ self._int = 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 = 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 context._raise_error(ConversionSyntax,
- "Invalid literal for Decimal: %r" % value)
return self
raise TypeError("Cannot convert %r to Decimal" % value)
NaNs and infinities are considered nonzero.
"""
- return self._is_special or self._int[0] != 0
+ return self._is_special or self._int != '0'
def __cmp__(self, other):
other = _convert_other(other)
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)
+ self_padded = self._int + '0'*(self._exp - other._exp)
+ other_padded = other._int + '0'*(other._exp - self._exp)
return cmp(self_padded, other_padded) * (-1)**self._sign
elif self_adjusted > other_adjusted:
return (-1)**self._sign
To show the internals exactly as they are.
"""
- return (self._sign, self._int, self._exp)
+ return (self._sign, tuple(map(int, self._int)), self._exp)
def __repr__(self):
"""Represents the number as an instance of Decimal."""
if self._is_special:
if self._isnan():
minus = '-'*self._sign
- if self._int == (0,):
+ if self._int == '0':
info = ''
else:
- info = ''.join(map(str, self._int))
+ info = self._int
if self._isnan() == 2:
return minus + 'sNaN' + info
return minus + 'NaN' + info
if context is None:
context = getcontext()
- tmp = list(map(str, self._int))
+ tmp = list(self._int)
numdigits = len(self._int)
leftdigits = self._exp + numdigits
if eng and not self: # self = 0eX wants 0[.0[0]]eY, not [[0]0]0eY
sign = min(self._sign, other._sign)
if negativezero:
sign = 1
- ans = Decimal( (sign, (0,), exp))
+ ans = _dec_from_triple(sign, '0', exp)
if shouldround:
ans = ans._fix(context)
return ans
if op1.sign != op2.sign:
# Equal and opposite
if op1.int == op2.int:
- ans = Decimal((negativezero, (0,), exp))
+ ans = _dec_from_triple(negativezero, '0', exp)
if shouldround:
ans = ans._fix(context)
return ans
For example:
Decimal('5.624e10')._increment() == Decimal('5.625e10')
"""
- L = list(self._int)
+ L = list(map(int, self._int))
L[-1] += 1
spot = len(L)-1
while L[spot] == 10:
break
L[spot-1] += 1
spot -= 1
- return Decimal((self._sign, L, self._exp))
+ return _dec_from_triple(self._sign, "".join(map(str, L)), self._exp)
def __mul__(self, other, context=None):
"""Return self * other.
# Special case for multiplying by zero
if not self or not other:
- ans = Decimal((resultsign, (0,), resultexp))
+ ans = _dec_from_triple(resultsign, '0', resultexp)
if shouldround:
# Fixing in case the exponent is out of bounds
ans = ans._fix(context)
return ans
# Special case for multiplying by power of 10
- if self._int == (1,):
- ans = Decimal((resultsign, other._int, resultexp))
+ if self._int == '1':
+ ans = _dec_from_triple(resultsign, other._int, resultexp)
if shouldround:
ans = ans._fix(context)
return ans
- if other._int == (1,):
- ans = Decimal((resultsign, self._int, resultexp))
+ if other._int == '1':
+ ans = _dec_from_triple(resultsign, self._int, resultexp)
if shouldround:
ans = ans._fix(context)
return ans
op1 = _WorkRep(self)
op2 = _WorkRep(other)
- ans = Decimal((resultsign,
- tuple(map(int, str(op1.int * op2.int))),
- resultexp))
+ ans = _dec_from_triple(resultsign, str(op1.int * op2.int), resultexp)
if shouldround:
ans = ans._fix(context)
if other._isinfinity():
context._raise_error(Clamped, 'Division by infinity')
- return Decimal((sign, (0,), context.Etiny()))
+ return _dec_from_triple(sign, '0', context.Etiny())
# Special cases for zeroes
if not other:
coeff //= 10
exp += 1
- ans = Decimal((sign, list(map(int, str(coeff))), exp))
+ ans = _dec_from_triple(sign, str(coeff), exp)
return ans._fix(context)
def _divide(self, other, context):
expdiff = self.adjusted() - other.adjusted()
if not self or other._isinfinity() or expdiff <= -2:
- return (Decimal((sign, (0,), 0)),
+ return (_dec_from_triple(sign, '0', 0),
self._rescale(ideal_exp, context.rounding))
if expdiff <= context.prec:
op1 = _WorkRep(self)
op2.int *= 10**(op2.exp - op1.exp)
q, r = divmod(op1.int, op2.int)
if q < 10**context.prec:
- return (Decimal((sign, list(map(int, str(q))), 0)),
- Decimal((self._sign, list(map(int, str(r))),
- ideal_exp)))
+ return (_dec_from_triple(sign, str(q), 0),
+ _dec_from_triple(self._sign, str(r), ideal_exp))
# Here the quotient is too large to be representable
ans = context._raise_error(DivisionImpossible,
# self = 0 -> remainder = self, with ideal exponent
ideal_exponent = min(self._exp, other._exp)
if not self:
- ans = Decimal((self._sign, (0,), ideal_exponent))
+ ans = _dec_from_triple(self._sign, '0', ideal_exponent)
return ans._fix(context)
# catch most cases of large or small quotient
sign = 1-sign
r = -r
- ans = Decimal((sign, list(map(int, str(r))), ideal_exponent))
+ ans = _dec_from_triple(sign, str(r), ideal_exponent)
return ans._fix(context)
def __floordiv__(self, other, context=None):
raise OverflowError("Cannot convert infinity to int")
s = (-1)**self._sign
if self._exp >= 0:
- return s*int(''.join(map(str, self._int)))*10**self._exp
+ return s*int(self._int)*10**self._exp
else:
- return s*int(''.join(map(str, self._int))[:self._exp] or '0')
+ return s*int(self._int[:self._exp] or '0')
def _fix_nan(self, context):
"""Decapitate the payload of a NaN to fit the context"""
# precision-1 if _clamp=1.
max_payload_len = context.prec - context._clamp
if len(payload) > max_payload_len:
- pos = len(payload)-max_payload_len
- while pos < len(payload) and payload[pos] == 0:
- pos += 1
- payload = payload[pos:]
- return Decimal((self._sign, payload, self._exp))
+ payload = payload[len(payload)-max_payload_len:].lstrip('0')
+ return _dec_from_triple(self._sign, payload, self._exp, True)
return Decimal(self)
def _fix(self, context):
new_exp = min(max(self._exp, Etiny), exp_max)
if new_exp != self._exp:
context._raise_error(Clamped)
- return Decimal((self._sign, (0,), new_exp))
+ return _dec_from_triple(self._sign, '0', new_exp)
else:
return Decimal(self)
# we get here only if rescaling rounds the
# cofficient up to exactly 10**context.prec
if ans._exp < Etop:
- ans = Decimal((ans._sign, ans._int[:-1], ans._exp+1))
+ ans = _dec_from_triple(ans._sign,
+ ans._int[:-1], ans._exp+1)
else:
# Inexact and Rounded have already been raised
ans = context._raise_error(Overflow, 'above Emax',
# fold down if _clamp == 1 and self has too few digits
if context._clamp == 1 and self._exp > Etop:
context._raise_error(Clamped)
- self_padded = self._int + (0,)*(self._exp - Etop)
- return Decimal((self._sign, self_padded, Etop))
+ self_padded = self._int + '0'*(self._exp - Etop)
+ return _dec_from_triple(self._sign, self_padded, Etop)
# here self was representable to begin with; return unchanged
return Decimal(self)
def _round_down(self, prec):
"""Also known as round-towards-0, truncate."""
newexp = self._exp + len(self._int) - prec
- return Decimal((self._sign, self._int[:prec] or (0,), newexp))
+ return _dec_from_triple(self._sign, self._int[:prec] or '0', newexp)
def _round_up(self, prec):
"""Rounds away from 0."""
newexp = self._exp + len(self._int) - prec
- tmp = Decimal((self._sign, self._int[:prec] or (0,), newexp))
+ tmp = _dec_from_triple(self._sign, self._int[:prec] or '0', newexp)
for digit in self._int[prec:]:
- if digit != 0:
+ if digit != '0':
return tmp._increment()
return tmp
def _round_half_up(self, prec):
"""Rounds 5 up (away from 0)"""
- if self._int[prec] >= 5:
+ if self._int[prec] in '56789':
return self._round_up(prec)
else:
return self._round_down(prec)
def _round_half_down(self, prec):
"""Round 5 down"""
- if self._int[prec] == 5:
+ if self._int[prec] == '5':
for digit in self._int[prec+1:]:
- if digit != 0:
+ if digit != '0':
break
else:
return self._round_down(prec)
def _round_half_even(self, prec):
"""Round 5 to even, rest to nearest."""
- if prec and self._int[prec-1] & 1:
+ if prec and self._int[prec-1] in '13579':
return self._round_half_up(prec)
else:
return self._round_half_down(prec)
def _round_05up(self, prec):
"""Round down unless digit prec-1 is 0 or 5."""
- if prec == 0 or self._int[prec-1] in (0, 5):
+ if prec == 0 or self._int[prec-1] in '05':
return self._round_up(prec)
else:
return self._round_down(prec)
base = pow(base, 10, modulo)
base = pow(base, exponent.int, modulo)
- return Decimal((sign, list(map(int, str(base))), 0))
+ return _dec_from_triple(sign, str(base), 0)
def _power_exact(self, other, p):
"""Attempt to compute self**other exactly.
zeros = min(exponent-ideal_exponent, p-1)
else:
zeros = 0
- return Decimal((0, (1,) + (0,)*zeros, exponent-zeros))
+ return _dec_from_triple(0, '1' + '0'*zeros, exponent-zeros)
# case where y is negative: xc must be either a power
# of 2 or a power of 5.
if xc >= 10**p:
return None
xe = -e-xe
- return Decimal((0, list(map(int, str(xc))), xe))
+ return _dec_from_triple(0, str(xc), xe)
# now y is positive; find m and n such that y = m/n
if ye >= 0:
zeros = min(xe-ideal_exponent, p-len(str_xc))
else:
zeros = 0
- return Decimal((0, list(map(int, str_xc))+[0,]*zeros, xe-zeros))
+ return _dec_from_triple(0, str_xc+'0'*zeros, xe-zeros)
def __pow__(self, other, modulo=None, context=None):
"""Return self ** other [ % modulo].
return context._raise_error(InvalidOperation,
'x ** y with x negative and y not an integer')
# negate self, without doing any unwanted rounding
- self = Decimal((0, self._int, self._exp))
+ self = self.copy_negate()
# 0**(+ve or Inf)= 0; 0**(-ve or -Inf) = Infinity
if not self:
if other._sign == 0:
- return Decimal((result_sign, (0,), 0))
+ return _dec_from_triple(result_sign, '0', 0)
else:
return Infsign[result_sign]
if other._sign == 0:
return Infsign[result_sign]
else:
- return Decimal((result_sign, (0,), 0))
+ return _dec_from_triple(result_sign, '0', 0)
# 1**other = 1, but the choice of exponent and the flags
# depend on the exponent of self, and on whether other is a
context._raise_error(Rounded)
exp = 1-context.prec
- return Decimal((result_sign, (1,)+(0,)*-exp, exp))
+ return _dec_from_triple(result_sign, '1'+'0'*-exp, exp)
# compute adjusted exponent of self
self_adj = self.adjusted()
# self ** -infinity is infinity if self < 1, 0 if self > 1
if other._isinfinity():
if (other._sign == 0) == (self_adj < 0):
- return Decimal((result_sign, (0,), 0))
+ return _dec_from_triple(result_sign, '0', 0)
else:
return Infsign[result_sign]
# self > 1 and other +ve, or self < 1 and other -ve
# possibility of overflow
if bound >= len(str(context.Emax)):
- ans = Decimal((result_sign, (1,), context.Emax+1))
+ ans = _dec_from_triple(result_sign, '1', context.Emax+1)
else:
# self > 1 and other -ve, or self < 1 and other +ve
# possibility of underflow to 0
Etiny = context.Etiny()
if bound >= len(str(-Etiny)):
- ans = Decimal((result_sign, (1,), Etiny-1))
+ ans = _dec_from_triple(result_sign, '1', Etiny-1)
# try for an exact result with precision +1
if ans is None:
ans = self._power_exact(other, context.prec + 1)
if ans is not None and result_sign == 1:
- ans = Decimal((1, ans._int, ans._exp))
+ ans = _dec_from_triple(1, ans._int, ans._exp)
# usual case: inexact result, x**y computed directly as exp(y*log(x))
if ans is None:
break
extra += 3
- ans = Decimal((result_sign, list(map(int, str(coeff))), exp))
+ ans = _dec_from_triple(result_sign, str(coeff), exp)
# the specification says that for non-integer other we need to
# raise Inexact, even when the result is actually exact. In
# pad with zeros up to length context.prec+1 if necessary
if len(ans._int) <= context.prec:
expdiff = context.prec+1 - len(ans._int)
- ans = Decimal((ans._sign, ans._int+(0,)*expdiff, ans._exp-expdiff))
+ ans = _dec_from_triple(ans._sign, ans._int+'0'*expdiff,
+ ans._exp-expdiff)
if ans.adjusted() < context.Emin:
context._raise_error(Underflow)
return dup
if not dup:
- return Decimal( (dup._sign, (0,), 0) )
+ return _dec_from_triple(dup._sign, '0', 0)
exp_max = [context.Emax, context.Etop()][context._clamp]
end = len(dup._int)
exp = dup._exp
- while dup._int[end-1] == 0 and exp < exp_max:
+ while dup._int[end-1] == '0' and exp < exp_max:
exp += 1
end -= 1
- return Decimal( (dup._sign, dup._int[:end], exp) )
+ return _dec_from_triple(dup._sign, dup._int[:end], exp)
def quantize(self, exp, rounding=None, context=None, watchexp=True):
"""Quantize self so its exponent is the same as that of exp.
'target exponent out of bounds in quantize')
if not self:
- ans = Decimal((self._sign, (0,), exp._exp))
+ ans = _dec_from_triple(self._sign, '0', exp._exp)
return ans._fix(context)
self_adjusted = self.adjusted()
if self._is_special:
return Decimal(self)
if not self:
- return Decimal((self._sign, (0,), exp))
+ return _dec_from_triple(self._sign, '0', exp)
if self._exp >= exp:
# pad answer with zeros if necessary
- return Decimal((self._sign, self._int + (0,)*(self._exp - exp), exp))
+ return _dec_from_triple(self._sign,
+ self._int + '0'*(self._exp - exp), exp)
# too many digits; round and lose data. If self.adjusted() <
# exp-1, replace self by 10**(exp-1) before rounding
digits = len(self._int) + self._exp - exp
if digits < 0:
- self = Decimal((self._sign, (1,), exp-1))
+ self = _dec_from_triple(self._sign, '1', exp-1)
digits = 0
this_function = getattr(self, self._pick_rounding_function[rounding])
return this_function(digits)
if self._exp >= 0:
return Decimal(self)
if not self:
- return Decimal((self._sign, (0,), 0))
+ return _dec_from_triple(self._sign, '0', 0)
if context is None:
context = getcontext()
if rounding is None:
if not self:
# exponent = self._exp // 2. sqrt(-0) = -0
- ans = Decimal((self._sign, (0,), self._exp // 2))
+ ans = _dec_from_triple(self._sign, '0', self._exp // 2)
return ans._fix(context)
if context is None:
if n % 5 == 0:
n += 1
- ans = Decimal((0, list(map(int, str(n))), e))
+ ans = _dec_from_triple(0, str(n), e)
# round, and fit to current context
context = context._shallow_copy()
if self._exp >= 0:
return True
rest = self._int[self._exp:]
- return rest == (0,)*len(rest)
+ return rest == '0'*len(rest)
def _iseven(self):
"""Returns True if self is even. Assumes self is an integer."""
if not self or self._exp > 0:
return True
- return self._int[-1+self._exp] & 1 == 0
+ return self._int[-1+self._exp] in '02468'
def adjusted(self):
"""Return the adjusted exponent of self"""
def copy_abs(self):
"""Returns a copy with the sign set to 0. """
- return Decimal((0, self._int, self._exp))
+ return _dec_from_triple(0, self._int, self._exp, self._is_special)
def copy_negate(self):
"""Returns a copy with the sign inverted."""
if self._sign:
- return Decimal((0, self._int, self._exp))
+ return _dec_from_triple(0, self._int, self._exp, self._is_special)
else:
- return Decimal((1, self._int, self._exp))
+ return _dec_from_triple(1, self._int, self._exp, self._is_special)
def copy_sign(self, other):
"""Returns self with the sign of other."""
- return Decimal((other._sign, self._int, self._exp))
+ return _dec_from_triple(other._sign, self._int,
+ self._exp, self._is_special)
def exp(self, context=None):
"""Returns e ** self."""
# larger exponent the result either overflows or underflows.
if self._sign == 0 and adj > len(str((context.Emax+1)*3)):
# overflow
- ans = Decimal((0, (1,), context.Emax+1))
+ ans = _dec_from_triple(0, '1', context.Emax+1)
elif self._sign == 1 and adj > len(str((-context.Etiny()+1)*3)):
# underflow to 0
- ans = Decimal((0, (1,), context.Etiny()-1))
+ ans = _dec_from_triple(0, '1', context.Etiny()-1)
elif self._sign == 0 and adj < -p:
# p+1 digits; final round will raise correct flags
- ans = Decimal((0, (1,) + (0,)*(p-1) + (1,), -p))
+ ans = _dec_from_triple(0, '1' + '0'*(p-1) + '1', -p)
elif self._sign == 1 and adj < -p-1:
# p+1 digits; final round will raise correct flags
- ans = Decimal((0, (9,)*(p+1), -p-1))
+ ans = _dec_from_triple(0, '9'*(p+1), -p-1)
# general case
else:
op = _WorkRep(self)
break
extra += 3
- ans = Decimal((0, list(map(int, str(coeff))), exp))
+ ans = _dec_from_triple(0, str(coeff), exp)
# at this stage, ans should round correctly with *any*
# rounding mode, not just with ROUND_HALF_EVEN
def is_zero(self):
"""Return True if self is a zero; otherwise return False."""
- return not self._is_special and self._int[0] == 0
+ return not self._is_special and self._int == '0'
def _ln_exp_bound(self):
"""Compute a lower bound for the adjusted exponent of self.ln().
if coeff % (5*10**(len(str(abs(coeff)))-p-1)):
break
places += 3
- ans = Decimal((int(coeff<0), list(map(int, str(abs(coeff)))), -places))
+ ans = _dec_from_triple(int(coeff<0), str(abs(coeff)), -places)
context = context._shallow_copy()
rounding = context._set_rounding(ROUND_HALF_EVEN)
'log10 of a negative value')
# log10(10**n) = n
- if self._int[0] == 1 and self._int[1:] == (0,)*(len(self._int) - 1):
+ if self._int[0] == '1' and self._int[1:] == '0'*(len(self._int) - 1):
# answer may need rounding
ans = Decimal(self._exp + len(self._int) - 1)
else:
if coeff % (5*10**(len(str(abs(coeff)))-p-1)):
break
places += 3
- ans = Decimal((int(coeff<0), list(map(int, str(abs(coeff)))),
- -places))
+ ans = _dec_from_triple(int(coeff<0), str(abs(coeff)), -places)
context = context._shallow_copy()
rounding = context._set_rounding(ROUND_HALF_EVEN)
if self._sign != 0 or self._exp != 0:
return False
for dig in self._int:
- if dig not in (0, 1):
+ if dig not in '01':
return False
return True
def _fill_logical(self, context, opa, opb):
dif = context.prec - len(opa)
if dif > 0:
- opa = (0,)*dif + opa
+ opa = '0'*dif + opa
elif dif < 0:
opa = opa[-context.prec:]
dif = context.prec - len(opb)
if dif > 0:
- opb = (0,)*dif + opb
+ opb = '0'*dif + opb
elif dif < 0:
opb = opb[-context.prec:]
return opa, opb
(opa, opb) = self._fill_logical(context, self._int, other._int)
# make the operation, and clean starting zeroes
- result = [a&b for a,b in zip(opa,opb)]
- for i,d in enumerate(result):
- if d == 1:
- break
- result = tuple(result[i:])
-
- # if empty, we must have at least a zero
- if not result:
- result = (0,)
- return Decimal((0, result, 0))
+ result = "".join([str(int(a)&int(b)) for a,b in zip(opa,opb)])
+ return _dec_from_triple(0, result.lstrip('0') or '0', 0)
def logical_invert(self, context=None):
"""Invert all its digits."""
if context is None:
context = getcontext()
- return self.logical_xor(Decimal((0,(1,)*context.prec,0)), context)
+ return self.logical_xor(_dec_from_triple(0,'1'*context.prec,0),
+ context)
def logical_or(self, other, context=None):
"""Applies an 'or' operation between self and other's digits."""
(opa, opb) = self._fill_logical(context, self._int, other._int)
# make the operation, and clean starting zeroes
- result = [a|b for a,b in zip(opa,opb)]
- for i,d in enumerate(result):
- if d == 1:
- break
- result = tuple(result[i:])
-
- # if empty, we must have at least a zero
- if not result:
- result = (0,)
- return Decimal((0, result, 0))
+ result = "".join(str(int(a)|int(b)) for a,b in zip(opa,opb))
+ return _dec_from_triple(0, result.lstrip('0') or '0', 0)
def logical_xor(self, other, context=None):
"""Applies an 'xor' operation between self and other's digits."""
(opa, opb) = self._fill_logical(context, self._int, other._int)
# make the operation, and clean starting zeroes
- result = [a^b for a,b in zip(opa,opb)]
- for i,d in enumerate(result):
- if d == 1:
- break
- result = tuple(result[i:])
-
- # if empty, we must have at least a zero
- if not result:
- result = (0,)
- return Decimal((0, result, 0))
+ result = "".join(str(int(a)^int(b)) for a,b in zip(opa,opb))
+ return _dec_from_triple(0, result.lstrip('0') or '0', 0)
def max_mag(self, other, context=None):
"""Compares the values numerically with their sign ignored."""
if self._isinfinity() == -1:
return negInf
if self._isinfinity() == 1:
- return Decimal((0, (9,)*context.prec, context.Etop()))
+ return _dec_from_triple(0, '9'*context.prec, context.Etop())
context = context.copy()
context._set_rounding(ROUND_FLOOR)
new_self = self._fix(context)
if new_self != self:
return new_self
- return self.__sub__(Decimal((0, (1,), context.Etiny()-1)), context)
+ return self.__sub__(_dec_from_triple(0, '1', context.Etiny()-1),
+ context)
def next_plus(self, context=None):
"""Returns the smallest representable number larger than itself."""
if self._isinfinity() == 1:
return Inf
if self._isinfinity() == -1:
- return Decimal((1, (9,)*context.prec, context.Etop()))
+ return _dec_from_triple(1, '9'*context.prec, context.Etop())
context = context.copy()
context._set_rounding(ROUND_CEILING)
new_self = self._fix(context)
if new_self != self:
return new_self
- return self.__add__(Decimal((0, (1,), context.Etiny()-1)), context)
+ return self.__add__(_dec_from_triple(0, '1', context.Etiny()-1),
+ context)
def next_toward(self, other, context=None):
"""Returns the number closest to self, in the direction towards other.
comparison = self.__cmp__(other)
if comparison == 0:
- return Decimal((other._sign, self._int, self._exp))
+ return self.copy_sign(other)
if comparison == -1:
ans = self.next_plus(context)
rotdig = self._int
topad = context.prec - len(rotdig)
if topad:
- rotdig = ((0,)*topad) + rotdig
+ rotdig = '0'*topad + rotdig
# let's rotate!
rotated = rotdig[torot:] + rotdig[:torot]
-
- # clean starting zeroes
- for i,d in enumerate(rotated):
- if d != 0:
- break
- rotated = rotated[i:]
-
- return Decimal((self._sign, rotated, self._exp))
-
+ return _dec_from_triple(self._sign,
+ rotated.lstrip('0') or '0', self._exp)
def scaleb (self, other, context=None):
"""Returns self operand after adding the second value to its exp."""
if self._isinfinity():
return Decimal(self)
- d = Decimal((self._sign, self._int, self._exp + int(other)))
+ d = _dec_from_triple(self._sign, self._int, self._exp + int(other))
d = d._fix(context)
return d
rotdig = self._int
topad = context.prec - len(rotdig)
if topad:
- rotdig = ((0,)*topad) + rotdig
+ rotdig = '0'*topad + rotdig
# let's shift!
if torot < 0:
rotated = rotdig[:torot]
else:
- rotated = (rotdig + ((0,) * torot))
+ rotated = rotdig + '0'*torot
rotated = rotated[-context.prec:]
- # clean starting zeroes
- if rotated:
- for i,d in enumerate(rotated):
- if d != 0:
- break
- rotated = rotated[i:]
- else:
- rotated = (0,)
-
- return Decimal((self._sign, rotated, self._exp))
-
+ return _dec_from_triple(self._sign,
+ rotated.lstrip('0') or '0', self._exp)
# Support for pickling, copy, and deepcopy
def __reduce__(self):
return self # My components are also immutable
return self.__class__(str(self))
+def _dec_from_triple(sign, coefficient, exponent, special=False):
+ """Create a decimal instance directly, without any validation,
+ normalization (e.g. removal of leading zeros) or argument
+ conversion.
+
+ This function is for *internal use only*.
+ """
+
+ self = object.__new__(Decimal)
+ self._sign = sign
+ self._int = coefficient
+ self._exp = exponent
+ self._is_special = special
+
+ return self
+
##### Context class #######################################################
self.exp = None
elif isinstance(value, Decimal):
self.sign = value._sign
- cum = 0
- for digit in value._int:
- cum = cum * 10 + digit
- self.int = cum
+ self.int = int(value._int)
self.exp = value._exp
else:
# assert isinstance(value, tuple)
raise TypeError("Unable to convert %s to Decimal" % other)
return NotImplemented
-_infinity_map = {
- 'inf' : 1,
- 'infinity' : 1,
- '+inf' : 1,
- '+infinity' : 1,
- '-inf' : -1,
- '-infinity' : -1
-}
-
-def _isinfinity(num):
- """Determines whether a string or float is infinity.
-
- +1 for negative infinity; 0 for finite ; +1 for positive infinity
- """
- num = str(num).lower()
- return _infinity_map.get(num, 0)
-
-def _isnan(num):
- """Determines whether a string or float is NaN
-
- (1, sign, diagnostic info as string) => NaN
- (2, sign, diagnostic info as string) => sNaN
- 0 => not a NaN
- """
- num = str(num).lower()
- if not num:
- return 0
-
- # Get the sign, get rid of trailing [+-]
- sign = 0
- if num[0] == '+':
- num = num[1:]
- elif num[0] == '-': # elif avoids '+-nan'
- num = num[1:]
- sign = 1
-
- if num.startswith('nan'):
- if len(num) > 3 and not num[3:].isdigit(): # diagnostic info
- return 0
- return (1, sign, num[3:].lstrip('0'))
- if num.startswith('snan'):
- if len(num) > 4 and not num[4:].isdigit():
- return 0
- return (2, sign, num[4:].lstrip('0'))
- return 0
-
-
##### Setup Specific Contexts ############################################
# The default context prototype used by Context()
)
-##### Useful Constants (internal use only) ################################
-
-# Reusable defaults
-Inf = Decimal('Inf')
-negInf = Decimal('-Inf')
-NaN = Decimal('NaN')
-Dec_0 = Decimal(0)
-Dec_p1 = Decimal(1)
-Dec_n1 = Decimal(-1)
-Dec_p2 = Decimal(2)
-Dec_n2 = Decimal(-2)
-
-# Infsign[sign] is infinity w/ that sign
-Infsign = (Inf, negInf)
-
-
##### crud for parsing strings #############################################
import re
-# There's an optional sign at the start, and an optional exponent
-# at the end. The exponent has an optional sign and at least one
-# digit. In between, must have either at least one digit followed
-# by an optional fraction, or a decimal point followed by at least
-# one digit. Yuck.
+# Regular expression used for parsing numeric strings. Additional
+# comments:
+#
+# 1. Uncomment the two '\s*' lines to allow leading and/or trailing
+# whitespace. But note that the specification disallows whitespace in
+# a numeric string.
+#
+# 2. For finite numbers (not infinities and NaNs) the body of the
+# number between the optional sign and the optional exponent must have
+# at least one decimal digit, possibly after the decimal point. The
+# lookahead expression '(?=\d|\.\d)' checks this.
+#
+# As the flag UNICODE is not enabled here, we're explicitly avoiding any
+# other meaning for \d than the numbers [0-9].
-_parser = re.compile(r"""
+import re
+_parser = re.compile(r""" # A numeric string consists of:
# \s*
- (?P<sign>[-+])?
+ (?P<sign>[-+])? # an optional sign, followed by either...
(
- (?P<int>\d+) (\. (?P<frac>\d*))?
+ (?=\d|\.\d) # ...a number (with at least one digit)
+ (?P<int>\d*) # consisting of a (possibly empty) integer part
+ (\.(?P<frac>\d*))? # followed by an optional fractional part
+ (E(?P<exp>[-+]?\d+))? # followed by an optional exponent, or...
|
- \. (?P<onlyfrac>\d+)
+ Inf(inity)? # ...an infinity, or...
+ |
+ (?P<signal>s)? # ...an (optionally signaling)
+ NaN # NaN
+ (?P<diag>\d*) # with (possibly empty) diagnostic information.
)
- ([eE](?P<exp>[-+]? \d+))?
# \s*
$
-""", re.VERBOSE).match # Uncomment the \s* to allow leading or trailing spaces.
+""", re.VERBOSE | re.IGNORECASE).match
del re
-def _string2exact(s):
- """Return sign, n, p s.t.
- Float string value == -1**sign * n * 10**p exactly
- """
- m = _parser(s)
- if m is None:
- raise ValueError("invalid literal for Decimal: %r" % s)
+##### Useful Constants (internal use only) ################################
- if m.group('sign') == "-":
- sign = 1
- else:
- sign = 0
+# Reusable defaults
+Inf = Decimal('Inf')
+negInf = Decimal('-Inf')
+NaN = Decimal('NaN')
+Dec_0 = Decimal(0)
+Dec_p1 = Decimal(1)
+Dec_n1 = Decimal(-1)
+Dec_p2 = Decimal(2)
+Dec_n2 = Decimal(-2)
- exp = m.group('exp')
- if exp is None:
- exp = 0
- else:
- exp = int(exp)
+# Infsign[sign] is infinity w/ that sign
+Infsign = (Inf, negInf)
- intpart = m.group('int')
- if intpart is None:
- intpart = ""
- fracpart = m.group('onlyfrac')
- else:
- fracpart = m.group('frac')
- if fracpart is None:
- fracpart = ""
-
- exp -= len(fracpart)
-
- mantissa = intpart + fracpart
- tmp = list(map(int, mantissa))
- backup = tmp
- while tmp and tmp[0] == 0:
- del tmp[0]
-
- # It's a zero
- if not tmp:
- if backup:
- return (sign, tuple(backup), exp)
- return (sign, (0,), exp)
- mantissa = tuple(tmp)
-
- return (sign, mantissa, exp)
if __name__ == '__main__':
"""
def __init__(self, out):
self.__out = out
+ self.__debugger_used = False
pdb.Pdb.__init__(self, stdout=out)
+ def set_trace(self, frame=None):
+ self.__debugger_used = True
+ if frame is None:
+ frame = sys._getframe().f_back
+ pdb.Pdb.set_trace(self, frame)
+
+ def set_continue(self):
+ # Calling set_continue unconditionally would break unit test
+ # coverage reporting, as Bdb.set_continue calls sys.settrace(None).
+ if self.__debugger_used:
+ pdb.Pdb.set_continue(self)
+
def trace_dispatch(self, *args):
# Redirect stdout to the given stream.
save_stdout = sys.stdout
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- This set of tests primarily tests the existence of the operator.
-- Additon, subtraction, rounding, and more overflows are tested
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
precision: 9
rounding: half_up
addx1117 add -1e-4 +1e-383 -> -0.00009999999999999999 Rounded Inexact
addx1118 add -1e-5 +1e-383 -> -0.000009999999999999999 Rounded Inexact
addx1119 add -1e-6 +1e-383 -> -9.999999999999999E-7 Rounded Inexact
+addx1120 add +1e-383 -1e+2 -> -99.99999999999999 Rounded Inexact
+addx1121 add +1e-383 -1e+1 -> -9.999999999999999 Rounded Inexact
+addx1123 add +1e-383 -1 -> -0.9999999999999999 Rounded Inexact
+addx1124 add +1e-383 -1e-1 -> -0.09999999999999999 Rounded Inexact
+addx1125 add +1e-383 -1e-2 -> -0.009999999999999999 Rounded Inexact
+addx1126 add +1e-383 -1e-3 -> -0.0009999999999999999 Rounded Inexact
+addx1127 add +1e-383 -1e-4 -> -0.00009999999999999999 Rounded Inexact
+addx1128 add +1e-383 -1e-5 -> -0.000009999999999999999 Rounded Inexact
+addx1129 add +1e-383 -1e-6 -> -9.999999999999999E-7 Rounded Inexact
rounding: down
precision: 7
addx6057 add '1E+2' '1E+4' -> '1.01E+4'
-- from above
-addx6061 add 1 '0.1' -> '1.1'
-addx6062 add 1 '0.01' -> '1.01'
-addx6063 add 1 '0.001' -> '1.001'
-addx6064 add 1 '0.0001' -> '1.0001'
-addx6065 add 1 '0.00001' -> '1.00001'
-addx6066 add 1 '0.000001' -> '1.000001'
-addx6067 add 1 '0.0000001' -> '1.0000001'
-addx6068 add 1 '0.00000001' -> '1.00000001'
+addx6060 add 1 '0.1' -> '1.1'
+addx6061 add 1 '0.01' -> '1.01'
+addx6062 add 1 '0.001' -> '1.001'
+addx6063 add 1 '0.0001' -> '1.0001'
+addx6064 add 1 '0.00001' -> '1.00001'
+addx6065 add 1 '0.000001' -> '1.000001'
+addx6066 add 1 '0.0000001' -> '1.0000001'
+addx6067 add 1 '0.00000001' -> '1.00000001'
-- cancellation to integer
-addx6069 add 99999999999999123456789 -99999999999999E+9 -> 123456789
+addx6068 add 99999999999999123456789 -99999999999999E+9 -> 123456789
+-- similar from FMA fun
+addx6069 add "-1234567890123455.234567890123454" "1234567890123456" -> 0.765432109876546
-- some funny zeros [in case of bad signum]
addx6070 add 1 0 -> 1
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
-- This file tests base conversions from string to a decimal number
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- This set of tests uses the same limits as the 8-byte concrete
-- representation, but applies clamping without using format-specific
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- [New 2006.11.27]\r
\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- Note that we cannot assume add/subtract tests cover paths adequately,
-- here, because the code might be quite different (comparison cannot
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that it cannot be assumed that add/subtract tests cover paths\r
-- for this operation adequately, here, because the code might be\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests are for decDoubles only; all arguments are\r
-- representable in a decDouble\r
ddadd71707 add 130E-2 -1E0 -> 0.30\r
ddadd71708 add 1E2 -1E4 -> -9.9E+3\r
\r
+-- query from Vincent Kulandaisamy\r
+rounding: ceiling\r
+ddadd71801 add 7.8822773805862E+277 -5.1757503820663E-21 -> 7.882277380586200E+277 Inexact Rounded\r
+ddadd71802 add 7.882277380586200E+277 12.341 -> 7.882277380586201E+277 Inexact Rounded\r
+ddadd71803 add 7.882277380586201E+277 2.7270545046613E-31 -> 7.882277380586202E+277 Inexact Rounded\r
+\r
+ddadd71811 add 12.341 -5.1757503820663E-21 -> 12.34100000000000 Inexact Rounded\r
+ddadd71812 add 12.34100000000000 2.7270545046613E-31 -> 12.34100000000001 Inexact Rounded\r
+ddadd71813 add 12.34100000000001 7.8822773805862E+277 -> 7.882277380586201E+277 Inexact Rounded\r
+\r
-- Gappy coefficients; check residue handling even with full coefficient gap\r
rounding: half_even\r
\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This file tests base conversions from string to a decimal number\r
-- and back to a string (in Scientific form)\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This file tests that copy operations leave uncanonical operands\r
-- unchanged, and vice versa\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- [New 2006.11.27]\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-- [Previously called decimal64.decTest]\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests is for the eight-byte concrete representation.\r
-- Its characteristics are:\r
decd829 apply #2238000115afb55b -> 4294967295\r
decd830 apply #2238000115afb57a -> 4294967296\r
decd831 apply #2238000115afb57b -> 4294967297\r
+\r
+-- for narrowing\r
+decd840 apply #2870000000000000 -> 2.000000000000000E-99\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
ddfma375088 fma 1 12345678 1E-34 -> 12345678.00000001 Inexact Rounded\r
ddfma375089 fma 1 12345678 1E-35 -> 12345678.00000001 Inexact Rounded\r
\r
+-- desctructive subtraction (from remainder tests)\r
+\r
+-- +++ some of these will be off-by-one remainder vs remainderNear\r
+\r
+ddfma4000 fma -1234567890123454 1.000000000000001 1234567890123456 -> 0.765432109876546\r
+ddfma4001 fma -1234567890123443 1.00000000000001 1234567890123456 -> 0.65432109876557\r
+ddfma4002 fma -1234567890123332 1.0000000000001 1234567890123456 -> 0.5432109876668\r
+ddfma4003 fma -308641972530863 4.000000000000001 1234567890123455 -> 2.691358027469137\r
+ddfma4004 fma -308641972530863 4.000000000000001 1234567890123456 -> 3.691358027469137\r
+ddfma4005 fma -246913578024696 4.9999999999999 1234567890123456 -> 0.6913578024696\r
+ddfma4006 fma -246913578024691 4.99999999999999 1234567890123456 -> 3.46913578024691\r
+ddfma4007 fma -246913578024691 4.999999999999999 1234567890123456 -> 1.246913578024691\r
+ddfma4008 fma -246913578024691 5.000000000000001 1234567890123456 -> 0.753086421975309\r
+ddfma4009 fma -246913578024690 5.00000000000001 1234567890123456 -> 3.53086421975310\r
+ddfma4010 fma -246913578024686 5.0000000000001 1234567890123456 -> 1.3086421975314\r
+ddfma4011 fma -1234567890123455 1.000000000000001 1234567890123456 -> -0.234567890123455\r
+ddfma4012 fma -1234567890123444 1.00000000000001 1234567890123456 -> -0.34567890123444\r
+ddfma4013 fma -1234567890123333 1.0000000000001 1234567890123456 -> -0.4567890123333\r
+ddfma4014 fma -308641972530864 4.000000000000001 1234567890123455 -> -1.308641972530864\r
+ddfma4015 fma -308641972530864 4.000000000000001 1234567890123456 -> -0.308641972530864\r
+ddfma4016 fma -246913578024696 4.9999999999999 1234567890123456 -> 0.6913578024696\r
+ddfma4017 fma -246913578024692 4.99999999999999 1234567890123456 -> -1.53086421975308\r
+ddfma4018 fma -246913578024691 4.999999999999999 1234567890123456 -> 1.246913578024691\r
+ddfma4019 fma -246913578024691 5.000000000000001 1234567890123456 -> 0.753086421975309\r
+ddfma4020 fma -246913578024691 5.00000000000001 1234567890123456 -> -1.46913578024691\r
+ddfma4021 fma -246913578024686 5.0000000000001 1234567890123456 -> 1.3086421975314\r
+\r
+\r
-- Null tests\r
ddfma39990 fma 1 10 # -> NaN Invalid_operation\r
ddfma39991 fma 1 # 10 -> NaN Invalid_operation\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests are for decDoubles only; all arguments are\r
-- representable in a decDouble\r
-- hugest\r
ddmul909 multiply 9999999999999999 9999999999999999 -> 9.999999999999998E+31 Inexact Rounded\r
\r
+-- power-of-ten edge cases\r
+ddmul1001 multiply 1 10 -> 10\r
+ddmul1002 multiply 1 100 -> 100\r
+ddmul1003 multiply 1 1000 -> 1000\r
+ddmul1004 multiply 1 10000 -> 10000\r
+ddmul1005 multiply 1 100000 -> 100000\r
+ddmul1006 multiply 1 1000000 -> 1000000\r
+ddmul1007 multiply 1 10000000 -> 10000000\r
+ddmul1008 multiply 1 100000000 -> 100000000\r
+ddmul1009 multiply 1 1000000000 -> 1000000000\r
+ddmul1010 multiply 1 10000000000 -> 10000000000\r
+ddmul1011 multiply 1 100000000000 -> 100000000000\r
+ddmul1012 multiply 1 1000000000000 -> 1000000000000\r
+ddmul1013 multiply 1 10000000000000 -> 10000000000000\r
+ddmul1014 multiply 1 100000000000000 -> 100000000000000\r
+ddmul1015 multiply 1 1000000000000000 -> 1000000000000000\r
+ddmul1021 multiply 10 1 -> 10\r
+ddmul1022 multiply 10 10 -> 100\r
+ddmul1023 multiply 10 100 -> 1000\r
+ddmul1024 multiply 10 1000 -> 10000\r
+ddmul1025 multiply 10 10000 -> 100000\r
+ddmul1026 multiply 10 100000 -> 1000000\r
+ddmul1027 multiply 10 1000000 -> 10000000\r
+ddmul1028 multiply 10 10000000 -> 100000000\r
+ddmul1029 multiply 10 100000000 -> 1000000000\r
+ddmul1030 multiply 10 1000000000 -> 10000000000\r
+ddmul1031 multiply 10 10000000000 -> 100000000000\r
+ddmul1032 multiply 10 100000000000 -> 1000000000000\r
+ddmul1033 multiply 10 1000000000000 -> 10000000000000\r
+ddmul1034 multiply 10 10000000000000 -> 100000000000000\r
+ddmul1035 multiply 10 100000000000000 -> 1000000000000000\r
+ddmul1041 multiply 100 0.1 -> 10.0\r
+ddmul1042 multiply 100 1 -> 100\r
+ddmul1043 multiply 100 10 -> 1000\r
+ddmul1044 multiply 100 100 -> 10000\r
+ddmul1045 multiply 100 1000 -> 100000\r
+ddmul1046 multiply 100 10000 -> 1000000\r
+ddmul1047 multiply 100 100000 -> 10000000\r
+ddmul1048 multiply 100 1000000 -> 100000000\r
+ddmul1049 multiply 100 10000000 -> 1000000000\r
+ddmul1050 multiply 100 100000000 -> 10000000000\r
+ddmul1051 multiply 100 1000000000 -> 100000000000\r
+ddmul1052 multiply 100 10000000000 -> 1000000000000\r
+ddmul1053 multiply 100 100000000000 -> 10000000000000\r
+ddmul1054 multiply 100 1000000000000 -> 100000000000000\r
+ddmul1055 multiply 100 10000000000000 -> 1000000000000000\r
+ddmul1061 multiply 1000 0.01 -> 10.00\r
+ddmul1062 multiply 1000 0.1 -> 100.0\r
+ddmul1063 multiply 1000 1 -> 1000\r
+ddmul1064 multiply 1000 10 -> 10000\r
+ddmul1065 multiply 1000 100 -> 100000\r
+ddmul1066 multiply 1000 1000 -> 1000000\r
+ddmul1067 multiply 1000 10000 -> 10000000\r
+ddmul1068 multiply 1000 100000 -> 100000000\r
+ddmul1069 multiply 1000 1000000 -> 1000000000\r
+ddmul1070 multiply 1000 10000000 -> 10000000000\r
+ddmul1071 multiply 1000 100000000 -> 100000000000\r
+ddmul1072 multiply 1000 1000000000 -> 1000000000000\r
+ddmul1073 multiply 1000 10000000000 -> 10000000000000\r
+ddmul1074 multiply 1000 100000000000 -> 100000000000000\r
+ddmul1075 multiply 1000 1000000000000 -> 1000000000000000\r
+ddmul1081 multiply 10000 0.001 -> 10.000\r
+ddmul1082 multiply 10000 0.01 -> 100.00\r
+ddmul1083 multiply 10000 0.1 -> 1000.0\r
+ddmul1084 multiply 10000 1 -> 10000\r
+ddmul1085 multiply 10000 10 -> 100000\r
+ddmul1086 multiply 10000 100 -> 1000000\r
+ddmul1087 multiply 10000 1000 -> 10000000\r
+ddmul1088 multiply 10000 10000 -> 100000000\r
+ddmul1089 multiply 10000 100000 -> 1000000000\r
+ddmul1090 multiply 10000 1000000 -> 10000000000\r
+ddmul1091 multiply 10000 10000000 -> 100000000000\r
+ddmul1092 multiply 10000 100000000 -> 1000000000000\r
+ddmul1093 multiply 10000 1000000000 -> 10000000000000\r
+ddmul1094 multiply 10000 10000000000 -> 100000000000000\r
+ddmul1095 multiply 10000 100000000000 -> 1000000000000000\r
+\r
+ddmul1097 multiply 10000 99999999999 -> 999999999990000\r
+ddmul1098 multiply 10000 99999999999 -> 999999999990000\r
+\r
+\r
+\r
+\r
-- Null tests\r
-ddmul990 multiply 10 # -> NaN Invalid_operation\r
-ddmul991 multiply # 10 -> NaN Invalid_operation\r
+ddmul9990 multiply 10 # -> NaN Invalid_operation\r
+ddmul9991 multiply # 10 -> NaN Invalid_operation\r
\r
\r
\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Most of the tests here assume a "regular pattern", where the\r
-- sign and coefficient are +1.\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
ddrem1057 remainder -1e-277 1e+311 -> -1E-277\r
ddrem1058 remainder -1e-277 -1e+311 -> -1E-277\r
\r
+-- destructive subtract\r
+ddrem1101 remainder 1234567890123456 1.000000000000001 -> 0.765432109876546\r
+ddrem1102 remainder 1234567890123456 1.00000000000001 -> 0.65432109876557\r
+ddrem1103 remainder 1234567890123456 1.0000000000001 -> 0.5432109876668\r
+ddrem1104 remainder 1234567890123455 4.000000000000001 -> 2.691358027469137\r
+ddrem1105 remainder 1234567890123456 4.000000000000001 -> 3.691358027469137\r
+ddrem1106 remainder 1234567890123456 4.9999999999999 -> 0.6913578024696\r
+ddrem1107 remainder 1234567890123456 4.99999999999999 -> 3.46913578024691\r
+ddrem1108 remainder 1234567890123456 4.999999999999999 -> 1.246913578024691\r
+ddrem1109 remainder 1234567890123456 5.000000000000001 -> 0.753086421975309\r
+ddrem1110 remainder 1234567890123456 5.00000000000001 -> 3.53086421975310\r
+ddrem1111 remainder 1234567890123456 5.0000000000001 -> 1.3086421975314\r
+\r
-- Null tests\r
ddrem1000 remainder 10 # -> NaN Invalid_operation\r
ddrem1001 remainder # 10 -> NaN Invalid_operation\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
\r
ddrmn980 remaindernear 123e1 1000E299 -> 1.23E+3 -- 123E+1 internally\r
\r
+\r
-- overflow and underflow tests [from divide]\r
ddrmn1051 remaindernear 1e+277 1e-311 -> NaN Division_impossible\r
ddrmn1052 remaindernear 1e+277 -1e-311 -> NaN Division_impossible\r
ddrmn1057 remaindernear -1e-277 1e+311 -> -1E-277\r
ddrmn1058 remaindernear -1e-277 -1e+311 -> -1E-277\r
\r
+-- destructive subtract\r
+ddrmn1100 remainderNear 1234567890123456 1.000000000000001 -> -0.234567890123455\r
+ddrmn1101 remainderNear 1234567890123456 1.00000000000001 -> -0.34567890123444\r
+ddrmn1102 remainderNear 1234567890123456 1.0000000000001 -> -0.4567890123333\r
+ddrmn1103 remainderNear 1234567890123455 4.000000000000001 -> -1.308641972530864\r
+ddrmn1104 remainderNear 1234567890123456 4.000000000000001 -> -0.308641972530864\r
+ddrmn1115 remainderNear 1234567890123456 4.9999999999999 -> 0.6913578024696\r
+ddrmn1116 remainderNear 1234567890123456 4.99999999999999 -> -1.53086421975308\r
+ddrmn1117 remainderNear 1234567890123456 4.999999999999999 -> 1.246913578024691\r
+ddrmn1118 remainderNear 1234567890123456 5.000000000000001 -> 0.753086421975309\r
+ddrmn1119 remainderNear 1234567890123456 5.00000000000001 -> -1.46913578024691\r
+ddrmn1110 remainderNear 1234567890123456 5.0000000000001 -> 1.3086421975314\r
+\r
-- Null tests\r
ddrmn1000 remaindernear 10 # -> NaN Invalid_operation\r
ddrmn1001 remaindernear # 10 -> NaN Invalid_operation\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decDoubles.\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests are for decDoubles only; all arguments are\r
-- representable in a decDouble\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests tests the extended specification 'round-to-integral\r
-- value-exact' operations (from IEEE 854, later modified in 754r).\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
precision: 16\r
maxExponent: 384\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- decDouble tests
dectest: ddAbs
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- decQuad tests
dectest: dqAbs
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- decSingle tests
dectest: dsBase
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests are for decQuads only; all arguments are\r
-- representable in a decQuad\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This file tests base conversions from string to a decimal number\r
-- and back to a string (in Scientific form)\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This file tests that copy operations leave uncanonical operands\r
-- unchanged, and vice versa\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- [New 2006.11.27]\r
\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Note that we cannot assume add/subtract tests cover paths adequately,\r
-- here, because the code might be quite different (comparison cannot\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-- [Previously called decimal128.decTest]\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests is for the sixteen-byte concrete representation.\r
-- Its characteristics are:\r
decq829 apply #22080000000000000000000115afb55b -> 4294967295\r
decq830 apply #22080000000000000000000115afb57a -> 4294967296\r
decq831 apply #22080000000000000000000115afb57b -> 4294967297\r
+\r
+-- VG testcase\r
+decq840 apply #2080000000000000F294000000172636 -> 8.81125000000001349436E-1548\r
+decq841 apply #20800000000000008000000000000000 -> 8.000000000000000000E-1550\r
+decq842 apply #1EF98490000000010F6E4E0000000000 -> 7.049000000000010795488000000000000E-3097\r
+decq843 multiply #20800000000000008000000000000000 #2080000000000000F294000000172636 -> #1EF98490000000010F6E4E0000000000 Rounded\r
+\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
dqadd375088 fma 1 12398765432112345678945678 1E-34 -> 12398765432112345678945678.00000001 Inexact Rounded\r
dqadd375089 fma 1 12398765432112345678945678 1E-35 -> 12398765432112345678945678.00000001 Inexact Rounded\r
\r
+-- Destructive subtract (from remainder tests)\r
+\r
+-- +++ some of these will be off-by-one remainder vs remainderNear\r
+\r
+dqfma4000 fma -1234567890123456789012345678901233 1.000000000000000000000000000000001 1234567890123456789012345678901234 -> -0.234567890123456789012345678901233\r
+dqfma4001 fma -1234567890123456789012345678901222 1.00000000000000000000000000000001 1234567890123456789012345678901234 -> -0.34567890123456789012345678901222\r
+dqfma4002 fma -1234567890123456789012345678901111 1.0000000000000000000000000000001 1234567890123456789012345678901234 -> -0.4567890123456789012345678901111\r
+dqfma4003 fma -308641972530864197253086419725314 4.000000000000000000000000000000001 1234567890123456789012345678901255 -> -1.308641972530864197253086419725314\r
+dqfma4004 fma -308641972530864197253086419725308 4.000000000000000000000000000000001 1234567890123456789012345678901234 -> 1.691358027469135802746913580274692\r
+dqfma4005 fma -246913578024691357802469135780252 4.9999999999999999999999999999999 1234567890123456789012345678901234 -> -1.3086421975308642197530864219748\r
+dqfma4006 fma -246913578024691357802469135780247 4.99999999999999999999999999999999 1234567890123456789012345678901234 -> 1.46913578024691357802469135780247\r
+dqfma4007 fma -246913578024691357802469135780247 4.999999999999999999999999999999999 1234567890123456789012345678901234 -> -0.753086421975308642197530864219753\r
+dqfma4008 fma -246913578024691357802469135780247 5.000000000000000000000000000000001 1234567890123456789012345678901234 -> -1.246913578024691357802469135780247\r
+dqfma4009 fma -246913578024691357802469135780246 5.00000000000000000000000000000001 1234567890123456789012345678901234 -> 1.53086421975308642197530864219754\r
+dqfma4010 fma -246913578024691357802469135780242 5.0000000000000000000000000000001 1234567890123456789012345678901234 -> -0.6913578024691357802469135780242\r
+dqfma4011 fma -1234567890123456789012345678901232 1.000000000000000000000000000000001 1234567890123456789012345678901234 -> 0.765432109876543210987654321098768\r
+dqfma4012 fma -1234567890123456789012345678901221 1.00000000000000000000000000000001 1234567890123456789012345678901234 -> 0.65432109876543210987654321098779\r
+dqfma4013 fma -1234567890123456789012345678901110 1.0000000000000000000000000000001 1234567890123456789012345678901234 -> 0.5432109876543210987654321098890\r
+dqfma4014 fma -308641972530864197253086419725313 4.000000000000000000000000000000001 1234567890123456789012345678901255 -> 2.691358027469135802746913580274687\r
+dqfma4015 fma -308641972530864197253086419725308 4.000000000000000000000000000000001 1234567890123456789012345678901234 -> 1.691358027469135802746913580274692\r
+dqfma4016 fma -246913578024691357802469135780251 4.9999999999999999999999999999999 1234567890123456789012345678901234 -> 3.6913578024691357802469135780251\r
+dqfma4017 fma -246913578024691357802469135780247 4.99999999999999999999999999999999 1234567890123456789012345678901234 -> 1.46913578024691357802469135780247\r
+dqfma4018 fma -246913578024691357802469135780246 4.999999999999999999999999999999999 1234567890123456789012345678901234 -> 4.246913578024691357802469135780246\r
+dqfma4019 fma -246913578024691357802469135780241 5.0000000000000000000000000000001 1234567890123456789012345678901234 -> 4.3086421975308642197530864219759\r
+\r
-- Null tests\r
dqadd39990 fma 1 10 # -> NaN Invalid_operation\r
dqadd39991 fma 1 # 10 -> NaN Invalid_operation\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests are for decQuads only; all arguments are\r
-- representable in a decQuad\r
\r
-- hugest\r
dqmul909 multiply 9999999999999999999999999999999999 9999999999999999999999999999999999 -> 9.999999999999999999999999999999998E+67 Inexact Rounded\r
+-- VG case\r
+dqmul910 multiply 8.81125000000001349436E-1548 8.000000000000000000E-1550 -> 7.049000000000010795488000000000000E-3097 Rounded\r
\r
-- Examples from SQL proposal (Krishna Kulkarni)\r
precision: 34\r
rounding: half_up\r
maxExponent: 6144\r
minExponent: -6143\r
-dqmul1001 multiply 130E-2 120E-2 -> 1.5600\r
-dqmul1002 multiply 130E-2 12E-1 -> 1.560\r
-dqmul1003 multiply 130E-2 1E0 -> 1.30\r
-dqmul1004 multiply 1E2 1E4 -> 1E+6\r
+dqmul911 multiply 130E-2 120E-2 -> 1.5600\r
+dqmul912 multiply 130E-2 12E-1 -> 1.560\r
+dqmul913 multiply 130E-2 1E0 -> 1.30\r
+dqmul914 multiply 1E2 1E4 -> 1E+6\r
+\r
+-- power-of-ten edge cases\r
+dqmul1001 multiply 1 10 -> 10\r
+dqmul1002 multiply 1 100 -> 100\r
+dqmul1003 multiply 1 1000 -> 1000\r
+dqmul1004 multiply 1 10000 -> 10000\r
+dqmul1005 multiply 1 100000 -> 100000\r
+dqmul1006 multiply 1 1000000 -> 1000000\r
+dqmul1007 multiply 1 10000000 -> 10000000\r
+dqmul1008 multiply 1 100000000 -> 100000000\r
+dqmul1009 multiply 1 1000000000 -> 1000000000\r
+dqmul1010 multiply 1 10000000000 -> 10000000000\r
+dqmul1011 multiply 1 100000000000 -> 100000000000\r
+dqmul1012 multiply 1 1000000000000 -> 1000000000000\r
+dqmul1013 multiply 1 10000000000000 -> 10000000000000\r
+dqmul1014 multiply 1 100000000000000 -> 100000000000000\r
+dqmul1015 multiply 1 1000000000000000 -> 1000000000000000\r
+\r
+dqmul1016 multiply 1 1000000000000000000 -> 1000000000000000000\r
+dqmul1017 multiply 1 100000000000000000000000000 -> 100000000000000000000000000\r
+dqmul1018 multiply 1 1000000000000000000000000000 -> 1000000000000000000000000000\r
+dqmul1019 multiply 1 10000000000000000000000000000 -> 10000000000000000000000000000\r
+dqmul1020 multiply 1 1000000000000000000000000000000000 -> 1000000000000000000000000000000000\r
+\r
+dqmul1021 multiply 10 1 -> 10\r
+dqmul1022 multiply 10 10 -> 100\r
+dqmul1023 multiply 10 100 -> 1000\r
+dqmul1024 multiply 10 1000 -> 10000\r
+dqmul1025 multiply 10 10000 -> 100000\r
+dqmul1026 multiply 10 100000 -> 1000000\r
+dqmul1027 multiply 10 1000000 -> 10000000\r
+dqmul1028 multiply 10 10000000 -> 100000000\r
+dqmul1029 multiply 10 100000000 -> 1000000000\r
+dqmul1030 multiply 10 1000000000 -> 10000000000\r
+dqmul1031 multiply 10 10000000000 -> 100000000000\r
+dqmul1032 multiply 10 100000000000 -> 1000000000000\r
+dqmul1033 multiply 10 1000000000000 -> 10000000000000\r
+dqmul1034 multiply 10 10000000000000 -> 100000000000000\r
+dqmul1035 multiply 10 100000000000000 -> 1000000000000000\r
+\r
+dqmul1036 multiply 10 100000000000000000 -> 1000000000000000000\r
+dqmul1037 multiply 10 10000000000000000000000000 -> 100000000000000000000000000\r
+dqmul1038 multiply 10 100000000000000000000000000 -> 1000000000000000000000000000\r
+dqmul1039 multiply 10 1000000000000000000000000000 -> 10000000000000000000000000000\r
+dqmul1040 multiply 10 100000000000000000000000000000000 -> 1000000000000000000000000000000000\r
+\r
+dqmul1041 multiply 100 0.1 -> 10.0\r
+dqmul1042 multiply 100 1 -> 100\r
+dqmul1043 multiply 100 10 -> 1000\r
+dqmul1044 multiply 100 100 -> 10000\r
+dqmul1045 multiply 100 1000 -> 100000\r
+dqmul1046 multiply 100 10000 -> 1000000\r
+dqmul1047 multiply 100 100000 -> 10000000\r
+dqmul1048 multiply 100 1000000 -> 100000000\r
+dqmul1049 multiply 100 10000000 -> 1000000000\r
+dqmul1050 multiply 100 100000000 -> 10000000000\r
+dqmul1051 multiply 100 1000000000 -> 100000000000\r
+dqmul1052 multiply 100 10000000000 -> 1000000000000\r
+dqmul1053 multiply 100 100000000000 -> 10000000000000\r
+dqmul1054 multiply 100 1000000000000 -> 100000000000000\r
+dqmul1055 multiply 100 10000000000000 -> 1000000000000000\r
+\r
+dqmul1056 multiply 100 10000000000000000 -> 1000000000000000000\r
+dqmul1057 multiply 100 1000000000000000000000000 -> 100000000000000000000000000\r
+dqmul1058 multiply 100 10000000000000000000000000 -> 1000000000000000000000000000\r
+dqmul1059 multiply 100 100000000000000000000000000 -> 10000000000000000000000000000\r
+dqmul1060 multiply 100 10000000000000000000000000000000 -> 1000000000000000000000000000000000\r
+\r
+dqmul1061 multiply 1000 0.01 -> 10.00\r
+dqmul1062 multiply 1000 0.1 -> 100.0\r
+dqmul1063 multiply 1000 1 -> 1000\r
+dqmul1064 multiply 1000 10 -> 10000\r
+dqmul1065 multiply 1000 100 -> 100000\r
+dqmul1066 multiply 1000 1000 -> 1000000\r
+dqmul1067 multiply 1000 10000 -> 10000000\r
+dqmul1068 multiply 1000 100000 -> 100000000\r
+dqmul1069 multiply 1000 1000000 -> 1000000000\r
+dqmul1070 multiply 1000 10000000 -> 10000000000\r
+dqmul1071 multiply 1000 100000000 -> 100000000000\r
+dqmul1072 multiply 1000 1000000000 -> 1000000000000\r
+dqmul1073 multiply 1000 10000000000 -> 10000000000000\r
+dqmul1074 multiply 1000 100000000000 -> 100000000000000\r
+dqmul1075 multiply 1000 1000000000000 -> 1000000000000000\r
+\r
+dqmul1076 multiply 1000 1000000000000000 -> 1000000000000000000\r
+dqmul1077 multiply 1000 100000000000000000000000 -> 100000000000000000000000000\r
+dqmul1078 multiply 1000 1000000000000000000000000 -> 1000000000000000000000000000\r
+dqmul1079 multiply 1000 10000000000000000000000000 -> 10000000000000000000000000000\r
+dqmul1080 multiply 1000 1000000000000000000000000000000 -> 1000000000000000000000000000000000\r
+\r
+dqmul1081 multiply 10000 0.001 -> 10.000\r
+dqmul1082 multiply 10000 0.01 -> 100.00\r
+dqmul1083 multiply 10000 0.1 -> 1000.0\r
+dqmul1084 multiply 10000 1 -> 10000\r
+dqmul1085 multiply 10000 10 -> 100000\r
+dqmul1086 multiply 10000 100 -> 1000000\r
+dqmul1087 multiply 10000 1000 -> 10000000\r
+dqmul1088 multiply 10000 10000 -> 100000000\r
+dqmul1089 multiply 10000 100000 -> 1000000000\r
+dqmul1090 multiply 10000 1000000 -> 10000000000\r
+dqmul1091 multiply 10000 10000000 -> 100000000000\r
+dqmul1092 multiply 10000 100000000 -> 1000000000000\r
+dqmul1093 multiply 10000 1000000000 -> 10000000000000\r
+dqmul1094 multiply 10000 10000000000 -> 100000000000000\r
+dqmul1095 multiply 10000 100000000000 -> 1000000000000000\r
+\r
+dqmul1096 multiply 10000 100000000000000 -> 1000000000000000000\r
+dqmul1097 multiply 10000 10000000000000000000000 -> 100000000000000000000000000\r
+dqmul1098 multiply 10000 100000000000000000000000 -> 1000000000000000000000000000\r
+dqmul1099 multiply 10000 1000000000000000000000000 -> 10000000000000000000000000000\r
+dqmul1100 multiply 10000 100000000000000000000000000000 -> 1000000000000000000000000000000000\r
+\r
+dqmul1107 multiply 10000 99999999999 -> 999999999990000\r
+dqmul1108 multiply 10000 99999999999 -> 999999999990000\r
\r
-- Null tests\r
-dqmul990 multiply 10 # -> NaN Invalid_operation\r
-dqmul991 multiply # 10 -> NaN Invalid_operation\r
+dqmul9990 multiply 10 # -> NaN Invalid_operation\r
+dqmul9991 multiply # 10 -> NaN Invalid_operation\r
\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Most of the tests here assume a "regular pattern", where the\r
-- sign and coefficient are +1.\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- Gyuris example\r
dqrem1070 remainder 8.336804418094040989630006819881709E-6143 8.336804418094040989630006819889000E-6143 -> 8.336804418094040989630006819881709E-6143\r
\r
+-- destructive subtract\r
+dqrem1120 remainder 1234567890123456789012345678901234 1.000000000000000000000000000000001 -> 0.765432109876543210987654321098768\r
+dqrem1121 remainder 1234567890123456789012345678901234 1.00000000000000000000000000000001 -> 0.65432109876543210987654321098779\r
+dqrem1122 remainder 1234567890123456789012345678901234 1.0000000000000000000000000000001 -> 0.5432109876543210987654321098890\r
+dqrem1123 remainder 1234567890123456789012345678901255 4.000000000000000000000000000000001 -> 2.691358027469135802746913580274687\r
+dqrem1124 remainder 1234567890123456789012345678901234 4.000000000000000000000000000000001 -> 1.691358027469135802746913580274692\r
+dqrem1125 remainder 1234567890123456789012345678901234 4.9999999999999999999999999999999 -> 3.6913578024691357802469135780251\r
+dqrem1126 remainder 1234567890123456789012345678901234 4.99999999999999999999999999999999 -> 1.46913578024691357802469135780247\r
+dqrem1127 remainder 1234567890123456789012345678901234 4.999999999999999999999999999999999 -> 4.246913578024691357802469135780246\r
+dqrem1128 remainder 1234567890123456789012345678901234 5.0000000000000000000000000000001 -> 4.3086421975308642197530864219759\r
+\r
-- Null tests\r
dqrem1000 remainder 10 # -> NaN Invalid_operation\r
dqrem1001 remainder # 10 -> NaN Invalid_operation\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- Gyuris example\r
dqrmn1070 remainder 8.336804418094040989630006819881709E-6143 8.336804418094040989630006819889000E-6143 -> 8.336804418094040989630006819881709E-6143\r
\r
+-- destructive subtract\r
+dqrmn1101 remaindernear 1234567890123456789012345678901234 1.000000000000000000000000000000001 -> -0.234567890123456789012345678901233\r
+dqrmn1102 remaindernear 1234567890123456789012345678901234 1.00000000000000000000000000000001 -> -0.34567890123456789012345678901222\r
+dqrmn1103 remaindernear 1234567890123456789012345678901234 1.0000000000000000000000000000001 -> -0.4567890123456789012345678901111\r
+dqrmn1104 remaindernear 1234567890123456789012345678901255 4.000000000000000000000000000000001 -> -1.308641972530864197253086419725314\r
+dqrmn1105 remaindernear 1234567890123456789012345678901234 4.000000000000000000000000000000001 -> 1.691358027469135802746913580274692\r
+dqrmn1106 remaindernear 1234567890123456789012345678901234 4.9999999999999999999999999999999 -> -1.3086421975308642197530864219748\r
+dqrmn1107 remaindernear 1234567890123456789012345678901234 4.99999999999999999999999999999999 -> 1.46913578024691357802469135780247\r
+dqrmn1108 remaindernear 1234567890123456789012345678901234 4.999999999999999999999999999999999 -> -0.753086421975308642197530864219753\r
+dqrmn1109 remaindernear 1234567890123456789012345678901234 5.000000000000000000000000000000001 -> -1.246913578024691357802469135780247\r
+dqrmn1110 remaindernear 1234567890123456789012345678901234 5.00000000000000000000000000000001 -> 1.53086421975308642197530864219754\r
+dqrmn1111 remaindernear 1234567890123456789012345678901234 5.0000000000000000000000000000001 -> -0.6913578024691357802469135780242\r
+\r
-- Null tests\r
dqrmn1000 remaindernear 10 # -> NaN Invalid_operation\r
dqrmn1001 remaindernear # 10 -> NaN Invalid_operation\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- All operands and results are decQuads.\r
extended: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests are for decQuads only; all arguments are\r
-- representable in a decQuad\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests tests the extended specification 'round-to-integral\r
-- value-exact' operations (from IEEE 854, later modified in 754r).\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
clamp: 1\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This file tests base conversions from string to a decimal number\r
-- and back to a string (in Scientific form)\r
dsbas1107 toSci +1E-383 -> 0E-101 Inexact Rounded Subnormal Underflow Clamped\r
dsbas1108 toSci +9.999999999999999E+384 -> Infinity Overflow Inexact Rounded\r
\r
-\r
+-- narrowing case\r
+dsbas1110 toSci 2.000000000000000E-99 -> 2.00E-99 Rounded Subnormal\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-- [Previously called decimal32.decTest]\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests is for the four-byte concrete representation.\r
-- Its characteristics are:\r
decs786 apply #225002ff -> 999\r
decs787 apply #225003ff -> 999\r
\r
+-- narrowing case\r
+decs790 apply 2.00E-99 -> #00000100 Subnormal\r
+decs791 apply #00000100 -> 2.00E-99 Subnormal\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- Tests of the exponential funtion. Currently all testcases here\r
-- show results which are correctly rounded (within <= 0.5 ulp).\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 16\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This emphasises the testing of notable cases, as they will often\r
-- have unusual paths (especially the 10**n results).\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This emphasises the testing of notable cases, as they will often\r
-- have unusual paths (especially the 10**n results).\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- we assume that base comparison is tested in compare.decTest, so
-- these mainly cover special cases and rounding
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- we assume that base comparison is tested in compare.decTest, so
-- these mainly cover special cases and rounding
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- we assume that base comparison is tested in compare.decTest, so\r
-- these mainly cover special cases and rounding\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- This set of tests primarily tests the existence of the operator.
-- Subtraction, rounding, and more overflows are tested elsewhere.
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- This set of tests primarily tests the existence of the operator.
-- Addition and rounding, and most overflows, are tested elsewhere.
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- In addition to the power operator testcases here, see also the file
-- powersqrt.decTest which includes all the tests from
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- These testcases are taken from squareroot.decTest but are\r
-- evaluated using the power operator. The differences in results\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- Most of the tests here assume a "regular pattern", where the
-- sign and coefficient are +1.
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.55
+version: 2.57
-- These testcases test calculations at precisions 31, 32, and 33, to
-- exercise the boundaries around 2**5
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
maxexponent: 999999999
------------------------------------------------------------------------
-- [This used to be called normalize.]
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.55
+version: 2.57
extended: 1
precision: 9
rmnx606 remaindernear 31.5 3 -> 1.5 -- i=10
rmnx607 remaindernear 34.5 3 -> -1.5 -- i=11
+-- zero signs
+rmnx650 remaindernear 1 1 -> 0
+rmnx651 remaindernear -1 1 -> -0
+rmnx652 remaindernear 1 -1 -> 0
+rmnx653 remaindernear -1 -1 -> -0
+rmnx654 remaindernear 0 1 -> 0
+rmnx655 remaindernear -0 1 -> -0
+rmnx656 remaindernear 0 -1 -> 0
+rmnx657 remaindernear -0 -1 -> -0
+rmnx658 remaindernear 0.00 1 -> 0.00
+rmnx659 remaindernear -0.00 1 -> -0.00
+
-- Specials
rmnx680 remaindernear Inf -Inf -> NaN Invalid_operation
rmnx681 remaindernear Inf -1000 -> NaN Invalid_operation
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- [obsolete] Quantize.decTest has the improved version
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- These tests require that implementations take account of residues in
-- order to get correct results for some rounding modes. Rather than
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
extended: 1
precision: 9
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- core tests (using Extended: 1) --------------------------------------
dectest: base
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --
-- mfc@uk.ibm.com --
------------------------------------------------------------------------
-version: 2.56
+version: 2.57
-- This set of tests tests the extended specification 'round-to-integral
-- value' operation (from IEEE 854, later modified in 754r).
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
-- This set of tests tests the extended specification 'round-to-integral\r
-- value' operation (from IEEE 854, later modified in 754r).\r
-- IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK --\r
-- mfc@uk.ibm.com --\r
------------------------------------------------------------------------\r
-version: 2.56\r
+version: 2.57\r
\r
extended: 1\r
precision: 9\r
self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, None, 1), 2) )
self.assertRaises(ValueError, Decimal, (1, (4, -3, 4, 9, 1), 2) )
self.assertRaises(ValueError, Decimal, (1, (4, 10, 4, 9, 1), 2) )
+ self.assertRaises(ValueError, Decimal, (1, (4, 3, 4, 'a', 1), 2) )
def test_explicit_from_Decimal(self):
provided.
>>> import unittest, pkgutil, test
+ >>> added_loader = False
>>> if not hasattr(test, '__loader__'):
... test.__loader__ = pkgutil.get_loader(test)
... added_loader = True
verify(c[0].__class__.__name__ == "cell") # don't have a type object handy
cantset(f, "__closure__", c)
+def test_empty_cell():
+ def f(): print(a)
+ try:
+ f.__closure__[0].cell_contents
+ except ValueError:
+ pass
+ else:
+ raise TestFailed("shouldn't be able to read an empty cell")
+
+ a = 12
+
def test_func_doc():
def f(): pass
verify(f.__doc__ is None)
def testmore():
test_func_closure()
+ test_empty_cell()
test_func_doc()
test_func_globals()
test_func_name()
# skip some "files" we don't care about...
if filename == "<string>":
continue
+ if filename.startswith("<doctest "):
+ continue
if filename.endswith((".pyc", ".pyo")):
filename = filename[:-1]
/* Do not follow links. */
if (ins(d, "O_NOFOLLOW", (long)O_NOFOLLOW)) return -1;
#endif
+#ifdef O_NOATIME
+ /* Do not update the access time. */
+ if (ins(d, "O_NOATIME", (long)O_NOATIME)) return -1;
+#endif
/* These come from sysexits.h */
#ifdef EX_OK
static PyObject *
cell_get_contents(PyCellObject *op, void *closure)
{
- Py_XINCREF(op->ob_ref);
+ if (op->ob_ref == NULL)
+ {
+ PyErr_SetString(PyExc_ValueError, "Cell is empty");
+ return NULL;
+ }
+ Py_INCREF(op->ob_ref);
return op->ob_ref;
}
struct compiling {
char *c_encoding; /* source encoding */
PyArena *c_arena; /* arena for allocating memeory */
+ const char *c_filename; /* filename */
};
static asdl_seq *seq_for_testlist(struct compiling *, const node *);
c.c_encoding = "utf-8";
}
c.c_arena = arena;
+ c.c_filename = filename;
k = 0;
switch (TYPE(n)) {
projects / python / commitdiff