How to Round Number in Matlab

Ammar Ali Feb 12, 2024
  1. Round Numbers in MATLAB Using round()
  2. Round Numbers in MATLAB Using floor()
  3. Round Numbers in MATLAB Using the ceil() Function
  4. Round Numbers in MATLAB Using the fix() Function
  5. Conclusion
How to Round Number in Matlab

Rounding numbers is a fundamental operation in numerical computing, and MATLAB offers a variety of powerful functions to accomplish this task with precision and flexibility. Whether you’re working with single numbers or entire matrices, MATLAB’s rounding functions provide diverse methods for rounding toward positive or negative infinity, towards zero, or to a specific number of decimal places.

In this article, we will explore the syntax and functionality of key MATLAB rounding functions – round(), floor(), ceil(), and fix() – offering insights and practical examples to equip you with the knowledge needed to round numbers effectively in your MATLAB endeavors. Whether you’re a beginner or an experienced MATLAB user, mastering these rounding techniques will enhance the accuracy and efficiency of your numerical computations.

Round Numbers in MATLAB Using round()

The round() function in MATLAB is designed to round each element of an array to the nearest integer. The syntax of the round() function is relatively simple:

rounded_value = round(input_value, decimal_places);

Where:

  • input_value: The number or array of numbers to be rounded.
  • decimal_places: (Optional) The number of decimal places to round to. If omitted, the function rounds to the nearest integer.

Now, let’s delve into practical examples to understand how to use round() effectively.

Example 1: Basic Rounding

% Basic rounding to the nearest integer
number = 7.68
rounded_number = round(number)

In this example, we aim to illustrate the fundamental usage of the round() function by rounding a single floating-point number to the nearest integer.

The variable number is assigned the value 7.68, and we apply the round() function without specifying the number of decimal places. As a result, the function rounds the value to the nearest integer.

Output:

number =

    7.6800


rounded_number =

     8

Example 2: Round to Decimal Places

% Rounding to 2 decimal places
decimal_number = 12.3456
rounded_decimal = round(decimal_number, 2)

Here, we demonstrate how to round a floating-point number to a specific number of decimal places. The variable decimal_number is assigned the value 12.3456, and we use the round() function with the second argument set to 2 to round to two decimal places.

Output:

decimal_number =

   12.3456


rounded_decimal =

   12.3500

Example 3: Round a Matrix

% Rounding elements of a matrix
matrix = [3.14, 2.718; 1.618, 0.577]
rounded_matrix = round(matrix)

This example explores the application of the round() function to matrices. We create a matrix named matrix with four floating-point elements.

By applying the round() function to the entire matrix, each element is independently rounded to the nearest integer. The resulting rounded_matrix is a new matrix with the rounded values.

Output:

matrix =

    3.1400    2.7180
    1.6180    0.5770

rounded_matrix =

     3     3
     2     1

Example 4: Round to Significant Digits

% Rounding to 3 significant digits
numbers = [12345, 0.98765, 67890]
rounded_significant = round(numbers, 3, 'significant')

In this example, we showcase the ability of the round() function to round a vector of numbers to a specified number of significant digits. The vector numbers contains three values: 12345, 0.98765, and 67890.

Using the round() function with the 'significant' property and setting the significant digit argument to 3, we obtain the vector rounded_significant with values rounded to three significant digits.

Output:

numbers =

   1.0e+04 *

    1.2345    0.0001    6.7890

rounded_significant =

   1.0e+04 *

    1.2300    0.0001    6.7900

These examples showcase the versatility of the round() function in MATLAB. Whether rounding to the nearest integer, specific decimal places, or significant digits, round() proves to be a valuable tool for numerical operations.

Round Numbers in MATLAB Using floor()

While the round() function we discussed earlier provides rounding to the nearest integer, MATLAB also offers the floor() function for a different kind of rounding – rounding towards negative infinity.

The floor() function in MATLAB rounds each element of an array to the nearest integer less than or equal to that element. Its syntax is simple:

rounded_value = floor(input_value);

Where:

  • input_value: The number or array of numbers to be rounded down to the nearest integer.

Now, let’s explore a practical example to understand how to use floor() effectively.

Example 1: Round Down to the Nearest Integer

% Rounding down a floating-point number
floating_number = 15.89
rounded_down_number = floor(floating_number)

In this example, we take a single floating-point number, 15.89, and apply the floor() function to round it down to the nearest integer. The floor() function effectively removes the decimal part of the number.

Output:

floating_number =

   15.8900

rounded_down_number =

    15

This example demonstrates the basic use of floor() for rounding down a floating-point number to the nearest integer.

Example 2: Round Towards Negative Infinity

One of the key characteristics of the floor() function is that it always rounds towards negative infinity. This is particularly useful when you need to ensure that the rounded result is less than or equal to the original value.

Here’s an example:

