Class Decimal

Returns the absolute value of self.

If the keyword argument 'round' is false, do not round. The expression self.__abs__(round=False) is equivalent to self.copy_abs().

Returns self + other.

-INF + INF (or the reverse) cause InvalidOperation errors.

Format a Decimal instance according to the given specifier.

The specifier should be a standard format specifier, with the form described in PEP 3101. Formatting types 'e', 'E', 'f', 'F', 'g', 'G', 'n' and '%' are supported. If the formatting type is omitted it defaults to 'g' or 'G', depending on the value of context.capitals.

Overrides: object.__format__

hash(x)

Overrides: object.__hash__

Converts to a long.

Equivalent to long(int(self))

Return self * other.

(+-) INF * 0 (or its reverse) raise InvalidOperation.

Returns a copy with the sign switched.

Rounds, if it has reason.

Create a decimal point instance.

>>> Decimal('3.14')              # string input
Decimal('3.14')
>>> Decimal((0, (3, 1, 4), -2))  # tuple (sign, digit_tuple, exponent)
Decimal('3.14')
>>> Decimal(314)                 # int or long
Decimal('314')
>>> Decimal(Decimal(314))        # another decimal instance
Decimal('314')
>>> Decimal('  3.14  \n')        # leading and trailing whitespace okay
Decimal('3.14')

Returns: a new object with type S, a subtype of T

Overrides: object.__new__

Return True if self is nonzero; otherwise return False.

NaNs and infinities are considered nonzero.

Returns a copy, unless it is a sNaN.

Rounds the number (if more then precision digits)

Return self ** other [ % modulo].

With two arguments, compute self**other.

With three arguments, compute (self**other) % modulo. For the three argument form, the following restrictions on the arguments hold:

• all three arguments must be integral
• other must be nonnegative
• either self or other (or both) must be nonzero
• modulo must be nonzero and must have at most p digits, where p is the context precision.

If any of these restrictions is violated the InvalidOperation flag is raised.

The result of pow(self, other, modulo) is identical to the result that would be obtained by computing (self**other) % modulo with unbounded precision, but is computed more efficiently. It is always exact.

Returns self + other.

-INF + INF (or the reverse) cause InvalidOperation errors.

helper for pickle

Overrides: object.__reduce__

(inherited documentation)

Represents the number as an instance of Decimal.

Overrides: object.__repr__

Return self * other.

(+-) INF * 0 (or its reverse) raise InvalidOperation.

Return string representation of the number in scientific notation.

Captures all of the information in the underlying representation.

Overrides: object.__str__

Represents the number as a triple tuple.

To show the internals exactly as they are.

Returns the same Decimal object.

As we do not have different encodings for the same number, the received object already is in its canonical form.

Compares one to another.

-1 => a < b 0 => a = b 1 => a > b NaN => one is NaN Like __cmp__, but returns Decimal instances.

Compares self to the other operand numerically.

It's pretty much like compare(), but all NaNs signal, with signaling NaNs taking precedence over quiet NaNs.

Compares self to other using the abstract representations.

This is not like the standard compare, which use their numerical value. Note that a total ordering is defined for all possible abstract representations.

Compares self to other using abstract repr., ignoring sign.

Like compare_total, but with operand's sign ignored and assumed to be 0.

Fused multiply-add.

Returns self*other+third with no rounding of the intermediate product self*other.

self and other are multiplied together, with no rounding of the result. The third operand is then added to the result, and a single final rounding is performed.

Converts a float to a decimal number, exactly.

Note that Decimal.from_float(0.1) is not the same as Decimal('0.1'). Since 0.1 is not exactly representable in binary floating point, the value is stored as the nearest representable value which is 0x1.999999999999ap-4. The exact equivalent of the value in decimal is 0.1000000000000000055511151231257827021181583404541015625.

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_float(float('nan'))
Decimal('NaN')
>>> Decimal.from_float(float('inf'))
Decimal('Infinity')
>>> Decimal.from_float(-float('inf'))
Decimal('-Infinity')
>>> Decimal.from_float(-0.0)
Decimal('-0')

Return True if self is canonical; otherwise return False.

Currently, the encoding of a Decimal instance is always canonical, so this method returns True for any Decimal.

Return True if self is finite; otherwise return False.

A Decimal instance is considered finite if it is neither infinite nor a NaN.

Returns the exponent of the magnitude of self's MSD.

The result is the integer which is the exponent of the magnitude of the most significant digit of self (as though it were truncated to a single digit while maintaining the value of that digit and without limiting the resulting exponent).

Returns the larger value.

Like max(self, other) except if one is not a number, returns NaN (and signals if one is sNaN). Also rounds.

Returns the smaller value.

Like min(self, other) except if one is not a number, returns NaN (and signals if one is sNaN). Also rounds.

Returns the number closest to self, in the direction towards other.

The result is the closest representable number to self (excluding self) that is in the direction towards other, unless both have the same value. If the two operands are numerically equal, then the result is a copy of self with the sign set to be the same as the sign of other.

Returns an indication of the class of self.

The class is one of the following strings:
  sNaN
  NaN
  -Infinity
  -Normal
  -Subnormal
  -Zero
  +Zero
  +Subnormal
  +Normal
  +Infinity

Quantize self so its exponent is the same as that of exp.

Similar to self._rescale(exp._exp) but with error checking.

Return True if self and other have the same exponent; otherwise
return False.

If either operand is a special value, the following rules are used:
   * return True if both operands are infinities
   * return True if both operands are NaNs
   * otherwise, return False.

Convert to engineering-type string.

Engineering notation has an exponent which is a multiple of 3, so there are up to 3 digits left of the decimal place.

Same rules for when in exponential and when as a value as in __str__.

Rounds to a nearby integer.

If no rounding mode is specified, take the rounding mode from the context. This method raises the Rounded and Inexact flags when appropriate.

See also: to_integral_value, which does exactly the same as this method except that it doesn't raise Inexact or Rounded.

imag

Get Method:

unreachable.imag(self)

real

Get Method:

unreachable.real(self)