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