How to Round Number in Matlab
-
Round Numbers in MATLAB Using
round() -
Round Numbers in MATLAB Using
floor() -
Round Numbers in MATLAB Using the
ceil()Function -
Round Numbers in MATLAB Using the
fix()Function - Conclusion
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.
