decimal.py revision daeceb2de80047f25aedbf16bf40dc5d619e64dd
1# Copyright (c) 2004 Python Software Foundation. 2# All rights reserved. 3 4# Written by Eric Price <eprice at tjhsst.edu> 5# and Facundo Batista <facundo at taniquetil.com.ar> 6# and Raymond Hettinger <python at rcn.com> 7# and Aahz <aahz at pobox.com> 8# and Tim Peters 9 10# This module is currently Py2.3 compatible and should be kept that way 11# unless a major compelling advantage arises. IOW, 2.3 compatibility is 12# strongly preferred, but not guaranteed. 13 14# Also, this module should be kept in sync with the latest updates of 15# the IBM specification as it evolves. Those updates will be treated 16# as bug fixes (deviation from the spec is a compatibility, usability 17# bug) and will be backported. At this point the spec is stabilizing 18# and the updates are becoming fewer, smaller, and less significant. 19 20""" 21This is a Py2.3 implementation of decimal floating point arithmetic based on 22the General Decimal Arithmetic Specification: 23 24 www2.hursley.ibm.com/decimal/decarith.html 25 26and IEEE standard 854-1987: 27 28 www.cs.berkeley.edu/~ejr/projects/754/private/drafts/854-1987/dir.html 29 30Decimal floating point has finite precision with arbitrarily large bounds. 31 32The purpose of this module is to support arithmetic using familiar 33"schoolhouse" rules and to avoid some of the tricky representation 34issues associated with binary floating point. The package is especially 35useful for financial applications or for contexts where users have 36expectations that are at odds with binary floating point (for instance, 37in binary floating point, 1.00 % 0.1 gives 0.09999999999999995 instead 38of the expected Decimal('0.00') returned by decimal floating point). 39 40Here are some examples of using the decimal module: 41 42>>> from decimal import * 43>>> setcontext(ExtendedContext) 44>>> Decimal(0) 45Decimal('0') 46>>> Decimal('1') 47Decimal('1') 48>>> Decimal('-.0123') 49Decimal('-0.0123') 50>>> Decimal(123456) 51Decimal('123456') 52>>> Decimal('123.45e12345678901234567890') 53Decimal('1.2345E+12345678901234567892') 54>>> Decimal('1.33') + Decimal('1.27') 55Decimal('2.60') 56>>> Decimal('12.34') + Decimal('3.87') - Decimal('18.41') 57Decimal('-2.20') 58>>> dig = Decimal(1) 59>>> print dig / Decimal(3) 600.333333333 61>>> getcontext().prec = 18 62>>> print dig / Decimal(3) 630.333333333333333333 64>>> print dig.sqrt() 651 66>>> print Decimal(3).sqrt() 671.73205080756887729 68>>> print Decimal(3) ** 123 694.85192780976896427E+58 70>>> inf = Decimal(1) / Decimal(0) 71>>> print inf 72Infinity 73>>> neginf = Decimal(-1) / Decimal(0) 74>>> print neginf 75-Infinity 76>>> print neginf + inf 77NaN 78>>> print neginf * inf 79-Infinity 80>>> print dig / 0 81Infinity 82>>> getcontext().traps[DivisionByZero] = 1 83>>> print dig / 0 84Traceback (most recent call last): 85 ... 86 ... 87 ... 88DivisionByZero: x / 0 89>>> c = Context() 90>>> c.traps[InvalidOperation] = 0 91>>> print c.flags[InvalidOperation] 920 93>>> c.divide(Decimal(0), Decimal(0)) 94Decimal('NaN') 95>>> c.traps[InvalidOperation] = 1 96>>> print c.flags[InvalidOperation] 971 98>>> c.flags[InvalidOperation] = 0 99>>> print c.flags[InvalidOperation] 1000 101>>> print c.divide(Decimal(0), Decimal(0)) 102Traceback (most recent call last): 103 ... 104 ... 105 ... 106InvalidOperation: 0 / 0 107>>> print c.flags[InvalidOperation] 1081 109>>> c.flags[InvalidOperation] = 0 110>>> c.traps[InvalidOperation] = 0 111>>> print c.divide(Decimal(0), Decimal(0)) 112NaN 113>>> print c.flags[InvalidOperation] 1141 115>>> 116""" 117 118__all__ = [ 119 # Two major classes 120 'Decimal', 'Context', 121 122 # Contexts 123 'DefaultContext', 'BasicContext', 'ExtendedContext', 124 125 # Exceptions 126 'DecimalException', 'Clamped', 'InvalidOperation', 'DivisionByZero', 127 'Inexact', 'Rounded', 'Subnormal', 'Overflow', 'Underflow', 128 129 # Constants for use in setting up contexts 130 'ROUND_DOWN', 'ROUND_HALF_UP', 'ROUND_HALF_EVEN', 'ROUND_CEILING', 131 'ROUND_FLOOR', 'ROUND_UP', 'ROUND_HALF_DOWN', 'ROUND_05UP', 132 133 # Functions for manipulating contexts 134 'setcontext', 'getcontext', 'localcontext' 135] 136 137__version__ = '1.68' # Highest version of the spec this complies with 138 139import copy as _copy 140import math as _math 141import numbers as _numbers 142 143try: 144 from collections import namedtuple as _namedtuple 145 DecimalTuple = _namedtuple('DecimalTuple', 'sign digits exponent') 146except ImportError: 147 DecimalTuple = lambda *args: args 148 149# Rounding 150ROUND_DOWN = 'ROUND_DOWN' 151ROUND_HALF_UP = 'ROUND_HALF_UP' 152ROUND_HALF_EVEN = 'ROUND_HALF_EVEN' 153ROUND_CEILING = 'ROUND_CEILING' 154ROUND_FLOOR = 'ROUND_FLOOR' 155ROUND_UP = 'ROUND_UP' 156ROUND_HALF_DOWN = 'ROUND_HALF_DOWN' 157ROUND_05UP = 'ROUND_05UP' 158 159# Errors 160 161class DecimalException(ArithmeticError): 162 """Base exception class. 163 164 Used exceptions derive from this. 165 If an exception derives from another exception besides this (such as 166 Underflow (Inexact, Rounded, Subnormal) that indicates that it is only 167 called if the others are present. This isn't actually used for 168 anything, though. 169 170 handle -- Called when context._raise_error is called and the 171 trap_enabler is set. First argument is self, second is the 172 context. More arguments can be given, those being after 173 the explanation in _raise_error (For example, 174 context._raise_error(NewError, '(-x)!', self._sign) would 175 call NewError().handle(context, self._sign).) 176 177 To define a new exception, it should be sufficient to have it derive 178 from DecimalException. 179 """ 180 def handle(self, context, *args): 181 pass 182 183 184class Clamped(DecimalException): 185 """Exponent of a 0 changed to fit bounds. 186 187 This occurs and signals clamped if the exponent of a result has been 188 altered in order to fit the constraints of a specific concrete 189 representation. This may occur when the exponent of a zero result would 190 be outside the bounds of a representation, or when a large normal 191 number would have an encoded exponent that cannot be represented. In 192 this latter case, the exponent is reduced to fit and the corresponding 193 number of zero digits are appended to the coefficient ("fold-down"). 194 """ 195 196class InvalidOperation(DecimalException): 197 """An invalid operation was performed. 198 199 Various bad things cause this: 200 201 Something creates a signaling NaN 202 -INF + INF 203 0 * (+-)INF 204 (+-)INF / (+-)INF 205 x % 0 206 (+-)INF % x 207 x._rescale( non-integer ) 208 sqrt(-x) , x > 0 209 0 ** 0 210 x ** (non-integer) 211 x ** (+-)INF 212 An operand is invalid 213 214 The result of the operation after these is a quiet positive NaN, 215 except when the cause is a signaling NaN, in which case the result is 216 also a quiet NaN, but with the original sign, and an optional 217 diagnostic information. 218 """ 219 def handle(self, context, *args): 220 if args: 221 ans = _dec_from_triple(args[0]._sign, args[0]._int, 'n', True) 222 return ans._fix_nan(context) 223 return _NaN 224 225class ConversionSyntax(InvalidOperation): 226 """Trying to convert badly formed string. 227 228 This occurs and signals invalid-operation if an string is being 229 converted to a number and it does not conform to the numeric string 230 syntax. The result is [0,qNaN]. 231 """ 232 def handle(self, context, *args): 233 return _NaN 234 235class DivisionByZero(DecimalException, ZeroDivisionError): 236 """Division by 0. 237 238 This occurs and signals division-by-zero if division of a finite number 239 by zero was attempted (during a divide-integer or divide operation, or a 240 power operation with negative right-hand operand), and the dividend was 241 not zero. 242 243 The result of the operation is [sign,inf], where sign is the exclusive 244 or of the signs of the operands for divide, or is 1 for an odd power of 245 -0, for power. 246 """ 247 248 def handle(self, context, sign, *args): 249 return _SignedInfinity[sign] 250 251class DivisionImpossible(InvalidOperation): 252 """Cannot perform the division adequately. 253 254 This occurs and signals invalid-operation if the integer result of a 255 divide-integer or remainder operation had too many digits (would be 256 longer than precision). The result is [0,qNaN]. 257 """ 258 259 def handle(self, context, *args): 260 return _NaN 261 262class DivisionUndefined(InvalidOperation, ZeroDivisionError): 263 """Undefined result of division. 264 265 This occurs and signals invalid-operation if division by zero was 266 attempted (during a divide-integer, divide, or remainder operation), and 267 the dividend is also zero. The result is [0,qNaN]. 268 """ 269 270 def handle(self, context, *args): 271 return _NaN 272 273class Inexact(DecimalException): 274 """Had to round, losing information. 275 276 This occurs and signals inexact whenever the result of an operation is 277 not exact (that is, it needed to be rounded and any discarded digits 278 were non-zero), or if an overflow or underflow condition occurs. The 279 result in all cases is unchanged. 280 281 The inexact signal may be tested (or trapped) to determine if a given 282 operation (or sequence of operations) was inexact. 283 """ 284 285class InvalidContext(InvalidOperation): 286 """Invalid context. Unknown rounding, for example. 287 288 This occurs and signals invalid-operation if an invalid context was 289 detected during an operation. This can occur if contexts are not checked 290 on creation and either the precision exceeds the capability of the 291 underlying concrete representation or an unknown or unsupported rounding 292 was specified. These aspects of the context need only be checked when 293 the values are required to be used. The result is [0,qNaN]. 294 """ 295 296 def handle(self, context, *args): 297 return _NaN 298 299class Rounded(DecimalException): 300 """Number got rounded (not necessarily changed during rounding). 301 302 This occurs and signals rounded whenever the result of an operation is 303 rounded (that is, some zero or non-zero digits were discarded from the 304 coefficient), or if an overflow or underflow condition occurs. The 305 result in all cases is unchanged. 306 307 The rounded signal may be tested (or trapped) to determine if a given 308 operation (or sequence of operations) caused a loss of precision. 309 """ 310 311class Subnormal(DecimalException): 312 """Exponent < Emin before rounding. 313 314 This occurs and signals subnormal whenever the result of a conversion or 315 operation is subnormal (that is, its adjusted exponent is less than 316 Emin, before any rounding). The result in all cases is unchanged. 317 318 The subnormal signal may be tested (or trapped) to determine if a given 319 or operation (or sequence of operations) yielded a subnormal result. 320 """ 321 322class Overflow(Inexact, Rounded): 323 """Numerical overflow. 324 325 This occurs and signals overflow if the adjusted exponent of a result 326 (from a conversion or from an operation that is not an attempt to divide 327 by zero), after rounding, would be greater than the largest value that 328 can be handled by the implementation (the value Emax). 329 330 The result depends on the rounding mode: 331 332 For round-half-up and round-half-even (and for round-half-down and 333 round-up, if implemented), the result of the operation is [sign,inf], 334 where sign is the sign of the intermediate result. For round-down, the 335 result is the largest finite number that can be represented in the 336 current precision, with the sign of the intermediate result. For 337 round-ceiling, the result is the same as for round-down if the sign of 338 the intermediate result is 1, or is [0,inf] otherwise. For round-floor, 339 the result is the same as for round-down if the sign of the intermediate 340 result is 0, or is [1,inf] otherwise. In all cases, Inexact and Rounded 341 will also be raised. 342 """ 343 344 def handle(self, context, sign, *args): 345 if context.rounding in (ROUND_HALF_UP, ROUND_HALF_EVEN, 346 ROUND_HALF_DOWN, ROUND_UP): 347 return _SignedInfinity[sign] 348 if sign == 0: 349 if context.rounding == ROUND_CEILING: 350 return _SignedInfinity[sign] 351 return _dec_from_triple(sign, '9'*context.prec, 352 context.Emax-context.prec+1) 353 if sign == 1: 354 if context.rounding == ROUND_FLOOR: 355 return _SignedInfinity[sign] 356 return _dec_from_triple(sign, '9'*context.prec, 357 context.Emax-context.prec+1) 358 359 360class Underflow(Inexact, Rounded, Subnormal): 361 """Numerical underflow with result rounded to 0. 362 363 This occurs and signals underflow if a result is inexact and the 364 adjusted exponent of the result would be smaller (more negative) than 365 the smallest value that can be handled by the implementation (the value 366 Emin). That is, the result is both inexact and subnormal. 367 368 The result after an underflow will be a subnormal number rounded, if 369 necessary, so that its exponent is not less than Etiny. This may result 370 in 0 with the sign of the intermediate result and an exponent of Etiny. 371 372 In all cases, Inexact, Rounded, and Subnormal will also be raised. 373 """ 374 375# List of public traps and flags 376_signals = [Clamped, DivisionByZero, Inexact, Overflow, Rounded, 377 Underflow, InvalidOperation, Subnormal] 378 379# Map conditions (per the spec) to signals 380_condition_map = {ConversionSyntax:InvalidOperation, 381 DivisionImpossible:InvalidOperation, 382 DivisionUndefined:InvalidOperation, 383 InvalidContext:InvalidOperation} 384 385##### Context Functions ################################################## 386 387# The getcontext() and setcontext() function manage access to a thread-local 388# current context. Py2.4 offers direct support for thread locals. If that 389# is not available, use threading.currentThread() which is slower but will 390# work for older Pythons. If threads are not part of the build, create a 391# mock threading object with threading.local() returning the module namespace. 392 393try: 394 import threading 395except ImportError: 396 # Python was compiled without threads; create a mock object instead 397 import sys 398 class MockThreading(object): 399 def local(self, sys=sys): 400 return sys.modules[__name__] 401 threading = MockThreading() 402 del sys, MockThreading 403 404try: 405 threading.local 406 407except AttributeError: 408 409 # To fix reloading, force it to create a new context 410 # Old contexts have different exceptions in their dicts, making problems. 411 if hasattr(threading.currentThread(), '__decimal_context__'): 412 del threading.currentThread().__decimal_context__ 413 414 def setcontext(context): 415 """Set this thread's context to context.""" 416 if context in (DefaultContext, BasicContext, ExtendedContext): 417 context = context.copy() 418 context.clear_flags() 419 threading.currentThread().__decimal_context__ = context 420 421 def getcontext(): 422 """Returns this thread's context. 423 424 If this thread does not yet have a context, returns 425 a new context and sets this thread's context. 426 New contexts are copies of DefaultContext. 427 """ 428 try: 429 return threading.currentThread().__decimal_context__ 430 except AttributeError: 431 context = Context() 432 threading.currentThread().__decimal_context__ = context 433 return context 434 435else: 436 437 local = threading.local() 438 if hasattr(local, '__decimal_context__'): 439 del local.__decimal_context__ 440 441 def getcontext(_local=local): 442 """Returns this thread's context. 443 444 If this thread does not yet have a context, returns 445 a new context and sets this thread's context. 446 New contexts are copies of DefaultContext. 447 """ 448 try: 449 return _local.__decimal_context__ 450 except AttributeError: 451 context = Context() 452 _local.__decimal_context__ = context 453 return context 454 455 def setcontext(context, _local=local): 456 """Set this thread's context to context.""" 457 if context in (DefaultContext, BasicContext, ExtendedContext): 458 context = context.copy() 459 context.clear_flags() 460 _local.__decimal_context__ = context 461 462 del threading, local # Don't contaminate the namespace 463 464def localcontext(ctx=None): 465 """Return a context manager for a copy of the supplied context 466 467 Uses a copy of the current context if no context is specified 468 The returned context manager creates a local decimal context 469 in a with statement: 470 def sin(x): 471 with localcontext() as ctx: 472 ctx.prec += 2 473 # Rest of sin calculation algorithm 474 # uses a precision 2 greater than normal 475 return +s # Convert result to normal precision 476 477 def sin(x): 478 with localcontext(ExtendedContext): 479 # Rest of sin calculation algorithm 480 # uses the Extended Context from the 481 # General Decimal Arithmetic Specification 482 return +s # Convert result to normal context 483 484 >>> setcontext(DefaultContext) 485 >>> print getcontext().prec 486 28 487 >>> with localcontext(): 488 ... ctx = getcontext() 489 ... ctx.prec += 2 490 ... print ctx.prec 491 ... 492 30 493 >>> with localcontext(ExtendedContext): 494 ... print getcontext().prec 495 ... 496 9 497 >>> print getcontext().prec 498 28 499 """ 500 if ctx is None: ctx = getcontext() 501 return _ContextManager(ctx) 502 503 504##### Decimal class ####################################################### 505 506class Decimal(object): 507 """Floating point class for decimal arithmetic.""" 508 509 __slots__ = ('_exp','_int','_sign', '_is_special') 510 # Generally, the value of the Decimal instance is given by 511 # (-1)**_sign * _int * 10**_exp 512 # Special values are signified by _is_special == True 513 514 # We're immutable, so use __new__ not __init__ 515 def __new__(cls, value="0", context=None): 516 """Create a decimal point instance. 517 518 >>> Decimal('3.14') # string input 519 Decimal('3.14') 520 >>> Decimal((0, (3, 1, 4), -2)) # tuple (sign, digit_tuple, exponent) 521 Decimal('3.14') 522 >>> Decimal(314) # int or long 523 Decimal('314') 524 >>> Decimal(Decimal(314)) # another decimal instance 525 Decimal('314') 526 >>> Decimal(' 3.14 \\n') # leading and trailing whitespace okay 527 Decimal('3.14') 528 """ 529 530 # Note that the coefficient, self._int, is actually stored as 531 # a string rather than as a tuple of digits. This speeds up 532 # the "digits to integer" and "integer to digits" conversions 533 # that are used in almost every arithmetic operation on 534 # Decimals. This is an internal detail: the as_tuple function 535 # and the Decimal constructor still deal with tuples of 536 # digits. 537 538 self = object.__new__(cls) 539 540 # From a string 541 # REs insist on real strings, so we can too. 542 if isinstance(value, basestring): 543 m = _parser(value.strip()) 544 if m is None: 545 if context is None: 546 context = getcontext() 547 return context._raise_error(ConversionSyntax, 548 "Invalid literal for Decimal: %r" % value) 549 550 if m.group('sign') == "-": 551 self._sign = 1 552 else: 553 self._sign = 0 554 intpart = m.group('int') 555 if intpart is not None: 556 # finite number 557 fracpart = m.group('frac') 558 exp = int(m.group('exp') or '0') 559 if fracpart is not None: 560 self._int = str((intpart+fracpart).lstrip('0') or '0') 561 self._exp = exp - len(fracpart) 562 else: 563 self._int = str(intpart.lstrip('0') or '0') 564 self._exp = exp 565 self._is_special = False 566 else: 567 diag = m.group('diag') 568 if diag is not None: 569 # NaN 570 self._int = str(diag.lstrip('0')) 571 if m.group('signal'): 572 self._exp = 'N' 573 else: 574 self._exp = 'n' 575 else: 576 # infinity 577 self._int = '0' 578 self._exp = 'F' 579 self._is_special = True 580 return self 581 582 # From an integer 583 if isinstance(value, (int,long)): 584 if value >= 0: 585 self._sign = 0 586 else: 587 self._sign = 1 588 self._exp = 0 589 self._int = str(abs(value)) 590 self._is_special = False 591 return self 592 593 # From another decimal 594 if isinstance(value, Decimal): 595 self._exp = value._exp 596 self._sign = value._sign 597 self._int = value._int 598 self._is_special = value._is_special 599 return self 600 601 # From an internal working value 602 if isinstance(value, _WorkRep): 603 self._sign = value.sign 604 self._int = str(value.int) 605 self._exp = int(value.exp) 606 self._is_special = False 607 return self 608 609 # tuple/list conversion (possibly from as_tuple()) 610 if isinstance(value, (list,tuple)): 611 if len(value) != 3: 612 raise ValueError('Invalid tuple size in creation of Decimal ' 613 'from list or tuple. The list or tuple ' 614 'should have exactly three elements.') 615 # process sign. The isinstance test rejects floats 616 if not (isinstance(value[0], (int, long)) and value[0] in (0,1)): 617 raise ValueError("Invalid sign. The first value in the tuple " 618 "should be an integer; either 0 for a " 619 "positive number or 1 for a negative number.") 620 self._sign = value[0] 621 if value[2] == 'F': 622 # infinity: value[1] is ignored 623 self._int = '0' 624 self._exp = value[2] 625 self._is_special = True 626 else: 627 # process and validate the digits in value[1] 628 digits = [] 629 for digit in value[1]: 630 if isinstance(digit, (int, long)) and 0 <= digit <= 9: 631 # skip leading zeros 632 if digits or digit != 0: 633 digits.append(digit) 634 else: 635 raise ValueError("The second value in the tuple must " 636 "be composed of integers in the range " 637 "0 through 9.") 638 if value[2] in ('n', 'N'): 639 # NaN: digits form the diagnostic 640 self._int = ''.join(map(str, digits)) 641 self._exp = value[2] 642 self._is_special = True 643 elif isinstance(value[2], (int, long)): 644 # finite number: digits give the coefficient 645 self._int = ''.join(map(str, digits or [0])) 646 self._exp = value[2] 647 self._is_special = False 648 else: 649 raise ValueError("The third value in the tuple must " 650 "be an integer, or one of the " 651 "strings 'F', 'n', 'N'.") 652 return self 653 654 if isinstance(value, float): 655 raise TypeError("Cannot convert float to Decimal. " + 656 "First convert the float to a string") 657 658 raise TypeError("Cannot convert %r to Decimal" % value) 659 660 # @classmethod, but @decorator is not valid Python 2.3 syntax, so 661 # don't use it (see notes on Py2.3 compatibility at top of file) 662 def from_float(cls, f): 663 """Converts a float to a decimal number, exactly. 664 665 Note that Decimal.from_float(0.1) is not the same as Decimal('0.1'). 666 Since 0.1 is not exactly representable in binary floating point, the 667 value is stored as the nearest representable value which is 668 0x1.999999999999ap-4. The exact equivalent of the value in decimal 669 is 0.1000000000000000055511151231257827021181583404541015625. 670 671 >>> Decimal.from_float(0.1) 672 Decimal('0.1000000000000000055511151231257827021181583404541015625') 673 >>> Decimal.from_float(float('nan')) 674 Decimal('NaN') 675 >>> Decimal.from_float(float('inf')) 676 Decimal('Infinity') 677 >>> Decimal.from_float(-float('inf')) 678 Decimal('-Infinity') 679 >>> Decimal.from_float(-0.0) 680 Decimal('-0') 681 682 """ 683 if isinstance(f, (int, long)): # handle integer inputs 684 return cls(f) 685 if _math.isinf(f) or _math.isnan(f): # raises TypeError if not a float 686 return cls(repr(f)) 687 if _math.copysign(1.0, f) == 1.0: 688 sign = 0 689 else: 690 sign = 1 691 n, d = abs(f).as_integer_ratio() 692 k = d.bit_length() - 1 693 result = _dec_from_triple(sign, str(n*5**k), -k) 694 if cls is Decimal: 695 return result 696 else: 697 return cls(result) 698 from_float = classmethod(from_float) 699 700 def _isnan(self): 701 """Returns whether the number is not actually one. 702 703 0 if a number 704 1 if NaN 705 2 if sNaN 706 """ 707 if self._is_special: 708 exp = self._exp 709 if exp == 'n': 710 return 1 711 elif exp == 'N': 712 return 2 713 return 0 714 715 def _isinfinity(self): 716 """Returns whether the number is infinite 717 718 0 if finite or not a number 719 1 if +INF 720 -1 if -INF 721 """ 722 if self._exp == 'F': 723 if self._sign: 724 return -1 725 return 1 726 return 0 727 728 def _check_nans(self, other=None, context=None): 729 """Returns whether the number is not actually one. 730 731 if self, other are sNaN, signal 732 if self, other are NaN return nan 733 return 0 734 735 Done before operations. 736 """ 737 738 self_is_nan = self._isnan() 739 if other is None: 740 other_is_nan = False 741 else: 742 other_is_nan = other._isnan() 743 744 if self_is_nan or other_is_nan: 745 if context is None: 746 context = getcontext() 747 748 if self_is_nan == 2: 749 return context._raise_error(InvalidOperation, 'sNaN', 750 self) 751 if other_is_nan == 2: 752 return context._raise_error(InvalidOperation, 'sNaN', 753 other) 754 if self_is_nan: 755 return self._fix_nan(context) 756 757 return other._fix_nan(context) 758 return 0 759 760 def _compare_check_nans(self, other, context): 761 """Version of _check_nans used for the signaling comparisons 762 compare_signal, __le__, __lt__, __ge__, __gt__. 763 764 Signal InvalidOperation if either self or other is a (quiet 765 or signaling) NaN. Signaling NaNs take precedence over quiet 766 NaNs. 767 768 Return 0 if neither operand is a NaN. 769 770 """ 771 if context is None: 772 context = getcontext() 773 774 if self._is_special or other._is_special: 775 if self.is_snan(): 776 return context._raise_error(InvalidOperation, 777 'comparison involving sNaN', 778 self) 779 elif other.is_snan(): 780 return context._raise_error(InvalidOperation, 781 'comparison involving sNaN', 782 other) 783 elif self.is_qnan(): 784 return context._raise_error(InvalidOperation, 785 'comparison involving NaN', 786 self) 787 elif other.is_qnan(): 788 return context._raise_error(InvalidOperation, 789 'comparison involving NaN', 790 other) 791 return 0 792 793 def __nonzero__(self): 794 """Return True if self is nonzero; otherwise return False. 795 796 NaNs and infinities are considered nonzero. 797 """ 798 return self._is_special or self._int != '0' 799 800 def _cmp(self, other): 801 """Compare the two non-NaN decimal instances self and other. 802 803 Returns -1 if self < other, 0 if self == other and 1 804 if self > other. This routine is for internal use only.""" 805 806 if self._is_special or other._is_special: 807 self_inf = self._isinfinity() 808 other_inf = other._isinfinity() 809 if self_inf == other_inf: 810 return 0 811 elif self_inf < other_inf: 812 return -1 813 else: 814 return 1 815 816 # check for zeros; Decimal('0') == Decimal('-0') 817 if not self: 818 if not other: 819 return 0 820 else: 821 return -((-1)**other._sign) 822 if not other: 823 return (-1)**self._sign 824 825 # If different signs, neg one is less 826 if other._sign < self._sign: 827 return -1 828 if self._sign < other._sign: 829 return 1 830 831 self_adjusted = self.adjusted() 832 other_adjusted = other.adjusted() 833 if self_adjusted == other_adjusted: 834 self_padded = self._int + '0'*(self._exp - other._exp) 835 other_padded = other._int + '0'*(other._exp - self._exp) 836 if self_padded == other_padded: 837 return 0 838 elif self_padded < other_padded: 839 return -(-1)**self._sign 840 else: 841 return (-1)**self._sign 842 elif self_adjusted > other_adjusted: 843 return (-1)**self._sign 844 else: # self_adjusted < other_adjusted 845 return -((-1)**self._sign) 846 847 # Note: The Decimal standard doesn't cover rich comparisons for 848 # Decimals. In particular, the specification is silent on the 849 # subject of what should happen for a comparison involving a NaN. 850 # We take the following approach: 851 # 852 # == comparisons involving a NaN always return False 853 # != comparisons involving a NaN always return True 854 # <, >, <= and >= comparisons involving a (quiet or signaling) 855 # NaN signal InvalidOperation, and return False if the 856 # InvalidOperation is not trapped. 857 # 858 # This behavior is designed to conform as closely as possible to 859 # that specified by IEEE 754. 860 861 def __eq__(self, other): 862 other = _convert_other(other) 863 if other is NotImplemented: 864 return other 865 if self.is_nan() or other.is_nan(): 866 return False 867 return self._cmp(other) == 0 868 869 def __ne__(self, other): 870 other = _convert_other(other) 871 if other is NotImplemented: 872 return other 873 if self.is_nan() or other.is_nan(): 874 return True 875 return self._cmp(other) != 0 876 877 def __lt__(self, other, context=None): 878 other = _convert_other(other) 879 if other is NotImplemented: 880 return other 881 ans = self._compare_check_nans(other, context) 882 if ans: 883 return False 884 return self._cmp(other) < 0 885 886 def __le__(self, other, context=None): 887 other = _convert_other(other) 888 if other is NotImplemented: 889 return other 890 ans = self._compare_check_nans(other, context) 891 if ans: 892 return False 893 return self._cmp(other) <= 0 894 895 def __gt__(self, other, context=None): 896 other = _convert_other(other) 897 if other is NotImplemented: 898 return other 899 ans = self._compare_check_nans(other, context) 900 if ans: 901 return False 902 return self._cmp(other) > 0 903 904 def __ge__(self, other, context=None): 905 other = _convert_other(other) 906 if other is NotImplemented: 907 return other 908 ans = self._compare_check_nans(other, context) 909 if ans: 910 return False 911 return self._cmp(other) >= 0 912 913 def compare(self, other, context=None): 914 """Compares one to another. 915 916 -1 => a < b 917 0 => a = b 918 1 => a > b 919 NaN => one is NaN 920 Like __cmp__, but returns Decimal instances. 921 """ 922 other = _convert_other(other, raiseit=True) 923 924 # Compare(NaN, NaN) = NaN 925 if (self._is_special or other and other._is_special): 926 ans = self._check_nans(other, context) 927 if ans: 928 return ans 929 930 return Decimal(self._cmp(other)) 931 932 def __hash__(self): 933 """x.__hash__() <==> hash(x)""" 934 # Decimal integers must hash the same as the ints 935 # 936 # The hash of a nonspecial noninteger Decimal must depend only 937 # on the value of that Decimal, and not on its representation. 938 # For example: hash(Decimal('100E-1')) == hash(Decimal('10')). 939 if self._is_special: 940 if self._isnan(): 941 raise TypeError('Cannot hash a NaN value.') 942 return hash(str(self)) 943 if not self: 944 return 0 945 if self._isinteger(): 946 op = _WorkRep(self.to_integral_value()) 947 # to make computation feasible for Decimals with large 948 # exponent, we use the fact that hash(n) == hash(m) for 949 # any two nonzero integers n and m such that (i) n and m 950 # have the same sign, and (ii) n is congruent to m modulo 951 # 2**64-1. So we can replace hash((-1)**s*c*10**e) with 952 # hash((-1)**s*c*pow(10, e, 2**64-1). 953 return hash((-1)**op.sign*op.int*pow(10, op.exp, 2**64-1)) 954 # The value of a nonzero nonspecial Decimal instance is 955 # faithfully represented by the triple consisting of its sign, 956 # its adjusted exponent, and its coefficient with trailing 957 # zeros removed. 958 return hash((self._sign, 959 self._exp+len(self._int), 960 self._int.rstrip('0'))) 961 962 def as_tuple(self): 963 """Represents the number as a triple tuple. 964 965 To show the internals exactly as they are. 966 """ 967 return DecimalTuple(self._sign, tuple(map(int, self._int)), self._exp) 968 969 def __repr__(self): 970 """Represents the number as an instance of Decimal.""" 971 # Invariant: eval(repr(d)) == d 972 return "Decimal('%s')" % str(self) 973 974 def __str__(self, eng=False, context=None): 975 """Return string representation of the number in scientific notation. 976 977 Captures all of the information in the underlying representation. 978 """ 979 980 sign = ['', '-'][self._sign] 981 if self._is_special: 982 if self._exp == 'F': 983 return sign + 'Infinity' 984 elif self._exp == 'n': 985 return sign + 'NaN' + self._int 986 else: # self._exp == 'N' 987 return sign + 'sNaN' + self._int 988 989 # number of digits of self._int to left of decimal point 990 leftdigits = self._exp + len(self._int) 991 992 # dotplace is number of digits of self._int to the left of the 993 # decimal point in the mantissa of the output string (that is, 994 # after adjusting the exponent) 995 if self._exp <= 0 and leftdigits > -6: 996 # no exponent required 997 dotplace = leftdigits 998 elif not eng: 999 # usual scientific notation: 1 digit on left of the point 1000 dotplace = 1 1001 elif self._int == '0': 1002 # engineering notation, zero 1003 dotplace = (leftdigits + 1) % 3 - 1 1004 else: 1005 # engineering notation, nonzero 1006 dotplace = (leftdigits - 1) % 3 + 1 1007 1008 if dotplace <= 0: 1009 intpart = '0' 1010 fracpart = '.' + '0'*(-dotplace) + self._int 1011 elif dotplace >= len(self._int): 1012 intpart = self._int+'0'*(dotplace-len(self._int)) 1013 fracpart = '' 1014 else: 1015 intpart = self._int[:dotplace] 1016 fracpart = '.' + self._int[dotplace:] 1017 if leftdigits == dotplace: 1018 exp = '' 1019 else: 1020 if context is None: 1021 context = getcontext() 1022 exp = ['e', 'E'][context.capitals] + "%+d" % (leftdigits-dotplace) 1023 1024 return sign + intpart + fracpart + exp 1025 1026 def to_eng_string(self, context=None): 1027 """Convert to engineering-type string. 1028 1029 Engineering notation has an exponent which is a multiple of 3, so there 1030 are up to 3 digits left of the decimal place. 1031 1032 Same rules for when in exponential and when as a value as in __str__. 1033 """ 1034 return self.__str__(eng=True, context=context) 1035 1036 def __neg__(self, context=None): 1037 """Returns a copy with the sign switched. 1038 1039 Rounds, if it has reason. 1040 """ 1041 if self._is_special: 1042 ans = self._check_nans(context=context) 1043 if ans: 1044 return ans 1045 1046 if not self: 1047 # -Decimal('0') is Decimal('0'), not Decimal('-0') 1048 ans = self.copy_abs() 1049 else: 1050 ans = self.copy_negate() 1051 1052 if context is None: 1053 context = getcontext() 1054 return ans._fix(context) 1055 1056 def __pos__(self, context=None): 1057 """Returns a copy, unless it is a sNaN. 1058 1059 Rounds the number (if more then precision digits) 1060 """ 1061 if self._is_special: 1062 ans = self._check_nans(context=context) 1063 if ans: 1064 return ans 1065 1066 if not self: 1067 # + (-0) = 0 1068 ans = self.copy_abs() 1069 else: 1070 ans = Decimal(self) 1071 1072 if context is None: 1073 context = getcontext() 1074 return ans._fix(context) 1075 1076 def __abs__(self, round=True, context=None): 1077 """Returns the absolute value of self. 1078 1079 If the keyword argument 'round' is false, do not round. The 1080 expression self.__abs__(round=False) is equivalent to 1081 self.copy_abs(). 1082 """ 1083 if not round: 1084 return self.copy_abs() 1085 1086 if self._is_special: 1087 ans = self._check_nans(context=context) 1088 if ans: 1089 return ans 1090 1091 if self._sign: 1092 ans = self.__neg__(context=context) 1093 else: 1094 ans = self.__pos__(context=context) 1095 1096 return ans 1097 1098 def __add__(self, other, context=None): 1099 """Returns self + other. 1100 1101 -INF + INF (or the reverse) cause InvalidOperation errors. 1102 """ 1103 other = _convert_other(other) 1104 if other is NotImplemented: 1105 return other 1106 1107 if context is None: 1108 context = getcontext() 1109 1110 if self._is_special or other._is_special: 1111 ans = self._check_nans(other, context) 1112 if ans: 1113 return ans 1114 1115 if self._isinfinity(): 1116 # If both INF, same sign => same as both, opposite => error. 1117 if self._sign != other._sign and other._isinfinity(): 1118 return context._raise_error(InvalidOperation, '-INF + INF') 1119 return Decimal(self) 1120 if other._isinfinity(): 1121 return Decimal(other) # Can't both be infinity here 1122 1123 exp = min(self._exp, other._exp) 1124 negativezero = 0 1125 if context.rounding == ROUND_FLOOR and self._sign != other._sign: 1126 # If the answer is 0, the sign should be negative, in this case. 1127 negativezero = 1 1128 1129 if not self and not other: 1130 sign = min(self._sign, other._sign) 1131 if negativezero: 1132 sign = 1 1133 ans = _dec_from_triple(sign, '0', exp) 1134 ans = ans._fix(context) 1135 return ans 1136 if not self: 1137 exp = max(exp, other._exp - context.prec-1) 1138 ans = other._rescale(exp, context.rounding) 1139 ans = ans._fix(context) 1140 return ans 1141 if not other: 1142 exp = max(exp, self._exp - context.prec-1) 1143 ans = self._rescale(exp, context.rounding) 1144 ans = ans._fix(context) 1145 return ans 1146 1147 op1 = _WorkRep(self) 1148 op2 = _WorkRep(other) 1149 op1, op2 = _normalize(op1, op2, context.prec) 1150 1151 result = _WorkRep() 1152 if op1.sign != op2.sign: 1153 # Equal and opposite 1154 if op1.int == op2.int: 1155 ans = _dec_from_triple(negativezero, '0', exp) 1156 ans = ans._fix(context) 1157 return ans 1158 if op1.int < op2.int: 1159 op1, op2 = op2, op1 1160 # OK, now abs(op1) > abs(op2) 1161 if op1.sign == 1: 1162 result.sign = 1 1163 op1.sign, op2.sign = op2.sign, op1.sign 1164 else: 1165 result.sign = 0 1166 # So we know the sign, and op1 > 0. 1167 elif op1.sign == 1: 1168 result.sign = 1 1169 op1.sign, op2.sign = (0, 0) 1170 else: 1171 result.sign = 0 1172 # Now, op1 > abs(op2) > 0 1173 1174 if op2.sign == 0: 1175 result.int = op1.int + op2.int 1176 else: 1177 result.int = op1.int - op2.int 1178 1179 result.exp = op1.exp 1180 ans = Decimal(result) 1181 ans = ans._fix(context) 1182 return ans 1183 1184 __radd__ = __add__ 1185 1186 def __sub__(self, other, context=None): 1187 """Return self - other""" 1188 other = _convert_other(other) 1189 if other is NotImplemented: 1190 return other 1191 1192 if self._is_special or other._is_special: 1193 ans = self._check_nans(other, context=context) 1194 if ans: 1195 return ans 1196 1197 # self - other is computed as self + other.copy_negate() 1198 return self.__add__(other.copy_negate(), context=context) 1199 1200 def __rsub__(self, other, context=None): 1201 """Return other - self""" 1202 other = _convert_other(other) 1203 if other is NotImplemented: 1204 return other 1205 1206 return other.__sub__(self, context=context) 1207 1208 def __mul__(self, other, context=None): 1209 """Return self * other. 1210 1211 (+-) INF * 0 (or its reverse) raise InvalidOperation. 1212 """ 1213 other = _convert_other(other) 1214 if other is NotImplemented: 1215 return other 1216 1217 if context is None: 1218 context = getcontext() 1219 1220 resultsign = self._sign ^ other._sign 1221 1222 if self._is_special or other._is_special: 1223 ans = self._check_nans(other, context) 1224 if ans: 1225 return ans 1226 1227 if self._isinfinity(): 1228 if not other: 1229 return context._raise_error(InvalidOperation, '(+-)INF * 0') 1230 return _SignedInfinity[resultsign] 1231 1232 if other._isinfinity(): 1233 if not self: 1234 return context._raise_error(InvalidOperation, '0 * (+-)INF') 1235 return _SignedInfinity[resultsign] 1236 1237 resultexp = self._exp + other._exp 1238 1239 # Special case for multiplying by zero 1240 if not self or not other: 1241 ans = _dec_from_triple(resultsign, '0', resultexp) 1242 # Fixing in case the exponent is out of bounds 1243 ans = ans._fix(context) 1244 return ans 1245 1246 # Special case for multiplying by power of 10 1247 if self._int == '1': 1248 ans = _dec_from_triple(resultsign, other._int, resultexp) 1249 ans = ans._fix(context) 1250 return ans 1251 if other._int == '1': 1252 ans = _dec_from_triple(resultsign, self._int, resultexp) 1253 ans = ans._fix(context) 1254 return ans 1255 1256 op1 = _WorkRep(self) 1257 op2 = _WorkRep(other) 1258 1259 ans = _dec_from_triple(resultsign, str(op1.int * op2.int), resultexp) 1260 ans = ans._fix(context) 1261 1262 return ans 1263 __rmul__ = __mul__ 1264 1265 def __truediv__(self, other, context=None): 1266 """Return self / other.""" 1267 other = _convert_other(other) 1268 if other is NotImplemented: 1269 return NotImplemented 1270 1271 if context is None: 1272 context = getcontext() 1273 1274 sign = self._sign ^ other._sign 1275 1276 if self._is_special or other._is_special: 1277 ans = self._check_nans(other, context) 1278 if ans: 1279 return ans 1280 1281 if self._isinfinity() and other._isinfinity(): 1282 return context._raise_error(InvalidOperation, '(+-)INF/(+-)INF') 1283 1284 if self._isinfinity(): 1285 return _SignedInfinity[sign] 1286 1287 if other._isinfinity(): 1288 context._raise_error(Clamped, 'Division by infinity') 1289 return _dec_from_triple(sign, '0', context.Etiny()) 1290 1291 # Special cases for zeroes 1292 if not other: 1293 if not self: 1294 return context._raise_error(DivisionUndefined, '0 / 0') 1295 return context._raise_error(DivisionByZero, 'x / 0', sign) 1296 1297 if not self: 1298 exp = self._exp - other._exp 1299 coeff = 0 1300 else: 1301 # OK, so neither = 0, INF or NaN 1302 shift = len(other._int) - len(self._int) + context.prec + 1 1303 exp = self._exp - other._exp - shift 1304 op1 = _WorkRep(self) 1305 op2 = _WorkRep(other) 1306 if shift >= 0: 1307 coeff, remainder = divmod(op1.int * 10**shift, op2.int) 1308 else: 1309 coeff, remainder = divmod(op1.int, op2.int * 10**-shift) 1310 if remainder: 1311 # result is not exact; adjust to ensure correct rounding 1312 if coeff % 5 == 0: 1313 coeff += 1 1314 else: 1315 # result is exact; get as close to ideal exponent as possible 1316 ideal_exp = self._exp - other._exp 1317 while exp < ideal_exp and coeff % 10 == 0: 1318 coeff //= 10 1319 exp += 1 1320 1321 ans = _dec_from_triple(sign, str(coeff), exp) 1322 return ans._fix(context) 1323 1324 def _divide(self, other, context): 1325 """Return (self // other, self % other), to context.prec precision. 1326 1327 Assumes that neither self nor other is a NaN, that self is not 1328 infinite and that other is nonzero. 1329 """ 1330 sign = self._sign ^ other._sign 1331 if other._isinfinity(): 1332 ideal_exp = self._exp 1333 else: 1334 ideal_exp = min(self._exp, other._exp) 1335 1336 expdiff = self.adjusted() - other.adjusted() 1337 if not self or other._isinfinity() or expdiff <= -2: 1338 return (_dec_from_triple(sign, '0', 0), 1339 self._rescale(ideal_exp, context.rounding)) 1340 if expdiff <= context.prec: 1341 op1 = _WorkRep(self) 1342 op2 = _WorkRep(other) 1343 if op1.exp >= op2.exp: 1344 op1.int *= 10**(op1.exp - op2.exp) 1345 else: 1346 op2.int *= 10**(op2.exp - op1.exp) 1347 q, r = divmod(op1.int, op2.int) 1348 if q < 10**context.prec: 1349 return (_dec_from_triple(sign, str(q), 0), 1350 _dec_from_triple(self._sign, str(r), ideal_exp)) 1351 1352 # Here the quotient is too large to be representable 1353 ans = context._raise_error(DivisionImpossible, 1354 'quotient too large in //, % or divmod') 1355 return ans, ans 1356 1357 def __rtruediv__(self, other, context=None): 1358 """Swaps self/other and returns __truediv__.""" 1359 other = _convert_other(other) 1360 if other is NotImplemented: 1361 return other 1362 return other.__truediv__(self, context=context) 1363 1364 __div__ = __truediv__ 1365 __rdiv__ = __rtruediv__ 1366 1367 def __divmod__(self, other, context=None): 1368 """ 1369 Return (self // other, self % other) 1370 """ 1371 other = _convert_other(other) 1372 if other is NotImplemented: 1373 return other 1374 1375 if context is None: 1376 context = getcontext() 1377 1378 ans = self._check_nans(other, context) 1379 if ans: 1380 return (ans, ans) 1381 1382 sign = self._sign ^ other._sign 1383 if self._isinfinity(): 1384 if other._isinfinity(): 1385 ans = context._raise_error(InvalidOperation, 'divmod(INF, INF)') 1386 return ans, ans 1387 else: 1388 return (_SignedInfinity[sign], 1389 context._raise_error(InvalidOperation, 'INF % x')) 1390 1391 if not other: 1392 if not self: 1393 ans = context._raise_error(DivisionUndefined, 'divmod(0, 0)') 1394 return ans, ans 1395 else: 1396 return (context._raise_error(DivisionByZero, 'x // 0', sign), 1397 context._raise_error(InvalidOperation, 'x % 0')) 1398 1399 quotient, remainder = self._divide(other, context) 1400 remainder = remainder._fix(context) 1401 return quotient, remainder 1402 1403 def __rdivmod__(self, other, context=None): 1404 """Swaps self/other and returns __divmod__.""" 1405 other = _convert_other(other) 1406 if other is NotImplemented: 1407 return other 1408 return other.__divmod__(self, context=context) 1409 1410 def __mod__(self, other, context=None): 1411 """ 1412 self % other 1413 """ 1414 other = _convert_other(other) 1415 if other is NotImplemented: 1416 return other 1417 1418 if context is None: 1419 context = getcontext() 1420 1421 ans = self._check_nans(other, context) 1422 if ans: 1423 return ans 1424 1425 if self._isinfinity(): 1426 return context._raise_error(InvalidOperation, 'INF % x') 1427 elif not other: 1428 if self: 1429 return context._raise_error(InvalidOperation, 'x % 0') 1430 else: 1431 return context._raise_error(DivisionUndefined, '0 % 0') 1432 1433 remainder = self._divide(other, context)[1] 1434 remainder = remainder._fix(context) 1435 return remainder 1436 1437 def __rmod__(self, other, context=None): 1438 """Swaps self/other and returns __mod__.""" 1439 other = _convert_other(other) 1440 if other is NotImplemented: 1441 return other 1442 return other.__mod__(self, context=context) 1443 1444 def remainder_near(self, other, context=None): 1445 """ 1446 Remainder nearest to 0- abs(remainder-near) <= other/2 1447 """ 1448 if context is None: 1449 context = getcontext() 1450 1451 other = _convert_other(other, raiseit=True) 1452 1453 ans = self._check_nans(other, context) 1454 if ans: 1455 return ans 1456 1457 # self == +/-infinity -> InvalidOperation 1458 if self._isinfinity(): 1459 return context._raise_error(InvalidOperation, 1460 'remainder_near(infinity, x)') 1461 1462 # other == 0 -> either InvalidOperation or DivisionUndefined 1463 if not other: 1464 if self: 1465 return context._raise_error(InvalidOperation, 1466 'remainder_near(x, 0)') 1467 else: 1468 return context._raise_error(DivisionUndefined, 1469 'remainder_near(0, 0)') 1470 1471 # other = +/-infinity -> remainder = self 1472 if other._isinfinity(): 1473 ans = Decimal(self) 1474 return ans._fix(context) 1475 1476 # self = 0 -> remainder = self, with ideal exponent 1477 ideal_exponent = min(self._exp, other._exp) 1478 if not self: 1479 ans = _dec_from_triple(self._sign, '0', ideal_exponent) 1480 return ans._fix(context) 1481 1482 # catch most cases of large or small quotient 1483 expdiff = self.adjusted() - other.adjusted() 1484 if expdiff >= context.prec + 1: 1485 # expdiff >= prec+1 => abs(self/other) > 10**prec 1486 return context._raise_error(DivisionImpossible) 1487 if expdiff <= -2: 1488 # expdiff <= -2 => abs(self/other) < 0.1 1489 ans = self._rescale(ideal_exponent, context.rounding) 1490 return ans._fix(context) 1491 1492 # adjust both arguments to have the same exponent, then divide 1493 op1 = _WorkRep(self) 1494 op2 = _WorkRep(other) 1495 if op1.exp >= op2.exp: 1496 op1.int *= 10**(op1.exp - op2.exp) 1497 else: 1498 op2.int *= 10**(op2.exp - op1.exp) 1499 q, r = divmod(op1.int, op2.int) 1500 # remainder is r*10**ideal_exponent; other is +/-op2.int * 1501 # 10**ideal_exponent. Apply correction to ensure that 1502 # abs(remainder) <= abs(other)/2 1503 if 2*r + (q&1) > op2.int: 1504 r -= op2.int 1505 q += 1 1506 1507 if q >= 10**context.prec: 1508 return context._raise_error(DivisionImpossible) 1509 1510 # result has same sign as self unless r is negative 1511 sign = self._sign 1512 if r < 0: 1513 sign = 1-sign 1514 r = -r 1515 1516 ans = _dec_from_triple(sign, str(r), ideal_exponent) 1517 return ans._fix(context) 1518 1519 def __floordiv__(self, other, context=None): 1520 """self // other""" 1521 other = _convert_other(other) 1522 if other is NotImplemented: 1523 return other 1524 1525 if context is None: 1526 context = getcontext() 1527 1528 ans = self._check_nans(other, context) 1529 if ans: 1530 return ans 1531 1532 if self._isinfinity(): 1533 if other._isinfinity(): 1534 return context._raise_error(InvalidOperation, 'INF // INF') 1535 else: 1536 return _SignedInfinity[self._sign ^ other._sign] 1537 1538 if not other: 1539 if self: 1540 return context._raise_error(DivisionByZero, 'x // 0', 1541 self._sign ^ other._sign) 1542 else: 1543 return context._raise_error(DivisionUndefined, '0 // 0') 1544 1545 return self._divide(other, context)[0] 1546 1547 def __rfloordiv__(self, other, context=None): 1548 """Swaps self/other and returns __floordiv__.""" 1549 other = _convert_other(other) 1550 if other is NotImplemented: 1551 return other 1552 return other.__floordiv__(self, context=context) 1553 1554 def __float__(self): 1555 """Float representation.""" 1556 return float(str(self)) 1557 1558 def __int__(self): 1559 """Converts self to an int, truncating if necessary.""" 1560 if self._is_special: 1561 if self._isnan(): 1562 context = getcontext() 1563 return context._raise_error(InvalidContext) 1564 elif self._isinfinity(): 1565 raise OverflowError("Cannot convert infinity to int") 1566 s = (-1)**self._sign 1567 if self._exp >= 0: 1568 return s*int(self._int)*10**self._exp 1569 else: 1570 return s*int(self._int[:self._exp] or '0') 1571 1572 __trunc__ = __int__ 1573 1574 def real(self): 1575 return self 1576 real = property(real) 1577 1578 def imag(self): 1579 return Decimal(0) 1580 imag = property(imag) 1581 1582 def conjugate(self): 1583 return self 1584 1585 def __complex__(self): 1586 return complex(float(self)) 1587 1588 def __long__(self): 1589 """Converts to a long. 1590 1591 Equivalent to long(int(self)) 1592 """ 1593 return long(self.__int__()) 1594 1595 def _fix_nan(self, context): 1596 """Decapitate the payload of a NaN to fit the context""" 1597 payload = self._int 1598 1599 # maximum length of payload is precision if _clamp=0, 1600 # precision-1 if _clamp=1. 1601 max_payload_len = context.prec - context._clamp 1602 if len(payload) > max_payload_len: 1603 payload = payload[len(payload)-max_payload_len:].lstrip('0') 1604 return _dec_from_triple(self._sign, payload, self._exp, True) 1605 return Decimal(self) 1606 1607 def _fix(self, context): 1608 """Round if it is necessary to keep self within prec precision. 1609 1610 Rounds and fixes the exponent. Does not raise on a sNaN. 1611 1612 Arguments: 1613 self - Decimal instance 1614 context - context used. 1615 """ 1616 1617 if self._is_special: 1618 if self._isnan(): 1619 # decapitate payload if necessary 1620 return self._fix_nan(context) 1621 else: 1622 # self is +/-Infinity; return unaltered 1623 return Decimal(self) 1624 1625 # if self is zero then exponent should be between Etiny and 1626 # Emax if _clamp==0, and between Etiny and Etop if _clamp==1. 1627 Etiny = context.Etiny() 1628 Etop = context.Etop() 1629 if not self: 1630 exp_max = [context.Emax, Etop][context._clamp] 1631 new_exp = min(max(self._exp, Etiny), exp_max) 1632 if new_exp != self._exp: 1633 context._raise_error(Clamped) 1634 return _dec_from_triple(self._sign, '0', new_exp) 1635 else: 1636 return Decimal(self) 1637 1638 # exp_min is the smallest allowable exponent of the result, 1639 # equal to max(self.adjusted()-context.prec+1, Etiny) 1640 exp_min = len(self._int) + self._exp - context.prec 1641 if exp_min > Etop: 1642 # overflow: exp_min > Etop iff self.adjusted() > Emax 1643 context._raise_error(Inexact) 1644 context._raise_error(Rounded) 1645 return context._raise_error(Overflow, 'above Emax', self._sign) 1646 self_is_subnormal = exp_min < Etiny 1647 if self_is_subnormal: 1648 context._raise_error(Subnormal) 1649 exp_min = Etiny 1650 1651 # round if self has too many digits 1652 if self._exp < exp_min: 1653 context._raise_error(Rounded) 1654 digits = len(self._int) + self._exp - exp_min 1655 if digits < 0: 1656 self = _dec_from_triple(self._sign, '1', exp_min-1) 1657 digits = 0 1658 this_function = getattr(self, self._pick_rounding_function[context.rounding]) 1659 changed = this_function(digits) 1660 coeff = self._int[:digits] or '0' 1661 if changed == 1: 1662 coeff = str(int(coeff)+1) 1663 ans = _dec_from_triple(self._sign, coeff, exp_min) 1664 1665 if changed: 1666 context._raise_error(Inexact) 1667 if self_is_subnormal: 1668 context._raise_error(Underflow) 1669 if not ans: 1670 # raise Clamped on underflow to 0 1671 context._raise_error(Clamped) 1672 elif len(ans._int) == context.prec+1: 1673 # we get here only if rescaling rounds the 1674 # cofficient up to exactly 10**context.prec 1675 if ans._exp < Etop: 1676 ans = _dec_from_triple(ans._sign, 1677 ans._int[:-1], ans._exp+1) 1678 else: 1679 # Inexact and Rounded have already been raised 1680 ans = context._raise_error(Overflow, 'above Emax', 1681 self._sign) 1682 return ans 1683 1684 # fold down if _clamp == 1 and self has too few digits 1685 if context._clamp == 1 and self._exp > Etop: 1686 context._raise_error(Clamped) 1687 self_padded = self._int + '0'*(self._exp - Etop) 1688 return _dec_from_triple(self._sign, self_padded, Etop) 1689 1690 # here self was representable to begin with; return unchanged 1691 return Decimal(self) 1692 1693 _pick_rounding_function = {} 1694 1695 # for each of the rounding functions below: 1696 # self is a finite, nonzero Decimal 1697 # prec is an integer satisfying 0 <= prec < len(self._int) 1698 # 1699 # each function returns either -1, 0, or 1, as follows: 1700 # 1 indicates that self should be rounded up (away from zero) 1701 # 0 indicates that self should be truncated, and that all the 1702 # digits to be truncated are zeros (so the value is unchanged) 1703 # -1 indicates that there are nonzero digits to be truncated 1704 1705 def _round_down(self, prec): 1706 """Also known as round-towards-0, truncate.""" 1707 if _all_zeros(self._int, prec): 1708 return 0 1709 else: 1710 return -1 1711 1712 def _round_up(self, prec): 1713 """Rounds away from 0.""" 1714 return -self._round_down(prec) 1715 1716 def _round_half_up(self, prec): 1717 """Rounds 5 up (away from 0)""" 1718 if self._int[prec] in '56789': 1719 return 1 1720 elif _all_zeros(self._int, prec): 1721 return 0 1722 else: 1723 return -1 1724 1725 def _round_half_down(self, prec): 1726 """Round 5 down""" 1727 if _exact_half(self._int, prec): 1728 return -1 1729 else: 1730 return self._round_half_up(prec) 1731 1732 def _round_half_even(self, prec): 1733 """Round 5 to even, rest to nearest.""" 1734 if _exact_half(self._int, prec) and \ 1735 (prec == 0 or self._int[prec-1] in '02468'): 1736 return -1 1737 else: 1738 return self._round_half_up(prec) 1739 1740 def _round_ceiling(self, prec): 1741 """Rounds up (not away from 0 if negative.)""" 1742 if self._sign: 1743 return self._round_down(prec) 1744 else: 1745 return -self._round_down(prec) 1746 1747 def _round_floor(self, prec): 1748 """Rounds down (not towards 0 if negative)""" 1749 if not self._sign: 1750 return self._round_down(prec) 1751 else: 1752 return -self._round_down(prec) 1753 1754 def _round_05up(self, prec): 1755 """Round down unless digit prec-1 is 0 or 5.""" 1756 if prec and self._int[prec-1] not in '05': 1757 return self._round_down(prec) 1758 else: 1759 return -self._round_down(prec) 1760 1761 def fma(self, other, third, context=None): 1762 """Fused multiply-add. 1763 1764 Returns self*other+third with no rounding of the intermediate 1765 product self*other. 1766 1767 self and other are multiplied together, with no rounding of 1768 the result. The third operand is then added to the result, 1769 and a single final rounding is performed. 1770 """ 1771 1772 other = _convert_other(other, raiseit=True) 1773 1774 # compute product; raise InvalidOperation if either operand is 1775 # a signaling NaN or if the product is zero times infinity. 1776 if self._is_special or other._is_special: 1777 if context is None: 1778 context = getcontext() 1779 if self._exp == 'N': 1780 return context._raise_error(InvalidOperation, 'sNaN', self) 1781 if other._exp == 'N': 1782 return context._raise_error(InvalidOperation, 'sNaN', other) 1783 if self._exp == 'n': 1784 product = self 1785 elif other._exp == 'n': 1786 product = other 1787 elif self._exp == 'F': 1788 if not other: 1789 return context._raise_error(InvalidOperation, 1790 'INF * 0 in fma') 1791 product = _SignedInfinity[self._sign ^ other._sign] 1792 elif other._exp == 'F': 1793 if not self: 1794 return context._raise_error(InvalidOperation, 1795 '0 * INF in fma') 1796 product = _SignedInfinity[self._sign ^ other._sign] 1797 else: 1798 product = _dec_from_triple(self._sign ^ other._sign, 1799 str(int(self._int) * int(other._int)), 1800 self._exp + other._exp) 1801 1802 third = _convert_other(third, raiseit=True) 1803 return product.__add__(third, context) 1804 1805 def _power_modulo(self, other, modulo, context=None): 1806 """Three argument version of __pow__""" 1807 1808 # if can't convert other and modulo to Decimal, raise 1809 # TypeError; there's no point returning NotImplemented (no 1810 # equivalent of __rpow__ for three argument pow) 1811 other = _convert_other(other, raiseit=True) 1812 modulo = _convert_other(modulo, raiseit=True) 1813 1814 if context is None: 1815 context = getcontext() 1816 1817 # deal with NaNs: if there are any sNaNs then first one wins, 1818 # (i.e. behaviour for NaNs is identical to that of fma) 1819 self_is_nan = self._isnan() 1820 other_is_nan = other._isnan() 1821 modulo_is_nan = modulo._isnan() 1822 if self_is_nan or other_is_nan or modulo_is_nan: 1823 if self_is_nan == 2: 1824 return context._raise_error(InvalidOperation, 'sNaN', 1825 self) 1826 if other_is_nan == 2: 1827 return context._raise_error(InvalidOperation, 'sNaN', 1828 other) 1829 if modulo_is_nan == 2: 1830 return context._raise_error(InvalidOperation, 'sNaN', 1831 modulo) 1832 if self_is_nan: 1833 return self._fix_nan(context) 1834 if other_is_nan: 1835 return other._fix_nan(context) 1836 return modulo._fix_nan(context) 1837 1838 # check inputs: we apply same restrictions as Python's pow() 1839 if not (self._isinteger() and 1840 other._isinteger() and 1841 modulo._isinteger()): 1842 return context._raise_error(InvalidOperation, 1843 'pow() 3rd argument not allowed ' 1844 'unless all arguments are integers') 1845 if other < 0: 1846 return context._raise_error(InvalidOperation, 1847 'pow() 2nd argument cannot be ' 1848 'negative when 3rd argument specified') 1849 if not modulo: 1850 return context._raise_error(InvalidOperation, 1851 'pow() 3rd argument cannot be 0') 1852 1853 # additional restriction for decimal: the modulus must be less 1854 # than 10**prec in absolute value 1855 if modulo.adjusted() >= context.prec: 1856 return context._raise_error(InvalidOperation, 1857 'insufficient precision: pow() 3rd ' 1858 'argument must not have more than ' 1859 'precision digits') 1860 1861 # define 0**0 == NaN, for consistency with two-argument pow 1862 # (even though it hurts!) 1863 if not other and not self: 1864 return context._raise_error(InvalidOperation, 1865 'at least one of pow() 1st argument ' 1866 'and 2nd argument must be nonzero ;' 1867 '0**0 is not defined') 1868 1869 # compute sign of result 1870 if other._iseven(): 1871 sign = 0 1872 else: 1873 sign = self._sign 1874 1875 # convert modulo to a Python integer, and self and other to 1876 # Decimal integers (i.e. force their exponents to be >= 0) 1877 modulo = abs(int(modulo)) 1878 base = _WorkRep(self.to_integral_value()) 1879 exponent = _WorkRep(other.to_integral_value()) 1880 1881 # compute result using integer pow() 1882 base = (base.int % modulo * pow(10, base.exp, modulo)) % modulo 1883 for i in xrange(exponent.exp): 1884 base = pow(base, 10, modulo) 1885 base = pow(base, exponent.int, modulo) 1886 1887 return _dec_from_triple(sign, str(base), 0) 1888 1889 def _power_exact(self, other, p): 1890 """Attempt to compute self**other exactly. 1891 1892 Given Decimals self and other and an integer p, attempt to 1893 compute an exact result for the power self**other, with p 1894 digits of precision. Return None if self**other is not 1895 exactly representable in p digits. 1896 1897 Assumes that elimination of special cases has already been 1898 performed: self and other must both be nonspecial; self must 1899 be positive and not numerically equal to 1; other must be 1900 nonzero. For efficiency, other._exp should not be too large, 1901 so that 10**abs(other._exp) is a feasible calculation.""" 1902 1903 # In the comments below, we write x for the value of self and 1904 # y for the value of other. Write x = xc*10**xe and y = 1905 # yc*10**ye. 1906 1907 # The main purpose of this method is to identify the *failure* 1908 # of x**y to be exactly representable with as little effort as 1909 # possible. So we look for cheap and easy tests that 1910 # eliminate the possibility of x**y being exact. Only if all 1911 # these tests are passed do we go on to actually compute x**y. 1912 1913 # Here's the main idea. First normalize both x and y. We 1914 # express y as a rational m/n, with m and n relatively prime 1915 # and n>0. Then for x**y to be exactly representable (at 1916 # *any* precision), xc must be the nth power of a positive 1917 # integer and xe must be divisible by n. If m is negative 1918 # then additionally xc must be a power of either 2 or 5, hence 1919 # a power of 2**n or 5**n. 1920 # 1921 # There's a limit to how small |y| can be: if y=m/n as above 1922 # then: 1923 # 1924 # (1) if xc != 1 then for the result to be representable we 1925 # need xc**(1/n) >= 2, and hence also xc**|y| >= 2. So 1926 # if |y| <= 1/nbits(xc) then xc < 2**nbits(xc) <= 1927 # 2**(1/|y|), hence xc**|y| < 2 and the result is not 1928 # representable. 1929 # 1930 # (2) if xe != 0, |xe|*(1/n) >= 1, so |xe|*|y| >= 1. Hence if 1931 # |y| < 1/|xe| then the result is not representable. 1932 # 1933 # Note that since x is not equal to 1, at least one of (1) and 1934 # (2) must apply. Now |y| < 1/nbits(xc) iff |yc|*nbits(xc) < 1935 # 10**-ye iff len(str(|yc|*nbits(xc)) <= -ye. 1936 # 1937 # There's also a limit to how large y can be, at least if it's 1938 # positive: the normalized result will have coefficient xc**y, 1939 # so if it's representable then xc**y < 10**p, and y < 1940 # p/log10(xc). Hence if y*log10(xc) >= p then the result is 1941 # not exactly representable. 1942 1943 # if len(str(abs(yc*xe)) <= -ye then abs(yc*xe) < 10**-ye, 1944 # so |y| < 1/xe and the result is not representable. 1945 # Similarly, len(str(abs(yc)*xc_bits)) <= -ye implies |y| 1946 # < 1/nbits(xc). 1947 1948 x = _WorkRep(self) 1949 xc, xe = x.int, x.exp 1950 while xc % 10 == 0: 1951 xc //= 10 1952 xe += 1 1953 1954 y = _WorkRep(other) 1955 yc, ye = y.int, y.exp 1956 while yc % 10 == 0: 1957 yc //= 10 1958 ye += 1 1959 1960 # case where xc == 1: result is 10**(xe*y), with xe*y 1961 # required to be an integer 1962 if xc == 1: 1963 if ye >= 0: 1964 exponent = xe*yc*10**ye 1965 else: 1966 exponent, remainder = divmod(xe*yc, 10**-ye) 1967 if remainder: 1968 return None 1969 if y.sign == 1: 1970 exponent = -exponent 1971 # if other is a nonnegative integer, use ideal exponent 1972 if other._isinteger() and other._sign == 0: 1973 ideal_exponent = self._exp*int(other) 1974 zeros = min(exponent-ideal_exponent, p-1) 1975 else: 1976 zeros = 0 1977 return _dec_from_triple(0, '1' + '0'*zeros, exponent-zeros) 1978 1979 # case where y is negative: xc must be either a power 1980 # of 2 or a power of 5. 1981 if y.sign == 1: 1982 last_digit = xc % 10 1983 if last_digit in (2,4,6,8): 1984 # quick test for power of 2 1985 if xc & -xc != xc: 1986 return None 1987 # now xc is a power of 2; e is its exponent 1988 e = _nbits(xc)-1 1989 # find e*y and xe*y; both must be integers 1990 if ye >= 0: 1991 y_as_int = yc*10**ye 1992 e = e*y_as_int 1993 xe = xe*y_as_int 1994 else: 1995 ten_pow = 10**-ye 1996 e, remainder = divmod(e*yc, ten_pow) 1997 if remainder: 1998 return None 1999 xe, remainder = divmod(xe*yc, ten_pow) 2000 if remainder: 2001 return None 2002 2003 if e*65 >= p*93: # 93/65 > log(10)/log(5) 2004 return None 2005 xc = 5**e 2006 2007 elif last_digit == 5: 2008 # e >= log_5(xc) if xc is a power of 5; we have 2009 # equality all the way up to xc=5**2658 2010 e = _nbits(xc)*28//65 2011 xc, remainder = divmod(5**e, xc) 2012 if remainder: 2013 return None 2014 while xc % 5 == 0: 2015 xc //= 5 2016 e -= 1 2017 if ye >= 0: 2018 y_as_integer = yc*10**ye 2019 e = e*y_as_integer 2020 xe = xe*y_as_integer 2021 else: 2022 ten_pow = 10**-ye 2023 e, remainder = divmod(e*yc, ten_pow) 2024 if remainder: 2025 return None 2026 xe, remainder = divmod(xe*yc, ten_pow) 2027 if remainder: 2028 return None 2029 if e*3 >= p*10: # 10/3 > log(10)/log(2) 2030 return None 2031 xc = 2**e 2032 else: 2033 return None 2034 2035 if xc >= 10**p: 2036 return None 2037 xe = -e-xe 2038 return _dec_from_triple(0, str(xc), xe) 2039 2040 # now y is positive; find m and n such that y = m/n 2041 if ye >= 0: 2042 m, n = yc*10**ye, 1 2043 else: 2044 if xe != 0 and len(str(abs(yc*xe))) <= -ye: 2045 return None 2046 xc_bits = _nbits(xc) 2047 if xc != 1 and len(str(abs(yc)*xc_bits)) <= -ye: 2048 return None 2049 m, n = yc, 10**(-ye) 2050 while m % 2 == n % 2 == 0: 2051 m //= 2 2052 n //= 2 2053 while m % 5 == n % 5 == 0: 2054 m //= 5 2055 n //= 5 2056 2057 # compute nth root of xc*10**xe 2058 if n > 1: 2059 # if 1 < xc < 2**n then xc isn't an nth power 2060 if xc != 1 and xc_bits <= n: 2061 return None 2062 2063 xe, rem = divmod(xe, n) 2064 if rem != 0: 2065 return None 2066 2067 # compute nth root of xc using Newton's method 2068 a = 1L << -(-_nbits(xc)//n) # initial estimate 2069 while True: 2070 q, r = divmod(xc, a**(n-1)) 2071 if a <= q: 2072 break 2073 else: 2074 a = (a*(n-1) + q)//n 2075 if not (a == q and r == 0): 2076 return None 2077 xc = a 2078 2079 # now xc*10**xe is the nth root of the original xc*10**xe 2080 # compute mth power of xc*10**xe 2081 2082 # if m > p*100//_log10_lb(xc) then m > p/log10(xc), hence xc**m > 2083 # 10**p and the result is not representable. 2084 if xc > 1 and m > p*100//_log10_lb(xc): 2085 return None 2086 xc = xc**m 2087 xe *= m 2088 if xc > 10**p: 2089 return None 2090 2091 # by this point the result *is* exactly representable 2092 # adjust the exponent to get as close as possible to the ideal 2093 # exponent, if necessary 2094 str_xc = str(xc) 2095 if other._isinteger() and other._sign == 0: 2096 ideal_exponent = self._exp*int(other) 2097 zeros = min(xe-ideal_exponent, p-len(str_xc)) 2098 else: 2099 zeros = 0 2100 return _dec_from_triple(0, str_xc+'0'*zeros, xe-zeros) 2101 2102 def __pow__(self, other, modulo=None, context=None): 2103 """Return self ** other [ % modulo]. 2104 2105 With two arguments, compute self**other. 2106 2107 With three arguments, compute (self**other) % modulo. For the 2108 three argument form, the following restrictions on the 2109 arguments hold: 2110 2111 - all three arguments must be integral 2112 - other must be nonnegative 2113 - either self or other (or both) must be nonzero 2114 - modulo must be nonzero and must have at most p digits, 2115 where p is the context precision. 2116 2117 If any of these restrictions is violated the InvalidOperation 2118 flag is raised. 2119 2120 The result of pow(self, other, modulo) is identical to the 2121 result that would be obtained by computing (self**other) % 2122 modulo with unbounded precision, but is computed more 2123 efficiently. It is always exact. 2124 """ 2125 2126 if modulo is not None: 2127 return self._power_modulo(other, modulo, context) 2128 2129 other = _convert_other(other) 2130 if other is NotImplemented: 2131 return other 2132 2133 if context is None: 2134 context = getcontext() 2135 2136 # either argument is a NaN => result is NaN 2137 ans = self._check_nans(other, context) 2138 if ans: 2139 return ans 2140 2141 # 0**0 = NaN (!), x**0 = 1 for nonzero x (including +/-Infinity) 2142 if not other: 2143 if not self: 2144 return context._raise_error(InvalidOperation, '0 ** 0') 2145 else: 2146 return _One 2147 2148 # result has sign 1 iff self._sign is 1 and other is an odd integer 2149 result_sign = 0 2150 if self._sign == 1: 2151 if other._isinteger(): 2152 if not other._iseven(): 2153 result_sign = 1 2154 else: 2155 # -ve**noninteger = NaN 2156 # (-0)**noninteger = 0**noninteger 2157 if self: 2158 return context._raise_error(InvalidOperation, 2159 'x ** y with x negative and y not an integer') 2160 # negate self, without doing any unwanted rounding 2161 self = self.copy_negate() 2162 2163 # 0**(+ve or Inf)= 0; 0**(-ve or -Inf) = Infinity 2164 if not self: 2165 if other._sign == 0: 2166 return _dec_from_triple(result_sign, '0', 0) 2167 else: 2168 return _SignedInfinity[result_sign] 2169 2170 # Inf**(+ve or Inf) = Inf; Inf**(-ve or -Inf) = 0 2171 if self._isinfinity(): 2172 if other._sign == 0: 2173 return _SignedInfinity[result_sign] 2174 else: 2175 return _dec_from_triple(result_sign, '0', 0) 2176 2177 # 1**other = 1, but the choice of exponent and the flags 2178 # depend on the exponent of self, and on whether other is a 2179 # positive integer, a negative integer, or neither 2180 if self == _One: 2181 if other._isinteger(): 2182 # exp = max(self._exp*max(int(other), 0), 2183 # 1-context.prec) but evaluating int(other) directly 2184 # is dangerous until we know other is small (other 2185 # could be 1e999999999) 2186 if other._sign == 1: 2187 multiplier = 0 2188 elif other > context.prec: 2189 multiplier = context.prec 2190 else: 2191 multiplier = int(other) 2192 2193 exp = self._exp * multiplier 2194 if exp < 1-context.prec: 2195 exp = 1-context.prec 2196 context._raise_error(Rounded) 2197 else: 2198 context._raise_error(Inexact) 2199 context._raise_error(Rounded) 2200 exp = 1-context.prec 2201 2202 return _dec_from_triple(result_sign, '1'+'0'*-exp, exp) 2203 2204 # compute adjusted exponent of self 2205 self_adj = self.adjusted() 2206 2207 # self ** infinity is infinity if self > 1, 0 if self < 1 2208 # self ** -infinity is infinity if self < 1, 0 if self > 1 2209 if other._isinfinity(): 2210 if (other._sign == 0) == (self_adj < 0): 2211 return _dec_from_triple(result_sign, '0', 0) 2212 else: 2213 return _SignedInfinity[result_sign] 2214 2215 # from here on, the result always goes through the call 2216 # to _fix at the end of this function. 2217 ans = None 2218 2219 # crude test to catch cases of extreme overflow/underflow. If 2220 # log10(self)*other >= 10**bound and bound >= len(str(Emax)) 2221 # then 10**bound >= 10**len(str(Emax)) >= Emax+1 and hence 2222 # self**other >= 10**(Emax+1), so overflow occurs. The test 2223 # for underflow is similar. 2224 bound = self._log10_exp_bound() + other.adjusted() 2225 if (self_adj >= 0) == (other._sign == 0): 2226 # self > 1 and other +ve, or self < 1 and other -ve 2227 # possibility of overflow 2228 if bound >= len(str(context.Emax)): 2229 ans = _dec_from_triple(result_sign, '1', context.Emax+1) 2230 else: 2231 # self > 1 and other -ve, or self < 1 and other +ve 2232 # possibility of underflow to 0 2233 Etiny = context.Etiny() 2234 if bound >= len(str(-Etiny)): 2235 ans = _dec_from_triple(result_sign, '1', Etiny-1) 2236 2237 # try for an exact result with precision +1 2238 if ans is None: 2239 ans = self._power_exact(other, context.prec + 1) 2240 if ans is not None and result_sign == 1: 2241 ans = _dec_from_triple(1, ans._int, ans._exp) 2242 2243 # usual case: inexact result, x**y computed directly as exp(y*log(x)) 2244 if ans is None: 2245 p = context.prec 2246 x = _WorkRep(self) 2247 xc, xe = x.int, x.exp 2248 y = _WorkRep(other) 2249 yc, ye = y.int, y.exp 2250 if y.sign == 1: 2251 yc = -yc 2252 2253 # compute correctly rounded result: start with precision +3, 2254 # then increase precision until result is unambiguously roundable 2255 extra = 3 2256 while True: 2257 coeff, exp = _dpower(xc, xe, yc, ye, p+extra) 2258 if coeff % (5*10**(len(str(coeff))-p-1)): 2259 break 2260 extra += 3 2261 2262 ans = _dec_from_triple(result_sign, str(coeff), exp) 2263 2264 # the specification says that for non-integer other we need to 2265 # raise Inexact, even when the result is actually exact. In 2266 # the same way, we need to raise Underflow here if the result 2267 # is subnormal. (The call to _fix will take care of raising 2268 # Rounded and Subnormal, as usual.) 2269 if not other._isinteger(): 2270 context._raise_error(Inexact) 2271 # pad with zeros up to length context.prec+1 if necessary 2272 if len(ans._int) <= context.prec: 2273 expdiff = context.prec+1 - len(ans._int) 2274 ans = _dec_from_triple(ans._sign, ans._int+'0'*expdiff, 2275 ans._exp-expdiff) 2276 if ans.adjusted() < context.Emin: 2277 context._raise_error(Underflow) 2278 2279 # unlike exp, ln and log10, the power function respects the 2280 # rounding mode; no need to use ROUND_HALF_EVEN here 2281 ans = ans._fix(context) 2282 return ans 2283 2284 def __rpow__(self, other, context=None): 2285 """Swaps self/other and returns __pow__.""" 2286 other = _convert_other(other) 2287 if other is NotImplemented: 2288 return other 2289 return other.__pow__(self, context=context) 2290 2291 def normalize(self, context=None): 2292 """Normalize- strip trailing 0s, change anything equal to 0 to 0e0""" 2293 2294 if context is None: 2295 context = getcontext() 2296 2297 if self._is_special: 2298 ans = self._check_nans(context=context) 2299 if ans: 2300 return ans 2301 2302 dup = self._fix(context) 2303 if dup._isinfinity(): 2304 return dup 2305 2306 if not dup: 2307 return _dec_from_triple(dup._sign, '0', 0) 2308 exp_max = [context.Emax, context.Etop()][context._clamp] 2309 end = len(dup._int) 2310 exp = dup._exp 2311 while dup._int[end-1] == '0' and exp < exp_max: 2312 exp += 1 2313 end -= 1 2314 return _dec_from_triple(dup._sign, dup._int[:end], exp) 2315 2316 def quantize(self, exp, rounding=None, context=None, watchexp=True): 2317 """Quantize self so its exponent is the same as that of exp. 2318 2319 Similar to self._rescale(exp._exp) but with error checking. 2320 """ 2321 exp = _convert_other(exp, raiseit=True) 2322 2323 if context is None: 2324 context = getcontext() 2325 if rounding is None: 2326 rounding = context.rounding 2327 2328 if self._is_special or exp._is_special: 2329 ans = self._check_nans(exp, context) 2330 if ans: 2331 return ans 2332 2333 if exp._isinfinity() or self._isinfinity(): 2334 if exp._isinfinity() and self._isinfinity(): 2335 return Decimal(self) # if both are inf, it is OK 2336 return context._raise_error(InvalidOperation, 2337 'quantize with one INF') 2338 2339 # if we're not watching exponents, do a simple rescale 2340 if not watchexp: 2341 ans = self._rescale(exp._exp, rounding) 2342 # raise Inexact and Rounded where appropriate 2343 if ans._exp > self._exp: 2344 context._raise_error(Rounded) 2345 if ans != self: 2346 context._raise_error(Inexact) 2347 return ans 2348 2349 # exp._exp should be between Etiny and Emax 2350 if not (context.Etiny() <= exp._exp <= context.Emax): 2351 return context._raise_error(InvalidOperation, 2352 'target exponent out of bounds in quantize') 2353 2354 if not self: 2355 ans = _dec_from_triple(self._sign, '0', exp._exp) 2356 return ans._fix(context) 2357 2358 self_adjusted = self.adjusted() 2359 if self_adjusted > context.Emax: 2360 return context._raise_error(InvalidOperation, 2361 'exponent of quantize result too large for current context') 2362 if self_adjusted - exp._exp + 1 > context.prec: 2363 return context._raise_error(InvalidOperation, 2364 'quantize result has too many digits for current context') 2365 2366 ans = self._rescale(exp._exp, rounding) 2367 if ans.adjusted() > context.Emax: 2368 return context._raise_error(InvalidOperation, 2369 'exponent of quantize result too large for current context') 2370 if len(ans._int) > context.prec: 2371 return context._raise_error(InvalidOperation, 2372 'quantize result has too many digits for current context') 2373 2374 # raise appropriate flags 2375 if ans._exp > self._exp: 2376 context._raise_error(Rounded) 2377 if ans != self: 2378 context._raise_error(Inexact) 2379 if ans and ans.adjusted() < context.Emin: 2380 context._raise_error(Subnormal) 2381 2382 # call to fix takes care of any necessary folddown 2383 ans = ans._fix(context) 2384 return ans 2385 2386 def same_quantum(self, other): 2387 """Return True if self and other have the same exponent; otherwise 2388 return False. 2389 2390 If either operand is a special value, the following rules are used: 2391 * return True if both operands are infinities 2392 * return True if both operands are NaNs 2393 * otherwise, return False. 2394 """ 2395 other = _convert_other(other, raiseit=True) 2396 if self._is_special or other._is_special: 2397 return (self.is_nan() and other.is_nan() or 2398 self.is_infinite() and other.is_infinite()) 2399 return self._exp == other._exp 2400 2401 def _rescale(self, exp, rounding): 2402 """Rescale self so that the exponent is exp, either by padding with zeros 2403 or by truncating digits, using the given rounding mode. 2404 2405 Specials are returned without change. This operation is 2406 quiet: it raises no flags, and uses no information from the 2407 context. 2408 2409 exp = exp to scale to (an integer) 2410 rounding = rounding mode 2411 """ 2412 if self._is_special: 2413 return Decimal(self) 2414 if not self: 2415 return _dec_from_triple(self._sign, '0', exp) 2416 2417 if self._exp >= exp: 2418 # pad answer with zeros if necessary 2419 return _dec_from_triple(self._sign, 2420 self._int + '0'*(self._exp - exp), exp) 2421 2422 # too many digits; round and lose data. If self.adjusted() < 2423 # exp-1, replace self by 10**(exp-1) before rounding 2424 digits = len(self._int) + self._exp - exp 2425 if digits < 0: 2426 self = _dec_from_triple(self._sign, '1', exp-1) 2427 digits = 0 2428 this_function = getattr(self, self._pick_rounding_function[rounding]) 2429 changed = this_function(digits) 2430 coeff = self._int[:digits] or '0' 2431 if changed == 1: 2432 coeff = str(int(coeff)+1) 2433 return _dec_from_triple(self._sign, coeff, exp) 2434 2435 def _round(self, places, rounding): 2436 """Round a nonzero, nonspecial Decimal to a fixed number of 2437 significant figures, using the given rounding mode. 2438 2439 Infinities, NaNs and zeros are returned unaltered. 2440 2441 This operation is quiet: it raises no flags, and uses no 2442 information from the context. 2443 2444 """ 2445 if places <= 0: 2446 raise ValueError("argument should be at least 1 in _round") 2447 if self._is_special or not self: 2448 return Decimal(self) 2449 ans = self._rescale(self.adjusted()+1-places, rounding) 2450 # it can happen that the rescale alters the adjusted exponent; 2451 # for example when rounding 99.97 to 3 significant figures. 2452 # When this happens we end up with an extra 0 at the end of 2453 # the number; a second rescale fixes this. 2454 if ans.adjusted() != self.adjusted(): 2455 ans = ans._rescale(ans.adjusted()+1-places, rounding) 2456 return ans 2457 2458 def to_integral_exact(self, rounding=None, context=None): 2459 """Rounds to a nearby integer. 2460 2461 If no rounding mode is specified, take the rounding mode from 2462 the context. This method raises the Rounded and Inexact flags 2463 when appropriate. 2464 2465 See also: to_integral_value, which does exactly the same as 2466 this method except that it doesn't raise Inexact or Rounded. 2467 """ 2468 if self._is_special: 2469 ans = self._check_nans(context=context) 2470 if ans: 2471 return ans 2472 return Decimal(self) 2473 if self._exp >= 0: 2474 return Decimal(self) 2475 if not self: 2476 return _dec_from_triple(self._sign, '0', 0) 2477 if context is None: 2478 context = getcontext() 2479 if rounding is None: 2480 rounding = context.rounding 2481 context._raise_error(Rounded) 2482 ans = self._rescale(0, rounding) 2483 if ans != self: 2484 context._raise_error(Inexact) 2485 return ans 2486 2487 def to_integral_value(self, rounding=None, context=None): 2488 """Rounds to the nearest integer, without raising inexact, rounded.""" 2489 if context is None: 2490 context = getcontext() 2491 if rounding is None: 2492 rounding = context.rounding 2493 if self._is_special: 2494 ans = self._check_nans(context=context) 2495 if ans: 2496 return ans 2497 return Decimal(self) 2498 if self._exp >= 0: 2499 return Decimal(self) 2500 else: 2501 return self._rescale(0, rounding) 2502 2503 # the method name changed, but we provide also the old one, for compatibility 2504 to_integral = to_integral_value 2505 2506 def sqrt(self, context=None): 2507 """Return the square root of self.""" 2508 if context is None: 2509 context = getcontext() 2510 2511 if self._is_special: 2512 ans = self._check_nans(context=context) 2513 if ans: 2514 return ans 2515 2516 if self._isinfinity() and self._sign == 0: 2517 return Decimal(self) 2518 2519 if not self: 2520 # exponent = self._exp // 2. sqrt(-0) = -0 2521 ans = _dec_from_triple(self._sign, '0', self._exp // 2) 2522 return ans._fix(context) 2523 2524 if self._sign == 1: 2525 return context._raise_error(InvalidOperation, 'sqrt(-x), x > 0') 2526 2527 # At this point self represents a positive number. Let p be 2528 # the desired precision and express self in the form c*100**e 2529 # with c a positive real number and e an integer, c and e 2530 # being chosen so that 100**(p-1) <= c < 100**p. Then the 2531 # (exact) square root of self is sqrt(c)*10**e, and 10**(p-1) 2532 # <= sqrt(c) < 10**p, so the closest representable Decimal at 2533 # precision p is n*10**e where n = round_half_even(sqrt(c)), 2534 # the closest integer to sqrt(c) with the even integer chosen 2535 # in the case of a tie. 2536 # 2537 # To ensure correct rounding in all cases, we use the 2538 # following trick: we compute the square root to an extra 2539 # place (precision p+1 instead of precision p), rounding down. 2540 # Then, if the result is inexact and its last digit is 0 or 5, 2541 # we increase the last digit to 1 or 6 respectively; if it's 2542 # exact we leave the last digit alone. Now the final round to 2543 # p places (or fewer in the case of underflow) will round 2544 # correctly and raise the appropriate flags. 2545 2546 # use an extra digit of precision 2547 prec = context.prec+1 2548 2549 # write argument in the form c*100**e where e = self._exp//2 2550 # is the 'ideal' exponent, to be used if the square root is 2551 # exactly representable. l is the number of 'digits' of c in 2552 # base 100, so that 100**(l-1) <= c < 100**l. 2553 op = _WorkRep(self) 2554 e = op.exp >> 1 2555 if op.exp & 1: 2556 c = op.int * 10 2557 l = (len(self._int) >> 1) + 1 2558 else: 2559 c = op.int 2560 l = len(self._int)+1 >> 1 2561 2562 # rescale so that c has exactly prec base 100 'digits' 2563 shift = prec-l 2564 if shift >= 0: 2565 c *= 100**shift 2566 exact = True 2567 else: 2568 c, remainder = divmod(c, 100**-shift) 2569 exact = not remainder 2570 e -= shift 2571 2572 # find n = floor(sqrt(c)) using Newton's method 2573 n = 10**prec 2574 while True: 2575 q = c//n 2576 if n <= q: 2577 break 2578 else: 2579 n = n + q >> 1 2580 exact = exact and n*n == c 2581 2582 if exact: 2583 # result is exact; rescale to use ideal exponent e 2584 if shift >= 0: 2585 # assert n % 10**shift == 0 2586 n //= 10**shift 2587 else: 2588 n *= 10**-shift 2589 e += shift 2590 else: 2591 # result is not exact; fix last digit as described above 2592 if n % 5 == 0: 2593 n += 1 2594 2595 ans = _dec_from_triple(0, str(n), e) 2596 2597 # round, and fit to current context 2598 context = context._shallow_copy() 2599 rounding = context._set_rounding(ROUND_HALF_EVEN) 2600 ans = ans._fix(context) 2601 context.rounding = rounding 2602 2603 return ans 2604 2605 def max(self, other, context=None): 2606 """Returns the larger value. 2607 2608 Like max(self, other) except if one is not a number, returns 2609 NaN (and signals if one is sNaN). Also rounds. 2610 """ 2611 other = _convert_other(other, raiseit=True) 2612 2613 if context is None: 2614 context = getcontext() 2615 2616 if self._is_special or other._is_special: 2617 # If one operand is a quiet NaN and the other is number, then the 2618 # number is always returned 2619 sn = self._isnan() 2620 on = other._isnan() 2621 if sn or on: 2622 if on == 1 and sn == 0: 2623 return self._fix(context) 2624 if sn == 1 and on == 0: 2625 return other._fix(context) 2626 return self._check_nans(other, context) 2627 2628 c = self._cmp(other) 2629 if c == 0: 2630 # If both operands are finite and equal in numerical value 2631 # then an ordering is applied: 2632 # 2633 # If the signs differ then max returns the operand with the 2634 # positive sign and min returns the operand with the negative sign 2635 # 2636 # If the signs are the same then the exponent is used to select 2637 # the result. This is exactly the ordering used in compare_total. 2638 c = self.compare_total(other) 2639 2640 if c == -1: 2641 ans = other 2642 else: 2643 ans = self 2644 2645 return ans._fix(context) 2646 2647 def min(self, other, context=None): 2648 """Returns the smaller value. 2649 2650 Like min(self, other) except if one is not a number, returns 2651 NaN (and signals if one is sNaN). Also rounds. 2652 """ 2653 other = _convert_other(other, raiseit=True) 2654 2655 if context is None: 2656 context = getcontext() 2657 2658 if self._is_special or other._is_special: 2659 # If one operand is a quiet NaN and the other is number, then the 2660 # number is always returned 2661 sn = self._isnan() 2662 on = other._isnan() 2663 if sn or on: 2664 if on == 1 and sn == 0: 2665 return self._fix(context) 2666 if sn == 1 and on == 0: 2667 return other._fix(context) 2668 return self._check_nans(other, context) 2669 2670 c = self._cmp(other) 2671 if c == 0: 2672 c = self.compare_total(other) 2673 2674 if c == -1: 2675 ans = self 2676 else: 2677 ans = other 2678 2679 return ans._fix(context) 2680 2681 def _isinteger(self): 2682 """Returns whether self is an integer""" 2683 if self._is_special: 2684 return False 2685 if self._exp >= 0: 2686 return True 2687 rest = self._int[self._exp:] 2688 return rest == '0'*len(rest) 2689 2690 def _iseven(self): 2691 """Returns True if self is even. Assumes self is an integer.""" 2692 if not self or self._exp > 0: 2693 return True 2694 return self._int[-1+self._exp] in '02468' 2695 2696 def adjusted(self): 2697 """Return the adjusted exponent of self""" 2698 try: 2699 return self._exp + len(self._int) - 1 2700 # If NaN or Infinity, self._exp is string 2701 except TypeError: 2702 return 0 2703 2704 def canonical(self, context=None): 2705 """Returns the same Decimal object. 2706 2707 As we do not have different encodings for the same number, the 2708 received object already is in its canonical form. 2709 """ 2710 return self 2711 2712 def compare_signal(self, other, context=None): 2713 """Compares self to the other operand numerically. 2714 2715 It's pretty much like compare(), but all NaNs signal, with signaling 2716 NaNs taking precedence over quiet NaNs. 2717 """ 2718 other = _convert_other(other, raiseit = True) 2719 ans = self._compare_check_nans(other, context) 2720 if ans: 2721 return ans 2722 return self.compare(other, context=context) 2723 2724 def compare_total(self, other): 2725 """Compares self to other using the abstract representations. 2726 2727 This is not like the standard compare, which use their numerical 2728 value. Note that a total ordering is defined for all possible abstract 2729 representations. 2730 """ 2731 # if one is negative and the other is positive, it's easy 2732 if self._sign and not other._sign: 2733 return _NegativeOne 2734 if not self._sign and other._sign: 2735 return _One 2736 sign = self._sign 2737 2738 # let's handle both NaN types 2739 self_nan = self._isnan() 2740 other_nan = other._isnan() 2741 if self_nan or other_nan: 2742 if self_nan == other_nan: 2743 if self._int < other._int: 2744 if sign: 2745 return _One 2746 else: 2747 return _NegativeOne 2748 if self._int > other._int: 2749 if sign: 2750 return _NegativeOne 2751 else: 2752 return _One 2753 return _Zero 2754 2755 if sign: 2756 if self_nan == 1: 2757 return _NegativeOne 2758 if other_nan == 1: 2759 return _One 2760 if self_nan == 2: 2761 return _NegativeOne 2762 if other_nan == 2: 2763 return _One 2764 else: 2765 if self_nan == 1: 2766 return _One 2767 if other_nan == 1: 2768 return _NegativeOne 2769 if self_nan == 2: 2770 return _One 2771 if other_nan == 2: 2772 return _NegativeOne 2773 2774 if self < other: 2775 return _NegativeOne 2776 if self > other: 2777 return _One 2778 2779 if self._exp < other._exp: 2780 if sign: 2781 return _One 2782 else: 2783 return _NegativeOne 2784 if self._exp > other._exp: 2785 if sign: 2786 return _NegativeOne 2787 else: 2788 return _One 2789 return _Zero 2790 2791 2792 def compare_total_mag(self, other): 2793 """Compares self to other using abstract repr., ignoring sign. 2794 2795 Like compare_total, but with operand's sign ignored and assumed to be 0. 2796 """ 2797 s = self.copy_abs() 2798 o = other.copy_abs() 2799 return s.compare_total(o) 2800 2801 def copy_abs(self): 2802 """Returns a copy with the sign set to 0. """ 2803 return _dec_from_triple(0, self._int, self._exp, self._is_special) 2804 2805 def copy_negate(self): 2806 """Returns a copy with the sign inverted.""" 2807 if self._sign: 2808 return _dec_from_triple(0, self._int, self._exp, self._is_special) 2809 else: 2810 return _dec_from_triple(1, self._int, self._exp, self._is_special) 2811 2812 def copy_sign(self, other): 2813 """Returns self with the sign of other.""" 2814 return _dec_from_triple(other._sign, self._int, 2815 self._exp, self._is_special) 2816 2817 def exp(self, context=None): 2818 """Returns e ** self.""" 2819 2820 if context is None: 2821 context = getcontext() 2822 2823 # exp(NaN) = NaN 2824 ans = self._check_nans(context=context) 2825 if ans: 2826 return ans 2827 2828 # exp(-Infinity) = 0 2829 if self._isinfinity() == -1: 2830 return _Zero 2831 2832 # exp(0) = 1 2833 if not self: 2834 return _One 2835 2836 # exp(Infinity) = Infinity 2837 if self._isinfinity() == 1: 2838 return Decimal(self) 2839 2840 # the result is now guaranteed to be inexact (the true 2841 # mathematical result is transcendental). There's no need to 2842 # raise Rounded and Inexact here---they'll always be raised as 2843 # a result of the call to _fix. 2844 p = context.prec 2845 adj = self.adjusted() 2846 2847 # we only need to do any computation for quite a small range 2848 # of adjusted exponents---for example, -29 <= adj <= 10 for 2849 # the default context. For smaller exponent the result is 2850 # indistinguishable from 1 at the given precision, while for 2851 # larger exponent the result either overflows or underflows. 2852 if self._sign == 0 and adj > len(str((context.Emax+1)*3)): 2853 # overflow 2854 ans = _dec_from_triple(0, '1', context.Emax+1) 2855 elif self._sign == 1 and adj > len(str((-context.Etiny()+1)*3)): 2856 # underflow to 0 2857 ans = _dec_from_triple(0, '1', context.Etiny()-1) 2858 elif self._sign == 0 and adj < -p: 2859 # p+1 digits; final round will raise correct flags 2860 ans = _dec_from_triple(0, '1' + '0'*(p-1) + '1', -p) 2861 elif self._sign == 1 and adj < -p-1: 2862 # p+1 digits; final round will raise correct flags 2863 ans = _dec_from_triple(0, '9'*(p+1), -p-1) 2864 # general case 2865 else: 2866 op = _WorkRep(self) 2867 c, e = op.int, op.exp 2868 if op.sign == 1: 2869 c = -c 2870 2871 # compute correctly rounded result: increase precision by 2872 # 3 digits at a time until we get an unambiguously 2873 # roundable result 2874 extra = 3 2875 while True: 2876 coeff, exp = _dexp(c, e, p+extra) 2877 if coeff % (5*10**(len(str(coeff))-p-1)): 2878 break 2879 extra += 3 2880 2881 ans = _dec_from_triple(0, str(coeff), exp) 2882 2883 # at this stage, ans should round correctly with *any* 2884 # rounding mode, not just with ROUND_HALF_EVEN 2885 context = context._shallow_copy() 2886 rounding = context._set_rounding(ROUND_HALF_EVEN) 2887 ans = ans._fix(context) 2888 context.rounding = rounding 2889 2890 return ans 2891 2892 def is_canonical(self): 2893 """Return True if self is canonical; otherwise return False. 2894 2895 Currently, the encoding of a Decimal instance is always 2896 canonical, so this method returns True for any Decimal. 2897 """ 2898 return True 2899 2900 def is_finite(self): 2901 """Return True if self is finite; otherwise return False. 2902 2903 A Decimal instance is considered finite if it is neither 2904 infinite nor a NaN. 2905 """ 2906 return not self._is_special 2907 2908 def is_infinite(self): 2909 """Return True if self is infinite; otherwise return False.""" 2910 return self._exp == 'F' 2911 2912 def is_nan(self): 2913 """Return True if self is a qNaN or sNaN; otherwise return False.""" 2914 return self._exp in ('n', 'N') 2915 2916 def is_normal(self, context=None): 2917 """Return True if self is a normal number; otherwise return False.""" 2918 if self._is_special or not self: 2919 return False 2920 if context is None: 2921 context = getcontext() 2922 return context.Emin <= self.adjusted() <= context.Emax 2923 2924 def is_qnan(self): 2925 """Return True if self is a quiet NaN; otherwise return False.""" 2926 return self._exp == 'n' 2927 2928 def is_signed(self): 2929 """Return True if self is negative; otherwise return False.""" 2930 return self._sign == 1 2931 2932 def is_snan(self): 2933 """Return True if self is a signaling NaN; otherwise return False.""" 2934 return self._exp == 'N' 2935 2936 def is_subnormal(self, context=None): 2937 """Return True if self is subnormal; otherwise return False.""" 2938 if self._is_special or not self: 2939 return False 2940 if context is None: 2941 context = getcontext() 2942 return self.adjusted() < context.Emin 2943 2944 def is_zero(self): 2945 """Return True if self is a zero; otherwise return False.""" 2946 return not self._is_special and self._int == '0' 2947 2948 def _ln_exp_bound(self): 2949 """Compute a lower bound for the adjusted exponent of self.ln(). 2950 In other words, compute r such that self.ln() >= 10**r. Assumes 2951 that self is finite and positive and that self != 1. 2952 """ 2953 2954 # for 0.1 <= x <= 10 we use the inequalities 1-1/x <= ln(x) <= x-1 2955 adj = self._exp + len(self._int) - 1 2956 if adj >= 1: 2957 # argument >= 10; we use 23/10 = 2.3 as a lower bound for ln(10) 2958 return len(str(adj*23//10)) - 1 2959 if adj <= -2: 2960 # argument <= 0.1 2961 return len(str((-1-adj)*23//10)) - 1 2962 op = _WorkRep(self) 2963 c, e = op.int, op.exp 2964 if adj == 0: 2965 # 1 < self < 10 2966 num = str(c-10**-e) 2967 den = str(c) 2968 return len(num) - len(den) - (num < den) 2969 # adj == -1, 0.1 <= self < 1 2970 return e + len(str(10**-e - c)) - 1 2971 2972 2973 def ln(self, context=None): 2974 """Returns the natural (base e) logarithm of self.""" 2975 2976 if context is None: 2977 context = getcontext() 2978 2979 # ln(NaN) = NaN 2980 ans = self._check_nans(context=context) 2981 if ans: 2982 return ans 2983 2984 # ln(0.0) == -Infinity 2985 if not self: 2986 return _NegativeInfinity 2987 2988 # ln(Infinity) = Infinity 2989 if self._isinfinity() == 1: 2990 return _Infinity 2991 2992 # ln(1.0) == 0.0 2993 if self == _One: 2994 return _Zero 2995 2996 # ln(negative) raises InvalidOperation 2997 if self._sign == 1: 2998 return context._raise_error(InvalidOperation, 2999 'ln of a negative value') 3000 3001 # result is irrational, so necessarily inexact 3002 op = _WorkRep(self) 3003 c, e = op.int, op.exp 3004 p = context.prec 3005 3006 # correctly rounded result: repeatedly increase precision by 3 3007 # until we get an unambiguously roundable result 3008 places = p - self._ln_exp_bound() + 2 # at least p+3 places 3009 while True: 3010 coeff = _dlog(c, e, places) 3011 # assert len(str(abs(coeff)))-p >= 1 3012 if coeff % (5*10**(len(str(abs(coeff)))-p-1)): 3013 break 3014 places += 3 3015 ans = _dec_from_triple(int(coeff<0), str(abs(coeff)), -places) 3016 3017 context = context._shallow_copy() 3018 rounding = context._set_rounding(ROUND_HALF_EVEN) 3019 ans = ans._fix(context) 3020 context.rounding = rounding 3021 return ans 3022 3023 def _log10_exp_bound(self): 3024 """Compute a lower bound for the adjusted exponent of self.log10(). 3025 In other words, find r such that self.log10() >= 10**r. 3026 Assumes that self is finite and positive and that self != 1. 3027 """ 3028 3029 # For x >= 10 or x < 0.1 we only need a bound on the integer 3030 # part of log10(self), and this comes directly from the 3031 # exponent of x. For 0.1 <= x <= 10 we use the inequalities 3032 # 1-1/x <= log(x) <= x-1. If x > 1 we have |log10(x)| > 3033 # (1-1/x)/2.31 > 0. If x < 1 then |log10(x)| > (1-x)/2.31 > 0 3034 3035 adj = self._exp + len(self._int) - 1 3036 if adj >= 1: 3037 # self >= 10 3038 return len(str(adj))-1 3039 if adj <= -2: 3040 # self < 0.1 3041 return len(str(-1-adj))-1 3042 op = _WorkRep(self) 3043 c, e = op.int, op.exp 3044 if adj == 0: 3045 # 1 < self < 10 3046 num = str(c-10**-e) 3047 den = str(231*c) 3048 return len(num) - len(den) - (num < den) + 2 3049 # adj == -1, 0.1 <= self < 1 3050 num = str(10**-e-c) 3051 return len(num) + e - (num < "231") - 1 3052 3053 def log10(self, context=None): 3054 """Returns the base 10 logarithm of self.""" 3055 3056 if context is None: 3057 context = getcontext() 3058 3059 # log10(NaN) = NaN 3060 ans = self._check_nans(context=context) 3061 if ans: 3062 return ans 3063 3064 # log10(0.0) == -Infinity 3065 if not self: 3066 return _NegativeInfinity 3067 3068 # log10(Infinity) = Infinity 3069 if self._isinfinity() == 1: 3070 return _Infinity 3071 3072 # log10(negative or -Infinity) raises InvalidOperation 3073 if self._sign == 1: 3074 return context._raise_error(InvalidOperation, 3075 'log10 of a negative value') 3076 3077 # log10(10**n) = n 3078 if self._int[0] == '1' and self._int[1:] == '0'*(len(self._int) - 1): 3079 # answer may need rounding 3080 ans = Decimal(self._exp + len(self._int) - 1) 3081 else: 3082 # result is irrational, so necessarily inexact 3083 op = _WorkRep(self) 3084 c, e = op.int, op.exp 3085 p = context.prec 3086 3087 # correctly rounded result: repeatedly increase precision 3088 # until result is unambiguously roundable 3089 places = p-self._log10_exp_bound()+2 3090 while True: 3091 coeff = _dlog10(c, e, places) 3092 # assert len(str(abs(coeff)))-p >= 1 3093 if coeff % (5*10**(len(str(abs(coeff)))-p-1)): 3094 break 3095 places += 3 3096 ans = _dec_from_triple(int(coeff<0), str(abs(coeff)), -places) 3097 3098 context = context._shallow_copy() 3099 rounding = context._set_rounding(ROUND_HALF_EVEN) 3100 ans = ans._fix(context) 3101 context.rounding = rounding 3102 return ans 3103 3104 def logb(self, context=None): 3105 """ Returns the exponent of the magnitude of self's MSD. 3106 3107 The result is the integer which is the exponent of the magnitude 3108 of the most significant digit of self (as though it were truncated 3109 to a single digit while maintaining the value of that digit and 3110 without limiting the resulting exponent). 3111 """ 3112 # logb(NaN) = NaN 3113 ans = self._check_nans(context=context) 3114 if ans: 3115 return ans 3116 3117 if context is None: 3118 context = getcontext() 3119 3120 # logb(+/-Inf) = +Inf 3121 if self._isinfinity(): 3122 return _Infinity 3123 3124 # logb(0) = -Inf, DivisionByZero 3125 if not self: 3126 return context._raise_error(DivisionByZero, 'logb(0)', 1) 3127 3128 # otherwise, simply return the adjusted exponent of self, as a 3129 # Decimal. Note that no attempt is made to fit the result 3130 # into the current context. 3131 return Decimal(self.adjusted()) 3132 3133 def _islogical(self): 3134 """Return True if self is a logical operand. 3135 3136 For being logical, it must be a finite number with a sign of 0, 3137 an exponent of 0, and a coefficient whose digits must all be 3138 either 0 or 1. 3139 """ 3140 if self._sign != 0 or self._exp != 0: 3141 return False 3142 for dig in self._int: 3143 if dig not in '01': 3144 return False 3145 return True 3146 3147 def _fill_logical(self, context, opa, opb): 3148 dif = context.prec - len(opa) 3149 if dif > 0: 3150 opa = '0'*dif + opa 3151 elif dif < 0: 3152 opa = opa[-context.prec:] 3153 dif = context.prec - len(opb) 3154 if dif > 0: 3155 opb = '0'*dif + opb 3156 elif dif < 0: 3157 opb = opb[-context.prec:] 3158 return opa, opb 3159 3160 def logical_and(self, other, context=None): 3161 """Applies an 'and' operation between self and other's digits.""" 3162 if context is None: 3163 context = getcontext() 3164 if not self._islogical() or not other._islogical(): 3165 return context._raise_error(InvalidOperation) 3166 3167 # fill to context.prec 3168 (opa, opb) = self._fill_logical(context, self._int, other._int) 3169 3170 # make the operation, and clean starting zeroes 3171 result = "".join([str(int(a)&int(b)) for a,b in zip(opa,opb)]) 3172 return _dec_from_triple(0, result.lstrip('0') or '0', 0) 3173 3174 def logical_invert(self, context=None): 3175 """Invert all its digits.""" 3176 if context is None: 3177 context = getcontext() 3178 return self.logical_xor(_dec_from_triple(0,'1'*context.prec,0), 3179 context) 3180 3181 def logical_or(self, other, context=None): 3182 """Applies an 'or' operation between self and other's digits.""" 3183 if context is None: 3184 context = getcontext() 3185 if not self._islogical() or not other._islogical(): 3186 return context._raise_error(InvalidOperation) 3187 3188 # fill to context.prec 3189 (opa, opb) = self._fill_logical(context, self._int, other._int) 3190 3191 # make the operation, and clean starting zeroes 3192 result = "".join([str(int(a)|int(b)) for a,b in zip(opa,opb)]) 3193 return _dec_from_triple(0, result.lstrip('0') or '0', 0) 3194 3195 def logical_xor(self, other, context=None): 3196 """Applies an 'xor' operation between self and other's digits.""" 3197 if context is None: 3198 context = getcontext() 3199 if not self._islogical() or not other._islogical(): 3200 return context._raise_error(InvalidOperation) 3201 3202 # fill to context.prec 3203 (opa, opb) = self._fill_logical(context, self._int, other._int) 3204 3205 # make the operation, and clean starting zeroes 3206 result = "".join([str(int(a)^int(b)) for a,b in zip(opa,opb)]) 3207 return _dec_from_triple(0, result.lstrip('0') or '0', 0) 3208 3209 def max_mag(self, other, context=None): 3210 """Compares the values numerically with their sign ignored.""" 3211 other = _convert_other(other, raiseit=True) 3212 3213 if context is None: 3214 context = getcontext() 3215 3216 if self._is_special or other._is_special: 3217 # If one operand is a quiet NaN and the other is number, then the 3218 # number is always returned 3219 sn = self._isnan() 3220 on = other._isnan() 3221 if sn or on: 3222 if on == 1 and sn == 0: 3223 return self._fix(context) 3224 if sn == 1 and on == 0: 3225 return other._fix(context) 3226 return self._check_nans(other, context) 3227 3228 c = self.copy_abs()._cmp(other.copy_abs()) 3229 if c == 0: 3230 c = self.compare_total(other) 3231 3232 if c == -1: 3233 ans = other 3234 else: 3235 ans = self 3236 3237 return ans._fix(context) 3238 3239 def min_mag(self, other, context=None): 3240 """Compares the values numerically with their sign ignored.""" 3241 other = _convert_other(other, raiseit=True) 3242 3243 if context is None: 3244 context = getcontext() 3245 3246 if self._is_special or other._is_special: 3247 # If one operand is a quiet NaN and the other is number, then the 3248 # number is always returned 3249 sn = self._isnan() 3250 on = other._isnan() 3251 if sn or on: 3252 if on == 1 and sn == 0: 3253 return self._fix(context) 3254 if sn == 1 and on == 0: 3255 return other._fix(context) 3256 return self._check_nans(other, context) 3257 3258 c = self.copy_abs()._cmp(other.copy_abs()) 3259 if c == 0: 3260 c = self.compare_total(other) 3261 3262 if c == -1: 3263 ans = self 3264 else: 3265 ans = other 3266 3267 return ans._fix(context) 3268 3269 def next_minus(self, context=None): 3270 """Returns the largest representable number smaller than itself.""" 3271 if context is None: 3272 context = getcontext() 3273 3274 ans = self._check_nans(context=context) 3275 if ans: 3276 return ans 3277 3278 if self._isinfinity() == -1: 3279 return _NegativeInfinity 3280 if self._isinfinity() == 1: 3281 return _dec_from_triple(0, '9'*context.prec, context.Etop()) 3282 3283 context = context.copy() 3284 context._set_rounding(ROUND_FLOOR) 3285 context._ignore_all_flags() 3286 new_self = self._fix(context) 3287 if new_self != self: 3288 return new_self 3289 return self.__sub__(_dec_from_triple(0, '1', context.Etiny()-1), 3290 context) 3291 3292 def next_plus(self, context=None): 3293 """Returns the smallest representable number larger than itself.""" 3294 if context is None: 3295 context = getcontext() 3296 3297 ans = self._check_nans(context=context) 3298 if ans: 3299 return ans 3300 3301 if self._isinfinity() == 1: 3302 return _Infinity 3303 if self._isinfinity() == -1: 3304 return _dec_from_triple(1, '9'*context.prec, context.Etop()) 3305 3306 context = context.copy() 3307 context._set_rounding(ROUND_CEILING) 3308 context._ignore_all_flags() 3309 new_self = self._fix(context) 3310 if new_self != self: 3311 return new_self 3312 return self.__add__(_dec_from_triple(0, '1', context.Etiny()-1), 3313 context) 3314 3315 def next_toward(self, other, context=None): 3316 """Returns the number closest to self, in the direction towards other. 3317 3318 The result is the closest representable number to self 3319 (excluding self) that is in the direction towards other, 3320 unless both have the same value. If the two operands are 3321 numerically equal, then the result is a copy of self with the 3322 sign set to be the same as the sign of other. 3323 """ 3324 other = _convert_other(other, raiseit=True) 3325 3326 if context is None: 3327 context = getcontext() 3328 3329 ans = self._check_nans(other, context) 3330 if ans: 3331 return ans 3332 3333 comparison = self._cmp(other) 3334 if comparison == 0: 3335 return self.copy_sign(other) 3336 3337 if comparison == -1: 3338 ans = self.next_plus(context) 3339 else: # comparison == 1 3340 ans = self.next_minus(context) 3341 3342 # decide which flags to raise using value of ans 3343 if ans._isinfinity(): 3344 context._raise_error(Overflow, 3345 'Infinite result from next_toward', 3346 ans._sign) 3347 context._raise_error(Rounded) 3348 context._raise_error(Inexact) 3349 elif ans.adjusted() < context.Emin: 3350 context._raise_error(Underflow) 3351 context._raise_error(Subnormal) 3352 context._raise_error(Rounded) 3353 context._raise_error(Inexact) 3354 # if precision == 1 then we don't raise Clamped for a 3355 # result 0E-Etiny. 3356 if not ans: 3357 context._raise_error(Clamped) 3358 3359 return ans 3360 3361 def number_class(self, context=None): 3362 """Returns an indication of the class of self. 3363 3364 The class is one of the following strings: 3365 sNaN 3366 NaN 3367 -Infinity 3368 -Normal 3369 -Subnormal 3370 -Zero 3371 +Zero 3372 +Subnormal 3373 +Normal 3374 +Infinity 3375 """ 3376 if self.is_snan(): 3377 return "sNaN" 3378 if self.is_qnan(): 3379 return "NaN" 3380 inf = self._isinfinity() 3381 if inf == 1: 3382 return "+Infinity" 3383 if inf == -1: 3384 return "-Infinity" 3385 if self.is_zero(): 3386 if self._sign: 3387 return "-Zero" 3388 else: 3389 return "+Zero" 3390 if context is None: 3391 context = getcontext() 3392 if self.is_subnormal(context=context): 3393 if self._sign: 3394 return "-Subnormal" 3395 else: 3396 return "+Subnormal" 3397 # just a normal, regular, boring number, :) 3398 if self._sign: 3399 return "-Normal" 3400 else: 3401 return "+Normal" 3402 3403 def radix(self): 3404 """Just returns 10, as this is Decimal, :)""" 3405 return Decimal(10) 3406 3407 def rotate(self, other, context=None): 3408 """Returns a rotated copy of self, value-of-other times.""" 3409 if context is None: 3410 context = getcontext() 3411 3412 ans = self._check_nans(other, context) 3413 if ans: 3414 return ans 3415 3416 if other._exp != 0: 3417 return context._raise_error(InvalidOperation) 3418 if not (-context.prec <= int(other) <= context.prec): 3419 return context._raise_error(InvalidOperation) 3420 3421 if self._isinfinity(): 3422 return Decimal(self) 3423 3424 # get values, pad if necessary 3425 torot = int(other) 3426 rotdig = self._int 3427 topad = context.prec - len(rotdig) 3428 if topad: 3429 rotdig = '0'*topad + rotdig 3430 3431 # let's rotate! 3432 rotated = rotdig[torot:] + rotdig[:torot] 3433 return _dec_from_triple(self._sign, 3434 rotated.lstrip('0') or '0', self._exp) 3435 3436 def scaleb (self, other, context=None): 3437 """Returns self operand after adding the second value to its exp.""" 3438 if context is None: 3439 context = getcontext() 3440 3441 ans = self._check_nans(other, context) 3442 if ans: 3443 return ans 3444 3445 if other._exp != 0: 3446 return context._raise_error(InvalidOperation) 3447 liminf = -2 * (context.Emax + context.prec) 3448 limsup = 2 * (context.Emax + context.prec) 3449 if not (liminf <= int(other) <= limsup): 3450 return context._raise_error(InvalidOperation) 3451 3452 if self._isinfinity(): 3453 return Decimal(self) 3454 3455 d = _dec_from_triple(self._sign, self._int, self._exp + int(other)) 3456 d = d._fix(context) 3457 return d 3458 3459 def shift(self, other, context=None): 3460 """Returns a shifted copy of self, value-of-other times.""" 3461 if context is None: 3462 context = getcontext() 3463 3464 ans = self._check_nans(other, context) 3465 if ans: 3466 return ans 3467 3468 if other._exp != 0: 3469 return context._raise_error(InvalidOperation) 3470 if not (-context.prec <= int(other) <= context.prec): 3471 return context._raise_error(InvalidOperation) 3472 3473 if self._isinfinity(): 3474 return Decimal(self) 3475 3476 # get values, pad if necessary 3477 torot = int(other) 3478 if not torot: 3479 return Decimal(self) 3480 rotdig = self._int 3481 topad = context.prec - len(rotdig) 3482 if topad: 3483 rotdig = '0'*topad + rotdig 3484 3485 # let's shift! 3486 if torot < 0: 3487 rotated = rotdig[:torot] 3488 else: 3489 rotated = rotdig + '0'*torot 3490 rotated = rotated[-context.prec:] 3491 3492 return _dec_from_triple(self._sign, 3493 rotated.lstrip('0') or '0', self._exp) 3494 3495 # Support for pickling, copy, and deepcopy 3496 def __reduce__(self): 3497 return (self.__class__, (str(self),)) 3498 3499 def __copy__(self): 3500 if type(self) == Decimal: 3501 return self # I'm immutable; therefore I am my own clone 3502 return self.__class__(str(self)) 3503 3504 def __deepcopy__(self, memo): 3505 if type(self) == Decimal: 3506 return self # My components are also immutable 3507 return self.__class__(str(self)) 3508 3509 # PEP 3101 support. See also _parse_format_specifier and _format_align 3510 def __format__(self, specifier, context=None): 3511 """Format a Decimal instance according to the given specifier. 3512 3513 The specifier should be a standard format specifier, with the 3514 form described in PEP 3101. Formatting types 'e', 'E', 'f', 3515 'F', 'g', 'G', and '%' are supported. If the formatting type 3516 is omitted it defaults to 'g' or 'G', depending on the value 3517 of context.capitals. 3518 3519 At this time the 'n' format specifier type (which is supposed 3520 to use the current locale) is not supported. 3521 """ 3522 3523 # Note: PEP 3101 says that if the type is not present then 3524 # there should be at least one digit after the decimal point. 3525 # We take the liberty of ignoring this requirement for 3526 # Decimal---it's presumably there to make sure that 3527 # format(float, '') behaves similarly to str(float). 3528 if context is None: 3529 context = getcontext() 3530 3531 spec = _parse_format_specifier(specifier) 3532 3533 # special values don't care about the type or precision... 3534 if self._is_special: 3535 return _format_align(str(self), spec) 3536 3537 # a type of None defaults to 'g' or 'G', depending on context 3538 # if type is '%', adjust exponent of self accordingly 3539 if spec['type'] is None: 3540 spec['type'] = ['g', 'G'][context.capitals] 3541 elif spec['type'] == '%': 3542 self = _dec_from_triple(self._sign, self._int, self._exp+2) 3543 3544 # round if necessary, taking rounding mode from the context 3545 rounding = context.rounding 3546 precision = spec['precision'] 3547 if precision is not None: 3548 if spec['type'] in 'eE': 3549 self = self._round(precision+1, rounding) 3550 elif spec['type'] in 'gG': 3551 if len(self._int) > precision: 3552 self = self._round(precision, rounding) 3553 elif spec['type'] in 'fF%': 3554 self = self._rescale(-precision, rounding) 3555 # special case: zeros with a positive exponent can't be 3556 # represented in fixed point; rescale them to 0e0. 3557 elif not self and self._exp > 0 and spec['type'] in 'fF%': 3558 self = self._rescale(0, rounding) 3559 3560 # figure out placement of the decimal point 3561 leftdigits = self._exp + len(self._int) 3562 if spec['type'] in 'fF%': 3563 dotplace = leftdigits 3564 elif spec['type'] in 'eE': 3565 if not self and precision is not None: 3566 dotplace = 1 - precision 3567 else: 3568 dotplace = 1 3569 elif spec['type'] in 'gG': 3570 if self._exp <= 0 and leftdigits > -6: 3571 dotplace = leftdigits 3572 else: 3573 dotplace = 1 3574 3575 # figure out main part of numeric string... 3576 if dotplace <= 0: 3577 num = '0.' + '0'*(-dotplace) + self._int 3578 elif dotplace >= len(self._int): 3579 # make sure we're not padding a '0' with extra zeros on the right 3580 assert dotplace==len(self._int) or self._int != '0' 3581 num = self._int + '0'*(dotplace-len(self._int)) 3582 else: 3583 num = self._int[:dotplace] + '.' + self._int[dotplace:] 3584 3585 # ...then the trailing exponent, or trailing '%' 3586 if leftdigits != dotplace or spec['type'] in 'eE': 3587 echar = {'E': 'E', 'e': 'e', 'G': 'E', 'g': 'e'}[spec['type']] 3588 num = num + "{0}{1:+}".format(echar, leftdigits-dotplace) 3589 elif spec['type'] == '%': 3590 num = num + '%' 3591 3592 # add sign 3593 if self._sign == 1: 3594 num = '-' + num 3595 return _format_align(num, spec) 3596 3597 3598def _dec_from_triple(sign, coefficient, exponent, special=False): 3599 """Create a decimal instance directly, without any validation, 3600 normalization (e.g. removal of leading zeros) or argument 3601 conversion. 3602 3603 This function is for *internal use only*. 3604 """ 3605 3606 self = object.__new__(Decimal) 3607 self._sign = sign 3608 self._int = coefficient 3609 self._exp = exponent 3610 self._is_special = special 3611 3612 return self 3613 3614# Register Decimal as a kind of Number (an abstract base class). 3615# However, do not register it as Real (because Decimals are not 3616# interoperable with floats). 3617_numbers.Number.register(Decimal) 3618 3619 3620##### Context class ####################################################### 3621 3622 3623# get rounding method function: 3624rounding_functions = [name for name in Decimal.__dict__.keys() 3625 if name.startswith('_round_')] 3626for name in rounding_functions: 3627 # name is like _round_half_even, goes to the global ROUND_HALF_EVEN value. 3628 globalname = name[1:].upper() 3629 val = globals()[globalname] 3630 Decimal._pick_rounding_function[val] = name 3631 3632del name, val, globalname, rounding_functions 3633 3634class _ContextManager(object): 3635 """Context manager class to support localcontext(). 3636 3637 Sets a copy of the supplied context in __enter__() and restores 3638 the previous decimal context in __exit__() 3639 """ 3640 def __init__(self, new_context): 3641 self.new_context = new_context.copy() 3642 def __enter__(self): 3643 self.saved_context = getcontext() 3644 setcontext(self.new_context) 3645 return self.new_context 3646 def __exit__(self, t, v, tb): 3647 setcontext(self.saved_context) 3648 3649class Context(object): 3650 """Contains the context for a Decimal instance. 3651 3652 Contains: 3653 prec - precision (for use in rounding, division, square roots..) 3654 rounding - rounding type (how you round) 3655 traps - If traps[exception] = 1, then the exception is 3656 raised when it is caused. Otherwise, a value is 3657 substituted in. 3658 flags - When an exception is caused, flags[exception] is set. 3659 (Whether or not the trap_enabler is set) 3660 Should be reset by user of Decimal instance. 3661 Emin - Minimum exponent 3662 Emax - Maximum exponent 3663 capitals - If 1, 1*10^1 is printed as 1E+1. 3664 If 0, printed as 1e1 3665 _clamp - If 1, change exponents if too high (Default 0) 3666 """ 3667 3668 def __init__(self, prec=None, rounding=None, 3669 traps=None, flags=None, 3670 Emin=None, Emax=None, 3671 capitals=None, _clamp=0, 3672 _ignored_flags=None): 3673 if flags is None: 3674 flags = [] 3675 if _ignored_flags is None: 3676 _ignored_flags = [] 3677 if not isinstance(flags, dict): 3678 flags = dict([(s, int(s in flags)) for s in _signals]) 3679 del s 3680 if traps is not None and not isinstance(traps, dict): 3681 traps = dict([(s, int(s in traps)) for s in _signals]) 3682 del s 3683 for name, val in locals().items(): 3684 if val is None: 3685 setattr(self, name, _copy.copy(getattr(DefaultContext, name))) 3686 else: 3687 setattr(self, name, val) 3688 del self.self 3689 3690 def __repr__(self): 3691 """Show the current context.""" 3692 s = [] 3693 s.append('Context(prec=%(prec)d, rounding=%(rounding)s, ' 3694 'Emin=%(Emin)d, Emax=%(Emax)d, capitals=%(capitals)d' 3695 % vars(self)) 3696 names = [f.__name__ for f, v in self.flags.items() if v] 3697 s.append('flags=[' + ', '.join(names) + ']') 3698 names = [t.__name__ for t, v in self.traps.items() if v] 3699 s.append('traps=[' + ', '.join(names) + ']') 3700 return ', '.join(s) + ')' 3701 3702 def clear_flags(self): 3703 """Reset all flags to zero""" 3704 for flag in self.flags: 3705 self.flags[flag] = 0 3706 3707 def _shallow_copy(self): 3708 """Returns a shallow copy from self.""" 3709 nc = Context(self.prec, self.rounding, self.traps, 3710 self.flags, self.Emin, self.Emax, 3711 self.capitals, self._clamp, self._ignored_flags) 3712 return nc 3713 3714 def copy(self): 3715 """Returns a deep copy from self.""" 3716 nc = Context(self.prec, self.rounding, self.traps.copy(), 3717 self.flags.copy(), self.Emin, self.Emax, 3718 self.capitals, self._clamp, self._ignored_flags) 3719 return nc 3720 __copy__ = copy 3721 3722 def _raise_error(self, condition, explanation = None, *args): 3723 """Handles an error 3724 3725 If the flag is in _ignored_flags, returns the default response. 3726 Otherwise, it sets the flag, then, if the corresponding 3727 trap_enabler is set, it reaises the exception. Otherwise, it returns 3728 the default value after setting the flag. 3729 """ 3730 error = _condition_map.get(condition, condition) 3731 if error in self._ignored_flags: 3732 # Don't touch the flag 3733 return error().handle(self, *args) 3734 3735 self.flags[error] = 1 3736 if not self.traps[error]: 3737 # The errors define how to handle themselves. 3738 return condition().handle(self, *args) 3739 3740 # Errors should only be risked on copies of the context 3741 # self._ignored_flags = [] 3742 raise error(explanation) 3743 3744 def _ignore_all_flags(self): 3745 """Ignore all flags, if they are raised""" 3746 return self._ignore_flags(*_signals) 3747 3748 def _ignore_flags(self, *flags): 3749 """Ignore the flags, if they are raised""" 3750 # Do not mutate-- This way, copies of a context leave the original 3751 # alone. 3752 self._ignored_flags = (self._ignored_flags + list(flags)) 3753 return list(flags) 3754 3755 def _regard_flags(self, *flags): 3756 """Stop ignoring the flags, if they are raised""" 3757 if flags and isinstance(flags[0], (tuple,list)): 3758 flags = flags[0] 3759 for flag in flags: 3760 self._ignored_flags.remove(flag) 3761 3762 # We inherit object.__hash__, so we must deny this explicitly 3763 __hash__ = None 3764 3765 def Etiny(self): 3766 """Returns Etiny (= Emin - prec + 1)""" 3767 return int(self.Emin - self.prec + 1) 3768 3769 def Etop(self): 3770 """Returns maximum exponent (= Emax - prec + 1)""" 3771 return int(self.Emax - self.prec + 1) 3772 3773 def _set_rounding(self, type): 3774 """Sets the rounding type. 3775 3776 Sets the rounding type, and returns the current (previous) 3777 rounding type. Often used like: 3778 3779 context = context.copy() 3780 # so you don't change the calling context 3781 # if an error occurs in the middle. 3782 rounding = context._set_rounding(ROUND_UP) 3783 val = self.__sub__(other, context=context) 3784 context._set_rounding(rounding) 3785 3786 This will make it round up for that operation. 3787 """ 3788 rounding = self.rounding 3789 self.rounding= type 3790 return rounding 3791 3792 def create_decimal(self, num='0'): 3793 """Creates a new Decimal instance but using self as context. 3794 3795 This method implements the to-number operation of the 3796 IBM Decimal specification.""" 3797 3798 if isinstance(num, basestring) and num != num.strip(): 3799 return self._raise_error(ConversionSyntax, 3800 "no trailing or leading whitespace is " 3801 "permitted.") 3802 3803 d = Decimal(num, context=self) 3804 if d._isnan() and len(d._int) > self.prec - self._clamp: 3805 return self._raise_error(ConversionSyntax, 3806 "diagnostic info too long in NaN") 3807 return d._fix(self) 3808 3809 def create_decimal_from_float(self, f): 3810 """Creates a new Decimal instance from a float but rounding using self 3811 as the context. 3812 3813 >>> context = Context(prec=5, rounding=ROUND_DOWN) 3814 >>> context.create_decimal_from_float(3.1415926535897932) 3815 Decimal('3.1415') 3816 >>> context = Context(prec=5, traps=[Inexact]) 3817 >>> context.create_decimal_from_float(3.1415926535897932) 3818 Traceback (most recent call last): 3819 ... 3820 Inexact: None 3821 3822 """ 3823 d = Decimal.from_float(f) # An exact conversion 3824 return d._fix(self) # Apply the context rounding 3825 3826 # Methods 3827 def abs(self, a): 3828 """Returns the absolute value of the operand. 3829 3830 If the operand is negative, the result is the same as using the minus 3831 operation on the operand. Otherwise, the result is the same as using 3832 the plus operation on the operand. 3833 3834 >>> ExtendedContext.abs(Decimal('2.1')) 3835 Decimal('2.1') 3836 >>> ExtendedContext.abs(Decimal('-100')) 3837 Decimal('100') 3838 >>> ExtendedContext.abs(Decimal('101.5')) 3839 Decimal('101.5') 3840 >>> ExtendedContext.abs(Decimal('-101.5')) 3841 Decimal('101.5') 3842 """ 3843 return a.__abs__(context=self) 3844 3845 def add(self, a, b): 3846 """Return the sum of the two operands. 3847 3848 >>> ExtendedContext.add(Decimal('12'), Decimal('7.00')) 3849 Decimal('19.00') 3850 >>> ExtendedContext.add(Decimal('1E+2'), Decimal('1.01E+4')) 3851 Decimal('1.02E+4') 3852 """ 3853 return a.__add__(b, context=self) 3854 3855 def _apply(self, a): 3856 return str(a._fix(self)) 3857 3858 def canonical(self, a): 3859 """Returns the same Decimal object. 3860 3861 As we do not have different encodings for the same number, the 3862 received object already is in its canonical form. 3863 3864 >>> ExtendedContext.canonical(Decimal('2.50')) 3865 Decimal('2.50') 3866 """ 3867 return a.canonical(context=self) 3868 3869 def compare(self, a, b): 3870 """Compares values numerically. 3871 3872 If the signs of the operands differ, a value representing each operand 3873 ('-1' if the operand is less than zero, '0' if the operand is zero or 3874 negative zero, or '1' if the operand is greater than zero) is used in 3875 place of that operand for the comparison instead of the actual 3876 operand. 3877 3878 The comparison is then effected by subtracting the second operand from 3879 the first and then returning a value according to the result of the 3880 subtraction: '-1' if the result is less than zero, '0' if the result is 3881 zero or negative zero, or '1' if the result is greater than zero. 3882 3883 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('3')) 3884 Decimal('-1') 3885 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('2.1')) 3886 Decimal('0') 3887 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('2.10')) 3888 Decimal('0') 3889 >>> ExtendedContext.compare(Decimal('3'), Decimal('2.1')) 3890 Decimal('1') 3891 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('-3')) 3892 Decimal('1') 3893 >>> ExtendedContext.compare(Decimal('-3'), Decimal('2.1')) 3894 Decimal('-1') 3895 """ 3896 return a.compare(b, context=self) 3897 3898 def compare_signal(self, a, b): 3899 """Compares the values of the two operands numerically. 3900 3901 It's pretty much like compare(), but all NaNs signal, with signaling 3902 NaNs taking precedence over quiet NaNs. 3903 3904 >>> c = ExtendedContext 3905 >>> c.compare_signal(Decimal('2.1'), Decimal('3')) 3906 Decimal('-1') 3907 >>> c.compare_signal(Decimal('2.1'), Decimal('2.1')) 3908 Decimal('0') 3909 >>> c.flags[InvalidOperation] = 0 3910 >>> print c.flags[InvalidOperation] 3911 0 3912 >>> c.compare_signal(Decimal('NaN'), Decimal('2.1')) 3913 Decimal('NaN') 3914 >>> print c.flags[InvalidOperation] 3915 1 3916 >>> c.flags[InvalidOperation] = 0 3917 >>> print c.flags[InvalidOperation] 3918 0 3919 >>> c.compare_signal(Decimal('sNaN'), Decimal('2.1')) 3920 Decimal('NaN') 3921 >>> print c.flags[InvalidOperation] 3922 1 3923 """ 3924 return a.compare_signal(b, context=self) 3925 3926 def compare_total(self, a, b): 3927 """Compares two operands using their abstract representation. 3928 3929 This is not like the standard compare, which use their numerical 3930 value. Note that a total ordering is defined for all possible abstract 3931 representations. 3932 3933 >>> ExtendedContext.compare_total(Decimal('12.73'), Decimal('127.9')) 3934 Decimal('-1') 3935 >>> ExtendedContext.compare_total(Decimal('-127'), Decimal('12')) 3936 Decimal('-1') 3937 >>> ExtendedContext.compare_total(Decimal('12.30'), Decimal('12.3')) 3938 Decimal('-1') 3939 >>> ExtendedContext.compare_total(Decimal('12.30'), Decimal('12.30')) 3940 Decimal('0') 3941 >>> ExtendedContext.compare_total(Decimal('12.3'), Decimal('12.300')) 3942 Decimal('1') 3943 >>> ExtendedContext.compare_total(Decimal('12.3'), Decimal('NaN')) 3944 Decimal('-1') 3945 """ 3946 return a.compare_total(b) 3947 3948 def compare_total_mag(self, a, b): 3949 """Compares two operands using their abstract representation ignoring sign. 3950 3951 Like compare_total, but with operand's sign ignored and assumed to be 0. 3952 """ 3953 return a.compare_total_mag(b) 3954 3955 def copy_abs(self, a): 3956 """Returns a copy of the operand with the sign set to 0. 3957 3958 >>> ExtendedContext.copy_abs(Decimal('2.1')) 3959 Decimal('2.1') 3960 >>> ExtendedContext.copy_abs(Decimal('-100')) 3961 Decimal('100') 3962 """ 3963 return a.copy_abs() 3964 3965 def copy_decimal(self, a): 3966 """Returns a copy of the decimal objet. 3967 3968 >>> ExtendedContext.copy_decimal(Decimal('2.1')) 3969 Decimal('2.1') 3970 >>> ExtendedContext.copy_decimal(Decimal('-1.00')) 3971 Decimal('-1.00') 3972 """ 3973 return Decimal(a) 3974 3975 def copy_negate(self, a): 3976 """Returns a copy of the operand with the sign inverted. 3977 3978 >>> ExtendedContext.copy_negate(Decimal('101.5')) 3979 Decimal('-101.5') 3980 >>> ExtendedContext.copy_negate(Decimal('-101.5')) 3981 Decimal('101.5') 3982 """ 3983 return a.copy_negate() 3984 3985 def copy_sign(self, a, b): 3986 """Copies the second operand's sign to the first one. 3987 3988 In detail, it returns a copy of the first operand with the sign 3989 equal to the sign of the second operand. 3990 3991 >>> ExtendedContext.copy_sign(Decimal( '1.50'), Decimal('7.33')) 3992 Decimal('1.50') 3993 >>> ExtendedContext.copy_sign(Decimal('-1.50'), Decimal('7.33')) 3994 Decimal('1.50') 3995 >>> ExtendedContext.copy_sign(Decimal( '1.50'), Decimal('-7.33')) 3996 Decimal('-1.50') 3997 >>> ExtendedContext.copy_sign(Decimal('-1.50'), Decimal('-7.33')) 3998 Decimal('-1.50') 3999 """ 4000 return a.copy_sign(b) 4001 4002 def divide(self, a, b): 4003 """Decimal division in a specified context. 4004 4005 >>> ExtendedContext.divide(Decimal('1'), Decimal('3')) 4006 Decimal('0.333333333') 4007 >>> ExtendedContext.divide(Decimal('2'), Decimal('3')) 4008 Decimal('0.666666667') 4009 >>> ExtendedContext.divide(Decimal('5'), Decimal('2')) 4010 Decimal('2.5') 4011 >>> ExtendedContext.divide(Decimal('1'), Decimal('10')) 4012 Decimal('0.1') 4013 >>> ExtendedContext.divide(Decimal('12'), Decimal('12')) 4014 Decimal('1') 4015 >>> ExtendedContext.divide(Decimal('8.00'), Decimal('2')) 4016 Decimal('4.00') 4017 >>> ExtendedContext.divide(Decimal('2.400'), Decimal('2.0')) 4018 Decimal('1.20') 4019 >>> ExtendedContext.divide(Decimal('1000'), Decimal('100')) 4020 Decimal('10') 4021 >>> ExtendedContext.divide(Decimal('1000'), Decimal('1')) 4022 Decimal('1000') 4023 >>> ExtendedContext.divide(Decimal('2.40E+6'), Decimal('2')) 4024 Decimal('1.20E+6') 4025 """ 4026 return a.__div__(b, context=self) 4027 4028 def divide_int(self, a, b): 4029 """Divides two numbers and returns the integer part of the result. 4030 4031 >>> ExtendedContext.divide_int(Decimal('2'), Decimal('3')) 4032 Decimal('0') 4033 >>> ExtendedContext.divide_int(Decimal('10'), Decimal('3')) 4034 Decimal('3') 4035 >>> ExtendedContext.divide_int(Decimal('1'), Decimal('0.3')) 4036 Decimal('3') 4037 """ 4038 return a.__floordiv__(b, context=self) 4039 4040 def divmod(self, a, b): 4041 return a.__divmod__(b, context=self) 4042 4043 def exp(self, a): 4044 """Returns e ** a. 4045 4046 >>> c = ExtendedContext.copy() 4047 >>> c.Emin = -999 4048 >>> c.Emax = 999 4049 >>> c.exp(Decimal('-Infinity')) 4050 Decimal('0') 4051 >>> c.exp(Decimal('-1')) 4052 Decimal('0.367879441') 4053 >>> c.exp(Decimal('0')) 4054 Decimal('1') 4055 >>> c.exp(Decimal('1')) 4056 Decimal('2.71828183') 4057 >>> c.exp(Decimal('0.693147181')) 4058 Decimal('2.00000000') 4059 >>> c.exp(Decimal('+Infinity')) 4060 Decimal('Infinity') 4061 """ 4062 return a.exp(context=self) 4063 4064 def fma(self, a, b, c): 4065 """Returns a multiplied by b, plus c. 4066 4067 The first two operands are multiplied together, using multiply, 4068 the third operand is then added to the result of that 4069 multiplication, using add, all with only one final rounding. 4070 4071 >>> ExtendedContext.fma(Decimal('3'), Decimal('5'), Decimal('7')) 4072 Decimal('22') 4073 >>> ExtendedContext.fma(Decimal('3'), Decimal('-5'), Decimal('7')) 4074 Decimal('-8') 4075 >>> ExtendedContext.fma(Decimal('888565290'), Decimal('1557.96930'), Decimal('-86087.7578')) 4076 Decimal('1.38435736E+12') 4077 """ 4078 return a.fma(b, c, context=self) 4079 4080 def is_canonical(self, a): 4081 """Return True if the operand is canonical; otherwise return False. 4082 4083 Currently, the encoding of a Decimal instance is always 4084 canonical, so this method returns True for any Decimal. 4085 4086 >>> ExtendedContext.is_canonical(Decimal('2.50')) 4087 True 4088 """ 4089 return a.is_canonical() 4090 4091 def is_finite(self, a): 4092 """Return True if the operand is finite; otherwise return False. 4093 4094 A Decimal instance is considered finite if it is neither 4095 infinite nor a NaN. 4096 4097 >>> ExtendedContext.is_finite(Decimal('2.50')) 4098 True 4099 >>> ExtendedContext.is_finite(Decimal('-0.3')) 4100 True 4101 >>> ExtendedContext.is_finite(Decimal('0')) 4102 True 4103 >>> ExtendedContext.is_finite(Decimal('Inf')) 4104 False 4105 >>> ExtendedContext.is_finite(Decimal('NaN')) 4106 False 4107 """ 4108 return a.is_finite() 4109 4110 def is_infinite(self, a): 4111 """Return True if the operand is infinite; otherwise return False. 4112 4113 >>> ExtendedContext.is_infinite(Decimal('2.50')) 4114 False 4115 >>> ExtendedContext.is_infinite(Decimal('-Inf')) 4116 True 4117 >>> ExtendedContext.is_infinite(Decimal('NaN')) 4118 False 4119 """ 4120 return a.is_infinite() 4121 4122 def is_nan(self, a): 4123 """Return True if the operand is a qNaN or sNaN; 4124 otherwise return False. 4125 4126 >>> ExtendedContext.is_nan(Decimal('2.50')) 4127 False 4128 >>> ExtendedContext.is_nan(Decimal('NaN')) 4129 True 4130 >>> ExtendedContext.is_nan(Decimal('-sNaN')) 4131 True 4132 """ 4133 return a.is_nan() 4134 4135 def is_normal(self, a): 4136 """Return True if the operand is a normal number; 4137 otherwise return False. 4138 4139 >>> c = ExtendedContext.copy() 4140 >>> c.Emin = -999 4141 >>> c.Emax = 999 4142 >>> c.is_normal(Decimal('2.50')) 4143 True 4144 >>> c.is_normal(Decimal('0.1E-999')) 4145 False 4146 >>> c.is_normal(Decimal('0.00')) 4147 False 4148 >>> c.is_normal(Decimal('-Inf')) 4149 False 4150 >>> c.is_normal(Decimal('NaN')) 4151 False 4152 """ 4153 return a.is_normal(context=self) 4154 4155 def is_qnan(self, a): 4156 """Return True if the operand is a quiet NaN; otherwise return False. 4157 4158 >>> ExtendedContext.is_qnan(Decimal('2.50')) 4159 False 4160 >>> ExtendedContext.is_qnan(Decimal('NaN')) 4161 True 4162 >>> ExtendedContext.is_qnan(Decimal('sNaN')) 4163 False 4164 """ 4165 return a.is_qnan() 4166 4167 def is_signed(self, a): 4168 """Return True if the operand is negative; otherwise return False. 4169 4170 >>> ExtendedContext.is_signed(Decimal('2.50')) 4171 False 4172 >>> ExtendedContext.is_signed(Decimal('-12')) 4173 True 4174 >>> ExtendedContext.is_signed(Decimal('-0')) 4175 True 4176 """ 4177 return a.is_signed() 4178 4179 def is_snan(self, a): 4180 """Return True if the operand is a signaling NaN; 4181 otherwise return False. 4182 4183 >>> ExtendedContext.is_snan(Decimal('2.50')) 4184 False 4185 >>> ExtendedContext.is_snan(Decimal('NaN')) 4186 False 4187 >>> ExtendedContext.is_snan(Decimal('sNaN')) 4188 True 4189 """ 4190 return a.is_snan() 4191 4192 def is_subnormal(self, a): 4193 """Return True if the operand is subnormal; otherwise return False. 4194 4195 >>> c = ExtendedContext.copy() 4196 >>> c.Emin = -999 4197 >>> c.Emax = 999 4198 >>> c.is_subnormal(Decimal('2.50')) 4199 False 4200 >>> c.is_subnormal(Decimal('0.1E-999')) 4201 True 4202 >>> c.is_subnormal(Decimal('0.00')) 4203 False 4204 >>> c.is_subnormal(Decimal('-Inf')) 4205 False 4206 >>> c.is_subnormal(Decimal('NaN')) 4207 False 4208 """ 4209 return a.is_subnormal(context=self) 4210 4211 def is_zero(self, a): 4212 """Return True if the operand is a zero; otherwise return False. 4213 4214 >>> ExtendedContext.is_zero(Decimal('0')) 4215 True 4216 >>> ExtendedContext.is_zero(Decimal('2.50')) 4217 False 4218 >>> ExtendedContext.is_zero(Decimal('-0E+2')) 4219 True 4220 """ 4221 return a.is_zero() 4222 4223 def ln(self, a): 4224 """Returns the natural (base e) logarithm of the operand. 4225 4226 >>> c = ExtendedContext.copy() 4227 >>> c.Emin = -999 4228 >>> c.Emax = 999 4229 >>> c.ln(Decimal('0')) 4230 Decimal('-Infinity') 4231 >>> c.ln(Decimal('1.000')) 4232 Decimal('0') 4233 >>> c.ln(Decimal('2.71828183')) 4234 Decimal('1.00000000') 4235 >>> c.ln(Decimal('10')) 4236 Decimal('2.30258509') 4237 >>> c.ln(Decimal('+Infinity')) 4238 Decimal('Infinity') 4239 """ 4240 return a.ln(context=self) 4241 4242 def log10(self, a): 4243 """Returns the base 10 logarithm of the operand. 4244 4245 >>> c = ExtendedContext.copy() 4246 >>> c.Emin = -999 4247 >>> c.Emax = 999 4248 >>> c.log10(Decimal('0')) 4249 Decimal('-Infinity') 4250 >>> c.log10(Decimal('0.001')) 4251 Decimal('-3') 4252 >>> c.log10(Decimal('1.000')) 4253 Decimal('0') 4254 >>> c.log10(Decimal('2')) 4255 Decimal('0.301029996') 4256 >>> c.log10(Decimal('10')) 4257 Decimal('1') 4258 >>> c.log10(Decimal('70')) 4259 Decimal('1.84509804') 4260 >>> c.log10(Decimal('+Infinity')) 4261 Decimal('Infinity') 4262 """ 4263 return a.log10(context=self) 4264 4265 def logb(self, a): 4266 """ Returns the exponent of the magnitude of the operand's MSD. 4267 4268 The result is the integer which is the exponent of the magnitude 4269 of the most significant digit of the operand (as though the 4270 operand were truncated to a single digit while maintaining the 4271 value of that digit and without limiting the resulting exponent). 4272 4273 >>> ExtendedContext.logb(Decimal('250')) 4274 Decimal('2') 4275 >>> ExtendedContext.logb(Decimal('2.50')) 4276 Decimal('0') 4277 >>> ExtendedContext.logb(Decimal('0.03')) 4278 Decimal('-2') 4279 >>> ExtendedContext.logb(Decimal('0')) 4280 Decimal('-Infinity') 4281 """ 4282 return a.logb(context=self) 4283 4284 def logical_and(self, a, b): 4285 """Applies the logical operation 'and' between each operand's digits. 4286 4287 The operands must be both logical numbers. 4288 4289 >>> ExtendedContext.logical_and(Decimal('0'), Decimal('0')) 4290 Decimal('0') 4291 >>> ExtendedContext.logical_and(Decimal('0'), Decimal('1')) 4292 Decimal('0') 4293 >>> ExtendedContext.logical_and(Decimal('1'), Decimal('0')) 4294 Decimal('0') 4295 >>> ExtendedContext.logical_and(Decimal('1'), Decimal('1')) 4296 Decimal('1') 4297 >>> ExtendedContext.logical_and(Decimal('1100'), Decimal('1010')) 4298 Decimal('1000') 4299 >>> ExtendedContext.logical_and(Decimal('1111'), Decimal('10')) 4300 Decimal('10') 4301 """ 4302 return a.logical_and(b, context=self) 4303 4304 def logical_invert(self, a): 4305 """Invert all the digits in the operand. 4306 4307 The operand must be a logical number. 4308 4309 >>> ExtendedContext.logical_invert(Decimal('0')) 4310 Decimal('111111111') 4311 >>> ExtendedContext.logical_invert(Decimal('1')) 4312 Decimal('111111110') 4313 >>> ExtendedContext.logical_invert(Decimal('111111111')) 4314 Decimal('0') 4315 >>> ExtendedContext.logical_invert(Decimal('101010101')) 4316 Decimal('10101010') 4317 """ 4318 return a.logical_invert(context=self) 4319 4320 def logical_or(self, a, b): 4321 """Applies the logical operation 'or' between each operand's digits. 4322 4323 The operands must be both logical numbers. 4324 4325 >>> ExtendedContext.logical_or(Decimal('0'), Decimal('0')) 4326 Decimal('0') 4327 >>> ExtendedContext.logical_or(Decimal('0'), Decimal('1')) 4328 Decimal('1') 4329 >>> ExtendedContext.logical_or(Decimal('1'), Decimal('0')) 4330 Decimal('1') 4331 >>> ExtendedContext.logical_or(Decimal('1'), Decimal('1')) 4332 Decimal('1') 4333 >>> ExtendedContext.logical_or(Decimal('1100'), Decimal('1010')) 4334 Decimal('1110') 4335 >>> ExtendedContext.logical_or(Decimal('1110'), Decimal('10')) 4336 Decimal('1110') 4337 """ 4338 return a.logical_or(b, context=self) 4339 4340 def logical_xor(self, a, b): 4341 """Applies the logical operation 'xor' between each operand's digits. 4342 4343 The operands must be both logical numbers. 4344 4345 >>> ExtendedContext.logical_xor(Decimal('0'), Decimal('0')) 4346 Decimal('0') 4347 >>> ExtendedContext.logical_xor(Decimal('0'), Decimal('1')) 4348 Decimal('1') 4349 >>> ExtendedContext.logical_xor(Decimal('1'), Decimal('0')) 4350 Decimal('1') 4351 >>> ExtendedContext.logical_xor(Decimal('1'), Decimal('1')) 4352 Decimal('0') 4353 >>> ExtendedContext.logical_xor(Decimal('1100'), Decimal('1010')) 4354 Decimal('110') 4355 >>> ExtendedContext.logical_xor(Decimal('1111'), Decimal('10')) 4356 Decimal('1101') 4357 """ 4358 return a.logical_xor(b, context=self) 4359 4360 def max(self, a,b): 4361 """max compares two values numerically and returns the maximum. 4362 4363 If either operand is a NaN then the general rules apply. 4364 Otherwise, the operands are compared as though by the compare 4365 operation. If they are numerically equal then the left-hand operand 4366 is chosen as the result. Otherwise the maximum (closer to positive 4367 infinity) of the two operands is chosen as the result. 4368 4369 >>> ExtendedContext.max(Decimal('3'), Decimal('2')) 4370 Decimal('3') 4371 >>> ExtendedContext.max(Decimal('-10'), Decimal('3')) 4372 Decimal('3') 4373 >>> ExtendedContext.max(Decimal('1.0'), Decimal('1')) 4374 Decimal('1') 4375 >>> ExtendedContext.max(Decimal('7'), Decimal('NaN')) 4376 Decimal('7') 4377 """ 4378 return a.max(b, context=self) 4379 4380 def max_mag(self, a, b): 4381 """Compares the values numerically with their sign ignored.""" 4382 return a.max_mag(b, context=self) 4383 4384 def min(self, a,b): 4385 """min compares two values numerically and returns the minimum. 4386 4387 If either operand is a NaN then the general rules apply. 4388 Otherwise, the operands are compared as though by the compare 4389 operation. If they are numerically equal then the left-hand operand 4390 is chosen as the result. Otherwise the minimum (closer to negative 4391 infinity) of the two operands is chosen as the result. 4392 4393 >>> ExtendedContext.min(Decimal('3'), Decimal('2')) 4394 Decimal('2') 4395 >>> ExtendedContext.min(Decimal('-10'), Decimal('3')) 4396 Decimal('-10') 4397 >>> ExtendedContext.min(Decimal('1.0'), Decimal('1')) 4398 Decimal('1.0') 4399 >>> ExtendedContext.min(Decimal('7'), Decimal('NaN')) 4400 Decimal('7') 4401 """ 4402 return a.min(b, context=self) 4403 4404 def min_mag(self, a, b): 4405 """Compares the values numerically with their sign ignored.""" 4406 return a.min_mag(b, context=self) 4407 4408 def minus(self, a): 4409 """Minus corresponds to unary prefix minus in Python. 4410 4411 The operation is evaluated using the same rules as subtract; the 4412 operation minus(a) is calculated as subtract('0', a) where the '0' 4413 has the same exponent as the operand. 4414 4415 >>> ExtendedContext.minus(Decimal('1.3')) 4416 Decimal('-1.3') 4417 >>> ExtendedContext.minus(Decimal('-1.3')) 4418 Decimal('1.3') 4419 """ 4420 return a.__neg__(context=self) 4421 4422 def multiply(self, a, b): 4423 """multiply multiplies two operands. 4424 4425 If either operand is a special value then the general rules apply. 4426 Otherwise, the operands are multiplied together ('long multiplication'), 4427 resulting in a number which may be as long as the sum of the lengths 4428 of the two operands. 4429 4430 >>> ExtendedContext.multiply(Decimal('1.20'), Decimal('3')) 4431 Decimal('3.60') 4432 >>> ExtendedContext.multiply(Decimal('7'), Decimal('3')) 4433 Decimal('21') 4434 >>> ExtendedContext.multiply(Decimal('0.9'), Decimal('0.8')) 4435 Decimal('0.72') 4436 >>> ExtendedContext.multiply(Decimal('0.9'), Decimal('-0')) 4437 Decimal('-0.0') 4438 >>> ExtendedContext.multiply(Decimal('654321'), Decimal('654321')) 4439 Decimal('4.28135971E+11') 4440 """ 4441 return a.__mul__(b, context=self) 4442 4443 def next_minus(self, a): 4444 """Returns the largest representable number smaller than a. 4445 4446 >>> c = ExtendedContext.copy() 4447 >>> c.Emin = -999 4448 >>> c.Emax = 999 4449 >>> ExtendedContext.next_minus(Decimal('1')) 4450 Decimal('0.999999999') 4451 >>> c.next_minus(Decimal('1E-1007')) 4452 Decimal('0E-1007') 4453 >>> ExtendedContext.next_minus(Decimal('-1.00000003')) 4454 Decimal('-1.00000004') 4455 >>> c.next_minus(Decimal('Infinity')) 4456 Decimal('9.99999999E+999') 4457 """ 4458 return a.next_minus(context=self) 4459 4460 def next_plus(self, a): 4461 """Returns the smallest representable number larger than a. 4462 4463 >>> c = ExtendedContext.copy() 4464 >>> c.Emin = -999 4465 >>> c.Emax = 999 4466 >>> ExtendedContext.next_plus(Decimal('1')) 4467 Decimal('1.00000001') 4468 >>> c.next_plus(Decimal('-1E-1007')) 4469 Decimal('-0E-1007') 4470 >>> ExtendedContext.next_plus(Decimal('-1.00000003')) 4471 Decimal('-1.00000002') 4472 >>> c.next_plus(Decimal('-Infinity')) 4473 Decimal('-9.99999999E+999') 4474 """ 4475 return a.next_plus(context=self) 4476 4477 def next_toward(self, a, b): 4478 """Returns the number closest to a, in direction towards b. 4479 4480 The result is the closest representable number from the first 4481 operand (but not the first operand) that is in the direction 4482 towards the second operand, unless the operands have the same 4483 value. 4484 4485 >>> c = ExtendedContext.copy() 4486 >>> c.Emin = -999 4487 >>> c.Emax = 999 4488 >>> c.next_toward(Decimal('1'), Decimal('2')) 4489 Decimal('1.00000001') 4490 >>> c.next_toward(Decimal('-1E-1007'), Decimal('1')) 4491 Decimal('-0E-1007') 4492 >>> c.next_toward(Decimal('-1.00000003'), Decimal('0')) 4493 Decimal('-1.00000002') 4494 >>> c.next_toward(Decimal('1'), Decimal('0')) 4495 Decimal('0.999999999') 4496 >>> c.next_toward(Decimal('1E-1007'), Decimal('-100')) 4497 Decimal('0E-1007') 4498 >>> c.next_toward(Decimal('-1.00000003'), Decimal('-10')) 4499 Decimal('-1.00000004') 4500 >>> c.next_toward(Decimal('0.00'), Decimal('-0.0000')) 4501 Decimal('-0.00') 4502 """ 4503 return a.next_toward(b, context=self) 4504 4505 def normalize(self, a): 4506 """normalize reduces an operand to its simplest form. 4507 4508 Essentially a plus operation with all trailing zeros removed from the 4509 result. 4510 4511 >>> ExtendedContext.normalize(Decimal('2.1')) 4512 Decimal('2.1') 4513 >>> ExtendedContext.normalize(Decimal('-2.0')) 4514 Decimal('-2') 4515 >>> ExtendedContext.normalize(Decimal('1.200')) 4516 Decimal('1.2') 4517 >>> ExtendedContext.normalize(Decimal('-120')) 4518 Decimal('-1.2E+2') 4519 >>> ExtendedContext.normalize(Decimal('120.00')) 4520 Decimal('1.2E+2') 4521 >>> ExtendedContext.normalize(Decimal('0.00')) 4522 Decimal('0') 4523 """ 4524 return a.normalize(context=self) 4525 4526 def number_class(self, a): 4527 """Returns an indication of the class of the operand. 4528 4529 The class is one of the following strings: 4530 -sNaN 4531 -NaN 4532 -Infinity 4533 -Normal 4534 -Subnormal 4535 -Zero 4536 +Zero 4537 +Subnormal 4538 +Normal 4539 +Infinity 4540 4541 >>> c = Context(ExtendedContext) 4542 >>> c.Emin = -999 4543 >>> c.Emax = 999 4544 >>> c.number_class(Decimal('Infinity')) 4545 '+Infinity' 4546 >>> c.number_class(Decimal('1E-10')) 4547 '+Normal' 4548 >>> c.number_class(Decimal('2.50')) 4549 '+Normal' 4550 >>> c.number_class(Decimal('0.1E-999')) 4551 '+Subnormal' 4552 >>> c.number_class(Decimal('0')) 4553 '+Zero' 4554 >>> c.number_class(Decimal('-0')) 4555 '-Zero' 4556 >>> c.number_class(Decimal('-0.1E-999')) 4557 '-Subnormal' 4558 >>> c.number_class(Decimal('-1E-10')) 4559 '-Normal' 4560 >>> c.number_class(Decimal('-2.50')) 4561 '-Normal' 4562 >>> c.number_class(Decimal('-Infinity')) 4563 '-Infinity' 4564 >>> c.number_class(Decimal('NaN')) 4565 'NaN' 4566 >>> c.number_class(Decimal('-NaN')) 4567 'NaN' 4568 >>> c.number_class(Decimal('sNaN')) 4569 'sNaN' 4570 """ 4571 return a.number_class(context=self) 4572 4573 def plus(self, a): 4574 """Plus corresponds to unary prefix plus in Python. 4575 4576 The operation is evaluated using the same rules as add; the 4577 operation plus(a) is calculated as add('0', a) where the '0' 4578 has the same exponent as the operand. 4579 4580 >>> ExtendedContext.plus(Decimal('1.3')) 4581 Decimal('1.3') 4582 >>> ExtendedContext.plus(Decimal('-1.3')) 4583 Decimal('-1.3') 4584 """ 4585 return a.__pos__(context=self) 4586 4587 def power(self, a, b, modulo=None): 4588 """Raises a to the power of b, to modulo if given. 4589 4590 With two arguments, compute a**b. If a is negative then b 4591 must be integral. The result will be inexact unless b is 4592 integral and the result is finite and can be expressed exactly 4593 in 'precision' digits. 4594 4595 With three arguments, compute (a**b) % modulo. For the 4596 three argument form, the following restrictions on the 4597 arguments hold: 4598 4599 - all three arguments must be integral 4600 - b must be nonnegative 4601 - at least one of a or b must be nonzero 4602 - modulo must be nonzero and have at most 'precision' digits 4603 4604 The result of pow(a, b, modulo) is identical to the result 4605 that would be obtained by computing (a**b) % modulo with 4606 unbounded precision, but is computed more efficiently. It is 4607 always exact. 4608 4609 >>> c = ExtendedContext.copy() 4610 >>> c.Emin = -999 4611 >>> c.Emax = 999 4612 >>> c.power(Decimal('2'), Decimal('3')) 4613 Decimal('8') 4614 >>> c.power(Decimal('-2'), Decimal('3')) 4615 Decimal('-8') 4616 >>> c.power(Decimal('2'), Decimal('-3')) 4617 Decimal('0.125') 4618 >>> c.power(Decimal('1.7'), Decimal('8')) 4619 Decimal('69.7575744') 4620 >>> c.power(Decimal('10'), Decimal('0.301029996')) 4621 Decimal('2.00000000') 4622 >>> c.power(Decimal('Infinity'), Decimal('-1')) 4623 Decimal('0') 4624 >>> c.power(Decimal('Infinity'), Decimal('0')) 4625 Decimal('1') 4626 >>> c.power(Decimal('Infinity'), Decimal('1')) 4627 Decimal('Infinity') 4628 >>> c.power(Decimal('-Infinity'), Decimal('-1')) 4629 Decimal('-0') 4630 >>> c.power(Decimal('-Infinity'), Decimal('0')) 4631 Decimal('1') 4632 >>> c.power(Decimal('-Infinity'), Decimal('1')) 4633 Decimal('-Infinity') 4634 >>> c.power(Decimal('-Infinity'), Decimal('2')) 4635 Decimal('Infinity') 4636 >>> c.power(Decimal('0'), Decimal('0')) 4637 Decimal('NaN') 4638 4639 >>> c.power(Decimal('3'), Decimal('7'), Decimal('16')) 4640 Decimal('11') 4641 >>> c.power(Decimal('-3'), Decimal('7'), Decimal('16')) 4642 Decimal('-11') 4643 >>> c.power(Decimal('-3'), Decimal('8'), Decimal('16')) 4644 Decimal('1') 4645 >>> c.power(Decimal('3'), Decimal('7'), Decimal('-16')) 4646 Decimal('11') 4647 >>> c.power(Decimal('23E12345'), Decimal('67E189'), Decimal('123456789')) 4648 Decimal('11729830') 4649 >>> c.power(Decimal('-0'), Decimal('17'), Decimal('1729')) 4650 Decimal('-0') 4651 >>> c.power(Decimal('-23'), Decimal('0'), Decimal('65537')) 4652 Decimal('1') 4653 """ 4654 return a.__pow__(b, modulo, context=self) 4655 4656 def quantize(self, a, b): 4657 """Returns a value equal to 'a' (rounded), having the exponent of 'b'. 4658 4659 The coefficient of the result is derived from that of the left-hand 4660 operand. It may be rounded using the current rounding setting (if the 4661 exponent is being increased), multiplied by a positive power of ten (if 4662 the exponent is being decreased), or is unchanged (if the exponent is 4663 already equal to that of the right-hand operand). 4664 4665 Unlike other operations, if the length of the coefficient after the 4666 quantize operation would be greater than precision then an Invalid 4667 operation condition is raised. This guarantees that, unless there is 4668 an error condition, the exponent of the result of a quantize is always 4669 equal to that of the right-hand operand. 4670 4671 Also unlike other operations, quantize will never raise Underflow, even 4672 if the result is subnormal and inexact. 4673 4674 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.001')) 4675 Decimal('2.170') 4676 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.01')) 4677 Decimal('2.17') 4678 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.1')) 4679 Decimal('2.2') 4680 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('1e+0')) 4681 Decimal('2') 4682 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('1e+1')) 4683 Decimal('0E+1') 4684 >>> ExtendedContext.quantize(Decimal('-Inf'), Decimal('Infinity')) 4685 Decimal('-Infinity') 4686 >>> ExtendedContext.quantize(Decimal('2'), Decimal('Infinity')) 4687 Decimal('NaN') 4688 >>> ExtendedContext.quantize(Decimal('-0.1'), Decimal('1')) 4689 Decimal('-0') 4690 >>> ExtendedContext.quantize(Decimal('-0'), Decimal('1e+5')) 4691 Decimal('-0E+5') 4692 >>> ExtendedContext.quantize(Decimal('+35236450.6'), Decimal('1e-2')) 4693 Decimal('NaN') 4694 >>> ExtendedContext.quantize(Decimal('-35236450.6'), Decimal('1e-2')) 4695 Decimal('NaN') 4696 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e-1')) 4697 Decimal('217.0') 4698 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e-0')) 4699 Decimal('217') 4700 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e+1')) 4701 Decimal('2.2E+2') 4702 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e+2')) 4703 Decimal('2E+2') 4704 """ 4705 return a.quantize(b, context=self) 4706 4707 def radix(self): 4708 """Just returns 10, as this is Decimal, :) 4709 4710 >>> ExtendedContext.radix() 4711 Decimal('10') 4712 """ 4713 return Decimal(10) 4714 4715 def remainder(self, a, b): 4716 """Returns the remainder from integer division. 4717 4718 The result is the residue of the dividend after the operation of 4719 calculating integer division as described for divide-integer, rounded 4720 to precision digits if necessary. The sign of the result, if 4721 non-zero, is the same as that of the original dividend. 4722 4723 This operation will fail under the same conditions as integer division 4724 (that is, if integer division on the same two operands would fail, the 4725 remainder cannot be calculated). 4726 4727 >>> ExtendedContext.remainder(Decimal('2.1'), Decimal('3')) 4728 Decimal('2.1') 4729 >>> ExtendedContext.remainder(Decimal('10'), Decimal('3')) 4730 Decimal('1') 4731 >>> ExtendedContext.remainder(Decimal('-10'), Decimal('3')) 4732 Decimal('-1') 4733 >>> ExtendedContext.remainder(Decimal('10.2'), Decimal('1')) 4734 Decimal('0.2') 4735 >>> ExtendedContext.remainder(Decimal('10'), Decimal('0.3')) 4736 Decimal('0.1') 4737 >>> ExtendedContext.remainder(Decimal('3.6'), Decimal('1.3')) 4738 Decimal('1.0') 4739 """ 4740 return a.__mod__(b, context=self) 4741 4742 def remainder_near(self, a, b): 4743 """Returns to be "a - b * n", where n is the integer nearest the exact 4744 value of "x / b" (if two integers are equally near then the even one 4745 is chosen). If the result is equal to 0 then its sign will be the 4746 sign of a. 4747 4748 This operation will fail under the same conditions as integer division 4749 (that is, if integer division on the same two operands would fail, the 4750 remainder cannot be calculated). 4751 4752 >>> ExtendedContext.remainder_near(Decimal('2.1'), Decimal('3')) 4753 Decimal('-0.9') 4754 >>> ExtendedContext.remainder_near(Decimal('10'), Decimal('6')) 4755 Decimal('-2') 4756 >>> ExtendedContext.remainder_near(Decimal('10'), Decimal('3')) 4757 Decimal('1') 4758 >>> ExtendedContext.remainder_near(Decimal('-10'), Decimal('3')) 4759 Decimal('-1') 4760 >>> ExtendedContext.remainder_near(Decimal('10.2'), Decimal('1')) 4761 Decimal('0.2') 4762 >>> ExtendedContext.remainder_near(Decimal('10'), Decimal('0.3')) 4763 Decimal('0.1') 4764 >>> ExtendedContext.remainder_near(Decimal('3.6'), Decimal('1.3')) 4765 Decimal('-0.3') 4766 """ 4767 return a.remainder_near(b, context=self) 4768 4769 def rotate(self, a, b): 4770 """Returns a rotated copy of a, b times. 4771 4772 The coefficient of the result is a rotated copy of the digits in 4773 the coefficient of the first operand. The number of places of 4774 rotation is taken from the absolute value of the second operand, 4775 with the rotation being to the left if the second operand is 4776 positive or to the right otherwise. 4777 4778 >>> ExtendedContext.rotate(Decimal('34'), Decimal('8')) 4779 Decimal('400000003') 4780 >>> ExtendedContext.rotate(Decimal('12'), Decimal('9')) 4781 Decimal('12') 4782 >>> ExtendedContext.rotate(Decimal('123456789'), Decimal('-2')) 4783 Decimal('891234567') 4784 >>> ExtendedContext.rotate(Decimal('123456789'), Decimal('0')) 4785 Decimal('123456789') 4786 >>> ExtendedContext.rotate(Decimal('123456789'), Decimal('+2')) 4787 Decimal('345678912') 4788 """ 4789 return a.rotate(b, context=self) 4790 4791 def same_quantum(self, a, b): 4792 """Returns True if the two operands have the same exponent. 4793 4794 The result is never affected by either the sign or the coefficient of 4795 either operand. 4796 4797 >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.001')) 4798 False 4799 >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.01')) 4800 True 4801 >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('1')) 4802 False 4803 >>> ExtendedContext.same_quantum(Decimal('Inf'), Decimal('-Inf')) 4804 True 4805 """ 4806 return a.same_quantum(b) 4807 4808 def scaleb (self, a, b): 4809 """Returns the first operand after adding the second value its exp. 4810 4811 >>> ExtendedContext.scaleb(Decimal('7.50'), Decimal('-2')) 4812 Decimal('0.0750') 4813 >>> ExtendedContext.scaleb(Decimal('7.50'), Decimal('0')) 4814 Decimal('7.50') 4815 >>> ExtendedContext.scaleb(Decimal('7.50'), Decimal('3')) 4816 Decimal('7.50E+3') 4817 """ 4818 return a.scaleb (b, context=self) 4819 4820 def shift(self, a, b): 4821 """Returns a shifted copy of a, b times. 4822 4823 The coefficient of the result is a shifted copy of the digits 4824 in the coefficient of the first operand. The number of places 4825 to shift is taken from the absolute value of the second operand, 4826 with the shift being to the left if the second operand is 4827 positive or to the right otherwise. Digits shifted into the 4828 coefficient are zeros. 4829 4830 >>> ExtendedContext.shift(Decimal('34'), Decimal('8')) 4831 Decimal('400000000') 4832 >>> ExtendedContext.shift(Decimal('12'), Decimal('9')) 4833 Decimal('0') 4834 >>> ExtendedContext.shift(Decimal('123456789'), Decimal('-2')) 4835 Decimal('1234567') 4836 >>> ExtendedContext.shift(Decimal('123456789'), Decimal('0')) 4837 Decimal('123456789') 4838 >>> ExtendedContext.shift(Decimal('123456789'), Decimal('+2')) 4839 Decimal('345678900') 4840 """ 4841 return a.shift(b, context=self) 4842 4843 def sqrt(self, a): 4844 """Square root of a non-negative number to context precision. 4845 4846 If the result must be inexact, it is rounded using the round-half-even 4847 algorithm. 4848 4849 >>> ExtendedContext.sqrt(Decimal('0')) 4850 Decimal('0') 4851 >>> ExtendedContext.sqrt(Decimal('-0')) 4852 Decimal('-0') 4853 >>> ExtendedContext.sqrt(Decimal('0.39')) 4854 Decimal('0.624499800') 4855 >>> ExtendedContext.sqrt(Decimal('100')) 4856 Decimal('10') 4857 >>> ExtendedContext.sqrt(Decimal('1')) 4858 Decimal('1') 4859 >>> ExtendedContext.sqrt(Decimal('1.0')) 4860 Decimal('1.0') 4861 >>> ExtendedContext.sqrt(Decimal('1.00')) 4862 Decimal('1.0') 4863 >>> ExtendedContext.sqrt(Decimal('7')) 4864 Decimal('2.64575131') 4865 >>> ExtendedContext.sqrt(Decimal('10')) 4866 Decimal('3.16227766') 4867 >>> ExtendedContext.prec 4868 9 4869 """ 4870 return a.sqrt(context=self) 4871 4872 def subtract(self, a, b): 4873 """Return the difference between the two operands. 4874 4875 >>> ExtendedContext.subtract(Decimal('1.3'), Decimal('1.07')) 4876 Decimal('0.23') 4877 >>> ExtendedContext.subtract(Decimal('1.3'), Decimal('1.30')) 4878 Decimal('0.00') 4879 >>> ExtendedContext.subtract(Decimal('1.3'), Decimal('2.07')) 4880 Decimal('-0.77') 4881 """ 4882 return a.__sub__(b, context=self) 4883 4884 def to_eng_string(self, a): 4885 """Converts a number to a string, using scientific notation. 4886 4887 The operation is not affected by the context. 4888 """ 4889 return a.to_eng_string(context=self) 4890 4891 def to_sci_string(self, a): 4892 """Converts a number to a string, using scientific notation. 4893 4894 The operation is not affected by the context. 4895 """ 4896 return a.__str__(context=self) 4897 4898 def to_integral_exact(self, a): 4899 """Rounds to an integer. 4900 4901 When the operand has a negative exponent, the result is the same 4902 as using the quantize() operation using the given operand as the 4903 left-hand-operand, 1E+0 as the right-hand-operand, and the precision 4904 of the operand as the precision setting; Inexact and Rounded flags 4905 are allowed in this operation. The rounding mode is taken from the 4906 context. 4907 4908 >>> ExtendedContext.to_integral_exact(Decimal('2.1')) 4909 Decimal('2') 4910 >>> ExtendedContext.to_integral_exact(Decimal('100')) 4911 Decimal('100') 4912 >>> ExtendedContext.to_integral_exact(Decimal('100.0')) 4913 Decimal('100') 4914 >>> ExtendedContext.to_integral_exact(Decimal('101.5')) 4915 Decimal('102') 4916 >>> ExtendedContext.to_integral_exact(Decimal('-101.5')) 4917 Decimal('-102') 4918 >>> ExtendedContext.to_integral_exact(Decimal('10E+5')) 4919 Decimal('1.0E+6') 4920 >>> ExtendedContext.to_integral_exact(Decimal('7.89E+77')) 4921 Decimal('7.89E+77') 4922 >>> ExtendedContext.to_integral_exact(Decimal('-Inf')) 4923 Decimal('-Infinity') 4924 """ 4925 return a.to_integral_exact(context=self) 4926 4927 def to_integral_value(self, a): 4928 """Rounds to an integer. 4929 4930 When the operand has a negative exponent, the result is the same 4931 as using the quantize() operation using the given operand as the 4932 left-hand-operand, 1E+0 as the right-hand-operand, and the precision 4933 of the operand as the precision setting, except that no flags will 4934 be set. The rounding mode is taken from the context. 4935 4936 >>> ExtendedContext.to_integral_value(Decimal('2.1')) 4937 Decimal('2') 4938 >>> ExtendedContext.to_integral_value(Decimal('100')) 4939 Decimal('100') 4940 >>> ExtendedContext.to_integral_value(Decimal('100.0')) 4941 Decimal('100') 4942 >>> ExtendedContext.to_integral_value(Decimal('101.5')) 4943 Decimal('102') 4944 >>> ExtendedContext.to_integral_value(Decimal('-101.5')) 4945 Decimal('-102') 4946 >>> ExtendedContext.to_integral_value(Decimal('10E+5')) 4947 Decimal('1.0E+6') 4948 >>> ExtendedContext.to_integral_value(Decimal('7.89E+77')) 4949 Decimal('7.89E+77') 4950 >>> ExtendedContext.to_integral_value(Decimal('-Inf')) 4951 Decimal('-Infinity') 4952 """ 4953 return a.to_integral_value(context=self) 4954 4955 # the method name changed, but we provide also the old one, for compatibility 4956 to_integral = to_integral_value 4957 4958class _WorkRep(object): 4959 __slots__ = ('sign','int','exp') 4960 # sign: 0 or 1 4961 # int: int or long 4962 # exp: None, int, or string 4963 4964 def __init__(self, value=None): 4965 if value is None: 4966 self.sign = None 4967 self.int = 0 4968 self.exp = None 4969 elif isinstance(value, Decimal): 4970 self.sign = value._sign 4971 self.int = int(value._int) 4972 self.exp = value._exp 4973 else: 4974 # assert isinstance(value, tuple) 4975 self.sign = value[0] 4976 self.int = value[1] 4977 self.exp = value[2] 4978 4979 def __repr__(self): 4980 return "(%r, %r, %r)" % (self.sign, self.int, self.exp) 4981 4982 __str__ = __repr__ 4983 4984 4985 4986def _normalize(op1, op2, prec = 0): 4987 """Normalizes op1, op2 to have the same exp and length of coefficient. 4988 4989 Done during addition. 4990 """ 4991 if op1.exp < op2.exp: 4992 tmp = op2 4993 other = op1 4994 else: 4995 tmp = op1 4996 other = op2 4997 4998 # Let exp = min(tmp.exp - 1, tmp.adjusted() - precision - 1). 4999 # Then adding 10**exp to tmp has the same effect (after rounding) 5000 # as adding any positive quantity smaller than 10**exp; similarly 5001 # for subtraction. So if other is smaller than 10**exp we replace 5002 # it with 10**exp. This avoids tmp.exp - other.exp getting too large. 5003 tmp_len = len(str(tmp.int)) 5004 other_len = len(str(other.int)) 5005 exp = tmp.exp + min(-1, tmp_len - prec - 2) 5006 if other_len + other.exp - 1 < exp: 5007 other.int = 1 5008 other.exp = exp 5009 5010 tmp.int *= 10 ** (tmp.exp - other.exp) 5011 tmp.exp = other.exp 5012 return op1, op2 5013 5014##### Integer arithmetic functions used by ln, log10, exp and __pow__ ##### 5015 5016# This function from Tim Peters was taken from here: 5017# http://mail.python.org/pipermail/python-list/1999-July/007758.html 5018# The correction being in the function definition is for speed, and 5019# the whole function is not resolved with math.log because of avoiding 5020# the use of floats. 5021def _nbits(n, correction = { 5022 '0': 4, '1': 3, '2': 2, '3': 2, 5023 '4': 1, '5': 1, '6': 1, '7': 1, 5024 '8': 0, '9': 0, 'a': 0, 'b': 0, 5025 'c': 0, 'd': 0, 'e': 0, 'f': 0}): 5026 """Number of bits in binary representation of the positive integer n, 5027 or 0 if n == 0. 5028 """ 5029 if n < 0: 5030 raise ValueError("The argument to _nbits should be nonnegative.") 5031 hex_n = "%x" % n 5032 return 4*len(hex_n) - correction[hex_n[0]] 5033 5034def _sqrt_nearest(n, a): 5035 """Closest integer to the square root of the positive integer n. a is 5036 an initial approximation to the square root. Any positive integer 5037 will do for a, but the closer a is to the square root of n the 5038 faster convergence will be. 5039 5040 """ 5041 if n <= 0 or a <= 0: 5042 raise ValueError("Both arguments to _sqrt_nearest should be positive.") 5043 5044 b=0 5045 while a != b: 5046 b, a = a, a--n//a>>1 5047 return a 5048 5049def _rshift_nearest(x, shift): 5050 """Given an integer x and a nonnegative integer shift, return closest 5051 integer to x / 2**shift; use round-to-even in case of a tie. 5052 5053 """ 5054 b, q = 1L << shift, x >> shift 5055 return q + (2*(x & (b-1)) + (q&1) > b) 5056 5057def _div_nearest(a, b): 5058 """Closest integer to a/b, a and b positive integers; rounds to even 5059 in the case of a tie. 5060 5061 """ 5062 q, r = divmod(a, b) 5063 return q + (2*r + (q&1) > b) 5064 5065def _ilog(x, M, L = 8): 5066 """Integer approximation to M*log(x/M), with absolute error boundable 5067 in terms only of x/M. 5068 5069 Given positive integers x and M, return an integer approximation to 5070 M * log(x/M). For L = 8 and 0.1 <= x/M <= 10 the difference 5071 between the approximation and the exact result is at most 22. For 5072 L = 8 and 1.0 <= x/M <= 10.0 the difference is at most 15. In 5073 both cases these are upper bounds on the error; it will usually be 5074 much smaller.""" 5075 5076 # The basic algorithm is the following: let log1p be the function 5077 # log1p(x) = log(1+x). Then log(x/M) = log1p((x-M)/M). We use 5078 # the reduction 5079 # 5080 # log1p(y) = 2*log1p(y/(1+sqrt(1+y))) 5081 # 5082 # repeatedly until the argument to log1p is small (< 2**-L in 5083 # absolute value). For small y we can use the Taylor series 5084 # expansion 5085 # 5086 # log1p(y) ~ y - y**2/2 + y**3/3 - ... - (-y)**T/T 5087 # 5088 # truncating at T such that y**T is small enough. The whole 5089 # computation is carried out in a form of fixed-point arithmetic, 5090 # with a real number z being represented by an integer 5091 # approximation to z*M. To avoid loss of precision, the y below 5092 # is actually an integer approximation to 2**R*y*M, where R is the 5093 # number of reductions performed so far. 5094 5095 y = x-M 5096 # argument reduction; R = number of reductions performed 5097 R = 0 5098 while (R <= L and long(abs(y)) << L-R >= M or 5099 R > L and abs(y) >> R-L >= M): 5100 y = _div_nearest(long(M*y) << 1, 5101 M + _sqrt_nearest(M*(M+_rshift_nearest(y, R)), M)) 5102 R += 1 5103 5104 # Taylor series with T terms 5105 T = -int(-10*len(str(M))//(3*L)) 5106 yshift = _rshift_nearest(y, R) 5107 w = _div_nearest(M, T) 5108 for k in xrange(T-1, 0, -1): 5109 w = _div_nearest(M, k) - _div_nearest(yshift*w, M) 5110 5111 return _div_nearest(w*y, M) 5112 5113def _dlog10(c, e, p): 5114 """Given integers c, e and p with c > 0, p >= 0, compute an integer 5115 approximation to 10**p * log10(c*10**e), with an absolute error of 5116 at most 1. Assumes that c*10**e is not exactly 1.""" 5117 5118 # increase precision by 2; compensate for this by dividing 5119 # final result by 100 5120 p += 2 5121 5122 # write c*10**e as d*10**f with either: 5123 # f >= 0 and 1 <= d <= 10, or 5124 # f <= 0 and 0.1 <= d <= 1. 5125 # Thus for c*10**e close to 1, f = 0 5126 l = len(str(c)) 5127 f = e+l - (e+l >= 1) 5128 5129 if p > 0: 5130 M = 10**p 5131 k = e+p-f 5132 if k >= 0: 5133 c *= 10**k 5134 else: 5135 c = _div_nearest(c, 10**-k) 5136 5137 log_d = _ilog(c, M) # error < 5 + 22 = 27 5138 log_10 = _log10_digits(p) # error < 1 5139 log_d = _div_nearest(log_d*M, log_10) 5140 log_tenpower = f*M # exact 5141 else: 5142 log_d = 0 # error < 2.31 5143 log_tenpower = _div_nearest(f, 10**-p) # error < 0.5 5144 5145 return _div_nearest(log_tenpower+log_d, 100) 5146 5147def _dlog(c, e, p): 5148 """Given integers c, e and p with c > 0, compute an integer 5149 approximation to 10**p * log(c*10**e), with an absolute error of 5150 at most 1. Assumes that c*10**e is not exactly 1.""" 5151 5152 # Increase precision by 2. The precision increase is compensated 5153 # for at the end with a division by 100. 5154 p += 2 5155 5156 # rewrite c*10**e as d*10**f with either f >= 0 and 1 <= d <= 10, 5157 # or f <= 0 and 0.1 <= d <= 1. Then we can compute 10**p * log(c*10**e) 5158 # as 10**p * log(d) + 10**p*f * log(10). 5159 l = len(str(c)) 5160 f = e+l - (e+l >= 1) 5161 5162 # compute approximation to 10**p*log(d), with error < 27 5163 if p > 0: 5164 k = e+p-f 5165 if k >= 0: 5166 c *= 10**k 5167 else: 5168 c = _div_nearest(c, 10**-k) # error of <= 0.5 in c 5169 5170 # _ilog magnifies existing error in c by a factor of at most 10 5171 log_d = _ilog(c, 10**p) # error < 5 + 22 = 27 5172 else: 5173 # p <= 0: just approximate the whole thing by 0; error < 2.31 5174 log_d = 0 5175 5176 # compute approximation to f*10**p*log(10), with error < 11. 5177 if f: 5178 extra = len(str(abs(f)))-1 5179 if p + extra >= 0: 5180 # error in f * _log10_digits(p+extra) < |f| * 1 = |f| 5181 # after division, error < |f|/10**extra + 0.5 < 10 + 0.5 < 11 5182 f_log_ten = _div_nearest(f*_log10_digits(p+extra), 10**extra) 5183 else: 5184 f_log_ten = 0 5185 else: 5186 f_log_ten = 0 5187 5188 # error in sum < 11+27 = 38; error after division < 0.38 + 0.5 < 1 5189 return _div_nearest(f_log_ten + log_d, 100) 5190 5191class _Log10Memoize(object): 5192 """Class to compute, store, and allow retrieval of, digits of the 5193 constant log(10) = 2.302585.... This constant is needed by 5194 Decimal.ln, Decimal.log10, Decimal.exp and Decimal.__pow__.""" 5195 def __init__(self): 5196 self.digits = "23025850929940456840179914546843642076011014886" 5197 5198 def getdigits(self, p): 5199 """Given an integer p >= 0, return floor(10**p)*log(10). 5200 5201 For example, self.getdigits(3) returns 2302. 5202 """ 5203 # digits are stored as a string, for quick conversion to 5204 # integer in the case that we've already computed enough 5205 # digits; the stored digits should always be correct 5206 # (truncated, not rounded to nearest). 5207 if p < 0: 5208 raise ValueError("p should be nonnegative") 5209 5210 if p >= len(self.digits): 5211 # compute p+3, p+6, p+9, ... digits; continue until at 5212 # least one of the extra digits is nonzero 5213 extra = 3 5214 while True: 5215 # compute p+extra digits, correct to within 1ulp 5216 M = 10**(p+extra+2) 5217 digits = str(_div_nearest(_ilog(10*M, M), 100)) 5218 if digits[-extra:] != '0'*extra: 5219 break 5220 extra += 3 5221 # keep all reliable digits so far; remove trailing zeros 5222 # and next nonzero digit 5223 self.digits = digits.rstrip('0')[:-1] 5224 return int(self.digits[:p+1]) 5225 5226_log10_digits = _Log10Memoize().getdigits 5227 5228def _iexp(x, M, L=8): 5229 """Given integers x and M, M > 0, such that x/M is small in absolute 5230 value, compute an integer approximation to M*exp(x/M). For 0 <= 5231 x/M <= 2.4, the absolute error in the result is bounded by 60 (and 5232 is usually much smaller).""" 5233 5234 # Algorithm: to compute exp(z) for a real number z, first divide z 5235 # by a suitable power R of 2 so that |z/2**R| < 2**-L. Then 5236 # compute expm1(z/2**R) = exp(z/2**R) - 1 using the usual Taylor 5237 # series 5238 # 5239 # expm1(x) = x + x**2/2! + x**3/3! + ... 5240 # 5241 # Now use the identity 5242 # 5243 # expm1(2x) = expm1(x)*(expm1(x)+2) 5244 # 5245 # R times to compute the sequence expm1(z/2**R), 5246 # expm1(z/2**(R-1)), ... , exp(z/2), exp(z). 5247 5248 # Find R such that x/2**R/M <= 2**-L 5249 R = _nbits((long(x)<<L)//M) 5250 5251 # Taylor series. (2**L)**T > M 5252 T = -int(-10*len(str(M))//(3*L)) 5253 y = _div_nearest(x, T) 5254 Mshift = long(M)<<R 5255 for i in xrange(T-1, 0, -1): 5256 y = _div_nearest(x*(Mshift + y), Mshift * i) 5257 5258 # Expansion 5259 for k in xrange(R-1, -1, -1): 5260 Mshift = long(M)<<(k+2) 5261 y = _div_nearest(y*(y+Mshift), Mshift) 5262 5263 return M+y 5264 5265def _dexp(c, e, p): 5266 """Compute an approximation to exp(c*10**e), with p decimal places of 5267 precision. 5268 5269 Returns integers d, f such that: 5270 5271 10**(p-1) <= d <= 10**p, and 5272 (d-1)*10**f < exp(c*10**e) < (d+1)*10**f 5273 5274 In other words, d*10**f is an approximation to exp(c*10**e) with p 5275 digits of precision, and with an error in d of at most 1. This is 5276 almost, but not quite, the same as the error being < 1ulp: when d 5277 = 10**(p-1) the error could be up to 10 ulp.""" 5278 5279 # we'll call iexp with M = 10**(p+2), giving p+3 digits of precision 5280 p += 2 5281 5282 # compute log(10) with extra precision = adjusted exponent of c*10**e 5283 extra = max(0, e + len(str(c)) - 1) 5284 q = p + extra 5285 5286 # compute quotient c*10**e/(log(10)) = c*10**(e+q)/(log(10)*10**q), 5287 # rounding down 5288 shift = e+q 5289 if shift >= 0: 5290 cshift = c*10**shift 5291 else: 5292 cshift = c//10**-shift 5293 quot, rem = divmod(cshift, _log10_digits(q)) 5294 5295 # reduce remainder back to original precision 5296 rem = _div_nearest(rem, 10**extra) 5297 5298 # error in result of _iexp < 120; error after division < 0.62 5299 return _div_nearest(_iexp(rem, 10**p), 1000), quot - p + 3 5300 5301def _dpower(xc, xe, yc, ye, p): 5302 """Given integers xc, xe, yc and ye representing Decimals x = xc*10**xe and 5303 y = yc*10**ye, compute x**y. Returns a pair of integers (c, e) such that: 5304 5305 10**(p-1) <= c <= 10**p, and 5306 (c-1)*10**e < x**y < (c+1)*10**e 5307 5308 in other words, c*10**e is an approximation to x**y with p digits 5309 of precision, and with an error in c of at most 1. (This is 5310 almost, but not quite, the same as the error being < 1ulp: when c 5311 == 10**(p-1) we can only guarantee error < 10ulp.) 5312 5313 We assume that: x is positive and not equal to 1, and y is nonzero. 5314 """ 5315 5316 # Find b such that 10**(b-1) <= |y| <= 10**b 5317 b = len(str(abs(yc))) + ye 5318 5319 # log(x) = lxc*10**(-p-b-1), to p+b+1 places after the decimal point 5320 lxc = _dlog(xc, xe, p+b+1) 5321 5322 # compute product y*log(x) = yc*lxc*10**(-p-b-1+ye) = pc*10**(-p-1) 5323 shift = ye-b 5324 if shift >= 0: 5325 pc = lxc*yc*10**shift 5326 else: 5327 pc = _div_nearest(lxc*yc, 10**-shift) 5328 5329 if pc == 0: 5330 # we prefer a result that isn't exactly 1; this makes it 5331 # easier to compute a correctly rounded result in __pow__ 5332 if ((len(str(xc)) + xe >= 1) == (yc > 0)): # if x**y > 1: 5333 coeff, exp = 10**(p-1)+1, 1-p 5334 else: 5335 coeff, exp = 10**p-1, -p 5336 else: 5337 coeff, exp = _dexp(pc, -(p+1), p+1) 5338 coeff = _div_nearest(coeff, 10) 5339 exp += 1 5340 5341 return coeff, exp 5342 5343def _log10_lb(c, correction = { 5344 '1': 100, '2': 70, '3': 53, '4': 40, '5': 31, 5345 '6': 23, '7': 16, '8': 10, '9': 5}): 5346 """Compute a lower bound for 100*log10(c) for a positive integer c.""" 5347 if c <= 0: 5348 raise ValueError("The argument to _log10_lb should be nonnegative.") 5349 str_c = str(c) 5350 return 100*len(str_c) - correction[str_c[0]] 5351 5352##### Helper Functions #################################################### 5353 5354def _convert_other(other, raiseit=False): 5355 """Convert other to Decimal. 5356 5357 Verifies that it's ok to use in an implicit construction. 5358 """ 5359 if isinstance(other, Decimal): 5360 return other 5361 if isinstance(other, (int, long)): 5362 return Decimal(other) 5363 if raiseit: 5364 raise TypeError("Unable to convert %s to Decimal" % other) 5365 return NotImplemented 5366 5367##### Setup Specific Contexts ############################################ 5368 5369# The default context prototype used by Context() 5370# Is mutable, so that new contexts can have different default values 5371 5372DefaultContext = Context( 5373 prec=28, rounding=ROUND_HALF_EVEN, 5374 traps=[DivisionByZero, Overflow, InvalidOperation], 5375 flags=[], 5376 Emax=999999999, 5377 Emin=-999999999, 5378 capitals=1 5379) 5380 5381# Pre-made alternate contexts offered by the specification 5382# Don't change these; the user should be able to select these 5383# contexts and be able to reproduce results from other implementations 5384# of the spec. 5385 5386BasicContext = Context( 5387 prec=9, rounding=ROUND_HALF_UP, 5388 traps=[DivisionByZero, Overflow, InvalidOperation, Clamped, Underflow], 5389 flags=[], 5390) 5391 5392ExtendedContext = Context( 5393 prec=9, rounding=ROUND_HALF_EVEN, 5394 traps=[], 5395 flags=[], 5396) 5397 5398 5399##### crud for parsing strings ############################################# 5400# 5401# Regular expression used for parsing numeric strings. Additional 5402# comments: 5403# 5404# 1. Uncomment the two '\s*' lines to allow leading and/or trailing 5405# whitespace. But note that the specification disallows whitespace in 5406# a numeric string. 5407# 5408# 2. For finite numbers (not infinities and NaNs) the body of the 5409# number between the optional sign and the optional exponent must have 5410# at least one decimal digit, possibly after the decimal point. The 5411# lookahead expression '(?=\d|\.\d)' checks this. 5412# 5413# As the flag UNICODE is not enabled here, we're explicitly avoiding any 5414# other meaning for \d than the numbers [0-9]. 5415 5416import re 5417_parser = re.compile(r""" # A numeric string consists of: 5418# \s* 5419 (?P<sign>[-+])? # an optional sign, followed by either... 5420 ( 5421 (?=[0-9]|\.[0-9]) # ...a number (with at least one digit) 5422 (?P<int>[0-9]*) # having a (possibly empty) integer part 5423 (\.(?P<frac>[0-9]*))? # followed by an optional fractional part 5424 (E(?P<exp>[-+]?[0-9]+))? # followed by an optional exponent, or... 5425 | 5426 Inf(inity)? # ...an infinity, or... 5427 | 5428 (?P<signal>s)? # ...an (optionally signaling) 5429 NaN # NaN 5430 (?P<diag>[0-9]*) # with (possibly empty) diagnostic info. 5431 ) 5432# \s* 5433 \Z 5434""", re.VERBOSE | re.IGNORECASE).match 5435 5436_all_zeros = re.compile('0*$').match 5437_exact_half = re.compile('50*$').match 5438 5439##### PEP3101 support functions ############################################## 5440# The functions parse_format_specifier and format_align have little to do 5441# with the Decimal class, and could potentially be reused for other pure 5442# Python numeric classes that want to implement __format__ 5443# 5444# A format specifier for Decimal looks like: 5445# 5446# [[fill]align][sign][0][minimumwidth][.precision][type] 5447# 5448 5449_parse_format_specifier_regex = re.compile(r"""\A 5450(?: 5451 (?P<fill>.)? 5452 (?P<align>[<>=^]) 5453)? 5454(?P<sign>[-+ ])? 5455(?P<zeropad>0)? 5456(?P<minimumwidth>(?!0)\d+)? 5457(?:\.(?P<precision>0|(?!0)\d+))? 5458(?P<type>[eEfFgG%])? 5459\Z 5460""", re.VERBOSE) 5461 5462del re 5463 5464def _parse_format_specifier(format_spec): 5465 """Parse and validate a format specifier. 5466 5467 Turns a standard numeric format specifier into a dict, with the 5468 following entries: 5469 5470 fill: fill character to pad field to minimum width 5471 align: alignment type, either '<', '>', '=' or '^' 5472 sign: either '+', '-' or ' ' 5473 minimumwidth: nonnegative integer giving minimum width 5474 precision: nonnegative integer giving precision, or None 5475 type: one of the characters 'eEfFgG%', or None 5476 unicode: either True or False (always True for Python 3.x) 5477 5478 """ 5479 m = _parse_format_specifier_regex.match(format_spec) 5480 if m is None: 5481 raise ValueError("Invalid format specifier: " + format_spec) 5482 5483 # get the dictionary 5484 format_dict = m.groupdict() 5485 5486 # defaults for fill and alignment 5487 fill = format_dict['fill'] 5488 align = format_dict['align'] 5489 if format_dict.pop('zeropad') is not None: 5490 # in the face of conflict, refuse the temptation to guess 5491 if fill is not None and fill != '0': 5492 raise ValueError("Fill character conflicts with '0'" 5493 " in format specifier: " + format_spec) 5494 if align is not None and align != '=': 5495 raise ValueError("Alignment conflicts with '0' in " 5496 "format specifier: " + format_spec) 5497 fill = '0' 5498 align = '=' 5499 format_dict['fill'] = fill or ' ' 5500 format_dict['align'] = align or '<' 5501 5502 if format_dict['sign'] is None: 5503 format_dict['sign'] = '-' 5504 5505 # turn minimumwidth and precision entries into integers. 5506 # minimumwidth defaults to 0; precision remains None if not given 5507 format_dict['minimumwidth'] = int(format_dict['minimumwidth'] or '0') 5508 if format_dict['precision'] is not None: 5509 format_dict['precision'] = int(format_dict['precision']) 5510 5511 # if format type is 'g' or 'G' then a precision of 0 makes little 5512 # sense; convert it to 1. Same if format type is unspecified. 5513 if format_dict['precision'] == 0: 5514 if format_dict['type'] in 'gG' or format_dict['type'] is None: 5515 format_dict['precision'] = 1 5516 5517 # record whether return type should be str or unicode 5518 format_dict['unicode'] = isinstance(format_spec, unicode) 5519 5520 return format_dict 5521 5522def _format_align(body, spec_dict): 5523 """Given an unpadded, non-aligned numeric string, add padding and 5524 aligment to conform with the given format specifier dictionary (as 5525 output from parse_format_specifier). 5526 5527 It's assumed that if body is negative then it starts with '-'. 5528 Any leading sign ('-' or '+') is stripped from the body before 5529 applying the alignment and padding rules, and replaced in the 5530 appropriate position. 5531 5532 """ 5533 # figure out the sign; we only examine the first character, so if 5534 # body has leading whitespace the results may be surprising. 5535 if len(body) > 0 and body[0] in '-+': 5536 sign = body[0] 5537 body = body[1:] 5538 else: 5539 sign = '' 5540 5541 if sign != '-': 5542 if spec_dict['sign'] in ' +': 5543 sign = spec_dict['sign'] 5544 else: 5545 sign = '' 5546 5547 # how much extra space do we have to play with? 5548 minimumwidth = spec_dict['minimumwidth'] 5549 fill = spec_dict['fill'] 5550 padding = fill*(max(minimumwidth - (len(sign+body)), 0)) 5551 5552 align = spec_dict['align'] 5553 if align == '<': 5554 result = padding + sign + body 5555 elif align == '>': 5556 result = sign + body + padding 5557 elif align == '=': 5558 result = sign + padding + body 5559 else: #align == '^' 5560 half = len(padding)//2 5561 result = padding[:half] + sign + body + padding[half:] 5562 5563 # make sure that result is unicode if necessary 5564 if spec_dict['unicode']: 5565 result = unicode(result) 5566 5567 return result 5568 5569##### Useful Constants (internal use only) ################################ 5570 5571# Reusable defaults 5572_Infinity = Decimal('Inf') 5573_NegativeInfinity = Decimal('-Inf') 5574_NaN = Decimal('NaN') 5575_Zero = Decimal(0) 5576_One = Decimal(1) 5577_NegativeOne = Decimal(-1) 5578 5579# _SignedInfinity[sign] is infinity w/ that sign 5580_SignedInfinity = (_Infinity, _NegativeInfinity) 5581 5582 5583 5584if __name__ == '__main__': 5585 import doctest, sys 5586 doctest.testmod(sys.modules[__name__]) 5587