decimal.py revision f33d01d304c349a7f555779c7c99930f1203adb7
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 the module is to support arithmetic using familiar 33"schoolhouse" rules and to avoid the some of 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', 132 133 # Functions for manipulating contexts 134 'setcontext', 'getcontext' 135] 136 137import copy as _copy 138 139#Rounding 140ROUND_DOWN = 'ROUND_DOWN' 141ROUND_HALF_UP = 'ROUND_HALF_UP' 142ROUND_HALF_EVEN = 'ROUND_HALF_EVEN' 143ROUND_CEILING = 'ROUND_CEILING' 144ROUND_FLOOR = 'ROUND_FLOOR' 145ROUND_UP = 'ROUND_UP' 146ROUND_HALF_DOWN = 'ROUND_HALF_DOWN' 147 148#Rounding decision (not part of the public API) 149NEVER_ROUND = 'NEVER_ROUND' # Round in division (non-divmod), sqrt ONLY 150ALWAYS_ROUND = 'ALWAYS_ROUND' # Every operation rounds at end. 151 152#Errors 153 154class DecimalException(ArithmeticError): 155 """Base exception class. 156 157 Used exceptions derive from this. 158 If an exception derives from another exception besides this (such as 159 Underflow (Inexact, Rounded, Subnormal) that indicates that it is only 160 called if the others are present. This isn't actually used for 161 anything, though. 162 163 handle -- Called when context._raise_error is called and the 164 trap_enabler is set. First argument is self, second is the 165 context. More arguments can be given, those being after 166 the explanation in _raise_error (For example, 167 context._raise_error(NewError, '(-x)!', self._sign) would 168 call NewError().handle(context, self._sign).) 169 170 To define a new exception, it should be sufficient to have it derive 171 from DecimalException. 172 """ 173 def handle(self, context, *args): 174 pass 175 176 177class Clamped(DecimalException): 178 """Exponent of a 0 changed to fit bounds. 179 180 This occurs and signals clamped if the exponent of a result has been 181 altered in order to fit the constraints of a specific concrete 182 representation. This may occur when the exponent of a zero result would 183 be outside the bounds of a representation, or when a large normal 184 number would have an encoded exponent that cannot be represented. In 185 this latter case, the exponent is reduced to fit and the corresponding 186 number of zero digits are appended to the coefficient ("fold-down"). 187 """ 188 189 190class InvalidOperation(DecimalException): 191 """An invalid operation was performed. 192 193 Various bad things cause this: 194 195 Something creates a signaling NaN 196 -INF + INF 197 0 * (+-)INF 198 (+-)INF / (+-)INF 199 x % 0 200 (+-)INF % x 201 x._rescale( non-integer ) 202 sqrt(-x) , x > 0 203 0 ** 0 204 x ** (non-integer) 205 x ** (+-)INF 206 An operand is invalid 207 """ 208 def handle(self, context, *args): 209 if args: 210 if args[0] == 1: #sNaN, must drop 's' but keep diagnostics 211 return Decimal( (args[1]._sign, args[1]._int, 'n') ) 212 return NaN 213 214class ConversionSyntax(InvalidOperation): 215 """Trying to convert badly formed string. 216 217 This occurs and signals invalid-operation if an string is being 218 converted to a number and it does not conform to the numeric string 219 syntax. The result is [0,qNaN]. 220 """ 221 222 def handle(self, context, *args): 223 return (0, (0,), 'n') #Passed to something which uses a tuple. 224 225class DivisionByZero(DecimalException, ZeroDivisionError): 226 """Division by 0. 227 228 This occurs and signals division-by-zero if division of a finite number 229 by zero was attempted (during a divide-integer or divide operation, or a 230 power operation with negative right-hand operand), and the dividend was 231 not zero. 232 233 The result of the operation is [sign,inf], where sign is the exclusive 234 or of the signs of the operands for divide, or is 1 for an odd power of 235 -0, for power. 236 """ 237 238 def handle(self, context, sign, double = None, *args): 239 if double is not None: 240 return (Infsign[sign],)*2 241 return Infsign[sign] 242 243class DivisionImpossible(InvalidOperation): 244 """Cannot perform the division adequately. 245 246 This occurs and signals invalid-operation if the integer result of a 247 divide-integer or remainder operation had too many digits (would be 248 longer than precision). The result is [0,qNaN]. 249 """ 250 251 def handle(self, context, *args): 252 return (NaN, NaN) 253 254class DivisionUndefined(InvalidOperation, ZeroDivisionError): 255 """Undefined result of division. 256 257 This occurs and signals invalid-operation if division by zero was 258 attempted (during a divide-integer, divide, or remainder operation), and 259 the dividend is also zero. The result is [0,qNaN]. 260 """ 261 262 def handle(self, context, tup=None, *args): 263 if tup is not None: 264 return (NaN, NaN) #for 0 %0, 0 // 0 265 return NaN 266 267class Inexact(DecimalException): 268 """Had to round, losing information. 269 270 This occurs and signals inexact whenever the result of an operation is 271 not exact (that is, it needed to be rounded and any discarded digits 272 were non-zero), or if an overflow or underflow condition occurs. The 273 result in all cases is unchanged. 274 275 The inexact signal may be tested (or trapped) to determine if a given 276 operation (or sequence of operations) was inexact. 277 """ 278 pass 279 280class InvalidContext(InvalidOperation): 281 """Invalid context. Unknown rounding, for example. 282 283 This occurs and signals invalid-operation if an invalid context was 284 detected during an operation. This can occur if contexts are not checked 285 on creation and either the precision exceeds the capability of the 286 underlying concrete representation or an unknown or unsupported rounding 287 was specified. These aspects of the context need only be checked when 288 the values are required to be used. The result is [0,qNaN]. 289 """ 290 291 def handle(self, context, *args): 292 return NaN 293 294class Rounded(DecimalException): 295 """Number got rounded (not necessarily changed during rounding). 296 297 This occurs and signals rounded whenever the result of an operation is 298 rounded (that is, some zero or non-zero digits were discarded from the 299 coefficient), or if an overflow or underflow condition occurs. The 300 result in all cases is unchanged. 301 302 The rounded signal may be tested (or trapped) to determine if a given 303 operation (or sequence of operations) caused a loss of precision. 304 """ 305 pass 306 307class Subnormal(DecimalException): 308 """Exponent < Emin before rounding. 309 310 This occurs and signals subnormal whenever the result of a conversion or 311 operation is subnormal (that is, its adjusted exponent is less than 312 Emin, before any rounding). The result in all cases is unchanged. 313 314 The subnormal signal may be tested (or trapped) to determine if a given 315 or operation (or sequence of operations) yielded a subnormal result. 316 """ 317 pass 318 319class Overflow(Inexact, Rounded): 320 """Numerical overflow. 321 322 This occurs and signals overflow if the adjusted exponent of a result 323 (from a conversion or from an operation that is not an attempt to divide 324 by zero), after rounding, would be greater than the largest value that 325 can be handled by the implementation (the value Emax). 326 327 The result depends on the rounding mode: 328 329 For round-half-up and round-half-even (and for round-half-down and 330 round-up, if implemented), the result of the operation is [sign,inf], 331 where sign is the sign of the intermediate result. For round-down, the 332 result is the largest finite number that can be represented in the 333 current precision, with the sign of the intermediate result. For 334 round-ceiling, the result is the same as for round-down if the sign of 335 the intermediate result is 1, or is [0,inf] otherwise. For round-floor, 336 the result is the same as for round-down if the sign of the intermediate 337 result is 0, or is [1,inf] otherwise. In all cases, Inexact and Rounded 338 will also be raised. 339 """ 340 341 def handle(self, context, sign, *args): 342 if context.rounding in (ROUND_HALF_UP, ROUND_HALF_EVEN, 343 ROUND_HALF_DOWN, ROUND_UP): 344 return Infsign[sign] 345 if sign == 0: 346 if context.rounding == ROUND_CEILING: 347 return Infsign[sign] 348 return Decimal((sign, (9,)*context.prec, 349 context.Emax-context.prec+1)) 350 if sign == 1: 351 if context.rounding == ROUND_FLOOR: 352 return Infsign[sign] 353 return Decimal( (sign, (9,)*context.prec, 354 context.Emax-context.prec+1)) 355 356 357class Underflow(Inexact, Rounded, Subnormal): 358 """Numerical underflow with result rounded to 0. 359 360 This occurs and signals underflow if a result is inexact and the 361 adjusted exponent of the result would be smaller (more negative) than 362 the smallest value that can be handled by the implementation (the value 363 Emin). That is, the result is both inexact and subnormal. 364 365 The result after an underflow will be a subnormal number rounded, if 366 necessary, so that its exponent is not less than Etiny. This may result 367 in 0 with the sign of the intermediate result and an exponent of Etiny. 368 369 In all cases, Inexact, Rounded, and Subnormal will also be raised. 370 """ 371 372# List of public traps and flags 373_signals = [Clamped, DivisionByZero, Inexact, Overflow, Rounded, 374 Underflow, InvalidOperation, Subnormal] 375 376# Map conditions (per the spec) to signals 377_condition_map = {ConversionSyntax:InvalidOperation, 378 DivisionImpossible:InvalidOperation, 379 DivisionUndefined:InvalidOperation, 380 InvalidContext:InvalidOperation} 381 382##### Context Functions ####################################### 383 384# The getcontext() and setcontext() function manage access to a thread-local 385# current context. Py2.4 offers direct support for thread locals. If that 386# is not available, use threading.currentThread() which is slower but will 387# work for older Pythons. If threads are not part of the build, create a 388# mock threading object with threading.local() returning the module namespace. 389 390try: 391 import threading 392except ImportError: 393 # Python was compiled without threads; create a mock object instead 394 import sys 395 class MockThreading: 396 def local(self, sys=sys): 397 return sys.modules[__name__] 398 threading = MockThreading() 399 del sys, MockThreading 400 401try: 402 threading.local 403 404except AttributeError: 405 406 #To fix reloading, force it to create a new context 407 #Old contexts have different exceptions in their dicts, making problems. 408 if hasattr(threading.currentThread(), '__decimal_context__'): 409 del threading.currentThread().__decimal_context__ 410 411 def setcontext(context): 412 """Set this thread's context to context.""" 413 if context in (DefaultContext, BasicContext, ExtendedContext): 414 context = context.copy() 415 context.clear_flags() 416 threading.currentThread().__decimal_context__ = context 417 418 def getcontext(): 419 """Returns this thread's context. 420 421 If this thread does not yet have a context, returns 422 a new context and sets this thread's context. 423 New contexts are copies of DefaultContext. 424 """ 425 try: 426 return threading.currentThread().__decimal_context__ 427 except AttributeError: 428 context = Context() 429 threading.currentThread().__decimal_context__ = context 430 return context 431 432else: 433 434 local = threading.local() 435 if hasattr(local, '__decimal_context__'): 436 del local.__decimal_context__ 437 438 def getcontext(_local=local): 439 """Returns this thread's context. 440 441 If this thread does not yet have a context, returns 442 a new context and sets this thread's context. 443 New contexts are copies of DefaultContext. 444 """ 445 try: 446 return _local.__decimal_context__ 447 except AttributeError: 448 context = Context() 449 _local.__decimal_context__ = context 450 return context 451 452 def setcontext(context, _local=local): 453 """Set this thread's context to context.""" 454 if context in (DefaultContext, BasicContext, ExtendedContext): 455 context = context.copy() 456 context.clear_flags() 457 _local.__decimal_context__ = context 458 459 del threading, local # Don't contaminate the namespace 460 461 462##### Decimal class ########################################### 463 464class Decimal(object): 465 """Floating point class for decimal arithmetic.""" 466 467 __slots__ = ('_exp','_int','_sign', '_is_special') 468 # Generally, the value of the Decimal instance is given by 469 # (-1)**_sign * _int * 10**_exp 470 # Special values are signified by _is_special == True 471 472 # We're immutable, so use __new__ not __init__ 473 def __new__(cls, value="0", context=None): 474 """Create a decimal point instance. 475 476 >>> Decimal('3.14') # string input 477 Decimal("3.14") 478 >>> Decimal((0, (3, 1, 4), -2)) # tuple input (sign, digit_tuple, exponent) 479 Decimal("3.14") 480 >>> Decimal(314) # int or long 481 Decimal("314") 482 >>> Decimal(Decimal(314)) # another decimal instance 483 Decimal("314") 484 """ 485 486 self = object.__new__(cls) 487 self._is_special = False 488 489 # From an internal working value 490 if isinstance(value, _WorkRep): 491 self._sign = value.sign 492 self._int = tuple(map(int, str(value.int))) 493 self._exp = int(value.exp) 494 return self 495 496 # From another decimal 497 if isinstance(value, Decimal): 498 self._exp = value._exp 499 self._sign = value._sign 500 self._int = value._int 501 self._is_special = value._is_special 502 return self 503 504 # From an integer 505 if isinstance(value, (int,long)): 506 if value >= 0: 507 self._sign = 0 508 else: 509 self._sign = 1 510 self._exp = 0 511 self._int = tuple(map(int, str(abs(value)))) 512 return self 513 514 # tuple/list conversion (possibly from as_tuple()) 515 if isinstance(value, (list,tuple)): 516 if len(value) != 3: 517 raise ValueError, 'Invalid arguments' 518 if value[0] not in (0,1): 519 raise ValueError, 'Invalid sign' 520 for digit in value[1]: 521 if not isinstance(digit, (int,long)) or digit < 0: 522 raise ValueError, "The second value in the tuple must be composed of non negative integer elements." 523 524 self._sign = value[0] 525 self._int = tuple(value[1]) 526 if value[2] in ('F','n','N'): 527 self._exp = value[2] 528 self._is_special = True 529 else: 530 self._exp = int(value[2]) 531 return self 532 533 if isinstance(value, float): 534 raise TypeError("Cannot convert float to Decimal. " + 535 "First convert the float to a string") 536 537 # Other argument types may require the context during interpretation 538 if context is None: 539 context = getcontext() 540 541 # From a string 542 # REs insist on real strings, so we can too. 543 if isinstance(value, basestring): 544 if _isinfinity(value): 545 self._exp = 'F' 546 self._int = (0,) 547 self._is_special = True 548 if _isinfinity(value) == 1: 549 self._sign = 0 550 else: 551 self._sign = 1 552 return self 553 if _isnan(value): 554 sig, sign, diag = _isnan(value) 555 self._is_special = True 556 if len(diag) > context.prec: #Diagnostic info too long 557 self._sign, self._int, self._exp = \ 558 context._raise_error(ConversionSyntax) 559 return self 560 if sig == 1: 561 self._exp = 'n' #qNaN 562 else: #sig == 2 563 self._exp = 'N' #sNaN 564 self._sign = sign 565 self._int = tuple(map(int, diag)) #Diagnostic info 566 return self 567 try: 568 self._sign, self._int, self._exp = _string2exact(value) 569 except ValueError: 570 self._is_special = True 571 self._sign, self._int, self._exp = context._raise_error(ConversionSyntax) 572 return self 573 574 raise TypeError("Cannot convert %r to Decimal" % value) 575 576 def _isnan(self): 577 """Returns whether the number is not actually one. 578 579 0 if a number 580 1 if NaN 581 2 if sNaN 582 """ 583 if self._is_special: 584 exp = self._exp 585 if exp == 'n': 586 return 1 587 elif exp == 'N': 588 return 2 589 return 0 590 591 def _isinfinity(self): 592 """Returns whether the number is infinite 593 594 0 if finite or not a number 595 1 if +INF 596 -1 if -INF 597 """ 598 if self._exp == 'F': 599 if self._sign: 600 return -1 601 return 1 602 return 0 603 604 def _check_nans(self, other = None, context=None): 605 """Returns whether the number is not actually one. 606 607 if self, other are sNaN, signal 608 if self, other are NaN return nan 609 return 0 610 611 Done before operations. 612 """ 613 614 self_is_nan = self._isnan() 615 if other is None: 616 other_is_nan = False 617 else: 618 other_is_nan = other._isnan() 619 620 if self_is_nan or other_is_nan: 621 if context is None: 622 context = getcontext() 623 624 if self_is_nan == 2: 625 return context._raise_error(InvalidOperation, 'sNaN', 626 1, self) 627 if other_is_nan == 2: 628 return context._raise_error(InvalidOperation, 'sNaN', 629 1, other) 630 if self_is_nan: 631 return self 632 633 return other 634 return 0 635 636 def __nonzero__(self): 637 """Is the number non-zero? 638 639 0 if self == 0 640 1 if self != 0 641 """ 642 if self._is_special: 643 return 1 644 return sum(self._int) != 0 645 646 def __cmp__(self, other, context=None): 647 other = _convert_other(other) 648 if other is NotImplemented: 649 return other 650 651 if self._is_special or other._is_special: 652 ans = self._check_nans(other, context) 653 if ans: 654 return 1 # Comparison involving NaN's always reports self > other 655 656 # INF = INF 657 return cmp(self._isinfinity(), other._isinfinity()) 658 659 if not self and not other: 660 return 0 #If both 0, sign comparison isn't certain. 661 662 #If different signs, neg one is less 663 if other._sign < self._sign: 664 return -1 665 if self._sign < other._sign: 666 return 1 667 668 self_adjusted = self.adjusted() 669 other_adjusted = other.adjusted() 670 if self_adjusted == other_adjusted and \ 671 self._int + (0,)*(self._exp - other._exp) == \ 672 other._int + (0,)*(other._exp - self._exp): 673 return 0 #equal, except in precision. ([0]*(-x) = []) 674 elif self_adjusted > other_adjusted and self._int[0] != 0: 675 return (-1)**self._sign 676 elif self_adjusted < other_adjusted and other._int[0] != 0: 677 return -((-1)**self._sign) 678 679 # Need to round, so make sure we have a valid context 680 if context is None: 681 context = getcontext() 682 683 context = context._shallow_copy() 684 rounding = context._set_rounding(ROUND_UP) #round away from 0 685 686 flags = context._ignore_all_flags() 687 res = self.__sub__(other, context=context) 688 689 context._regard_flags(*flags) 690 691 context.rounding = rounding 692 693 if not res: 694 return 0 695 elif res._sign: 696 return -1 697 return 1 698 699 def __eq__(self, other): 700 if not isinstance(other, (Decimal, int, long)): 701 return NotImplemented 702 return self.__cmp__(other) == 0 703 704 def __ne__(self, other): 705 if not isinstance(other, (Decimal, int, long)): 706 return NotImplemented 707 return self.__cmp__(other) != 0 708 709 def compare(self, other, context=None): 710 """Compares one to another. 711 712 -1 => a < b 713 0 => a = b 714 1 => a > b 715 NaN => one is NaN 716 Like __cmp__, but returns Decimal instances. 717 """ 718 other = _convert_other(other) 719 if other is NotImplemented: 720 return other 721 722 #compare(NaN, NaN) = NaN 723 if (self._is_special or other and other._is_special): 724 ans = self._check_nans(other, context) 725 if ans: 726 return ans 727 728 return Decimal(self.__cmp__(other, context)) 729 730 def __hash__(self): 731 """x.__hash__() <==> hash(x)""" 732 # Decimal integers must hash the same as the ints 733 # Non-integer decimals are normalized and hashed as strings 734 # Normalization assures that hast(100E-1) == hash(10) 735 if self._is_special: 736 if self._isnan(): 737 raise TypeError('Cannot hash a NaN value.') 738 return hash(str(self)) 739 i = int(self) 740 if self == Decimal(i): 741 return hash(i) 742 assert self.__nonzero__() # '-0' handled by integer case 743 return hash(str(self.normalize())) 744 745 def as_tuple(self): 746 """Represents the number as a triple tuple. 747 748 To show the internals exactly as they are. 749 """ 750 return (self._sign, self._int, self._exp) 751 752 def __repr__(self): 753 """Represents the number as an instance of Decimal.""" 754 # Invariant: eval(repr(d)) == d 755 return 'Decimal("%s")' % str(self) 756 757 def __str__(self, eng = 0, context=None): 758 """Return string representation of the number in scientific notation. 759 760 Captures all of the information in the underlying representation. 761 """ 762 763 if self._is_special: 764 if self._isnan(): 765 minus = '-'*self._sign 766 if self._int == (0,): 767 info = '' 768 else: 769 info = ''.join(map(str, self._int)) 770 if self._isnan() == 2: 771 return minus + 'sNaN' + info 772 return minus + 'NaN' + info 773 if self._isinfinity(): 774 minus = '-'*self._sign 775 return minus + 'Infinity' 776 777 if context is None: 778 context = getcontext() 779 780 tmp = map(str, self._int) 781 numdigits = len(self._int) 782 leftdigits = self._exp + numdigits 783 if eng and not self: #self = 0eX wants 0[.0[0]]eY, not [[0]0]0eY 784 if self._exp < 0 and self._exp >= -6: #short, no need for e/E 785 s = '-'*self._sign + '0.' + '0'*(abs(self._exp)) 786 return s 787 #exp is closest mult. of 3 >= self._exp 788 exp = ((self._exp - 1)// 3 + 1) * 3 789 if exp != self._exp: 790 s = '0.'+'0'*(exp - self._exp) 791 else: 792 s = '0' 793 if exp != 0: 794 if context.capitals: 795 s += 'E' 796 else: 797 s += 'e' 798 if exp > 0: 799 s += '+' #0.0e+3, not 0.0e3 800 s += str(exp) 801 s = '-'*self._sign + s 802 return s 803 if eng: 804 dotplace = (leftdigits-1)%3+1 805 adjexp = leftdigits -1 - (leftdigits-1)%3 806 else: 807 adjexp = leftdigits-1 808 dotplace = 1 809 if self._exp == 0: 810 pass 811 elif self._exp < 0 and adjexp >= 0: 812 tmp.insert(leftdigits, '.') 813 elif self._exp < 0 and adjexp >= -6: 814 tmp[0:0] = ['0'] * int(-leftdigits) 815 tmp.insert(0, '0.') 816 else: 817 if numdigits > dotplace: 818 tmp.insert(dotplace, '.') 819 elif numdigits < dotplace: 820 tmp.extend(['0']*(dotplace-numdigits)) 821 if adjexp: 822 if not context.capitals: 823 tmp.append('e') 824 else: 825 tmp.append('E') 826 if adjexp > 0: 827 tmp.append('+') 828 tmp.append(str(adjexp)) 829 if eng: 830 while tmp[0:1] == ['0']: 831 tmp[0:1] = [] 832 if len(tmp) == 0 or tmp[0] == '.' or tmp[0].lower() == 'e': 833 tmp[0:0] = ['0'] 834 if self._sign: 835 tmp.insert(0, '-') 836 837 return ''.join(tmp) 838 839 def to_eng_string(self, context=None): 840 """Convert to engineering-type string. 841 842 Engineering notation has an exponent which is a multiple of 3, so there 843 are up to 3 digits left of the decimal place. 844 845 Same rules for when in exponential and when as a value as in __str__. 846 """ 847 return self.__str__(eng=1, context=context) 848 849 def __neg__(self, context=None): 850 """Returns a copy with the sign switched. 851 852 Rounds, if it has reason. 853 """ 854 if self._is_special: 855 ans = self._check_nans(context=context) 856 if ans: 857 return ans 858 859 if not self: 860 # -Decimal('0') is Decimal('0'), not Decimal('-0') 861 sign = 0 862 elif self._sign: 863 sign = 0 864 else: 865 sign = 1 866 867 if context is None: 868 context = getcontext() 869 if context._rounding_decision == ALWAYS_ROUND: 870 return Decimal((sign, self._int, self._exp))._fix(context) 871 return Decimal( (sign, self._int, self._exp)) 872 873 def __pos__(self, context=None): 874 """Returns a copy, unless it is a sNaN. 875 876 Rounds the number (if more then precision digits) 877 """ 878 if self._is_special: 879 ans = self._check_nans(context=context) 880 if ans: 881 return ans 882 883 sign = self._sign 884 if not self: 885 # + (-0) = 0 886 sign = 0 887 888 if context is None: 889 context = getcontext() 890 891 if context._rounding_decision == ALWAYS_ROUND: 892 ans = self._fix(context) 893 else: 894 ans = Decimal(self) 895 ans._sign = sign 896 return ans 897 898 def __abs__(self, round=1, context=None): 899 """Returns the absolute value of self. 900 901 If the second argument is 0, do not round. 902 """ 903 if self._is_special: 904 ans = self._check_nans(context=context) 905 if ans: 906 return ans 907 908 if not round: 909 if context is None: 910 context = getcontext() 911 context = context._shallow_copy() 912 context._set_rounding_decision(NEVER_ROUND) 913 914 if self._sign: 915 ans = self.__neg__(context=context) 916 else: 917 ans = self.__pos__(context=context) 918 919 return ans 920 921 def __add__(self, other, context=None): 922 """Returns self + other. 923 924 -INF + INF (or the reverse) cause InvalidOperation errors. 925 """ 926 other = _convert_other(other) 927 if other is NotImplemented: 928 return other 929 930 if context is None: 931 context = getcontext() 932 933 if self._is_special or other._is_special: 934 ans = self._check_nans(other, context) 935 if ans: 936 return ans 937 938 if self._isinfinity(): 939 #If both INF, same sign => same as both, opposite => error. 940 if self._sign != other._sign and other._isinfinity(): 941 return context._raise_error(InvalidOperation, '-INF + INF') 942 return Decimal(self) 943 if other._isinfinity(): 944 return Decimal(other) #Can't both be infinity here 945 946 shouldround = context._rounding_decision == ALWAYS_ROUND 947 948 exp = min(self._exp, other._exp) 949 negativezero = 0 950 if context.rounding == ROUND_FLOOR and self._sign != other._sign: 951 #If the answer is 0, the sign should be negative, in this case. 952 negativezero = 1 953 954 if not self and not other: 955 sign = min(self._sign, other._sign) 956 if negativezero: 957 sign = 1 958 return Decimal( (sign, (0,), exp)) 959 if not self: 960 exp = max(exp, other._exp - context.prec-1) 961 ans = other._rescale(exp, watchexp=0, context=context) 962 if shouldround: 963 ans = ans._fix(context) 964 return ans 965 if not other: 966 exp = max(exp, self._exp - context.prec-1) 967 ans = self._rescale(exp, watchexp=0, context=context) 968 if shouldround: 969 ans = ans._fix(context) 970 return ans 971 972 op1 = _WorkRep(self) 973 op2 = _WorkRep(other) 974 op1, op2 = _normalize(op1, op2, shouldround, context.prec) 975 976 result = _WorkRep() 977 if op1.sign != op2.sign: 978 # Equal and opposite 979 if op1.int == op2.int: 980 if exp < context.Etiny(): 981 exp = context.Etiny() 982 context._raise_error(Clamped) 983 return Decimal((negativezero, (0,), exp)) 984 if op1.int < op2.int: 985 op1, op2 = op2, op1 986 #OK, now abs(op1) > abs(op2) 987 if op1.sign == 1: 988 result.sign = 1 989 op1.sign, op2.sign = op2.sign, op1.sign 990 else: 991 result.sign = 0 992 #So we know the sign, and op1 > 0. 993 elif op1.sign == 1: 994 result.sign = 1 995 op1.sign, op2.sign = (0, 0) 996 else: 997 result.sign = 0 998 #Now, op1 > abs(op2) > 0 999 1000 if op2.sign == 0: 1001 result.int = op1.int + op2.int 1002 else: 1003 result.int = op1.int - op2.int 1004 1005 result.exp = op1.exp 1006 ans = Decimal(result) 1007 if shouldround: 1008 ans = ans._fix(context) 1009 return ans 1010 1011 __radd__ = __add__ 1012 1013 def __sub__(self, other, context=None): 1014 """Return self + (-other)""" 1015 other = _convert_other(other) 1016 if other is NotImplemented: 1017 return other 1018 1019 if self._is_special or other._is_special: 1020 ans = self._check_nans(other, context=context) 1021 if ans: 1022 return ans 1023 1024 # -Decimal(0) = Decimal(0), which we don't want since 1025 # (-0 - 0 = -0 + (-0) = -0, but -0 + 0 = 0.) 1026 # so we change the sign directly to a copy 1027 tmp = Decimal(other) 1028 tmp._sign = 1-tmp._sign 1029 1030 return self.__add__(tmp, context=context) 1031 1032 def __rsub__(self, other, context=None): 1033 """Return other + (-self)""" 1034 other = _convert_other(other) 1035 if other is NotImplemented: 1036 return other 1037 1038 tmp = Decimal(self) 1039 tmp._sign = 1 - tmp._sign 1040 return other.__add__(tmp, context=context) 1041 1042 def _increment(self, round=1, context=None): 1043 """Special case of add, adding 1eExponent 1044 1045 Since it is common, (rounding, for example) this adds 1046 (sign)*one E self._exp to the number more efficiently than add. 1047 1048 For example: 1049 Decimal('5.624e10')._increment() == Decimal('5.625e10') 1050 """ 1051 if self._is_special: 1052 ans = self._check_nans(context=context) 1053 if ans: 1054 return ans 1055 1056 return Decimal(self) # Must be infinite, and incrementing makes no difference 1057 1058 L = list(self._int) 1059 L[-1] += 1 1060 spot = len(L)-1 1061 while L[spot] == 10: 1062 L[spot] = 0 1063 if spot == 0: 1064 L[0:0] = [1] 1065 break 1066 L[spot-1] += 1 1067 spot -= 1 1068 ans = Decimal((self._sign, L, self._exp)) 1069 1070 if context is None: 1071 context = getcontext() 1072 if round and context._rounding_decision == ALWAYS_ROUND: 1073 ans = ans._fix(context) 1074 return ans 1075 1076 def __mul__(self, other, context=None): 1077 """Return self * other. 1078 1079 (+-) INF * 0 (or its reverse) raise InvalidOperation. 1080 """ 1081 other = _convert_other(other) 1082 if other is NotImplemented: 1083 return other 1084 1085 if context is None: 1086 context = getcontext() 1087 1088 resultsign = self._sign ^ other._sign 1089 1090 if self._is_special or other._is_special: 1091 ans = self._check_nans(other, context) 1092 if ans: 1093 return ans 1094 1095 if self._isinfinity(): 1096 if not other: 1097 return context._raise_error(InvalidOperation, '(+-)INF * 0') 1098 return Infsign[resultsign] 1099 1100 if other._isinfinity(): 1101 if not self: 1102 return context._raise_error(InvalidOperation, '0 * (+-)INF') 1103 return Infsign[resultsign] 1104 1105 resultexp = self._exp + other._exp 1106 shouldround = context._rounding_decision == ALWAYS_ROUND 1107 1108 # Special case for multiplying by zero 1109 if not self or not other: 1110 ans = Decimal((resultsign, (0,), resultexp)) 1111 if shouldround: 1112 #Fixing in case the exponent is out of bounds 1113 ans = ans._fix(context) 1114 return ans 1115 1116 # Special case for multiplying by power of 10 1117 if self._int == (1,): 1118 ans = Decimal((resultsign, other._int, resultexp)) 1119 if shouldround: 1120 ans = ans._fix(context) 1121 return ans 1122 if other._int == (1,): 1123 ans = Decimal((resultsign, self._int, resultexp)) 1124 if shouldround: 1125 ans = ans._fix(context) 1126 return ans 1127 1128 op1 = _WorkRep(self) 1129 op2 = _WorkRep(other) 1130 1131 ans = Decimal( (resultsign, map(int, str(op1.int * op2.int)), resultexp)) 1132 if shouldround: 1133 ans = ans._fix(context) 1134 1135 return ans 1136 __rmul__ = __mul__ 1137 1138 def __div__(self, other, context=None): 1139 """Return self / other.""" 1140 return self._divide(other, context=context) 1141 __truediv__ = __div__ 1142 1143 def _divide(self, other, divmod = 0, context=None): 1144 """Return a / b, to context.prec precision. 1145 1146 divmod: 1147 0 => true division 1148 1 => (a //b, a%b) 1149 2 => a //b 1150 3 => a%b 1151 1152 Actually, if divmod is 2 or 3 a tuple is returned, but errors for 1153 computing the other value are not raised. 1154 """ 1155 other = _convert_other(other) 1156 if other is NotImplemented: 1157 if divmod in (0, 1): 1158 return NotImplemented 1159 return (NotImplemented, NotImplemented) 1160 1161 if context is None: 1162 context = getcontext() 1163 1164 sign = self._sign ^ other._sign 1165 1166 if self._is_special or other._is_special: 1167 ans = self._check_nans(other, context) 1168 if ans: 1169 if divmod: 1170 return (ans, ans) 1171 return ans 1172 1173 if self._isinfinity() and other._isinfinity(): 1174 if divmod: 1175 return (context._raise_error(InvalidOperation, 1176 '(+-)INF // (+-)INF'), 1177 context._raise_error(InvalidOperation, 1178 '(+-)INF % (+-)INF')) 1179 return context._raise_error(InvalidOperation, '(+-)INF/(+-)INF') 1180 1181 if self._isinfinity(): 1182 if divmod == 1: 1183 return (Infsign[sign], 1184 context._raise_error(InvalidOperation, 'INF % x')) 1185 elif divmod == 2: 1186 return (Infsign[sign], NaN) 1187 elif divmod == 3: 1188 return (Infsign[sign], 1189 context._raise_error(InvalidOperation, 'INF % x')) 1190 return Infsign[sign] 1191 1192 if other._isinfinity(): 1193 if divmod: 1194 return (Decimal((sign, (0,), 0)), Decimal(self)) 1195 context._raise_error(Clamped, 'Division by infinity') 1196 return Decimal((sign, (0,), context.Etiny())) 1197 1198 # Special cases for zeroes 1199 if not self and not other: 1200 if divmod: 1201 return context._raise_error(DivisionUndefined, '0 / 0', 1) 1202 return context._raise_error(DivisionUndefined, '0 / 0') 1203 1204 if not self: 1205 if divmod: 1206 otherside = Decimal(self) 1207 otherside._exp = min(self._exp, other._exp) 1208 return (Decimal((sign, (0,), 0)), otherside) 1209 exp = self._exp - other._exp 1210 if exp < context.Etiny(): 1211 exp = context.Etiny() 1212 context._raise_error(Clamped, '0e-x / y') 1213 if exp > context.Emax: 1214 exp = context.Emax 1215 context._raise_error(Clamped, '0e+x / y') 1216 return Decimal( (sign, (0,), exp) ) 1217 1218 if not other: 1219 if divmod: 1220 return context._raise_error(DivisionByZero, 'divmod(x,0)', 1221 sign, 1) 1222 return context._raise_error(DivisionByZero, 'x / 0', sign) 1223 1224 #OK, so neither = 0, INF or NaN 1225 1226 shouldround = context._rounding_decision == ALWAYS_ROUND 1227 1228 #If we're dividing into ints, and self < other, stop. 1229 #self.__abs__(0) does not round. 1230 if divmod and (self.__abs__(0, context) < other.__abs__(0, context)): 1231 1232 if divmod == 1 or divmod == 3: 1233 exp = min(self._exp, other._exp) 1234 ans2 = self._rescale(exp, context=context, watchexp=0) 1235 if shouldround: 1236 ans2 = ans2._fix(context) 1237 return (Decimal( (sign, (0,), 0) ), 1238 ans2) 1239 1240 elif divmod == 2: 1241 #Don't round the mod part, if we don't need it. 1242 return (Decimal( (sign, (0,), 0) ), Decimal(self)) 1243 1244 op1 = _WorkRep(self) 1245 op2 = _WorkRep(other) 1246 op1, op2, adjust = _adjust_coefficients(op1, op2) 1247 res = _WorkRep( (sign, 0, (op1.exp - op2.exp)) ) 1248 if divmod and res.exp > context.prec + 1: 1249 return context._raise_error(DivisionImpossible) 1250 1251 prec_limit = 10 ** context.prec 1252 while 1: 1253 while op2.int <= op1.int: 1254 res.int += 1 1255 op1.int -= op2.int 1256 if res.exp == 0 and divmod: 1257 if res.int >= prec_limit and shouldround: 1258 return context._raise_error(DivisionImpossible) 1259 otherside = Decimal(op1) 1260 frozen = context._ignore_all_flags() 1261 1262 exp = min(self._exp, other._exp) 1263 otherside = otherside._rescale(exp, context=context, watchexp=0) 1264 context._regard_flags(*frozen) 1265 if shouldround: 1266 otherside = otherside._fix(context) 1267 return (Decimal(res), otherside) 1268 1269 if op1.int == 0 and adjust >= 0 and not divmod: 1270 break 1271 if res.int >= prec_limit and shouldround: 1272 if divmod: 1273 return context._raise_error(DivisionImpossible) 1274 shouldround=1 1275 # Really, the answer is a bit higher, so adding a one to 1276 # the end will make sure the rounding is right. 1277 if op1.int != 0: 1278 res.int *= 10 1279 res.int += 1 1280 res.exp -= 1 1281 1282 break 1283 res.int *= 10 1284 res.exp -= 1 1285 adjust += 1 1286 op1.int *= 10 1287 op1.exp -= 1 1288 1289 if res.exp == 0 and divmod and op2.int > op1.int: 1290 #Solves an error in precision. Same as a previous block. 1291 1292 if res.int >= prec_limit and shouldround: 1293 return context._raise_error(DivisionImpossible) 1294 otherside = Decimal(op1) 1295 frozen = context._ignore_all_flags() 1296 1297 exp = min(self._exp, other._exp) 1298 otherside = otherside._rescale(exp, context=context) 1299 1300 context._regard_flags(*frozen) 1301 1302 return (Decimal(res), otherside) 1303 1304 ans = Decimal(res) 1305 if shouldround: 1306 ans = ans._fix(context) 1307 return ans 1308 1309 def __rdiv__(self, other, context=None): 1310 """Swaps self/other and returns __div__.""" 1311 other = _convert_other(other) 1312 if other is NotImplemented: 1313 return other 1314 return other.__div__(self, context=context) 1315 __rtruediv__ = __rdiv__ 1316 1317 def __divmod__(self, other, context=None): 1318 """ 1319 (self // other, self % other) 1320 """ 1321 return self._divide(other, 1, context) 1322 1323 def __rdivmod__(self, other, context=None): 1324 """Swaps self/other and returns __divmod__.""" 1325 other = _convert_other(other) 1326 if other is NotImplemented: 1327 return other 1328 return other.__divmod__(self, context=context) 1329 1330 def __mod__(self, other, context=None): 1331 """ 1332 self % other 1333 """ 1334 other = _convert_other(other) 1335 if other is NotImplemented: 1336 return other 1337 1338 if self._is_special or other._is_special: 1339 ans = self._check_nans(other, context) 1340 if ans: 1341 return ans 1342 1343 if self and not other: 1344 return context._raise_error(InvalidOperation, 'x % 0') 1345 1346 return self._divide(other, 3, context)[1] 1347 1348 def __rmod__(self, other, context=None): 1349 """Swaps self/other and returns __mod__.""" 1350 other = _convert_other(other) 1351 if other is NotImplemented: 1352 return other 1353 return other.__mod__(self, context=context) 1354 1355 def remainder_near(self, other, context=None): 1356 """ 1357 Remainder nearest to 0- abs(remainder-near) <= other/2 1358 """ 1359 other = _convert_other(other) 1360 if other is NotImplemented: 1361 return other 1362 1363 if self._is_special or other._is_special: 1364 ans = self._check_nans(other, context) 1365 if ans: 1366 return ans 1367 if self and not other: 1368 return context._raise_error(InvalidOperation, 'x % 0') 1369 1370 if context is None: 1371 context = getcontext() 1372 # If DivisionImpossible causes an error, do not leave Rounded/Inexact 1373 # ignored in the calling function. 1374 context = context._shallow_copy() 1375 flags = context._ignore_flags(Rounded, Inexact) 1376 #keep DivisionImpossible flags 1377 (side, r) = self.__divmod__(other, context=context) 1378 1379 if r._isnan(): 1380 context._regard_flags(*flags) 1381 return r 1382 1383 context = context._shallow_copy() 1384 rounding = context._set_rounding_decision(NEVER_ROUND) 1385 1386 if other._sign: 1387 comparison = other.__div__(Decimal(-2), context=context) 1388 else: 1389 comparison = other.__div__(Decimal(2), context=context) 1390 1391 context._set_rounding_decision(rounding) 1392 context._regard_flags(*flags) 1393 1394 s1, s2 = r._sign, comparison._sign 1395 r._sign, comparison._sign = 0, 0 1396 1397 if r < comparison: 1398 r._sign, comparison._sign = s1, s2 1399 #Get flags now 1400 self.__divmod__(other, context=context) 1401 return r._fix(context) 1402 r._sign, comparison._sign = s1, s2 1403 1404 rounding = context._set_rounding_decision(NEVER_ROUND) 1405 1406 (side, r) = self.__divmod__(other, context=context) 1407 context._set_rounding_decision(rounding) 1408 if r._isnan(): 1409 return r 1410 1411 decrease = not side._iseven() 1412 rounding = context._set_rounding_decision(NEVER_ROUND) 1413 side = side.__abs__(context=context) 1414 context._set_rounding_decision(rounding) 1415 1416 s1, s2 = r._sign, comparison._sign 1417 r._sign, comparison._sign = 0, 0 1418 if r > comparison or decrease and r == comparison: 1419 r._sign, comparison._sign = s1, s2 1420 context.prec += 1 1421 if len(side.__add__(Decimal(1), context=context)._int) >= context.prec: 1422 context.prec -= 1 1423 return context._raise_error(DivisionImpossible)[1] 1424 context.prec -= 1 1425 if self._sign == other._sign: 1426 r = r.__sub__(other, context=context) 1427 else: 1428 r = r.__add__(other, context=context) 1429 else: 1430 r._sign, comparison._sign = s1, s2 1431 1432 return r._fix(context) 1433 1434 def __floordiv__(self, other, context=None): 1435 """self // other""" 1436 return self._divide(other, 2, context)[0] 1437 1438 def __rfloordiv__(self, other, context=None): 1439 """Swaps self/other and returns __floordiv__.""" 1440 other = _convert_other(other) 1441 if other is NotImplemented: 1442 return other 1443 return other.__floordiv__(self, context=context) 1444 1445 def __float__(self): 1446 """Float representation.""" 1447 return float(str(self)) 1448 1449 def __int__(self): 1450 """Converts self to an int, truncating if necessary.""" 1451 if self._is_special: 1452 if self._isnan(): 1453 context = getcontext() 1454 return context._raise_error(InvalidContext) 1455 elif self._isinfinity(): 1456 raise OverflowError, "Cannot convert infinity to long" 1457 if self._exp >= 0: 1458 s = ''.join(map(str, self._int)) + '0'*self._exp 1459 else: 1460 s = ''.join(map(str, self._int))[:self._exp] 1461 if s == '': 1462 s = '0' 1463 sign = '-'*self._sign 1464 return int(sign + s) 1465 1466 def __long__(self): 1467 """Converts to a long. 1468 1469 Equivalent to long(int(self)) 1470 """ 1471 return long(self.__int__()) 1472 1473 def _fix(self, context): 1474 """Round if it is necessary to keep self within prec precision. 1475 1476 Rounds and fixes the exponent. Does not raise on a sNaN. 1477 1478 Arguments: 1479 self - Decimal instance 1480 context - context used. 1481 """ 1482 if self._is_special: 1483 return self 1484 if context is None: 1485 context = getcontext() 1486 prec = context.prec 1487 ans = self._fixexponents(context) 1488 if len(ans._int) > prec: 1489 ans = ans._round(prec, context=context) 1490 ans = ans._fixexponents(context) 1491 return ans 1492 1493 def _fixexponents(self, context): 1494 """Fix the exponents and return a copy with the exponent in bounds. 1495 Only call if known to not be a special value. 1496 """ 1497 folddown = context._clamp 1498 Emin = context.Emin 1499 ans = self 1500 ans_adjusted = ans.adjusted() 1501 if ans_adjusted < Emin: 1502 Etiny = context.Etiny() 1503 if ans._exp < Etiny: 1504 if not ans: 1505 ans = Decimal(self) 1506 ans._exp = Etiny 1507 context._raise_error(Clamped) 1508 return ans 1509 ans = ans._rescale(Etiny, context=context) 1510 #It isn't zero, and exp < Emin => subnormal 1511 context._raise_error(Subnormal) 1512 if context.flags[Inexact]: 1513 context._raise_error(Underflow) 1514 else: 1515 if ans: 1516 #Only raise subnormal if non-zero. 1517 context._raise_error(Subnormal) 1518 else: 1519 Etop = context.Etop() 1520 if folddown and ans._exp > Etop: 1521 context._raise_error(Clamped) 1522 ans = ans._rescale(Etop, context=context) 1523 else: 1524 Emax = context.Emax 1525 if ans_adjusted > Emax: 1526 if not ans: 1527 ans = Decimal(self) 1528 ans._exp = Emax 1529 context._raise_error(Clamped) 1530 return ans 1531 context._raise_error(Inexact) 1532 context._raise_error(Rounded) 1533 return context._raise_error(Overflow, 'above Emax', ans._sign) 1534 return ans 1535 1536 def _round(self, prec=None, rounding=None, context=None): 1537 """Returns a rounded version of self. 1538 1539 You can specify the precision or rounding method. Otherwise, the 1540 context determines it. 1541 """ 1542 1543 if self._is_special: 1544 ans = self._check_nans(context=context) 1545 if ans: 1546 return ans 1547 1548 if self._isinfinity(): 1549 return Decimal(self) 1550 1551 if context is None: 1552 context = getcontext() 1553 1554 if rounding is None: 1555 rounding = context.rounding 1556 if prec is None: 1557 prec = context.prec 1558 1559 if not self: 1560 if prec <= 0: 1561 dig = (0,) 1562 exp = len(self._int) - prec + self._exp 1563 else: 1564 dig = (0,) * prec 1565 exp = len(self._int) + self._exp - prec 1566 ans = Decimal((self._sign, dig, exp)) 1567 context._raise_error(Rounded) 1568 return ans 1569 1570 if prec == 0: 1571 temp = Decimal(self) 1572 temp._int = (0,)+temp._int 1573 prec = 1 1574 elif prec < 0: 1575 exp = self._exp + len(self._int) - prec - 1 1576 temp = Decimal( (self._sign, (0, 1), exp)) 1577 prec = 1 1578 else: 1579 temp = Decimal(self) 1580 1581 numdigits = len(temp._int) 1582 if prec == numdigits: 1583 return temp 1584 1585 # See if we need to extend precision 1586 expdiff = prec - numdigits 1587 if expdiff > 0: 1588 tmp = list(temp._int) 1589 tmp.extend([0] * expdiff) 1590 ans = Decimal( (temp._sign, tmp, temp._exp - expdiff)) 1591 return ans 1592 1593 #OK, but maybe all the lost digits are 0. 1594 lostdigits = self._int[expdiff:] 1595 if lostdigits == (0,) * len(lostdigits): 1596 ans = Decimal( (temp._sign, temp._int[:prec], temp._exp - expdiff)) 1597 #Rounded, but not Inexact 1598 context._raise_error(Rounded) 1599 return ans 1600 1601 # Okay, let's round and lose data 1602 1603 this_function = getattr(temp, self._pick_rounding_function[rounding]) 1604 #Now we've got the rounding function 1605 1606 if prec != context.prec: 1607 context = context._shallow_copy() 1608 context.prec = prec 1609 ans = this_function(prec, expdiff, context) 1610 context._raise_error(Rounded) 1611 context._raise_error(Inexact, 'Changed in rounding') 1612 1613 return ans 1614 1615 _pick_rounding_function = {} 1616 1617 def _round_down(self, prec, expdiff, context): 1618 """Also known as round-towards-0, truncate.""" 1619 return Decimal( (self._sign, self._int[:prec], self._exp - expdiff) ) 1620 1621 def _round_half_up(self, prec, expdiff, context, tmp = None): 1622 """Rounds 5 up (away from 0)""" 1623 1624 if tmp is None: 1625 tmp = Decimal( (self._sign,self._int[:prec], self._exp - expdiff)) 1626 if self._int[prec] >= 5: 1627 tmp = tmp._increment(round=0, context=context) 1628 if len(tmp._int) > prec: 1629 return Decimal( (tmp._sign, tmp._int[:-1], tmp._exp + 1)) 1630 return tmp 1631 1632 def _round_half_even(self, prec, expdiff, context): 1633 """Round 5 to even, rest to nearest.""" 1634 1635 tmp = Decimal( (self._sign, self._int[:prec], self._exp - expdiff)) 1636 half = (self._int[prec] == 5) 1637 if half: 1638 for digit in self._int[prec+1:]: 1639 if digit != 0: 1640 half = 0 1641 break 1642 if half: 1643 if self._int[prec-1] & 1 == 0: 1644 return tmp 1645 return self._round_half_up(prec, expdiff, context, tmp) 1646 1647 def _round_half_down(self, prec, expdiff, context): 1648 """Round 5 down""" 1649 1650 tmp = Decimal( (self._sign, self._int[:prec], self._exp - expdiff)) 1651 half = (self._int[prec] == 5) 1652 if half: 1653 for digit in self._int[prec+1:]: 1654 if digit != 0: 1655 half = 0 1656 break 1657 if half: 1658 return tmp 1659 return self._round_half_up(prec, expdiff, context, tmp) 1660 1661 def _round_up(self, prec, expdiff, context): 1662 """Rounds away from 0.""" 1663 tmp = Decimal( (self._sign, self._int[:prec], self._exp - expdiff) ) 1664 for digit in self._int[prec:]: 1665 if digit != 0: 1666 tmp = tmp._increment(round=1, context=context) 1667 if len(tmp._int) > prec: 1668 return Decimal( (tmp._sign, tmp._int[:-1], tmp._exp + 1)) 1669 else: 1670 return tmp 1671 return tmp 1672 1673 def _round_ceiling(self, prec, expdiff, context): 1674 """Rounds up (not away from 0 if negative.)""" 1675 if self._sign: 1676 return self._round_down(prec, expdiff, context) 1677 else: 1678 return self._round_up(prec, expdiff, context) 1679 1680 def _round_floor(self, prec, expdiff, context): 1681 """Rounds down (not towards 0 if negative)""" 1682 if not self._sign: 1683 return self._round_down(prec, expdiff, context) 1684 else: 1685 return self._round_up(prec, expdiff, context) 1686 1687 def __pow__(self, n, modulo = None, context=None): 1688 """Return self ** n (mod modulo) 1689 1690 If modulo is None (default), don't take it mod modulo. 1691 """ 1692 n = _convert_other(n) 1693 if n is NotImplemented: 1694 return n 1695 1696 if context is None: 1697 context = getcontext() 1698 1699 if self._is_special or n._is_special or n.adjusted() > 8: 1700 #Because the spot << doesn't work with really big exponents 1701 if n._isinfinity() or n.adjusted() > 8: 1702 return context._raise_error(InvalidOperation, 'x ** INF') 1703 1704 ans = self._check_nans(n, context) 1705 if ans: 1706 return ans 1707 1708 if not n._isinteger(): 1709 return context._raise_error(InvalidOperation, 'x ** (non-integer)') 1710 1711 if not self and not n: 1712 return context._raise_error(InvalidOperation, '0 ** 0') 1713 1714 if not n: 1715 return Decimal(1) 1716 1717 if self == Decimal(1): 1718 return Decimal(1) 1719 1720 sign = self._sign and not n._iseven() 1721 n = int(n) 1722 1723 if self._isinfinity(): 1724 if modulo: 1725 return context._raise_error(InvalidOperation, 'INF % x') 1726 if n > 0: 1727 return Infsign[sign] 1728 return Decimal( (sign, (0,), 0) ) 1729 1730 #with ludicrously large exponent, just raise an overflow and return inf. 1731 if not modulo and n > 0 and (self._exp + len(self._int) - 1) * n > context.Emax \ 1732 and self: 1733 1734 tmp = Decimal('inf') 1735 tmp._sign = sign 1736 context._raise_error(Rounded) 1737 context._raise_error(Inexact) 1738 context._raise_error(Overflow, 'Big power', sign) 1739 return tmp 1740 1741 elength = len(str(abs(n))) 1742 firstprec = context.prec 1743 1744 if not modulo and firstprec + elength + 1 > DefaultContext.Emax: 1745 return context._raise_error(Overflow, 'Too much precision.', sign) 1746 1747 mul = Decimal(self) 1748 val = Decimal(1) 1749 context = context._shallow_copy() 1750 context.prec = firstprec + elength + 1 1751 if n < 0: 1752 #n is a long now, not Decimal instance 1753 n = -n 1754 mul = Decimal(1).__div__(mul, context=context) 1755 1756 spot = 1 1757 while spot <= n: 1758 spot <<= 1 1759 1760 spot >>= 1 1761 #Spot is the highest power of 2 less than n 1762 while spot: 1763 val = val.__mul__(val, context=context) 1764 if val._isinfinity(): 1765 val = Infsign[sign] 1766 break 1767 if spot & n: 1768 val = val.__mul__(mul, context=context) 1769 if modulo is not None: 1770 val = val.__mod__(modulo, context=context) 1771 spot >>= 1 1772 context.prec = firstprec 1773 1774 if context._rounding_decision == ALWAYS_ROUND: 1775 return val._fix(context) 1776 return val 1777 1778 def __rpow__(self, other, context=None): 1779 """Swaps self/other and returns __pow__.""" 1780 other = _convert_other(other) 1781 if other is NotImplemented: 1782 return other 1783 return other.__pow__(self, context=context) 1784 1785 def normalize(self, context=None): 1786 """Normalize- strip trailing 0s, change anything equal to 0 to 0e0""" 1787 1788 if self._is_special: 1789 ans = self._check_nans(context=context) 1790 if ans: 1791 return ans 1792 1793 dup = self._fix(context) 1794 if dup._isinfinity(): 1795 return dup 1796 1797 if not dup: 1798 return Decimal( (dup._sign, (0,), 0) ) 1799 end = len(dup._int) 1800 exp = dup._exp 1801 while dup._int[end-1] == 0: 1802 exp += 1 1803 end -= 1 1804 return Decimal( (dup._sign, dup._int[:end], exp) ) 1805 1806 1807 def quantize(self, exp, rounding=None, context=None, watchexp=1): 1808 """Quantize self so its exponent is the same as that of exp. 1809 1810 Similar to self._rescale(exp._exp) but with error checking. 1811 """ 1812 if self._is_special or exp._is_special: 1813 ans = self._check_nans(exp, context) 1814 if ans: 1815 return ans 1816 1817 if exp._isinfinity() or self._isinfinity(): 1818 if exp._isinfinity() and self._isinfinity(): 1819 return self #if both are inf, it is OK 1820 if context is None: 1821 context = getcontext() 1822 return context._raise_error(InvalidOperation, 1823 'quantize with one INF') 1824 return self._rescale(exp._exp, rounding, context, watchexp) 1825 1826 def same_quantum(self, other): 1827 """Test whether self and other have the same exponent. 1828 1829 same as self._exp == other._exp, except NaN == sNaN 1830 """ 1831 if self._is_special or other._is_special: 1832 if self._isnan() or other._isnan(): 1833 return self._isnan() and other._isnan() and True 1834 if self._isinfinity() or other._isinfinity(): 1835 return self._isinfinity() and other._isinfinity() and True 1836 return self._exp == other._exp 1837 1838 def _rescale(self, exp, rounding=None, context=None, watchexp=1): 1839 """Rescales so that the exponent is exp. 1840 1841 exp = exp to scale to (an integer) 1842 rounding = rounding version 1843 watchexp: if set (default) an error is returned if exp is greater 1844 than Emax or less than Etiny. 1845 """ 1846 if context is None: 1847 context = getcontext() 1848 1849 if self._is_special: 1850 if self._isinfinity(): 1851 return context._raise_error(InvalidOperation, 'rescale with an INF') 1852 1853 ans = self._check_nans(context=context) 1854 if ans: 1855 return ans 1856 1857 if watchexp and (context.Emax < exp or context.Etiny() > exp): 1858 return context._raise_error(InvalidOperation, 'rescale(a, INF)') 1859 1860 if not self: 1861 ans = Decimal(self) 1862 ans._int = (0,) 1863 ans._exp = exp 1864 return ans 1865 1866 diff = self._exp - exp 1867 digits = len(self._int) + diff 1868 1869 if watchexp and digits > context.prec: 1870 return context._raise_error(InvalidOperation, 'Rescale > prec') 1871 1872 tmp = Decimal(self) 1873 tmp._int = (0,) + tmp._int 1874 digits += 1 1875 1876 if digits < 0: 1877 tmp._exp = -digits + tmp._exp 1878 tmp._int = (0,1) 1879 digits = 1 1880 tmp = tmp._round(digits, rounding, context=context) 1881 1882 if tmp._int[0] == 0 and len(tmp._int) > 1: 1883 tmp._int = tmp._int[1:] 1884 tmp._exp = exp 1885 1886 tmp_adjusted = tmp.adjusted() 1887 if tmp and tmp_adjusted < context.Emin: 1888 context._raise_error(Subnormal) 1889 elif tmp and tmp_adjusted > context.Emax: 1890 return context._raise_error(InvalidOperation, 'rescale(a, INF)') 1891 return tmp 1892 1893 def to_integral(self, rounding=None, context=None): 1894 """Rounds to the nearest integer, without raising inexact, rounded.""" 1895 if self._is_special: 1896 ans = self._check_nans(context=context) 1897 if ans: 1898 return ans 1899 if self._exp >= 0: 1900 return self 1901 if context is None: 1902 context = getcontext() 1903 flags = context._ignore_flags(Rounded, Inexact) 1904 ans = self._rescale(0, rounding, context=context) 1905 context._regard_flags(flags) 1906 return ans 1907 1908 def sqrt(self, context=None): 1909 """Return the square root of self. 1910 1911 Uses a converging algorithm (Xn+1 = 0.5*(Xn + self / Xn)) 1912 Should quadratically approach the right answer. 1913 """ 1914 if self._is_special: 1915 ans = self._check_nans(context=context) 1916 if ans: 1917 return ans 1918 1919 if self._isinfinity() and self._sign == 0: 1920 return Decimal(self) 1921 1922 if not self: 1923 #exponent = self._exp / 2, using round_down. 1924 #if self._exp < 0: 1925 # exp = (self._exp+1) // 2 1926 #else: 1927 exp = (self._exp) // 2 1928 if self._sign == 1: 1929 #sqrt(-0) = -0 1930 return Decimal( (1, (0,), exp)) 1931 else: 1932 return Decimal( (0, (0,), exp)) 1933 1934 if context is None: 1935 context = getcontext() 1936 1937 if self._sign == 1: 1938 return context._raise_error(InvalidOperation, 'sqrt(-x), x > 0') 1939 1940 tmp = Decimal(self) 1941 1942 expadd = tmp._exp // 2 1943 if tmp._exp & 1: 1944 tmp._int += (0,) 1945 tmp._exp = 0 1946 else: 1947 tmp._exp = 0 1948 1949 context = context._shallow_copy() 1950 flags = context._ignore_all_flags() 1951 firstprec = context.prec 1952 context.prec = 3 1953 if tmp.adjusted() & 1 == 0: 1954 ans = Decimal( (0, (8,1,9), tmp.adjusted() - 2) ) 1955 ans = ans.__add__(tmp.__mul__(Decimal((0, (2,5,9), -2)), 1956 context=context), context=context) 1957 ans._exp -= 1 + tmp.adjusted() // 2 1958 else: 1959 ans = Decimal( (0, (2,5,9), tmp._exp + len(tmp._int)- 3) ) 1960 ans = ans.__add__(tmp.__mul__(Decimal((0, (8,1,9), -3)), 1961 context=context), context=context) 1962 ans._exp -= 1 + tmp.adjusted() // 2 1963 1964 #ans is now a linear approximation. 1965 1966 Emax, Emin = context.Emax, context.Emin 1967 context.Emax, context.Emin = DefaultContext.Emax, DefaultContext.Emin 1968 1969 half = Decimal('0.5') 1970 1971 maxp = firstprec + 2 1972 rounding = context._set_rounding(ROUND_HALF_EVEN) 1973 while 1: 1974 context.prec = min(2*context.prec - 2, maxp) 1975 ans = half.__mul__(ans.__add__(tmp.__div__(ans, context=context), 1976 context=context), context=context) 1977 if context.prec == maxp: 1978 break 1979 1980 #round to the answer's precision-- the only error can be 1 ulp. 1981 context.prec = firstprec 1982 prevexp = ans.adjusted() 1983 ans = ans._round(context=context) 1984 1985 #Now, check if the other last digits are better. 1986 context.prec = firstprec + 1 1987 # In case we rounded up another digit and we should actually go lower. 1988 if prevexp != ans.adjusted(): 1989 ans._int += (0,) 1990 ans._exp -= 1 1991 1992 1993 lower = ans.__sub__(Decimal((0, (5,), ans._exp-1)), context=context) 1994 context._set_rounding(ROUND_UP) 1995 if lower.__mul__(lower, context=context) > (tmp): 1996 ans = ans.__sub__(Decimal((0, (1,), ans._exp)), context=context) 1997 1998 else: 1999 upper = ans.__add__(Decimal((0, (5,), ans._exp-1)),context=context) 2000 context._set_rounding(ROUND_DOWN) 2001 if upper.__mul__(upper, context=context) < tmp: 2002 ans = ans.__add__(Decimal((0, (1,), ans._exp)),context=context) 2003 2004 ans._exp += expadd 2005 2006 context.prec = firstprec 2007 context.rounding = rounding 2008 ans = ans._fix(context) 2009 2010 rounding = context._set_rounding_decision(NEVER_ROUND) 2011 if not ans.__mul__(ans, context=context) == self: 2012 # Only rounded/inexact if here. 2013 context._regard_flags(flags) 2014 context._raise_error(Rounded) 2015 context._raise_error(Inexact) 2016 else: 2017 #Exact answer, so let's set the exponent right. 2018 #if self._exp < 0: 2019 # exp = (self._exp +1)// 2 2020 #else: 2021 exp = self._exp // 2 2022 context.prec += ans._exp - exp 2023 ans = ans._rescale(exp, context=context) 2024 context.prec = firstprec 2025 context._regard_flags(flags) 2026 context.Emax, context.Emin = Emax, Emin 2027 2028 return ans._fix(context) 2029 2030 def max(self, other, context=None): 2031 """Returns the larger value. 2032 2033 like max(self, other) except if one is not a number, returns 2034 NaN (and signals if one is sNaN). Also rounds. 2035 """ 2036 other = _convert_other(other) 2037 if other is NotImplemented: 2038 return other 2039 2040 if self._is_special or other._is_special: 2041 # if one operand is a quiet NaN and the other is number, then the 2042 # number is always returned 2043 sn = self._isnan() 2044 on = other._isnan() 2045 if sn or on: 2046 if on == 1 and sn != 2: 2047 return self 2048 if sn == 1 and on != 2: 2049 return other 2050 return self._check_nans(other, context) 2051 2052 ans = self 2053 c = self.__cmp__(other) 2054 if c == 0: 2055 # if both operands are finite and equal in numerical value 2056 # then an ordering is applied: 2057 # 2058 # if the signs differ then max returns the operand with the 2059 # positive sign and min returns the operand with the negative sign 2060 # 2061 # if the signs are the same then the exponent is used to select 2062 # the result. 2063 if self._sign != other._sign: 2064 if self._sign: 2065 ans = other 2066 elif self._exp < other._exp and not self._sign: 2067 ans = other 2068 elif self._exp > other._exp and self._sign: 2069 ans = other 2070 elif c == -1: 2071 ans = other 2072 2073 if context is None: 2074 context = getcontext() 2075 if context._rounding_decision == ALWAYS_ROUND: 2076 return ans._fix(context) 2077 return ans 2078 2079 def min(self, other, context=None): 2080 """Returns the smaller value. 2081 2082 like min(self, other) except if one is not a number, returns 2083 NaN (and signals if one is sNaN). Also rounds. 2084 """ 2085 other = _convert_other(other) 2086 if other is NotImplemented: 2087 return other 2088 2089 if self._is_special or other._is_special: 2090 # if one operand is a quiet NaN and the other is number, then the 2091 # number is always returned 2092 sn = self._isnan() 2093 on = other._isnan() 2094 if sn or on: 2095 if on == 1 and sn != 2: 2096 return self 2097 if sn == 1 and on != 2: 2098 return other 2099 return self._check_nans(other, context) 2100 2101 ans = self 2102 c = self.__cmp__(other) 2103 if c == 0: 2104 # if both operands are finite and equal in numerical value 2105 # then an ordering is applied: 2106 # 2107 # if the signs differ then max returns the operand with the 2108 # positive sign and min returns the operand with the negative sign 2109 # 2110 # if the signs are the same then the exponent is used to select 2111 # the result. 2112 if self._sign != other._sign: 2113 if other._sign: 2114 ans = other 2115 elif self._exp > other._exp and not self._sign: 2116 ans = other 2117 elif self._exp < other._exp and self._sign: 2118 ans = other 2119 elif c == 1: 2120 ans = other 2121 2122 if context is None: 2123 context = getcontext() 2124 if context._rounding_decision == ALWAYS_ROUND: 2125 return ans._fix(context) 2126 return ans 2127 2128 def _isinteger(self): 2129 """Returns whether self is an integer""" 2130 if self._exp >= 0: 2131 return True 2132 rest = self._int[self._exp:] 2133 return rest == (0,)*len(rest) 2134 2135 def _iseven(self): 2136 """Returns 1 if self is even. Assumes self is an integer.""" 2137 if self._exp > 0: 2138 return 1 2139 return self._int[-1+self._exp] & 1 == 0 2140 2141 def adjusted(self): 2142 """Return the adjusted exponent of self""" 2143 try: 2144 return self._exp + len(self._int) - 1 2145 #If NaN or Infinity, self._exp is string 2146 except TypeError: 2147 return 0 2148 2149 # support for pickling, copy, and deepcopy 2150 def __reduce__(self): 2151 return (self.__class__, (str(self),)) 2152 2153 def __copy__(self): 2154 if type(self) == Decimal: 2155 return self # I'm immutable; therefore I am my own clone 2156 return self.__class__(str(self)) 2157 2158 def __deepcopy__(self, memo): 2159 if type(self) == Decimal: 2160 return self # My components are also immutable 2161 return self.__class__(str(self)) 2162 2163##### Context class ########################################### 2164 2165 2166# get rounding method function: 2167rounding_functions = [name for name in Decimal.__dict__.keys() if name.startswith('_round_')] 2168for name in rounding_functions: 2169 #name is like _round_half_even, goes to the global ROUND_HALF_EVEN value. 2170 globalname = name[1:].upper() 2171 val = globals()[globalname] 2172 Decimal._pick_rounding_function[val] = name 2173 2174del name, val, globalname, rounding_functions 2175 2176class Context(object): 2177 """Contains the context for a Decimal instance. 2178 2179 Contains: 2180 prec - precision (for use in rounding, division, square roots..) 2181 rounding - rounding type. (how you round) 2182 _rounding_decision - ALWAYS_ROUND, NEVER_ROUND -- do you round? 2183 traps - If traps[exception] = 1, then the exception is 2184 raised when it is caused. Otherwise, a value is 2185 substituted in. 2186 flags - When an exception is caused, flags[exception] is incremented. 2187 (Whether or not the trap_enabler is set) 2188 Should be reset by user of Decimal instance. 2189 Emin - Minimum exponent 2190 Emax - Maximum exponent 2191 capitals - If 1, 1*10^1 is printed as 1E+1. 2192 If 0, printed as 1e1 2193 _clamp - If 1, change exponents if too high (Default 0) 2194 """ 2195 2196 def __init__(self, prec=None, rounding=None, 2197 traps=None, flags=None, 2198 _rounding_decision=None, 2199 Emin=None, Emax=None, 2200 capitals=None, _clamp=0, 2201 _ignored_flags=None): 2202 if flags is None: 2203 flags = [] 2204 if _ignored_flags is None: 2205 _ignored_flags = [] 2206 if not isinstance(flags, dict): 2207 flags = dict([(s,s in flags) for s in _signals]) 2208 del s 2209 if traps is not None and not isinstance(traps, dict): 2210 traps = dict([(s,s in traps) for s in _signals]) 2211 del s 2212 for name, val in locals().items(): 2213 if val is None: 2214 setattr(self, name, _copy.copy(getattr(DefaultContext, name))) 2215 else: 2216 setattr(self, name, val) 2217 del self.self 2218 2219 def __repr__(self): 2220 """Show the current context.""" 2221 s = [] 2222 s.append('Context(prec=%(prec)d, rounding=%(rounding)s, Emin=%(Emin)d, Emax=%(Emax)d, capitals=%(capitals)d' % vars(self)) 2223 s.append('flags=[' + ', '.join([f.__name__ for f, v in self.flags.items() if v]) + ']') 2224 s.append('traps=[' + ', '.join([t.__name__ for t, v in self.traps.items() if v]) + ']') 2225 return ', '.join(s) + ')' 2226 2227 def clear_flags(self): 2228 """Reset all flags to zero""" 2229 for flag in self.flags: 2230 self.flags[flag] = 0 2231 2232 def _shallow_copy(self): 2233 """Returns a shallow copy from self.""" 2234 nc = Context(self.prec, self.rounding, self.traps, self.flags, 2235 self._rounding_decision, self.Emin, self.Emax, 2236 self.capitals, self._clamp, self._ignored_flags) 2237 return nc 2238 2239 def copy(self): 2240 """Returns a deep copy from self.""" 2241 nc = Context(self.prec, self.rounding, self.traps.copy(), self.flags.copy(), 2242 self._rounding_decision, self.Emin, self.Emax, 2243 self.capitals, self._clamp, self._ignored_flags) 2244 return nc 2245 __copy__ = copy 2246 2247 def _raise_error(self, condition, explanation = None, *args): 2248 """Handles an error 2249 2250 If the flag is in _ignored_flags, returns the default response. 2251 Otherwise, it increments the flag, then, if the corresponding 2252 trap_enabler is set, it reaises the exception. Otherwise, it returns 2253 the default value after incrementing the flag. 2254 """ 2255 error = _condition_map.get(condition, condition) 2256 if error in self._ignored_flags: 2257 #Don't touch the flag 2258 return error().handle(self, *args) 2259 2260 self.flags[error] += 1 2261 if not self.traps[error]: 2262 #The errors define how to handle themselves. 2263 return condition().handle(self, *args) 2264 2265 # Errors should only be risked on copies of the context 2266 #self._ignored_flags = [] 2267 raise error, explanation 2268 2269 def _ignore_all_flags(self): 2270 """Ignore all flags, if they are raised""" 2271 return self._ignore_flags(*_signals) 2272 2273 def _ignore_flags(self, *flags): 2274 """Ignore the flags, if they are raised""" 2275 # Do not mutate-- This way, copies of a context leave the original 2276 # alone. 2277 self._ignored_flags = (self._ignored_flags + list(flags)) 2278 return list(flags) 2279 2280 def _regard_flags(self, *flags): 2281 """Stop ignoring the flags, if they are raised""" 2282 if flags and isinstance(flags[0], (tuple,list)): 2283 flags = flags[0] 2284 for flag in flags: 2285 self._ignored_flags.remove(flag) 2286 2287 def __hash__(self): 2288 """A Context cannot be hashed.""" 2289 # We inherit object.__hash__, so we must deny this explicitly 2290 raise TypeError, "Cannot hash a Context." 2291 2292 def Etiny(self): 2293 """Returns Etiny (= Emin - prec + 1)""" 2294 return int(self.Emin - self.prec + 1) 2295 2296 def Etop(self): 2297 """Returns maximum exponent (= Emax - prec + 1)""" 2298 return int(self.Emax - self.prec + 1) 2299 2300 def _set_rounding_decision(self, type): 2301 """Sets the rounding decision. 2302 2303 Sets the rounding decision, and returns the current (previous) 2304 rounding decision. Often used like: 2305 2306 context = context._shallow_copy() 2307 # That so you don't change the calling context 2308 # if an error occurs in the middle (say DivisionImpossible is raised). 2309 2310 rounding = context._set_rounding_decision(NEVER_ROUND) 2311 instance = instance / Decimal(2) 2312 context._set_rounding_decision(rounding) 2313 2314 This will make it not round for that operation. 2315 """ 2316 2317 rounding = self._rounding_decision 2318 self._rounding_decision = type 2319 return rounding 2320 2321 def _set_rounding(self, type): 2322 """Sets the rounding type. 2323 2324 Sets the rounding type, and returns the current (previous) 2325 rounding type. Often used like: 2326 2327 context = context.copy() 2328 # so you don't change the calling context 2329 # if an error occurs in the middle. 2330 rounding = context._set_rounding(ROUND_UP) 2331 val = self.__sub__(other, context=context) 2332 context._set_rounding(rounding) 2333 2334 This will make it round up for that operation. 2335 """ 2336 rounding = self.rounding 2337 self.rounding= type 2338 return rounding 2339 2340 def create_decimal(self, num='0'): 2341 """Creates a new Decimal instance but using self as context.""" 2342 d = Decimal(num, context=self) 2343 return d._fix(self) 2344 2345 #Methods 2346 def abs(self, a): 2347 """Returns the absolute value of the operand. 2348 2349 If the operand is negative, the result is the same as using the minus 2350 operation on the operand. Otherwise, the result is the same as using 2351 the plus operation on the operand. 2352 2353 >>> ExtendedContext.abs(Decimal('2.1')) 2354 Decimal("2.1") 2355 >>> ExtendedContext.abs(Decimal('-100')) 2356 Decimal("100") 2357 >>> ExtendedContext.abs(Decimal('101.5')) 2358 Decimal("101.5") 2359 >>> ExtendedContext.abs(Decimal('-101.5')) 2360 Decimal("101.5") 2361 """ 2362 return a.__abs__(context=self) 2363 2364 def add(self, a, b): 2365 """Return the sum of the two operands. 2366 2367 >>> ExtendedContext.add(Decimal('12'), Decimal('7.00')) 2368 Decimal("19.00") 2369 >>> ExtendedContext.add(Decimal('1E+2'), Decimal('1.01E+4')) 2370 Decimal("1.02E+4") 2371 """ 2372 return a.__add__(b, context=self) 2373 2374 def _apply(self, a): 2375 return str(a._fix(self)) 2376 2377 def compare(self, a, b): 2378 """Compares values numerically. 2379 2380 If the signs of the operands differ, a value representing each operand 2381 ('-1' if the operand is less than zero, '0' if the operand is zero or 2382 negative zero, or '1' if the operand is greater than zero) is used in 2383 place of that operand for the comparison instead of the actual 2384 operand. 2385 2386 The comparison is then effected by subtracting the second operand from 2387 the first and then returning a value according to the result of the 2388 subtraction: '-1' if the result is less than zero, '0' if the result is 2389 zero or negative zero, or '1' if the result is greater than zero. 2390 2391 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('3')) 2392 Decimal("-1") 2393 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('2.1')) 2394 Decimal("0") 2395 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('2.10')) 2396 Decimal("0") 2397 >>> ExtendedContext.compare(Decimal('3'), Decimal('2.1')) 2398 Decimal("1") 2399 >>> ExtendedContext.compare(Decimal('2.1'), Decimal('-3')) 2400 Decimal("1") 2401 >>> ExtendedContext.compare(Decimal('-3'), Decimal('2.1')) 2402 Decimal("-1") 2403 """ 2404 return a.compare(b, context=self) 2405 2406 def divide(self, a, b): 2407 """Decimal division in a specified context. 2408 2409 >>> ExtendedContext.divide(Decimal('1'), Decimal('3')) 2410 Decimal("0.333333333") 2411 >>> ExtendedContext.divide(Decimal('2'), Decimal('3')) 2412 Decimal("0.666666667") 2413 >>> ExtendedContext.divide(Decimal('5'), Decimal('2')) 2414 Decimal("2.5") 2415 >>> ExtendedContext.divide(Decimal('1'), Decimal('10')) 2416 Decimal("0.1") 2417 >>> ExtendedContext.divide(Decimal('12'), Decimal('12')) 2418 Decimal("1") 2419 >>> ExtendedContext.divide(Decimal('8.00'), Decimal('2')) 2420 Decimal("4.00") 2421 >>> ExtendedContext.divide(Decimal('2.400'), Decimal('2.0')) 2422 Decimal("1.20") 2423 >>> ExtendedContext.divide(Decimal('1000'), Decimal('100')) 2424 Decimal("10") 2425 >>> ExtendedContext.divide(Decimal('1000'), Decimal('1')) 2426 Decimal("1000") 2427 >>> ExtendedContext.divide(Decimal('2.40E+6'), Decimal('2')) 2428 Decimal("1.20E+6") 2429 """ 2430 return a.__div__(b, context=self) 2431 2432 def divide_int(self, a, b): 2433 """Divides two numbers and returns the integer part of the result. 2434 2435 >>> ExtendedContext.divide_int(Decimal('2'), Decimal('3')) 2436 Decimal("0") 2437 >>> ExtendedContext.divide_int(Decimal('10'), Decimal('3')) 2438 Decimal("3") 2439 >>> ExtendedContext.divide_int(Decimal('1'), Decimal('0.3')) 2440 Decimal("3") 2441 """ 2442 return a.__floordiv__(b, context=self) 2443 2444 def divmod(self, a, b): 2445 return a.__divmod__(b, context=self) 2446 2447 def max(self, a,b): 2448 """max compares two values numerically and returns the maximum. 2449 2450 If either operand is a NaN then the general rules apply. 2451 Otherwise, the operands are compared as as though by the compare 2452 operation. If they are numerically equal then the left-hand operand 2453 is chosen as the result. Otherwise the maximum (closer to positive 2454 infinity) of the two operands is chosen as the result. 2455 2456 >>> ExtendedContext.max(Decimal('3'), Decimal('2')) 2457 Decimal("3") 2458 >>> ExtendedContext.max(Decimal('-10'), Decimal('3')) 2459 Decimal("3") 2460 >>> ExtendedContext.max(Decimal('1.0'), Decimal('1')) 2461 Decimal("1") 2462 >>> ExtendedContext.max(Decimal('7'), Decimal('NaN')) 2463 Decimal("7") 2464 """ 2465 return a.max(b, context=self) 2466 2467 def min(self, a,b): 2468 """min compares two values numerically and returns the minimum. 2469 2470 If either operand is a NaN then the general rules apply. 2471 Otherwise, the operands are compared as as though by the compare 2472 operation. If they are numerically equal then the left-hand operand 2473 is chosen as the result. Otherwise the minimum (closer to negative 2474 infinity) of the two operands is chosen as the result. 2475 2476 >>> ExtendedContext.min(Decimal('3'), Decimal('2')) 2477 Decimal("2") 2478 >>> ExtendedContext.min(Decimal('-10'), Decimal('3')) 2479 Decimal("-10") 2480 >>> ExtendedContext.min(Decimal('1.0'), Decimal('1')) 2481 Decimal("1.0") 2482 >>> ExtendedContext.min(Decimal('7'), Decimal('NaN')) 2483 Decimal("7") 2484 """ 2485 return a.min(b, context=self) 2486 2487 def minus(self, a): 2488 """Minus corresponds to unary prefix minus in Python. 2489 2490 The operation is evaluated using the same rules as subtract; the 2491 operation minus(a) is calculated as subtract('0', a) where the '0' 2492 has the same exponent as the operand. 2493 2494 >>> ExtendedContext.minus(Decimal('1.3')) 2495 Decimal("-1.3") 2496 >>> ExtendedContext.minus(Decimal('-1.3')) 2497 Decimal("1.3") 2498 """ 2499 return a.__neg__(context=self) 2500 2501 def multiply(self, a, b): 2502 """multiply multiplies two operands. 2503 2504 If either operand is a special value then the general rules apply. 2505 Otherwise, the operands are multiplied together ('long multiplication'), 2506 resulting in a number which may be as long as the sum of the lengths 2507 of the two operands. 2508 2509 >>> ExtendedContext.multiply(Decimal('1.20'), Decimal('3')) 2510 Decimal("3.60") 2511 >>> ExtendedContext.multiply(Decimal('7'), Decimal('3')) 2512 Decimal("21") 2513 >>> ExtendedContext.multiply(Decimal('0.9'), Decimal('0.8')) 2514 Decimal("0.72") 2515 >>> ExtendedContext.multiply(Decimal('0.9'), Decimal('-0')) 2516 Decimal("-0.0") 2517 >>> ExtendedContext.multiply(Decimal('654321'), Decimal('654321')) 2518 Decimal("4.28135971E+11") 2519 """ 2520 return a.__mul__(b, context=self) 2521 2522 def normalize(self, a): 2523 """normalize reduces an operand to its simplest form. 2524 2525 Essentially a plus operation with all trailing zeros removed from the 2526 result. 2527 2528 >>> ExtendedContext.normalize(Decimal('2.1')) 2529 Decimal("2.1") 2530 >>> ExtendedContext.normalize(Decimal('-2.0')) 2531 Decimal("-2") 2532 >>> ExtendedContext.normalize(Decimal('1.200')) 2533 Decimal("1.2") 2534 >>> ExtendedContext.normalize(Decimal('-120')) 2535 Decimal("-1.2E+2") 2536 >>> ExtendedContext.normalize(Decimal('120.00')) 2537 Decimal("1.2E+2") 2538 >>> ExtendedContext.normalize(Decimal('0.00')) 2539 Decimal("0") 2540 """ 2541 return a.normalize(context=self) 2542 2543 def plus(self, a): 2544 """Plus corresponds to unary prefix plus in Python. 2545 2546 The operation is evaluated using the same rules as add; the 2547 operation plus(a) is calculated as add('0', a) where the '0' 2548 has the same exponent as the operand. 2549 2550 >>> ExtendedContext.plus(Decimal('1.3')) 2551 Decimal("1.3") 2552 >>> ExtendedContext.plus(Decimal('-1.3')) 2553 Decimal("-1.3") 2554 """ 2555 return a.__pos__(context=self) 2556 2557 def power(self, a, b, modulo=None): 2558 """Raises a to the power of b, to modulo if given. 2559 2560 The right-hand operand must be a whole number whose integer part (after 2561 any exponent has been applied) has no more than 9 digits and whose 2562 fractional part (if any) is all zeros before any rounding. The operand 2563 may be positive, negative, or zero; if negative, the absolute value of 2564 the power is used, and the left-hand operand is inverted (divided into 2565 1) before use. 2566 2567 If the increased precision needed for the intermediate calculations 2568 exceeds the capabilities of the implementation then an Invalid operation 2569 condition is raised. 2570 2571 If, when raising to a negative power, an underflow occurs during the 2572 division into 1, the operation is not halted at that point but 2573 continues. 2574 2575 >>> ExtendedContext.power(Decimal('2'), Decimal('3')) 2576 Decimal("8") 2577 >>> ExtendedContext.power(Decimal('2'), Decimal('-3')) 2578 Decimal("0.125") 2579 >>> ExtendedContext.power(Decimal('1.7'), Decimal('8')) 2580 Decimal("69.7575744") 2581 >>> ExtendedContext.power(Decimal('Infinity'), Decimal('-2')) 2582 Decimal("0") 2583 >>> ExtendedContext.power(Decimal('Infinity'), Decimal('-1')) 2584 Decimal("0") 2585 >>> ExtendedContext.power(Decimal('Infinity'), Decimal('0')) 2586 Decimal("1") 2587 >>> ExtendedContext.power(Decimal('Infinity'), Decimal('1')) 2588 Decimal("Infinity") 2589 >>> ExtendedContext.power(Decimal('Infinity'), Decimal('2')) 2590 Decimal("Infinity") 2591 >>> ExtendedContext.power(Decimal('-Infinity'), Decimal('-2')) 2592 Decimal("0") 2593 >>> ExtendedContext.power(Decimal('-Infinity'), Decimal('-1')) 2594 Decimal("-0") 2595 >>> ExtendedContext.power(Decimal('-Infinity'), Decimal('0')) 2596 Decimal("1") 2597 >>> ExtendedContext.power(Decimal('-Infinity'), Decimal('1')) 2598 Decimal("-Infinity") 2599 >>> ExtendedContext.power(Decimal('-Infinity'), Decimal('2')) 2600 Decimal("Infinity") 2601 >>> ExtendedContext.power(Decimal('0'), Decimal('0')) 2602 Decimal("NaN") 2603 """ 2604 return a.__pow__(b, modulo, context=self) 2605 2606 def quantize(self, a, b): 2607 """Returns a value equal to 'a' (rounded) and having the exponent of 'b'. 2608 2609 The coefficient of the result is derived from that of the left-hand 2610 operand. It may be rounded using the current rounding setting (if the 2611 exponent is being increased), multiplied by a positive power of ten (if 2612 the exponent is being decreased), or is unchanged (if the exponent is 2613 already equal to that of the right-hand operand). 2614 2615 Unlike other operations, if the length of the coefficient after the 2616 quantize operation would be greater than precision then an Invalid 2617 operation condition is raised. This guarantees that, unless there is an 2618 error condition, the exponent of the result of a quantize is always 2619 equal to that of the right-hand operand. 2620 2621 Also unlike other operations, quantize will never raise Underflow, even 2622 if the result is subnormal and inexact. 2623 2624 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.001')) 2625 Decimal("2.170") 2626 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.01')) 2627 Decimal("2.17") 2628 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('0.1')) 2629 Decimal("2.2") 2630 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('1e+0')) 2631 Decimal("2") 2632 >>> ExtendedContext.quantize(Decimal('2.17'), Decimal('1e+1')) 2633 Decimal("0E+1") 2634 >>> ExtendedContext.quantize(Decimal('-Inf'), Decimal('Infinity')) 2635 Decimal("-Infinity") 2636 >>> ExtendedContext.quantize(Decimal('2'), Decimal('Infinity')) 2637 Decimal("NaN") 2638 >>> ExtendedContext.quantize(Decimal('-0.1'), Decimal('1')) 2639 Decimal("-0") 2640 >>> ExtendedContext.quantize(Decimal('-0'), Decimal('1e+5')) 2641 Decimal("-0E+5") 2642 >>> ExtendedContext.quantize(Decimal('+35236450.6'), Decimal('1e-2')) 2643 Decimal("NaN") 2644 >>> ExtendedContext.quantize(Decimal('-35236450.6'), Decimal('1e-2')) 2645 Decimal("NaN") 2646 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e-1')) 2647 Decimal("217.0") 2648 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e-0')) 2649 Decimal("217") 2650 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e+1')) 2651 Decimal("2.2E+2") 2652 >>> ExtendedContext.quantize(Decimal('217'), Decimal('1e+2')) 2653 Decimal("2E+2") 2654 """ 2655 return a.quantize(b, context=self) 2656 2657 def remainder(self, a, b): 2658 """Returns the remainder from integer division. 2659 2660 The result is the residue of the dividend after the operation of 2661 calculating integer division as described for divide-integer, rounded to 2662 precision digits if necessary. The sign of the result, if non-zero, is 2663 the same as that of the original dividend. 2664 2665 This operation will fail under the same conditions as integer division 2666 (that is, if integer division on the same two operands would fail, the 2667 remainder cannot be calculated). 2668 2669 >>> ExtendedContext.remainder(Decimal('2.1'), Decimal('3')) 2670 Decimal("2.1") 2671 >>> ExtendedContext.remainder(Decimal('10'), Decimal('3')) 2672 Decimal("1") 2673 >>> ExtendedContext.remainder(Decimal('-10'), Decimal('3')) 2674 Decimal("-1") 2675 >>> ExtendedContext.remainder(Decimal('10.2'), Decimal('1')) 2676 Decimal("0.2") 2677 >>> ExtendedContext.remainder(Decimal('10'), Decimal('0.3')) 2678 Decimal("0.1") 2679 >>> ExtendedContext.remainder(Decimal('3.6'), Decimal('1.3')) 2680 Decimal("1.0") 2681 """ 2682 return a.__mod__(b, context=self) 2683 2684 def remainder_near(self, a, b): 2685 """Returns to be "a - b * n", where n is the integer nearest the exact 2686 value of "x / b" (if two integers are equally near then the even one 2687 is chosen). If the result is equal to 0 then its sign will be the 2688 sign of a. 2689 2690 This operation will fail under the same conditions as integer division 2691 (that is, if integer division on the same two operands would fail, the 2692 remainder cannot be calculated). 2693 2694 >>> ExtendedContext.remainder_near(Decimal('2.1'), Decimal('3')) 2695 Decimal("-0.9") 2696 >>> ExtendedContext.remainder_near(Decimal('10'), Decimal('6')) 2697 Decimal("-2") 2698 >>> ExtendedContext.remainder_near(Decimal('10'), Decimal('3')) 2699 Decimal("1") 2700 >>> ExtendedContext.remainder_near(Decimal('-10'), Decimal('3')) 2701 Decimal("-1") 2702 >>> ExtendedContext.remainder_near(Decimal('10.2'), Decimal('1')) 2703 Decimal("0.2") 2704 >>> ExtendedContext.remainder_near(Decimal('10'), Decimal('0.3')) 2705 Decimal("0.1") 2706 >>> ExtendedContext.remainder_near(Decimal('3.6'), Decimal('1.3')) 2707 Decimal("-0.3") 2708 """ 2709 return a.remainder_near(b, context=self) 2710 2711 def same_quantum(self, a, b): 2712 """Returns True if the two operands have the same exponent. 2713 2714 The result is never affected by either the sign or the coefficient of 2715 either operand. 2716 2717 >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.001')) 2718 False 2719 >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('0.01')) 2720 True 2721 >>> ExtendedContext.same_quantum(Decimal('2.17'), Decimal('1')) 2722 False 2723 >>> ExtendedContext.same_quantum(Decimal('Inf'), Decimal('-Inf')) 2724 True 2725 """ 2726 return a.same_quantum(b) 2727 2728 def sqrt(self, a): 2729 """Returns the square root of a non-negative number to context precision. 2730 2731 If the result must be inexact, it is rounded using the round-half-even 2732 algorithm. 2733 2734 >>> ExtendedContext.sqrt(Decimal('0')) 2735 Decimal("0") 2736 >>> ExtendedContext.sqrt(Decimal('-0')) 2737 Decimal("-0") 2738 >>> ExtendedContext.sqrt(Decimal('0.39')) 2739 Decimal("0.624499800") 2740 >>> ExtendedContext.sqrt(Decimal('100')) 2741 Decimal("10") 2742 >>> ExtendedContext.sqrt(Decimal('1')) 2743 Decimal("1") 2744 >>> ExtendedContext.sqrt(Decimal('1.0')) 2745 Decimal("1.0") 2746 >>> ExtendedContext.sqrt(Decimal('1.00')) 2747 Decimal("1.0") 2748 >>> ExtendedContext.sqrt(Decimal('7')) 2749 Decimal("2.64575131") 2750 >>> ExtendedContext.sqrt(Decimal('10')) 2751 Decimal("3.16227766") 2752 >>> ExtendedContext.prec 2753 9 2754 """ 2755 return a.sqrt(context=self) 2756 2757 def subtract(self, a, b): 2758 """Return the difference between the two operands. 2759 2760 >>> ExtendedContext.subtract(Decimal('1.3'), Decimal('1.07')) 2761 Decimal("0.23") 2762 >>> ExtendedContext.subtract(Decimal('1.3'), Decimal('1.30')) 2763 Decimal("0.00") 2764 >>> ExtendedContext.subtract(Decimal('1.3'), Decimal('2.07')) 2765 Decimal("-0.77") 2766 """ 2767 return a.__sub__(b, context=self) 2768 2769 def to_eng_string(self, a): 2770 """Converts a number to a string, using scientific notation. 2771 2772 The operation is not affected by the context. 2773 """ 2774 return a.to_eng_string(context=self) 2775 2776 def to_sci_string(self, a): 2777 """Converts a number to a string, using scientific notation. 2778 2779 The operation is not affected by the context. 2780 """ 2781 return a.__str__(context=self) 2782 2783 def to_integral(self, a): 2784 """Rounds to an integer. 2785 2786 When the operand has a negative exponent, the result is the same 2787 as using the quantize() operation using the given operand as the 2788 left-hand-operand, 1E+0 as the right-hand-operand, and the precision 2789 of the operand as the precision setting, except that no flags will 2790 be set. The rounding mode is taken from the context. 2791 2792 >>> ExtendedContext.to_integral(Decimal('2.1')) 2793 Decimal("2") 2794 >>> ExtendedContext.to_integral(Decimal('100')) 2795 Decimal("100") 2796 >>> ExtendedContext.to_integral(Decimal('100.0')) 2797 Decimal("100") 2798 >>> ExtendedContext.to_integral(Decimal('101.5')) 2799 Decimal("102") 2800 >>> ExtendedContext.to_integral(Decimal('-101.5')) 2801 Decimal("-102") 2802 >>> ExtendedContext.to_integral(Decimal('10E+5')) 2803 Decimal("1.0E+6") 2804 >>> ExtendedContext.to_integral(Decimal('7.89E+77')) 2805 Decimal("7.89E+77") 2806 >>> ExtendedContext.to_integral(Decimal('-Inf')) 2807 Decimal("-Infinity") 2808 """ 2809 return a.to_integral(context=self) 2810 2811class _WorkRep(object): 2812 __slots__ = ('sign','int','exp') 2813 # sign: 0 or 1 2814 # int: int or long 2815 # exp: None, int, or string 2816 2817 def __init__(self, value=None): 2818 if value is None: 2819 self.sign = None 2820 self.int = 0 2821 self.exp = None 2822 elif isinstance(value, Decimal): 2823 self.sign = value._sign 2824 cum = 0 2825 for digit in value._int: 2826 cum = cum * 10 + digit 2827 self.int = cum 2828 self.exp = value._exp 2829 else: 2830 # assert isinstance(value, tuple) 2831 self.sign = value[0] 2832 self.int = value[1] 2833 self.exp = value[2] 2834 2835 def __repr__(self): 2836 return "(%r, %r, %r)" % (self.sign, self.int, self.exp) 2837 2838 __str__ = __repr__ 2839 2840 2841 2842def _normalize(op1, op2, shouldround = 0, prec = 0): 2843 """Normalizes op1, op2 to have the same exp and length of coefficient. 2844 2845 Done during addition. 2846 """ 2847 # Yes, the exponent is a long, but the difference between exponents 2848 # must be an int-- otherwise you'd get a big memory problem. 2849 numdigits = int(op1.exp - op2.exp) 2850 if numdigits < 0: 2851 numdigits = -numdigits 2852 tmp = op2 2853 other = op1 2854 else: 2855 tmp = op1 2856 other = op2 2857 2858 2859 if shouldround and numdigits > prec + 1: 2860 # Big difference in exponents - check the adjusted exponents 2861 tmp_len = len(str(tmp.int)) 2862 other_len = len(str(other.int)) 2863 if numdigits > (other_len + prec + 1 - tmp_len): 2864 # If the difference in adjusted exps is > prec+1, we know 2865 # other is insignificant, so might as well put a 1 after the precision. 2866 # (since this is only for addition.) Also stops use of massive longs. 2867 2868 extend = prec + 2 - tmp_len 2869 if extend <= 0: 2870 extend = 1 2871 tmp.int *= 10 ** extend 2872 tmp.exp -= extend 2873 other.int = 1 2874 other.exp = tmp.exp 2875 return op1, op2 2876 2877 tmp.int *= 10 ** numdigits 2878 tmp.exp -= numdigits 2879 return op1, op2 2880 2881def _adjust_coefficients(op1, op2): 2882 """Adjust op1, op2 so that op2.int * 10 > op1.int >= op2.int. 2883 2884 Returns the adjusted op1, op2 as well as the change in op1.exp-op2.exp. 2885 2886 Used on _WorkRep instances during division. 2887 """ 2888 adjust = 0 2889 #If op1 is smaller, make it larger 2890 while op2.int > op1.int: 2891 op1.int *= 10 2892 op1.exp -= 1 2893 adjust += 1 2894 2895 #If op2 is too small, make it larger 2896 while op1.int >= (10 * op2.int): 2897 op2.int *= 10 2898 op2.exp -= 1 2899 adjust -= 1 2900 2901 return op1, op2, adjust 2902 2903##### Helper Functions ######################################## 2904 2905def _convert_other(other): 2906 """Convert other to Decimal. 2907 2908 Verifies that it's ok to use in an implicit construction. 2909 """ 2910 if isinstance(other, Decimal): 2911 return other 2912 if isinstance(other, (int, long)): 2913 return Decimal(other) 2914 return NotImplemented 2915 2916_infinity_map = { 2917 'inf' : 1, 2918 'infinity' : 1, 2919 '+inf' : 1, 2920 '+infinity' : 1, 2921 '-inf' : -1, 2922 '-infinity' : -1 2923} 2924 2925def _isinfinity(num): 2926 """Determines whether a string or float is infinity. 2927 2928 +1 for negative infinity; 0 for finite ; +1 for positive infinity 2929 """ 2930 num = str(num).lower() 2931 return _infinity_map.get(num, 0) 2932 2933def _isnan(num): 2934 """Determines whether a string or float is NaN 2935 2936 (1, sign, diagnostic info as string) => NaN 2937 (2, sign, diagnostic info as string) => sNaN 2938 0 => not a NaN 2939 """ 2940 num = str(num).lower() 2941 if not num: 2942 return 0 2943 2944 #get the sign, get rid of trailing [+-] 2945 sign = 0 2946 if num[0] == '+': 2947 num = num[1:] 2948 elif num[0] == '-': #elif avoids '+-nan' 2949 num = num[1:] 2950 sign = 1 2951 2952 if num.startswith('nan'): 2953 if len(num) > 3 and not num[3:].isdigit(): #diagnostic info 2954 return 0 2955 return (1, sign, num[3:].lstrip('0')) 2956 if num.startswith('snan'): 2957 if len(num) > 4 and not num[4:].isdigit(): 2958 return 0 2959 return (2, sign, num[4:].lstrip('0')) 2960 return 0 2961 2962 2963##### Setup Specific Contexts ################################ 2964 2965# The default context prototype used by Context() 2966# Is mutable, so that new contexts can have different default values 2967 2968DefaultContext = Context( 2969 prec=28, rounding=ROUND_HALF_EVEN, 2970 traps=[DivisionByZero, Overflow, InvalidOperation], 2971 flags=[], 2972 _rounding_decision=ALWAYS_ROUND, 2973 Emax=999999999, 2974 Emin=-999999999, 2975 capitals=1 2976) 2977 2978# Pre-made alternate contexts offered by the specification 2979# Don't change these; the user should be able to select these 2980# contexts and be able to reproduce results from other implementations 2981# of the spec. 2982 2983BasicContext = Context( 2984 prec=9, rounding=ROUND_HALF_UP, 2985 traps=[DivisionByZero, Overflow, InvalidOperation, Clamped, Underflow], 2986 flags=[], 2987) 2988 2989ExtendedContext = Context( 2990 prec=9, rounding=ROUND_HALF_EVEN, 2991 traps=[], 2992 flags=[], 2993) 2994 2995 2996##### Useful Constants (internal use only) #################### 2997 2998#Reusable defaults 2999Inf = Decimal('Inf') 3000negInf = Decimal('-Inf') 3001 3002#Infsign[sign] is infinity w/ that sign 3003Infsign = (Inf, negInf) 3004 3005NaN = Decimal('NaN') 3006 3007 3008##### crud for parsing strings ################################# 3009import re 3010 3011# There's an optional sign at the start, and an optional exponent 3012# at the end. The exponent has an optional sign and at least one 3013# digit. In between, must have either at least one digit followed 3014# by an optional fraction, or a decimal point followed by at least 3015# one digit. Yuck. 3016 3017_parser = re.compile(r""" 3018# \s* 3019 (?P<sign>[-+])? 3020 ( 3021 (?P<int>\d+) (\. (?P<frac>\d*))? 3022 | 3023 \. (?P<onlyfrac>\d+) 3024 ) 3025 ([eE](?P<exp>[-+]? \d+))? 3026# \s* 3027 $ 3028""", re.VERBOSE).match #Uncomment the \s* to allow leading or trailing spaces. 3029 3030del re 3031 3032# return sign, n, p s.t. float string value == -1**sign * n * 10**p exactly 3033 3034def _string2exact(s): 3035 m = _parser(s) 3036 if m is None: 3037 raise ValueError("invalid literal for Decimal: %r" % s) 3038 3039 if m.group('sign') == "-": 3040 sign = 1 3041 else: 3042 sign = 0 3043 3044 exp = m.group('exp') 3045 if exp is None: 3046 exp = 0 3047 else: 3048 exp = int(exp) 3049 3050 intpart = m.group('int') 3051 if intpart is None: 3052 intpart = "" 3053 fracpart = m.group('onlyfrac') 3054 else: 3055 fracpart = m.group('frac') 3056 if fracpart is None: 3057 fracpart = "" 3058 3059 exp -= len(fracpart) 3060 3061 mantissa = intpart + fracpart 3062 tmp = map(int, mantissa) 3063 backup = tmp 3064 while tmp and tmp[0] == 0: 3065 del tmp[0] 3066 3067 # It's a zero 3068 if not tmp: 3069 if backup: 3070 return (sign, tuple(backup), exp) 3071 return (sign, (0,), exp) 3072 mantissa = tuple(tmp) 3073 3074 return (sign, mantissa, exp) 3075 3076 3077if __name__ == '__main__': 3078 import doctest, sys 3079 doctest.testmod(sys.modules[__name__]) 3080