# How to Create High Precision Data Types

5/5 - (1 vote)

## Problem Formulation and Solution Overview

In this article, you’ll learn how to create high-precision data types in Python.

💡 Definition: High-precision data types are numeric data types, such as integers, or floats, that use additional memory when complex mathematical calculations require extreme accuracy.

💬 Question: How would we write Python code to create high-precision data types?

We can accomplish this task by one of the following options:

## Method 1: Use the Math Library sqrt()

This example calls Python’s built-in `math `library and uses the `sqrt()` function from the same.

```from math import sqrt
print(sqrt(3)) ```

This code will always return the result in a float64 format with a precision of up to 16 decimal places.

## Method 2: Use NumPy sqrt()

If you prefer to select either a float32 or a float64 return format, use NumPy’s `sqrt()` function.

Before moving forward, this library will need to be installed. Click here for installation instructions.

```import numpy as np
print(np.sqrt(3, dtype=np.float64)) ```

NumPy’s `sqrt()` function, by default, assumes the `dtype` is `float64`, so there is no need to add this argument. However, for this example, it was added.

To return a float as a `float32`, change the `dtype `below and run. This returns a float with a precision of up to seven (7) decimal places.

```import numpy as np
print(np.sqrt(3, dtype=np.float32)) ```

## Method 3: Use Mpmath Library

If you require accurate precision to a more significant degree, the `mpmath` library is your go-to! This library breaks out of the traditional 32/64 restrictions.

Before moving forward, this library will need to be installed. Navigate to a terminal and enter the following at the command prompt:

`pip install mpmath`

Let’s test the precision.

```import mpmath as mp
from mpmath import *

mp.dps = 20
print(mpf('5') ** mpf('1.1'))```

Above, the `mpath` library is called, and all of its functions are imported.

For this example, we set the number of decimal places to 20 (`mp.dps = 20`).

Then, `mpf('5')` is called, which instantiates a real floating-point number.
A mathematical computation is declared (**), and another call to `mpf('1.1')` is made. The calculation is done and output to the terminal.

💡Note: To achieve accurate precision, pass the arguments to `mpf()` as Strings.

## Method 4: Use format()

This method uses Python’s `format()` function, where you can specify the precise number of decimal places.

```num = 22.9379999999
res = float("{:.5f}".format(num))
print(res)```

Above assigns a floating point with ten decimal places and saves to `num`. Then this number is formatted to five (5) places and saved to `res`. The results are output to the terminal.

💡Note: Notice all numbers are counted. In this case, two (2) before the decimal and three (3) after adding up to five (5).

## Method 5: Use round()

Python’s `round()` function rounds down a number to a specified number of decimal places.

```num = 4.986578934
print(round(num, ndigits=5))```

Above assigns a floating-point number to `num`.

Next, `round()` is called and `num` is passed as an argument, as well as the number of digits desired (`ndigits=5`). The result is output to the terminal.