# 1. Mathematical operations of decimal fixed-point and floating-point numbers

The decimal module implements fixed-point and floating-point arithmetic operations using a model that is familiar to most people, not to programmers (that is, IEEE floating-point arithmetic implemented by most computer hardware).Decimal instances can accurately represent how many numbers are, rounding them off, and limiting the number of valid numbers.

## 1.1 Decimal

The decimal value is represented as an instance of the Decimal class.The constructor takes an integer or string as a parameter.Before using floating-point numbers to create a Decimal, you can convert the floating-point number to a string so that the caller can explicitly handle the number of bits in the value, because a hardware floating-point representation may not be accurate.Alternatively, the class method from_float() can convert floating-point numbers to exact decimal representations.

```import decimal

fmt = '{0:<25} {1:<25}'

print(fmt.format('Input', 'Output'))
print(fmt.format('-' * 25, '-' * 25))

# Integer
print(fmt.format(5, decimal.Decimal(5)))

# String
print(fmt.format('3.14', decimal.Decimal('3.14')))

# Float
f = 0.1
print(fmt.format(repr(f), decimal.Decimal(str(f))))
print('{:<0.23g} {:<25}'.format(
f,
str(decimal.Decimal.from_float(f))[:25])
)```

Floating point value 0.1 is not represented as an exact binary value, so float is not represented as a Decimal value.In the last line of this output, the full string representation is truncated to 25 characters. Decimal can also be created from tuples containing a symbol symbol symbol (0 for positive and 1 for negative), a tuple of digits, and an integer index.(

```import decimal

# Tuple
t = (1, (1, 1), -2)
print('Input  :', t)
print('Decimal:', decimal.Decimal(t))```

Tuple-based representations are not easy to create, but they provide a portable way to export decimal values without losing precision.Tuples can be transported over the network or stored in databases that do not support precise decimal values and then converted back to Decimal instances. ## 1.2 Formatting

Decimal corresponds to Python's string formatting protocol, using the same syntax and options as other numeric types.(

```import decimal

d = decimal.Decimal(1.1)
print('Precision:')
print('{:.1}'.format(d))
print('{:.2}'.format(d))
print('{:.3}'.format(d))
print('{:.18}'.format(d))

print('\nWidth and precision combined:')
print('{:5.1f} {:5.1g}'.format(d, d))
print('{:5.2f} {:5.2g}'.format(d, d))
print('{:5.2f} {:5.2g}'.format(d, d))

print('{:05.1}'.format(d))
print('{:05.2}'.format(d))
print('{:05.3}'.format(d))```

The format string controls the width, precision (that is, the number of significant digits) of the output, and the way its fill values occupy the width. ## 1.3 Arithmetic operations

Decimal overloads simple arithmetic operators, so you can handle Decimal instances in the same way as built-in numeric types.

```import decimal

a = decimal.Decimal('5.1')
b = decimal.Decimal('3.14')
c = 4
d = 3.14

print('a     =', repr(a))
print('b     =', repr(b))
print('c     =', repr(c))
print('d     =', repr(d))
print()

print('a + b =', a + b)
print('a - b =', a - b)
print('a * b =', a * b)
print('a / b =', a / b)
print()

print('a + c =', a + c)
print('a - c =', a - c)
print('a * c =', a * c)
print('a / c =', a / c)
print()

print('a + d =', end=' ')
try:
print(a + d)
except TypeError as e:
print(e)```

Decimal operators also accept integer parameters, but floating-point values must be converted to Decimal instances before they can be used. In addition to basic arithmetic operations, Decimal also includes methods for finding base-10 logarithms and natural logarithms.The values returned by log10() and ln() are Decimal instances, so they can be used directly in the formula like other values.

## 1.4 Special Value

In addition to the expected numeric values, Decimal can represent many special values, including positive and negative infinity, Not a Number (NaN), and 0.

```import decimal

for value in ['Infinity', 'NaN', '0']:
print(decimal.Decimal(value), decimal.Decimal('-' + value))
print()

# Math with infinity
print('Infinity + 1:', (decimal.Decimal('Infinity') + 1))
print('-Infinity + 1:', (decimal.Decimal('-Infinity') + 1))

# Print comparing NaN
print(decimal.Decimal('NaN') == decimal.Decimal('Infinity'))
print(decimal.Decimal('NaN') != decimal.Decimal(1))```

Adding to an infinite value returns another infinite value.Comparing equality with NaN always returns false, while comparing inequality always returns true.Comparing the size with NaN to determine the sort order is undefined, which results in an error. ## 1.5 Context

So far, all previous examples have used the default behavior of the decimal module.You can also use a context to override certain settings, such as maintaining accuracy, how to complete rounding, error handling, and so on.Context can be applied to all Decimal instances in a thread or locally in a small code area.

### 1.5.1 Current Context

To get the current global context, you can use getcontext().

```import decimal

context = decimal.getcontext()

print('Emax     =', context.Emax)
print('Emin     =', context.Emin)
print('capitals =', context.capitals)
print('prec     =', context.prec)
print('rounding =', context.rounding)
print('flags    =')
for f, v in context.flags.items():
print('  {}: {}'.format(f, v))
print('traps    =')
for t, v in context.traps.items():
print('  {}: {}'.format(t, v))```

This sample script shows the common properties of the Context. ### 1.5.2 Precision

The prec property of the context controls the precision to be maintained for new values created as arithmetic results.Literal values maintain accuracy by this attribute.(

```import decimal

d = decimal.Decimal('0.123456')

for i in range(1, 5):
decimal.getcontext().prec = i
print(i, ':', d, d * 1)```

To change the precision, you can assign a new value directly between 1 and decimal.MAX_PREC for this attribute. ### 1.5.3 rounding

Rounding has several options to ensure that the values are within the required accuracy range.

ROUND_CEILING: Always rounds up towards infinity.

ROUND_DOWN: Always tends to zero rounding.

ROUND_FLOOR: Always rounds down toward negative infinity.

ROUND_HALF_DOWN: If the last valid number is greater than or greater than 5, it is rounded in the opposite direction of 0; responsible, it is rounded in the direction of 0.

ROUND_HALF_EVEN: Similar to ROUND_HALF_DOWN, however, if the last valid number is 5, the previous digit is checked.Even values cause the result to be rounded down, while odd values cause the result to be rounded up.

ROUND_HALF_UP: Similar to ROUND_HALF_DOWN, but if the last significant number is 5, the value is rounded in the opposite direction of 0.

ROUND_UP: Rounds in the opposite direction of 0.

ROUND_05UP: If the last bit is 0 or 5, it is rounded in the opposite direction of 0; otherwise, it is rounded to 0.

```import decimal

context = decimal.getcontext()

ROUNDING_MODES = [
'ROUND_CEILING',
'ROUND_DOWN',
'ROUND_FLOOR',
'ROUND_HALF_DOWN',
'ROUND_HALF_EVEN',
'ROUND_HALF_UP',
'ROUND_UP',
'ROUND_05UP',
]

header_fmt = '{:10} ' + ' '.join(['{:^8}'] * 6)

' ',
'1/8 (1)', '-1/8 (1)',
'1/8 (2)', '-1/8 (2)',
'1/8 (3)', '-1/8 (3)',
))
for rounding_mode in ROUNDING_MODES:
print('{0:10}'.format(rounding_mode.partition('_')[-1]),
end=' ')
for precision in [1, 2, 3]:
context.prec = precision
context.rounding = getattr(decimal, rounding_mode)
value = decimal.Decimal(1) / decimal.Decimal(8)
print('{0:^8}'.format(value), end=' ')
value = decimal.Decimal(-1) / decimal.Decimal(8)
print('{0:^8}'.format(value), end=' ')
print()```

This program shows the effect of using different algorithms to round the same value into different precision. ### 1.5.4 Local Context

You can use the with statement to apply a context to a block of code.

```import decimal

with decimal.localcontext() as c:
c.prec = 2
print('Local precision:', c.prec)
print('3.14 / 3 =', (decimal.Decimal('3.14') / 3))

print()
print('Default precision:', decimal.getcontext().prec)
print('3.14 / 3 =', (decimal.Decimal('3.14') / 3))```

Context supports the context manager API used by with, so this setting is only applied within a block. ### 1.5.5 Context for each instance

You can also construct a Decimal instance with a context from which precision and rounding parameters of the transformation can be inherited.

```import decimal

# Set up a context with limited precision
c = decimal.getcontext().copy()
c.prec = 3

# Create our constant
pi = c.create_decimal('3.1415')

# The constant value is rounded off
print('PI    :', pi)

# The result of using the constant uses the global context
print('RESULT:', decimal.Decimal('2.01') * pi)```

For example, this allows applications to select common value accuracy that differs from user data accuracy. The Global context instance is the thread local context, so you can configure threads individually using different values.

```import decimal
from queue import PriorityQueue

def __init__(self, a, b, prec, q):
self.a = a
self.b = b
self.prec = prec
self.q = q

def run(self):
c = decimal.getcontext().copy()
c.prec = self.prec
decimal.setcontext(c)
self.q.put((self.prec, a * b))

a = decimal.Decimal('3.14')
b = decimal.Decimal('1.234')
# A PriorityQueue will return values sorted by precision,
# no matter what order the threads finish.
q = PriorityQueue()
threads = [Multiplier(a, b, i, q) for i in range(1, 6)]
t.start() 