The **numpy.float_power()** function in Python is part of the NumPy library that is used to compute the element-wise power of array elements. It allows us to raise each element of an array to a specified power, providing flexibility and efficiency for handling power operations on arrays.

In this article, we will understand Python **numpy.float_power()** function, its syntax, and demonstrate it with various examples. Let’s get started.

## Syntax of numpy.float_power() Function

Let us get started by understanding the fundamental constituents of the **numpy.float_power()** function with the help of its syntax given below.

**Syntax:**

```
numpy.float_power(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None)
```

**Parameters:**

**x1:**This is the base array representing the base values.**x2:**This is the exponent array representing the exponent values.**out (optional):**This is an optional parameter that specifies the location where the result should be stored. If not provided, a new array will be created.**where (optional):**This parameter is used for conditional execution. If provided, only the elements where the condition is True will be included in the result.**casting (optional):**This parameter controls what kind of data casting may occur. The default is ‘same_kind’, which means that only casting between similar kinds (e.g., float to float) is allowed.**order (optional):**Specifies the memory layout of the result. The default is ‘K’ which means the order is determined by the input array’s memory layout.**dtype (optional):**This parameter allows us to set the data type of the output array. If not specified, it is determined by the data types of the input arrays.**subok (optional):**If True, then sub-classes will be passed through. If False, the returned array will always be a base-class array.

**Return:**

An array with the same shape as the input arrays is returned by the** numpy.float_power()** method, where each element is calculated as **x1^x2**.

## Examples of numpy.float_power() Function

Let us now look at some examples to demonstrate the use of **numpy.float_power()** function in Python.

### 1. Get the Scalar Power Value

In this example, we will compute the element-wise power by passing scalar inputs into the **numpy.float_power()** function.

**Example:**

```
import numpy as np
sc1 = 2
sc2 = 4
result = np.float_power(sc1, sc2)
print(result)
```

Here we imported the NumPy library as **np **then we took two scalar values: **sc1** and **sc2** and passed them into the **numpy.float_power()** function which will compute the power of **sc1** raised to the power of **sc2**, then we saved the output into the **result **variable. In last, we printed the** result **variable.

**Output:**

In the output, we can see that we got **16.0** as **2^4 = 16**. Since the **numpy.float_power() **function returns the result with a default data type of **float **that’s why we got **16.0**.

### 2. Get the Array Power Value

In this example, we will take** both the inputs as a one-dimensional array** and pass them to the **numpy.float_power()** function which will return us the array with the same shape by raising each element of the first array to the power of the corresponding element present in the second array.

**Example:**

```
import numpy as np
ar1 = np.array([12, 1, 2])
ar2 = np.array([2, 3, 2])
result = np.float_power(ar1, ar2)
print(result)
```

Here by using the NumPy library, we created arrays of one-dimension and passed them into the **numpy.float_power()** function which will calculate the element-wise power, then we saved the output in the **result **variable. At last, we printed it.

**Output:**

In the output, we can see that we got an array where the first element is **144.0** because **12 raises to the power of 2 is 144.0**. In the same way, the second element in the output array is **1^3=1.0 **and the third element in the output array is **4** as **2^2 = 4.0**.

### 3. Get the Array Power Value with a Scalar Base

In this example, we will compute the **scalar value raising to the power of each element from the one-dimensional array** using **numpy.float_power() **function.

**Example:**

```
import numpy as np
sc = 4
ar = np.array([1, 2, 3])
result = np.float_power(sc, ar)
print(result)
```

**Output:**

In the output, we can see that the first element in the output array is **4 **because** 4^1=4.0**. In the same manner for the second element** 4^2=16.0 **and for the third element we got **4^3 = 64.0**.

### 4. Passing the ‘order’ Parameter

In this example, we will **change the memory layout** of the resulting array. By default, it’s in** ‘k’ **order, but we’ll switch it to **‘F’** order, which is like a Fortran-style memory layout.

**Example:**

```
ar1 = np.array([[4, 5], [2, 7]])
ar2 = np.array([[4,2], [3,1]])
result = np.float_power(ar1,ar2, order='F')
print(result)
```

**Output:**

In the output, we can see that **numpy.float_power() **function calculated the element-wise power of the base array **ar1 **with the exponent array **ar2** resulting in an array whose memory layout is of **Fortran style** as we passed the order as **‘F’ **in** numpy.float_power() **function.

## Summary

Now that we have reached the end of this article, hope it has elaborated on the different ways to find the element-wise power of scalar value as well as the arrays by using the **numpy.float_power() **function from the **NumPy** library. For individuals who want to advance in Python, CodeforGeek has a ton of other entertaining and equally educational articles that could be quite beneficial.

## Reference

https://numpy.org/doc/stable/reference/generated/numpy.float_power.html