## 1. Overview

Floating-point numbers are numbers made of an integer and a decimal component. Rounding floating-point numbers in the shell is a handy technique for various tasks. It’s useful for data manipulation and formatting output.

In this tutorial, we’ll explore different methods for rounding floating-point numbers. First, we’ll discuss several methods, including parameter expansion and external commands. After that, we’ll present a brief comparison of the methods.

## 2. Validating the Input

First, **we may want to check that the input is a valid floating-point number**.

To do that, we can use a regular expression:

`$ [[ $number =~ ^[-+]?[0-9]+(\.[0-9]+)?$ ]]`

Tools like *awk* or *bc*, which we’ll discuss later on, can extract the numeric value from user input or file contents.

Subsequently, we can use several built-in commands to round the floating-point number.

## 3. Using Parameter Expansion

Parameter expansion is a built-in functionality of the shell. We can use one of its features for basic rounding. However, with this method, **there’s limited control over rounding behavior**.

For instance, we can write a script that truncates the decimal part of a floating-point number:

```
$ cat shell_rounding.sh
#!/bin/bash
read -p "Enter a floating-point number: " number
rounded_number=${number%.*}
echo "Rounded number: $rounded_number"
```

Let’s try a quick example:

```
$ bash shell_rounding.sh
Enter a floating-point number: 4.993
Rounded number: 4
```

This approach rounds down by default.

## 4. Using the *printf* Command

*printf* is part of the GNU Coreutils package. **It’s more efficient and customizable than using basic parameter expansion for rounding**.

Let’s create a rounding script:

```
$ cat round_to_integer.sh
#!/bin/bash
read -p "Enter a floating-point number: " number
rounded_number=$(printf "%.0f\n" $number)
echo "The rounded number: $rounded_number"
```

**This method follows the rules of elementary arithmetic**. Floating-point numbers with decimal values above 5 are rounded up, while decimal values below 5 are rounded down. For instance, 1.7 rounds up to 2, while 1.3 rounds down to 1.

Notably, when the decimal part is exactly 0.5, *printf* rounds to the nearest even integer. Let’s see some examples:

```
$ bash round_to_integer.sh
Enter a floating-point number: 1.5
The rounded number: 2
$ bash round_to_integer.sh
Enter a floating-point number: 2.5
The rounded number: 2
$ bash round_to_integer.sh
Enter a floating-point number: 3.5
The rounded number: 4
```

In this case, *2.5* rounds down to *2*, which is the nearest even integer. This approach is called *Banker’s Rounding*. It is commonly used in financial calculations and by modern computers (IEEE 754 floating-point arithmetic).

## 5. Using a Custom Function

**Another approach would be to create a custom function to handle rounding**.

Let’s write a rounding function which we can later use:

```
$ cat round_function.sh
round()
{
echo $(printf %.$2f $(echo "scale=$2;(((10^$2)*$1)+0.5)/(10^$2)" | bc))
}
```

The function takes two arguments: the number to round and the desired number of decimal places. It then uses *printf %.$2f* to format the output with the specified decimal places.

*bc* is a versatile calculator utility designed for arbitrary-precision arithmetic. **It enables various mathematical operations, including rounding with high precision**. However, it’s an external command and might require a separate installation to use.

Afterward, we can use the function in other scripts:

```
$ cat rounding.sh
#!/bin/bash
source round_function.sh
read -p "Enter a floating-point number: " number
rounded_number=$(round $number 2)
echo "The rounded number: $rounded_number"
```

First, we’re sourcing the *round_function.sh* script to make the *round* function available. After that, we can call the *round* function with the input number and the desired number of decimal places.

## 6. Using *Awk*

In the context of shell scripting, **external commands refer to programs that aren’t built-in functionalities of the shell itself**. They’re separate executable files located in system directories like */bin*, */usr/bin*, and so on.

We can use an external command like *awk* to round floating-point numbers. Awk is a scripting language specifically designed for processing text data line by line.

### 6.1. Rounding Down

Let’s suppose we have a text file with user input:

```
$ cat numbers.txt
3.14159
2.71828
10.5
-12.333
```

We can write an *awk* script to perform the rounding:

```
$ cat rounding_down.awk
{
decimal = $1 - int($1)
if (decimal < 0) {
rounded = int($1) - 1
} else {
rounded = int($1)
}
print rounded
}
```

The curly braces define a code block that gets executed for each line of the input file. *$1* refers to the first and only field in this case. *int()* is a built-in *awk* function. It converts the value to an integer by discarding the decimal part, thus rounding the floating-point number down to the nearest integer.

To perform the operation, we simply run the *awk* command along with the script and data file:

```
$ awk -f rounding_down.awk numbers.txt
3
2
10
-13
```

The result is always an integer, which is quite limited. What if we want to always round up?

### 6.2. Rounding Up

To round up, we’ll need to adjust the *rounding.awk* script to accommodate for that:

```
$ cat rounding_up.awk
{
decimal = $1 - int($1);
if (decimal > 0) {
rounded = int($1 + 1);
} else {
rounded = int($1);
}
print rounded
}
```

After that, we run the *awk* command:

```
$ awk -f rounding_up.awk numbers.txt
4
3
11
-12
```

Here, we’re checking the value of the decimal part. If it’s greater than 0, we add 1 and remove the decimal figures. **This script effectively rounds up every floating-point number to the next integer**.

### 6.3. Arithmetic Rounding

Lastly and most importantly, what if we want to stay in line with the rules of arithmetic? That is, we want to round up floating-point numbers with decimal parts greater than or equal to 0.5 and round down decimal parts less than 0.5.

Let’s adjust the script accordingly:

```
$ cat rounding.awk
{
decimal = $1 - int($1)
if (decimal < 0) {
rounded = int($1 - 0.5)
} else {
rounded = int($1 + 0.5)
}
print rounded
}
```

Then, we can run the *awk* command on the input file:

```
$ awk -f rounding.awk numbers.txt
3
3
11
-12
```

Now, we’re adding 0.5 to positive numbers. Therefore, if the decimal part was originally greater than or equal to 0.5, it rounds the number to the next integer. Conversely, if the decimal part was less than 0.5, the integer part remains unchanged.

For instance, adding 0.5 to 3.1 gives 3.6. It falls short of the next integer, and when we truncate the decimal part, the rounded number is 3. On the other hand, 2.7 plus 0.5 gives 3.2. When we truncate the decimal part, the number is rounded down to 3.

## 7. A Comparison of the Different Methods

Let’s compare the methods we’ve discussed:

Method | Description | Advantages | Disadvantages | Suitable for |
---|---|---|---|---|

Parameter Expansion | Built-in functionality | Simple, easy to use | Limited control over rounding behavior | Simple rounding tasks without high-precision requirements |

Using the printf command |
Part of the GNU Coreutils package | Efficient, customizable output formatting | Limited functionality | General purpose rounding tasks where arithmetic rounding behavior is desired |

Custom Function | User-defined function | Very flexible and customizable | Separate installation of bc adds complexity |
High-precision rounding tasks |

Awk | Scripting language for processing text data | Processes multiple lines of data | Rounds down by default. Requires additional script logic for other rounding behaviors | General purpose rounding tasks with multiple lines of data |

Choosing the right method depends largely on the task requirements and the desired output.

## 8. Conclusion

In summary, there are different methods for rounding floating-point numbers in the shell. Each method has a certain level of control over rounding behavior, output formatting, and precision.

In this article, we covered built-in functionalities like parameter expansion, along with *printf* and external commands like *bc* and *awk*. By understanding these techniques, we can effectively and precisely round floating-point numbers in shell scripts.