Introduction

Mathematical and arithmetic operations are essential in Bash scripting. Several automation tasks require basic arithmetic operations, such as converting CPU temperature to Fahrenheit. Implementing mathematical operations in Bash is simple and very easy to learn.

**This guide teaches you how to do basic math in Bash in several ways.**

Prerequisites

- Command line/terminal access
- A text editor for coding examples, such as nano or Vi/Vim
- Bash scripting

.

. Basic knowledge of Bash scripting. Why do you need math in Bash Scripting? Although math is not the primary purpose of

,

knowing how to do essential calculations is useful for several

use cases.

Common use cases include:

- Adding/subtracting/multiplying/dividing
- Rounding of numbers
- Increasing numbers and decrements
- Conversion units
- Floating-point calculations
- Find percentages.
- Work with different numerical bases (binary, octal or hexadecimal).

numbers.

.

.

.

.

Depending on the automation task, basic math and arithmetic in Bash scripting help to perform a quick calculation, producing immediate results in the desired format.

## Bash Mathematical Commands and Methods

Some Linux commands allow you to perform basic and advanced calculations right away. This section shows basic mathematical examples with each method.

### The

preferable way to do Bash math is to use shell arithmetic expansion. The built-in capability evaluates mathematical expressions and returns the result. The syntax for arithmetic expansions

is: $((expression)) The

syntax consists of

:

- Composite notation (()) that evaluates the expression
- The variable operator $ to store

.

the result.

For example, add two numbers and echo the result: echo

$((2+3))

Arithmetic expansion notation is the preferred method when working with Bash scripts. The notation is often seen in conjunction with **if** statements and for loops in Bash.

### awk Command

The awk command acts as a pattern expression selector. For example, to add using the awk command, use the following example statement: **awk**

‘BEGIN { x = 2; y = 3; print “x + y = “(x+y) }’

For variables x = **2** and y = 3, the output prints **x + y = 5** in the console.

### bc Command

The bc command

(short for **b**asic **c**alculator) is a command-line utility that represents the **bc** language. The program runs as an interactive program or takes standard input to perform arbitrary-precision arithmetic.

Pipe an equation from the standard input to the command to get results. For example:

echo “2+3” | bc

The output prints the result of the calculation

.

### dc

command

The **dc** command (short for d esk **c**alculator) is a calculator utility that supports reverse Polish notation. The program takes standard input and supports unlimited precision arithmetic.

Pipe a standard input equation into the command to get the result. For example:

echo “2 3 + p” | dc

The **p** in the equation sends the print signal to the **dc** command

. declare

### Command

The declare Bash command allows integer calculations. To use** declare** for calculations, add the **-i** option. For example

: declare -i x=2 y=3 z=x+y Echo each variable to

see the results:

echo $x + $y = $z

The output prints each variable to the console

. expr command The

**expr** command is a legacy command-line utility for evaluating integer arithmetic. An example expr command looks like this: **expr**

2 + 3

Separate the numbers and operation sign with spaces and run

the command to see the result of the calculation. factor

### Command

The factor command is

a command-line utility that prints the factors for any positive integer and the result is factored into prime numbers

.

For example, to print the factors of the number 100, Execution: factor 100

The output prints the factored number

. let

### Command

The Bash let command performs various arithmetic, bitwise and logical operations. The built-in command works only with integers. The following example shows the syntax for the let command: **let**

x=2+3 | echo $x

The output prints the results

. test command

### The

**test** command on Linux evaluates conditional expressions and is often paired with the Bash if statement. There are two variations for the test syntax: test

2 -gt 3; echo $?

Or alternatively:

[ 2 -gt 3 ]; echo $?

The **test** command evaluates whether two is greater than (**-gt**) three. If the expression is true, the result is zero (**0**) or one (**1**) if false.

## Bash Arithmetic Operators Bash

offers a wide range of arithmetic operators for various calculations and evaluations. Operators work with **let expansion,** **declare** and arithmetic.

Below is a quick reference table describing Bash arithmetic operators and their functionality.

## =How to do mathematics in

Bash Bash

offers different ways to perform mathematical calculations depending on the type of problem

.

Below are examples of some common problems that use Bash math commands or functionalities as a solution. Most examples use Bash arithmetic expansion notation. The section also covers common Bash math errors and how to solve them.

### Mathematics

with integers

Arithmetic expansion notation is the simplest to use and manipulate when working with integers. For example, create an expression with variables and calculate the result immediately:

echo $((x=2, y=3, x+y))

To evaluate multiple expressions, use compound notation, store each calculation in a variable, and echo the result. For example:

((x=2, y=3, a=x+y, b=x*y, c=x**y)); echo $a, $b $c

When trying to split, keep the following in mind:

1. Division by zero (0) is impossible and yields an error.

2. Bash arithmetic expansion does not support floating-point arithmetic. When trying to split in this case, the output shows zero (0).

The result of integer division must be an integer. Bash

arithmetic expansion uses the increment and decrease of integers of style C. The operator to increase or decrease is before or after the variable, producing a different behavior.

If the operator is before the variable (**++x** or **-x**), the increment or decrease occurs before the value assignment. To see how the pre-increment works, run the following lines:

number=1 echo $((++number))

The variable is incremented and the new value is immediately available

. If the

operator is after the variable (**x++** or **x-**), the increment or decrease occurs after the value assignment. To see how post-increment works, run the following:

number=1 echo $((number++)) echo $number

The variable remains the same and is incremented on the next use

. Floating-point arithmetic Although Bash arithmetic expansion does not support

