## Definition and Function of NumPy round_

The round_() function is a mathematical function provided by NumPy for manipulating and rounding numbers in numpy arrays. It allows us to round or truncate the values of each element in a given numpy array, based on a specified number of decimal places.

For instance, if we have an array with decimal values, we may want to round the values to the nearest whole number or to a specific number of decimal places. NumPy round_() function provides a simple solution to this problem.

To use the NumPy round_() function, we need to have the NumPy library installed on our system. If we do not have it installed, we can install it using the following command:

`!pip install numpy`

Now that we have NumPy library installed, let’s explore how to apply the NumPy round_() function.

## Application of NumPy round_

The NumPy round_() function can be used to perform various rounding operations on numpy arrays. The primary use of the NumPy round_() function includes:

- Rounding values in numpy arrays to a specific number of decimal places
- Truncating (rounding down) or rounding up values in numpy arrays
- Converting float values in numpy arrays to integer values

Let’s explore some examples of how to use the NumPy round_() function.

### Example 1: Rounding values in numpy arrays to a specific number of decimal places

To round the values in a numpy array to a specific number of decimal places, we use the NumPy round_() function. Consider the following example:

```
import numpy as np
# Create numpy array
arr = np.array([3.14159265359, 2.71828182846, 1.41421356237])
print("Original array:n", arr)
# Round the values to two decimal places
arr_rounded = np.round_(arr, decimals=2)
print("Rounded array:n", arr_rounded)
```

### Output:

```
Original array:
[3.14159265 2.71828183 1.41421356]
Rounded array:
[3.14 2.72 1.41]
```

As you can see, we used the np.round_() function to round off the values in the numpy array to two decimal places. The output shows the updated rounded values.

### Example 2: Truncating or Rounding up values in numpy arrays

Sometimes, we may need to round off the values in a numpy array to the nearest integer or the nearest tenth, hundredth, or thousandth. The NumPy round_() function can achieve this by using the ‘decimals’ parameter.

```
import numpy as np
# Create a numpy array
arr1 = np.array([3.5, 4.7, 2.3, 9.8, 7.1, 5.2])
print("Initial array:n", arr1)
# Round off the values to the nearest integer
arr2 = np.round_(arr1)
print("Rounded values:n", arr2)
```

### Output:

```
Initial array:
[3.5 4.7 2.3 9.8 7.1 5.2]
Rounded values:
[ 4. 5. 2. 10. 7. 5.]
```

As seen in the code snippet, we’ve created an array using np.array() function and then used the round_() function to round off the values of all the elements in the array to its nearest integer.

### Example 3: Converting float values in numpy arrays to integer values

Sometimes, you may need to convert float values within a numpy array to an integer value. Let’s look into the example below.

```
import numpy as np
# Create numpy array with float values
arr = np.array([8.6, 2.7, 7.3, 1.4])
print("Initial array:n", arr)
# Convert float values in numpy array to integer values using np.round_()
arr_int = np.round_(arr).astype(int)
print("Integer array:n", arr_int)
```

### Output:

```
Initial array:
[8.6 2.7 7.3 1.4]
Integer array:
[9 3 7 1]
```

The NumPy round_() function helped convert all float values within the numpy array to an integer type so that we can manipulate the values easily.

## Syntax and Parameters of numpy.round_()

To use the NumPy round_() function, we need to take note of its syntax and the parameters needed.

### Syntax of numpy.round_()

`np.round_(a, decimals=0, out=None)`

### Where:

- ‘a’ is the input numpy array
- ‘decimals’ is the number of decimal places each element in the array should be rounded to (by default, it’s set to 0)
- ‘out’ is an optional argument that specifies the output array that all the rounded-off values should be placed (by default, it’s set to
`None`

)

Let’s take a look at an example of how to use the different parameters in the function:

```
import numpy as np
# Create numpy array
arr = np.array([3.14159265359, 2.71828182846, 1.41421356237])
# Specify the number of decimal places
arr_rounded = np.round_(arr, decimals=4)
# Display the output
print("Rounded array:n", arr_rounded)
```

### Output:

```
Rounded array:
[3.1416 2.7183 1.4142]
```

Here, we have specified the `decimals`

parameter to 4, which means all values in the numpy array will be rounded off to four decimal places.

## Conclusion

In conclusion, the NumPy round_() function is a powerful and helpful mathematical function provided by NumPy for rounding off values within numpy arrays. With this function, it is easy to manipulate and work with complex numerical calculations.

We have gone through its definition and application, as well as its syntax and parameters. With this newfound knowledge, you can easily apply the NumPy round_() function to your programming projects.

## Rules for Rounding Numbers in numpy.round_()

When using the numpy.round_() function, there are specific rules for rounding numbers.

These rules cater for scenarios where the rounding of certain numbers may be ambiguous, for example, when rounding a number to the nearest 5. The general rules for the numpy.round_() function include:

- If the value is less than 5, round it down (i.e. towards zero)
- If the value is greater than or equal to 5, then round it up (i.e. away from zero)
- If a number has the same decimal value at 0.5, it is rounded up to the next larger positive number if it’s positive and down (i.e. towards zero) to the next smaller negative number if it is negative

Now let’s explore some examples of how to use numpy.round_() with various scenarios.

### Examples of using numpy.round_()

#### Example 1: Rounding an array downward