originalNegative = -6.45;
roundedDownNegative = floor(originalNegative);

disp(['Original Negative: ' num2str(originalNegative)]);
disp(['Rounded Down Negative: ' num2str(roundedDownNegative)]);

Output:

Original Negative: -6.45
Rounded Down Negative: -7

Here, the floor() function rounds down the negative decimal number -6.45 to the nearest integer less than or equal to -6.45, which is -7.

Round Numbers in MATLAB Using the ceil() Function

In addition to the round() and floor() functions, MATLAB offers the ceil() function, which rounds each element of an array towards positive infinity.

The ceil() function in MATLAB rounds each element of an array to the nearest integer greater than or equal to that element. Its syntax is straightforward:

rounded_value = ceil(input_value);

Where:

  • input_value: The number or array of numbers to be rounded up to the nearest integer.

Now, let’s delve into practical examples to understand how to use ceil() effectively.

Example 1: Round Up to the Nearest Integer

% Basic rounding up to the nearest integer
floating_number = 9.42
rounded_up_number = ceil(floating_number)

This example involves taking a single floating-point number, 9.42, and applying the ceil() function to round it up to the nearest integer. The ceil() function always rounds towards positive infinity.

Output:

floating_number =

    9.4200


rounded_up_number =

    10

The result, stored in the variable rounded_up_number, is 10, demonstrating the effect of rounding up with the ceil() function.

Example 2: Round to Decimal Places

% Rounding to 2 decimal places
decimal_number = 14.789
rounded_up_decimal = ceil(decimal_number * 100) / 100

This example demonstrates how to round a floating-point number to a specific number of decimal places. We achieve this by multiplying the number by 100, rounding it up with ceil(), and then dividing by 100 to bring it back to the original scale.

Output:

decimal_number =

   14.7890

rounded_up_decimal =

   14.7900

The variable rounded_up_decimal holds the result, showcasing the value rounded up to two decimal places.

Example 3: Round Towards Positive Infinity

Similar to the floor() function’s behavior towards negative infinity, the ceil() function always rounds towards positive infinity. This characteristic is advantageous when ensuring that the rounded result is greater than or equal to the original value.

originalNegative = -3.89;
roundedUpNegative = ceil(originalNegative);

disp(['Original Negative: ' num2str(originalNegative)]);
disp(['Rounded Up Negative: ' num2str(roundedUpNegative)]);

Output:

Original Negative: -3.89
Rounded Up Negative: -3

Here, the ceil() function rounds up the negative decimal number -3.89 to the nearest integer greater than or equal to -3.89, which is -3.

Round Numbers in MATLAB Using the fix() Function

MATLAB provides another valuable tool called fix(). The fix() function in MATLAB rounds each element of an array toward zero, effectively truncating the decimal part of positive numbers and shifting toward zero for negative numbers.

The syntax of the fix() function is straightforward:

rounded_value = fix(input_value);

Where:

  • input_value: The number or array of numbers to be rounded towards zero.

Now, let’s dive into practical examples to understand how to use fix() effectively.

Example 1: Round Towards Zero

% Basic rounding towards zero
floating_number = -6.75
rounded_zero = fix(floating_number)

In this example, we take a single floating-point number, -6.75, and apply the fix() function to round it towards zero. The fix() function effectively truncates the decimal part of the number.

Output:

floating_number =

   -6.7500


rounded_zero =

    -6

The result, stored in the variable rounded_zero, is -6, demonstrating the effect of rounding towards zero with the fix() function.

Example 2: Round to Decimal Places

% Rounding to 1 decimal place
decimal_number = 9.874
rounded_decimal = fix(decimal_number * 10) / 10

This example demonstrates how to round a floating-point number to a specific number of decimal places using fix(). We achieve this by multiplying the number by 10, rounding towards zero with fix(), and then dividing by 10 to bring it back to the original scale.

Output:

decimal_number =

    9.8740


rounded_decimal =

    9.8000

The variable rounded_decimal holds the result, showcasing the value rounded towards zero to one decimal place.

Conclusion

MATLAB provides a rich set of functions to round numbers with precision and flexibility, catering to diverse rounding requirements in numerical computations. The round(), floor(), ceil(), and fix() functions offer distinct approaches to rounding, allowing you to tailor your rounding methods based on specific needs.

Whether rounding to the nearest integer, a certain number of decimal places, towards positive or negative infinity, or towards zero, MATLAB’s versatile set of rounding functions empowers you to achieve precise results in your numerical analyses and computations. By understanding the syntax and applications of these functions, you can make informed choices to optimize your code for accurate and efficient rounding operations.

Author: Ammar Ali
Ammar Ali avatar Ammar Ali avatar

Hello! I am Ammar Ali, a programmer here to learn from experience, people, and docs, and create interesting and useful programming content. I mostly create content about Python, Matlab, and Microcontrollers like Arduino and PIC.

LinkedIn Facebook