Decimal numbers with fixed-point arithmetic

## Project description

The module *decimalfp* provides a *Decimal* number type which can represent
decimal numbers of (nearly) arbitrary magnitude and very large precision, i.e.
with a very large number of fractional digits.

### Usage

*decimalfp.Decimal* instances are created by giving a *value* (default: 0) and
a *precision* (i.e the number of fractional digits, default: None).

If *precision* is given, it must be of type *int* and >= 0.

If *value* is given, it must either be a string, an instance of
*number.Integral*, *number.Rational* (for example *fractions.Fraction*),
*decimal.Decimal* or *float* or be convertable to a *float* or an *int*.

If a string is given as value, it must be a string in one of two formats:

```
[+|-]<int>[.<frac>][<e|E>[+|-]<exp>] or
[+|-].<frac>[<e|E>[+|-]<exp>].
```

The value is always adjusted to the given precision or the precision is calculated from the given value, if no precision is given.

When the given *precision* is lower than the precision of the given *value*,
the result is rounded, according to the current default rounding mode (which
itself defaults to ROUND_HALF_EVEN).

When no *precision* is given and the given *value* is a *float* or a
*numbers.Rational* (but no *Decimal*), the *Decimal* constructor tries to
convert *value* exactly. But this is done only up a fixed limit of fractional
digits (imposed by the implementation, currently 65535). If *value* can not be
represented as a *Decimal* within this limit, an exception is raised.

*Decimal* does not deal with infinity, division by 0 always raises a
*ZeroDivisionError*. Likewise, infinite instances of type *float* or
*decimal.Decimal* can not be converted to *Decimal* instances. The same is
true for the 'not a number' instances of these types.

### Computations

When importing *decimalfp*, its *Decimal* type is registered in Pythons
numerical stack as subclass of *number.Rational*. It supports all operations
defined for that base class and its instances can be mixed in computations
with instances of all numeric types mentioned above.

All numerical operations give an exact result, i.e. they are not automatically
constraint to the precision of the operands or to a number of significant
digits (like the floating-point *Decimal* type from the standard module
*decimal*). When the result can not exactly be represented by a *Decimal*
instance within the limit of fractional digits, an instance of
*fractions.Fraction* is returned.

*Decimal* supports rounding via the built-in function *round* using the same
rounding mode as the *float* type by default (ROUND_HALF_EVEN in Python 3). In
addition, via the method *adjusted*, a *Decimal* with a different precision
can be derived, supporting all rounding modes defined by the standard library
module *decimal*.

For more details see the documentation provided with the source distribution or here.

## Project details

## Release history Release notifications | RSS feed

## Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Filename, size | File type | Python version | Upload date | Hashes |
---|---|---|---|---|

Filename, size decimalfp-0.12.2.tar.gz (139.0 kB) | File type Source | Python version None | Upload date | Hashes View |