# Numpy Exmp1: A Complete Guide Euler’s number, also known as ‘e’, is an important mathematical constant that was named after the 18th century mathematician, Leonhard Euler. This number has been estimated to have over a trillion digits of accuracy and is an important tool in mathematical calculations.

2.718281828459045……

Euler’s number

The dots at the end indicate that the number of digits goes on & on which provides the inference that ‘e’ falls into the category of irrational numbers. We shall get things started by first importing the numpy library using the following code.

In this article, we will explore the history of Euler’s number and how it is used in the Numpy Exmp1() function.

```import numpy as np
```

Thereafter, we shall explore further the expm1( ) function through each of the following sections.

• Syntax of the expm1( ) function
• Why use expm1(x) instead of exp(x)-1?
• Using expm1( ) on Scalars
• Using expm1( ) on N-Dimensional Arrays

## Syntax of the expm1( ) function

The functionality of the expm1( ) is similar to that of the exp( ) function where ‘e’ is raised to the power of a given number followed by subtracting one (1) from it. Following is the syntax of the expm1( ) function which contains both the mandatory and the optional inputs required for its functioning.

```numpy.expm1(x, out=None, *, where=True, dtype=None)
```

where,

• x – N-dimensional array or scalar which is to be raised to the power of e
• out – an optional construct set to none by default, but could be used to store the results in the desired array which is of the same length as the output
• * kwargs or keyword argument which is an optional construct used to pass keyword variable length of argument to a function
• where – an optional construct that is used to calculate the universal function (ufunc) at the given position when set to True (default setting) or not calculated when set to False
• dtype – an optional construct used to specify the data type which is being used

## Why use expm1(x) instead of exp(x)-1?

You may wonder what is the need to build a specific function for removing one from an exponential, rather than use the already available function exp( ) & remove one from it! (i.e) exp(x)-1.

Let’s do just that and find out whether there are any observable differences.

```x = 1.5
np.exp(x)-1
np.expm1(x)
```

Following are the results of the above code.

Well, it seems that all is well and both results are synonymous. But, what if we reduce ‘x’ a bit and deploy the same functions? Will those be able to return the same results? Let’s find out!

```x = 0.0001
np.exp(x)-1
np.expm1(x)
```

The results aren’t the same now, are they? Buha haa haa haa! (Sinister laughter)

The main reason behind this is that the exponential of any number close to ‘0’ will be very near to ‘1’. Thus, the exp(x)-1 seems to be not that accurate in returning the results and a dedicated function expm1( ) is made available within the numpy library of Python.

## Using expm1( ) on Scalars

You can also find the outcome by assigning a negative number to the expm1( ) function. This would in turn return the equivalent of exp(x), reciprocate it & then remove ‘1’ from it. For those who would like to jump directly to the results, here they are!

```a = -10
b = 0.000000009
np.expm1(a)
np.expm1(b)
```

## Using expm1( ) on N-Dimensional Arrays

The expm1( ) function also holds good when applied to an N-dimensional array as shown below.

```ar1 = np.array([[1, 8, 0.09],
[5.007, -3.303, 2]])
np.expm1(ar1)
```