## math.trunc Python | Math Trunc Method

##### Aniekan

Known for its versatility and extensive library support, Python provides programmers with a wide range of mathematical functions and methods through its built-in `math` module. One method that has proven to be very useful is the `math.trunc()` function in Python programming. This function allows developers to truncate the fractional part of a floating-point number, thereby obtaining its integer value.

Whether you need exact integer values ​​for calculations, data manipulation, or formatting, the `math.trunc()` method can help.

In this article, we take a deep dive into the `math.trunc()` Python method, covering its syntax, purpose, and exploring practical use cases that highlight its importance in programming. By understanding and learning this method, you will have a powerful tool for working efficiently with floating point numbers.

## Python math.trunc method introduction

The `math.trunc()` method, belong to the `math` module in Python, allows us to truncate the fractional or decimal part of a floating-point number and retrieve its integer component. By discarding the decimal portion, the method essentially returns the largest integer that is less than or equal to the given number.

To utilize the `math.trunc()` method effectively, we follow a specific syntax as outlined below:

``````import math
math.trunc(number)``````

We begin by importing the `math` module, which provides us with access to various mathematical functions and methods.

Next, we invoke the `trunc()` method from the `math` module, passing the desired floating-point value as the argument. The `number` parameter represents the specific floating-point value that we wish to truncate.

## Math Trunc Python Example and Uses

In the sections that follow, we will showcase various examples of the use of `math.trunc()`.

Each example demonstrates a unique case where the `math.trunc()` method can be employed to obtain the integer component of a given value.

Let’s begin our exploration.

### Truncating a Positive Float Number – Using math.trunc in Python

In this example, we will demonstrate how the `math.trunc()` method can be used to truncate a positive floating-point number and extract its integer component. Consider a scenario where we have a positive float number, such as `3.14159`, and we want to obtain the integer part by discarding the decimal portion. See the code snippet below:

``````import math
float_number = 3.14159
truncated_number = math.trunc(float_number)
print(truncated_number)    # prints 3
``````

We first import the `math` module to access the `math.trunc()` method. Next, we initialize the variable `float_number` with the positive float value we want to truncate, which is `3.14159` in this case. Then, we pass this variable as an argument to the `math.trunc()` method, which returns the truncated integer value. Finally, we print the result, which would be `3`.

Now that we have seen how to truncate a positive float number, let’s move on to the next example, where we will discuss truncating a negative float number.

### Truncating a Negative Float Number – Using math.trunc Python

In this example, we will focus on truncating a negative floating-point number using the `math.trunc()` method. When dealing with negative float numbers, `math.trunc()` simply discards the fractional part, and gives us the integer part.

Consider the code snippet below, which demonstrates how to truncate a negative float number using the `math.trunc()` method:

``````import math
float_number = -2.71828
truncated_number = math.trunc(float_number)
print(truncated_number)    # prints -2
``````

The negative value we want to truncate is `-2.71828` . When we assign it to the variable `float_number` , and then pass this variable as an argument to `math.trunc()`, we get the truncated negative integer that would be `-2`.

Now that we are done with truncating a negative float number, let’s proceed to an example of truncating a complex number.

### Truncating a Complex Number – Using Python math trunc

A complex number consists of a real part and an imaginary part, both of which can be floating-point values. Truncation in the context of complex numbers refers to extracting the integer component of either the real or imaginary part while discarding the fractional portion.

To illustrate, let’s consider a complex number, represented as 3.456 – 45.24j.

First, we want to truncate the real part of the complex number. By applying the `math.trunc()` method to the real part, we can obtain its integer value.

This method takes the initialized complex number as its argument, along with the `real` attribute, and returns the truncated integer value from the real part of the complex number.

Let’s examine the Python code snippet below to see this in action:

``````import math
complex_number = 3.456 - 45.24j
truncated_real_part = math.trunc(complex_number.real)
print(truncated_real_part)    # prints 3
``````

We applied the `math.trunc()` to the real part of the complex number by accessing the `real` attribute.

The method returns the truncated integer value of the real part, which is `3` in this case.

Additionally, if we need to do the same thing as previously done, but this time we want to truncate the imaginary part of a complex number. For that we will need to access the `imag` attribute.

The next code snippet is a slight modification to the previous code:

``````import math
complex_number = 3.456 - 45.24j
truncated_real_part = math.trunc(complex_number.imag)
print(truncated_real_part)    # prints -45
``````

In this code, we use `math.trunc()` on the complex number’s imaginary part, accessed through the `imag` attribute.

The method returns the truncated integer value of the imaginary part, which when printed, displays `-45`.

There may be situations where we want to truncate both parts simultaneously and obtain a new complex number with the truncated values.

To achieve this, we can define a custom function that takes a complex number as input, applies the `math.trunc()` method to its real and imaginary parts, and returns a new complex number with the truncated values.

#### Here’s an example of how we can define such a function in Python:

``````import math

def truncate_complex(complex_number):
truncated_real = math.trunc(complex_number.real)
truncated_imaginary = math.trunc(complex_number.imag)
return complex(truncated_real, truncated_imaginary)

# Example usage
original_complex = 3.456 - 45.24j
truncated_complex = truncate_complex(original_complex)
print(truncated_complex) # prints (3-45j)
``````

In this code snippet, we define the function `truncate_complex` that takes a `complex_number` parameter. Within the function, we use the `math.trunc()`` method to truncate the real and imaginary parts of the complex number separately. The truncated values are then used to create a new complex number using the complex() constructor, which is then returned.`

To demonstrate the usage of the function, we initialize a complex number `original_complex` with the value `3.456 - 45.24j`.

We then call `truncate_complex()`, passing `original_complex` as the argument.

What we got was the complex number `(3-45j)`. since both the real and imaginary parts have been truncated.

By defining a custom function like `truncate_complex()`, we can conveniently truncate both the real and imaginary parts of a complex number simultaneously and obtain a new complex number with the truncated values.

This provides flexibility and simplicity when working with complex numbers and performing truncation operations.

## Conclusion

The `math.trunc()` method in Python provides a convenient way to truncate the fractional or decimal part of floating-point numbers and extract their integer component.

By discarding the decimal portion, this method helps us achieve precise integer values for various calculations and data manipulations.

Whether dealing with positive float numbers, negative float numbers, or complex numbers, `math.trunc()` proves to be a valuable tool.

In this article, we explored the syntax and usage of the `math.trunc()` method through practical examples. By leveraging this method, Python developers can handle floating-point numbers with precision and flexibility.