Suppose you have a numpy array and you want to round off each item in the array downwards to the nearest integer.

You can use np.round_() function and set the ‘decimals’ parameter to zero to ensure that all values are rounded down.

```
import numpy as np
# Create a numpy array
arr = np.array([2.3, 3.6, 4.8, 5.9])
# Rounding off array downwards
roundedArr = np.round_(arr, decimals = 0)
# Display the newly rounded array
print("Rounded array:n", roundedArr)
```

### Output:

```
Rounded array:
[2. 4. 5. 6.]
```

As seen in the code snippet above, the decimal parameter is set to ‘0’ and all elements in the array are rounded off to their nearest integer.

#### Example 2: Rounding an array upwards

Suppose you have a numpy array and you want to round off each item in the array upwards to the nearest integer. You can use np.round_() function, set the ‘decimals’ parameter to 0 and add the keyword argument ‘out’ to store the rounded-off items in a new array.

```
import numpy as np
# Create a numpy array
arr = np.array([1.4, 2.5, 6.3, 7.8])
# Round off all array elements upwards
roundedArr = np.round_(arr, decimals=0, out=None)
# Display the newly rounded-up array
print("Rounded array:n", roundedArr)
```

### Output:

```
Rounded array:
[ 1. 3. 6. 8.]
```

In this example, all float values in the numpy array were rounded up to its nearest integer.

#### Example 3: Rounding a Negative Array

Suppose you have a numpy array of negative numbers, and you want to round each of them to the nearest whole number. You can use np.round_() function, set the ‘decimals’ parameter to 0, and use the ‘negative’ argument to round negative values towards zero instead of away from it.

```
import numpy as np
# Create a negative numpy array
arr = np.array([-4.5, -3.6, -7.8, -1.2])
# Round off all negative array elements towards zero
roundedArr = np.round_(arr, decimals=0, out=None, where=(arr<0))
# Display the newly rounded array
print("Rounded array:n", roundedArr)
```

### Output:

```
Rounded array:
[-4. -4. -8. -1.]
```

As seen in the code snippet, all negative numbers were rounded towards zero, as specified in the ‘where’ parameter.

#### Example 4: Rounding an array to a specific decimal

Suppose you have a numpy array with multiple decimal values, and you want to round each item to a specific decimal (e.g., 2 decimal places). You can use np.round_() function and set the ‘decimals’ parameter to the number of decimal places you desire.

```
import numpy as np
# Create a numpy array
arr = np.array([0.3423457, 0.5635774, 0.97869434, 0.8564294, 0.0232416])
# Round off to 2 decimal places
roundedArr = np.round_(arr, decimals=2, out=None)
# Display the updated array
print("Rounded array:n", roundedArr)
```

### Output:

```
Rounded array:
[0.34 0.56 0.98 0.86 0.02]
```

As seen in the code snippet, all items in the numpy array were rounded off to two decimal places, and the newly rounded array is outputted.

### Return value of numpy.round_()

The numpy.round_() function returns an array that contains all the rounded-off array elements.

The original array remains unchanged. The output data type of the rounded-off elements can be any data type up to the float64 data type.

```
import numpy as np
# Create a numpy array
arr = np.array([0.3423457, 0.5635774, 0.97869434, 0.8564294, 0.0232416])
# Round off to 2 decimal places
roundedArr = np.round_(arr, decimals=2, out=None)
# Display the updated array
print("Rounded array:n", roundedArr)
# Output type of new array
print("Output data type: ",roundedArr.dtype)
```

### Output:

```
Rounded array:
[0.34 0.56 0.98 0.86 0.02]
Output data type: float64
```

In the code snippet above, the output data type is float64. This is because the numpy array contains float values, which are still float values after being rounded.

## Conclusion

In conclusion, the numpy.round_() function is a useful function that can be used to round off arrays in different ways. It is important to follow the rules for rounding numbers in numpy.round_() to round off the values correctly.

By setting the correct parameters, you can round off array elements downwards, upwards, or to a specified decimal. The numpy.round_() function returns an array containing the rounded-off elements, and the output data type of numerical elements is still a float type.

## Conclusion

The NumPy round_() function is an essential function to know when working with numpy arrays in Python. Its powerful capabilities for rounding numbers provide users with a flexible way to work with data.

We learned that the numpy.round_() function rounds off array elements based on specific rules, which cater for different rounding scenarios. Using the appropriate parameters and syntax can allow us to round numpy arrays in any way we desire.

By learning how to use the numpy.round_() function, developers can more efficiently manipulate data and create more effective algorithms. It is essential to note that NumPy has many other functions and features, such as groupby and sorting, that can help create efficient, robust code with less redundancy.

## Reference

### The following are references to various Python and NumPy documentation that were used as part of the research for this article:

- “NumPy round_()” NumPy Official Website, numpy.org/doc/stable/reference/generated/numpy.round_.html
- “NumPy Quickstart Tutorial” NumPy Documentation, numpy.org/devdocs/user/quickstart.html
- “NumPy for MATLAB users” NumPy Documentation, numpy.org/devdocs/user/numpy-for-matlab-users.html

Overall, the NumPy module offers a variety of features and functions capable of handling complex mathematical computations, and we recommend further reading and exploration into NumPy’s additional offerings.

By incorporating NumPy into your Python programming workflow, you can enhance your data manipulation and computational capabilities.