### floating-point arithmetic

, there are other ways to perform such calculations. Below are four examples that use commands or programming languages available on most Linux systems.

1. Using awk

for up to 6 decimal places: **awk**

‘BEGIN { x = 2.3; y = 3.2; print “x * y = “(x * y) }’

2. Using **bc** with **-l** indicator for up to 20 decimal places:

echo “2.3 * 3.2” | BC-L

3. Using Perl for up to 20 decimal places:

Perl -e ‘print 2.3*3.2’

Perl often comes pre-installed on Linux systems

. 4. Using printf

and arithmetic expansion to convert

a fraction to a decimal: printf %.<precision>f “$((10**<multiplier> * <fraction>))e-<multiplier>”

Precision dictates how many decimal places, while multiplier is a power of ten. The number must be less than the multiplier. Otherwise, the formula puts trailing zeros in the result.

For example, convert

1/3 to a decimal with precision two: printf %.2f “$((10**3 * 1/3))e-3”

Avoid this method for accurate calculations and use it only for a small number of decimal places

. Calculating a Percentage

### and

Rounding Below are two ways to calculate a percentage in Bash

.

1. Use **printf** with arithmetic expansion.

printf %.2f “$((10**4 * part/total))e-4″%

For example, calculate what percentage

is 40 out of 71: printf %.2f%% “$((10**4 * 40/71))e-4″%

Precision is limited to two decimal places, and the answer is always rounded down

. 2. Use awk with printf for better accuracy: awk ‘BEGIN { printf “%.2f%%”, (part/total*100) }’ For example, calculate how many percentages are 40 out of 71

with: awk ‘BEGIN { printf “%.2f%%”, (40/71*100) }’ The answer is rounded up if the third decimal place is greater than five, providing better accuracy.

Find a factorial

### in the shell

To calculate a factorial for any number, use a recursive Bash function.

For small numbers,

Bash arithmetic expansion works well

: factorial () { if (($1 > 1)) then echo $(( $( factorial $(($1 – 1)) ) * $1 )) else echo 1 return fi } To check the factorial

of a number, use the following syntax:

factorial

5 The method is slow and has limited precision (up to factorial 20).

For greater accuracy, faster results and larger numbers, Use the **bc** command. For example:

echo ‘define factorial(x) {if (x>1){return x*factorial(x-1)};return 1} factorial(<number>)’ | bc

Replace **<number>** with the factorial number to be calculated. For example, to find the factorial of 50, use:

echo ‘define factorial(x) {if (x>1){return x*factorial(x-1)};return 1} factorial(50)’ | bc

The output prints the calculation result to the terminal.

Create a Bash calculator function

Create a simple Bash calculator function with the following code: calculate

() { printf “%sn” “$@” | bc -l; }

The function takes user input and pipes the equation into the **bc** command.

Alternatively, to avoid using programs, use Bash arithmetic expansion in a function:

calculate() { echo $((“$@”)); }

Note the limitations of arithmetic expansion. Floating-point arithmetic is not available with this feature.

Save the function in the .

bashrc file so that you always have the function available in the shell

.

### Use of different

arithmetic bases

By default, Bash arithmetic expansion uses base ten numbers. To change the number base, use the following format

: base#number

Where base is any integer between two and 64

.

For example, to perform a binary calculation

(base 2), use: echo $((2#1010+2#1010))

Octal calculations (base 8) use a 0 prefix as an alias. For example:

echo $((010+010))

Hexadecimal calculations (base 16) allow you to use 0x as the base prefix. For example

: echo $((0xA+0xA))

The output prints the result in base ten for any calculation

.

### Convert

units

Create a simple Bash script to convert units:

1. Open a text editor, such as Vim, and create a convert.sh script. For example:

vim convert.sh

2. Paste the following code

: #!/bin/bash ## Program for converting feet and inches echo “Enter a number to convert:” read echo number $number feet to inches: echo “$number*12” | BC-L Echo $number inches to feet: Echo “$number/12” | bc -l

The program uses Bash read to take user input and calculates the conversion from feet to inches and from inches to feet

.

3. Save the script and close: :

wq

4. Run the Bash script with:

. convert.sh

Enter a number and see the result. For different conversions, use appropriate conversion formulas.

### Resolving “bash error: value too large for

the base”

When working with different number bases, stay within the limits of the number base. For example, binary numbers use 0 and 1 to define numbers

: echo $((2#2+2#2)) When trying to use 2#2 as the number, an error is generated: bash: 2#2: value too large for the base (the error token is “2

#2″) The number is not the

correct format for binary use. To resolve the error, convert the number to binary to perform the calculation correctly

: echo $((2#10+2#10))

The binary number **10** is **2** in base ten

.

### Resolving “syntax error: invalid arithmetic operator”

Bash arithmetic expansion notation only works for integer calculations. Try adding two floating-point numbers, for example

: echo $((2.1+2.1))

The command prints

an error: bash: 2.1+2.1: syntax error: invalid arithmetic operator (error token is “.1+2.1”) To resolve the error,

use regular integer arithmetic or a different method to calculate the equation

.

### Resolving “bash error: expected integer expression”

When comparing two numbers, the **test** command requires integers. For example, try the following command

: [ 1 -gt 1.5 ]

The output prints an

error: bash: [: 1.5: expected integer expression

Resolve the error by comparing integer values.

Conclusion

You know how to do Bash arithmetic and various calculations through Bash scripts

.

For more advanced scientific calculations, use Python in conjunction with SciPy, NumPy, and other libraries.