How to do accurate decimal calculations using Python?

In this article, we will learn how to do accurate decimal calculations in Python.

usage instructions

• Using the Decimal() function of the decimal Module

• Use the fsum() function of the math module

It is a well-known shortcoming that floating point numbers cannot accurately represent all decimal numbers. Furthermore, even simple mathematical calculations can produce some errors. For example −

Example

The following program demonstrates the inability of floating-point integers to accurately represent all decimal numbers-

x = 4.2
y = 3.1
 
# printing the sum of both the variables
print("x + y =", x + y)
 
# checking if the sum is both the variables is equal to 7.3
print((x + y) == 7.3)

Output

When executed, the above program will generate the following output -

x + y = 7.300000000000001
False

These errors are a "feature" of the IEEE 754 arithmetic standard used by the system's underlying CPU and its floating-point unit. If you write code using float instances, there is nothing you can do to prevent such errors anyway, since Python's float data type uses native representation to hold the data.

Using the decimal module will give you greater accuracy at the cost of some performance. Let us see it below.

Method 1: Use the Decimal() function of the decimal module

Example

The following program shows an example of using the Decimal() function for precise decimal calculations:

# importing Decimal from decimal module
from decimal import Decimal
x = Decimal('4.2')
y = Decimal('3.1')
# printing the sum of both the variables
print("x + y =", x + y)
# checking if the sum is both the variables is equal to 7.3 using by passing the sum to the Decimal Function
print((x + y) == Decimal('7.3'))

Output

When executed, the above program will generate the following output -

x + y = 7.3
True

In the above code, it may feel a little strange at first that the number is specified as a string. However, decimal objects work exactly as you would expect (all common mathematical operations supported, etc.). When you print them or use them in string formatting functions, they look like ordinary numbers.

Controlling various aspects of calculations, such as the number of digits and rounding methods, is a key feature of decimal.

Example

To do this, create a local context and modify its settings.

# importing localcontext from decimal module
from decimal import localcontext
x = Decimal('2.3')
y = Decimal('2.7')
# dividing x by y(returns as a floating-point number)
print(x / y)
with localcontext() as context:
   # rounding the number upto 3 digits i.e, precision 3
   context.prec = 3
   # Dividing x by y with precision set to 3
   print(x / y)

Output

When executed, the above program will generate the following output -

0.8518518518518518518518518519
0.852

Increase accuracy value to '60' for better accuracy

Example

# importing localcontext from decimal module
import decimal
from decimal import localcontext
x = decimal.Decimal('2.3')
y = decimal.Decimal('2.7')
# dividing x by y(returns as a floating-point number)
print(x / y)
with localcontext() as context:
   # Rounding the number upto 60 digits i.e, precision 60
   context.prec = 60
   # Dividing x by y with precision set to 3
   print(x / y)

Output

When executed, the above program will generate the following output -

0.8518518518518518518518518519
0.851851851851851851851851851851851851851851851851851851851852

Method 2: Use the fsum() function of the math module

The decimal module implements IBM's "Universal Decimal Arithmetic Specification".

Needless to say, there are many customization options that are beyond the scope of this article.

Python beginners may be tempted to use the decimal module to solve precision problems with floating-point data types. But you also need to understand your application area. The ordinary floating point type is usually more commonly used when dealing with scientific or engineering problems, computer graphics, or other things of a scientific nature.

For example, few elements in the real world can be measured with the 17 digits of precision provided by floating point numbers. Therefore, even small calculation errors have no effect. Moreover, native floating point is also significantly faster, which is critical for situations where a large number of calculations need to be run.

Example

However, you can't completely avoid mistakes. Many algorithms have been widely studied by mathematicians, and some are better at handling errors than others. Additionally, some caution is required because the practice of subtracting cancellations and adding large and small numbers can have consequences.

inputList = [1.23e+18, 1, -1.23e+18]

# observe how the 1 disappears here if we perform sum() on the list
print(sum(inputList)) 

Output

When executed, the above program will generate the following output −

0.0

fsum() function is used to find the sum between a given range or iterable object. It requires importing the math library. It is widely used in mathematical calculations.

grammar

The following is the syntax of the function.

maths.fsum( iterable )

Iterable objects can be ranges, arrays, or lists.

Return type -

It returns a floating point number.

Example

The following example can be used for a more accurate implementation in math.fsum() -

# importing math module 
import math
# input list
inputList = [1.23e+18, 1, -1.23e+18]
# adding the sum of elements of the list using the fsum() function
print(math.fsum(inputList))

Output

When executed, the above program will generate the following output -

1.0

In contrast, you actually need to study and understand the error propagation characteristics of other algorithms.

Nevertheless, programs dealing with topics such as finance are where the decimal module is most commonly used. It is very unpleasant when small inaccuracies appear in the calculations of these systems.

Therefore, the decimal module provides a way to avoid this situation. Decimal objects are often encountered again when Python interacts with databases, especially when accessing financial data.

in conclusion

We learned in this article that under certain circumstances regular calculations fail, so we need correct decimal calculations. We learned how to perform accurate decimal calculations using two separate functions, decimal() and fsum(). We also learned how to use the localcontext() function to set the precision of the results.

The above is the detailed content of How to do accurate decimal calculations using Python?. For more information, please follow other related articles on the PHP Chinese website!