Table of Contents

## Problem Formulation and Solution Overview

💡 **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.

## 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.

`1.7320508075688772` |

## 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.

`1.7320508075688772` |

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))

` 1.7320508` |

## 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

If successful, you now have access to this amazing library!

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.

`5.8730947154400950296` |

## 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.

` 22.938` |

💡**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.

` 4.98658` |

## Summary

## Programmer Humor

At university, I found my love of writing and coding. Both of which I was able to use in my career.

During the past 15 years, I have held a number of positions such as:

In-house Corporate Technical Writer for various software programs such as Navision and Microsoft CRM

Corporate Trainer (staff of 30+)

Programming Instructor

Implementation Specialist for Navision and Microsoft CRM

Senior PHP Coder