## NumPyfloor()

Python offers a core library providing for scientific computing tools which are known as Numpy. It is an array object which is known for its multi-dimensional and high-performance arrays. NumPyfloor() is a mathematical function that is present in the tool used while coding in the Python language. It returns the floor value of the elements that are present in an array. So, for an array containing scalar values coma foreign element ‘x’ a value ‘i’ would be returned which would be the largest integer (such that the value of i<=x)

To simplify the advantage of a Numpy array we can look at its output delivery on the basis of three parameters. They are as follows:

• ## Size:

Numpy data structures pick up comparatively much lower space in the memory.

• ## Performance:

Compare two lists that are provided in the arrays, Numpy data structures are much faster.

• ## Functionality:

It is well known for a high level of Optimization going to inbuilt functions (for example; inbuilt linear algebra operations).

## Syntax

numpy.floor(x, /, out=None, *, where=True, casting=’same_kind’, order=’K’, dtype=None, subok=True[, signature, extobj]) = < ufunc 'floor'>

The floor of the scalar x is the largest integer i, such that i<= x. It is often denoted as.

## Parameters

Following is the list of element-wise breakdown of the floor() syntax where the detail has been listed below which explains the function and implication of all:

Parameters

## x:

stands for the set of arrays that would be processed by the floor() function.

It can be either a programmer defines a set of values or the user can be prompted to enter values, which will be used as a variable array.

## out:

Multiple features can be e allocated to out amongst None, ndarray, or tuple of ndarray along with None. This is an optional step.

• If None is mentioned then an array which is freshly allocated is returned.
• If tuple (possible to be written as a keyword in some instances only) is written, so the returned valued should have its length equal to the number of output.

## Where:

array_like ( it is optional to be included in the code)

The values reflected when False is used, indicates that the value in the output has to be left alone while the value reflected by True indicates that calculation has to be performed on the ufuncn at that memory position where the value is saved.

Returns:

## y:

ndarray or scalar values that are returned after processing of the entered code on the values entered by the user, which has been made by the programmer.

The floor of each element in x () is returned (This value returns the round down value in technical terms, i.e., for a number 9.9999 the value returned is 9 and not 10). This is a scalar value if x is a scalar entity.

## How NumPyfloor() Function works?

Numpy floor () checks the value of the input variable (must be a real number; assume x) and rounds the variable in a downwards manner to the nearest integer and finally returns the processed output. It must be noted that it is not rounded off but would be less than or equal to the value entered (i.e., x itself). It differs from another function [ceil()] which is used to return the variable rounded upwards.

Let us simplify the difference between the floor and ceil by the following table:

x Ceiling ⌈ x ⌉ {\displaystyle \lceil x\rceil } Floor ⌊ x ⌋ {\displaystyle \lfloor x\rfloor } Fraction { x } {\displaystyle \{x\}}
3 3 3 0.0
3.4 4 3 0.3
3.9 4 3 0.9
−3.7 −3 −4 0.3
−3 −3 −3 0.0

## Example to Implement floor() Function in Numpy

Let us explain the working of the floor function with the help of an example

## Code:

```import numpy as np
arr= [0.123, 0.009, 1.3, 1.2344, 9.99999] print ("Input a set of five numbers (integer or non-integer):", arr)
r_arr = np.floor(arr)
print("Changed array after Numpy floor function used:",r_arr)
```

## Output:

```Input a set of five numbers (integer or non-integer):
0.123, 0.009, 1.3, 1.2344, 9.99999*
Changed array after Numpy floor function used:,: [0. 0. 1. 1. 9.]
```

So we see that the output reflected the round down values for each of the numbers entered. This would have been round up if the numPyceil() function had been used.

### Explanation:

The functions numpy has to be imported from the python toolset

• The user is prompted to enter values for an array (the number of values the user has to enter is prompted in the output screen in the comments)
• The function flooroff_values are called, which approximants the numbers which have mean input by the user and returns the nearest integer
• The rounded values return on the output window (i. e., 0.1, 1., 0.).
• We can see that all the values which are returned are to the nearest integer.

Apply now for Advanced Python Training Course