Decimal fixed-point arithmetic

## Project description

The module *decimalfp* provides a *Decimal* number type which can represent
decimal numbers of arbitrary magnitude and arbitrary precision, i.e. any
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 rounding mode of the current context
held by the standard module *decimal* (which 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, for performance reasons, this is done only up a
fixed limit of fractional digits. This limit defaults to 32 and is accessible
as *decimalfp.LIMIT_PREC*. 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 *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 given by *decimalfp.LIMIT_PREC*, 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.10.1.tar.gz (214.8 kB) | File type Source | Python version None | Upload date | Hashes View |