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