What are Bash Arithmetic Operators

Bash Arithmetic

Do you know you can carry out complex arithmetic operations in your bash script? 

Many users don’t realize this aspect of bash scripts and overlook the mathematical capabilities of bash scripting. As such, they don’t consider the role of these capabilities in processing data and in-script calculation requirements. 

You can easily automate mathematical operations within your scripts and carry out complex data crunching without leaving the script environment. 

In this detailed tutorial, we’ll look into bash arithmetic operators. We’ll cover everything from the simplest calculations to more advanced techniques so you can easily tackle a wide range of calculations in your scripts. 

Let’s begin with an overview of these operations in bash scripts.

Table Of Contents

  1. Importance of Math in Bash Scripting
    1. Why Math Operations are Important in Bash Scripting
  2. Bash Arithmetic Operators
  3. Working with Math Commands and Methods in Bash
    1. Prerequisites
    2. Common Bash Math Commands and Methods
    3. Arithmetic Expansion Method – Double parentheses (( ))
  4. Practical Applications of Bash Arithmetic
    1. Example #1: Function to Calculate Disk Usage Percentage
    2. Example #2: Function to Convert Celsius to Fahrenheit
    3. Example #3: Function to Automate Backup Rotation
    4. Example #4: Function to Calculate Network Bandwidth Usage
    5. Example #5: Function to Calculate Factorial
  5. Common Errors in Bash Arithmetic
    1. Error #1: “bash error: value too great for base”
    2. Error #2: “syntax error: invalid arithmetic operator”
    3. Error #3: “bash error: integer expression expected”
    4. Error #4: Division by Zero
    5. Error #5: Floating-Point Arithmetic in Integer Context
  6. Conclusion
  7. FAQs

Importance of Math in Bash Scripting

Mathematical operations in bash scripting are essential for automating calculations and processing numerical data. 

Whether counting, calculating, or making decisions based on data, math operations make your scripts practical and functional. It’s about precision and efficiency, helping your scripts do the job accurately and enabling you to tackle complex tasks and challenges in the Linux environment.

Why Math Operations are Important in Bash Scripting

Here are several reasons why math is important in Bash scripting.

Automating Calculations

Bash scripting allows you to automate repetitive numerical calculations. This can be highly useful in scripts that carry out data processing tasks on large datasets.

Data Analysis and Processing

Many system administration tasks involve analyzing and processing numerical data. For instance, you might need to calculate disk space usage, monitor system resource consumption, or process user bandwidth data quota. Bash scripting with math operations makes these tasks more efficient.

Enhanced Decision Making

You often need to make data-based decisions in scripting. For example, a script might execute different commands based on a file’s size or the number of files in a directory.

Handling Time and Dates

Bash scripts are often used for scheduling tasks and executing specific actions based on precise timestamps. For instance, math operations calculate time intervals, expiration dates, or differences between two time windows. 

System Monitoring

Scripts that monitor system health or performance metrics often rely on arithmetic to analyze the precise CPU usage, memory consumption, and network bandwidth points to trigger alerts based on these calculations.

Complex Script Logic

Scripts can include complex logic where mathematical calculations decide the next action path. This includes scenarios like loop iterations based on specific numerical conditions, calculating percentages for tracking progress, or transforming data items.

Increased Script Efficiency

Sometimes, performing a calculation within a script is more efficient than quitting the script and relying upon external tools or commands. In-script mathematical operations reduce the overhead of calling other scripts and apps, making the scripts very lightweight. 

Customization and Flexibility

With math operations, scripts can be customized to handle a wider task list. You can easily adapt them to changing requirements with minimal changes.

Bash Arithmetic Operators

In bash scripting, arithmetic operators are used to perform calculations on numbers. These operators are similar to their counterparts in many programming languages. 

Bash supports a range of arithmetic operators, including addition (+), subtraction (-), multiplication (*), division (/), and modulus (%). Here’s an overview of the most commonly used bash arithmetic operators:

Bash Arithmetic Operators

Note: Remember, bash performs integer arithmetic, so operations like division (/) will not display floating-point results. For floating-point operations, you would need to use external tools like bc.

Working with Math Commands and Methods in Bash

Several Linux commands and methods perform mathematical operations. Understanding these can significantly enhance your ability to write efficient scripts.


You need the following before diving into bash arithmetics:

  • Terminal access.
  • A text editor like vi, vim, or nano.
  • A basic familiarity with Linux and the Bash command line is highly recommended. 
  • Prior experience in scripting or programming can be helpful but is not necessary.

Common Bash Math Commands and Methods

Here’s a breakdown of the most commonly used Bash math commands and methods:


The awk command was created at Bell Labs in the 1970s, and its name is a tribute to its inventors. It processes arithmetic operations and analyzes text line by line.

The simplest syntax of this command is: 

awk '{print expression}'

Here’s an example of the awk command:

$ echo | awk '{print 3+2}'

$ echo

The single quotes around the print statement are used to pass the statement to awk without any interpretation in command execution.


The bc (basic calculator) utility is a command-line tool that uses direct command or arguments to do arithmetic operations.

The basic syntax is: 

echo "expression" | bc

As you can see, you can pipe an equation directly into the bc command from standard input. For instance:

$ echo "3 + 2" | bc

$ echo bc

This command calculates the result of the expression “3 + 2” using the bc utility and outputs the results to the standard out.


The dc (desk calculator) utility uses a postfix notation for calculations. The utility works by entering numbers first, then the operation. This utility accepts standard input and can handle arithmetic operations with unlimited precision.

The typical syntax is: 

echo "expression" | dc

For instance, the following statement will process the result of the addition operation. The p at the end of the equation serves as a command to dc, instructing it to print the result.

echo "2 3 + p" | dc


The declare command in bash performs integer calculations, declares variables, and sets attributes. To utilize declare for this purpose, you should include the -i option, which specifies that the variables are integers. 

The basic syntax of declare command is: 

declare -i variable; variable=expression

For example,

declare -i num; num=3+2; 

echo $num

In the first statement, the declare command declares an integer variable (num) and assigns it the result of an arithmetic operation (3+2). The second statement simply prints the value of the variable to the standard output.

$ declare


The expr (expression) is a traditional command-line tool for evaluating integer-based arithmetic expressions. 

Here’s an example of the command:

$ expr 3 + 4

$ expr

Remember to include spaces to separate the numbers and the operator. 


The factor command is a simple utility that finds the prime factors of the given positive integer. The utility displays the factors of the integer passed to it. 

The command has a very simple syntax:

factor number

For example, here’s how to display the factors of 50:

$ factor


The let command in Bash is a built-in command that allows you to perform arithmetic operations on shell variables. It is particularly useful for integer arithmetic.

The basic syntax of the let command is:

let "expression"

You can use this command to assign the result of an arithmetic operation to a variable. The command can handle multiple expressions separated by a space.

$ let


The test command in bash evaluates conditional expressions. It’s primarily used to check file types and compare values. While not strictly an arithmetics-related command, it is still an integral element in scripts for making decisions based on numerical comparisons and other conditions.

The basic syntax of the test command is:

test expression 


[ expression ]

The test command returns a status code (0 for true, non-zero (usually 1) for false) based on the evaluation of the expression. It can be used for string comparisons, file checks, and integer comparisons. As such, it’s often used in if statements and loops.

Consider the following statement:

$ test 2 -gt 5; echo $?

$ test

Here, the test command checks if 2 is greater than 5. If true, the output returns a 0. If not true, the output is 1.

This statement can also be expressed as 

[ 2 -eq 2 ]; echo $?

$ [ 2 -eq 2]

Here is another example that demonstrates string comparison:

[ “abc” = “def” ];echo $?

echo $

Arithmetic Expansion Method – Double parentheses (( ))

In Bash scripting, the most recommended method for mathematical calculations is shell arithmetic expansion. This built-in feature of Bash evaluates arithmetic expressions and returns the results. 

The basic syntax for arithmetic expansion is as follows:


The double parentheses (( )) are used to evaluate the arithmetic expression. The dollar sign $ preceding the parentheses indicates that the result should be stored.

Note: You may find the square bracket notation ($[expression]) in some older scripts. This old-fashioned usage is not recommended these days.

For instance, if you want to add two numbers and display the result, you would use:

result=$((3 + 4))

echo $result 

$ result

Practical Applications of Bash Arithmetic

Using math commands and arithmetic operations in Bash functions can make your scripts more efficient. Here are some essential functions with examples to show you how you can use math in Bash:

Example #1: Function to Calculate Disk Usage Percentage

A common task in system administration is calculating the percentage of disk usage. You can automate this operation through the following bash script:


max_allowed_space=10000  # 10 GB in megabytes

used_space=$(df / | awk '{print $3}' | tail -n 1)

used_space=$((used_space / 1024))  # Convert to megabytes

if [ "$used_space" -gt "$max_allowed_space" ]; then

    echo "Disk space threshold exceeded. Used: $used_space MB."


This script calculates the used disk space and can be used to send an alert if it exceeds the specified threshold.

Example #2: Function to Convert Celsius to Fahrenheit

This function converts a temperature value in Celsius to Fahrenheit:


celsius_to_fahrenheit() {

    local celsius=$1

    local fahrenheit=$(echo "scale=2; $celsius * 9/5 + 32" | bc)

    echo "$celsius C = $fahrenheit F"


# Example

celsius_to_fahrenheit 25

Example #3: Function to Automate Backup Rotation

The following bash script can automate backup rotations based on file age. When executed, this script removes backup files older than a specified number of days.



current_date=$(date +%s)

for file in /path/to/backups/*; do

    file_date=$(date -r $file +%s)

    age=$(( ($current_date - $file_date) / 86400 ))

    if [ $age -gt $backup_life_days ]; then

        echo "Removing old backup: $file"

        rm $file




Example #4: Function to Calculate Network Bandwidth Usage

This function calculates the average bandwidth used over a period of time.


calculate_bandwidth_usage() {

    local initial_bytes=$(cat /sys/class/net/eth0/statistics/rx_bytes)

    sleep 60

    local final_bytes=$(cat /sys/class/net/eth0/statistics/rx_bytes)

    local bandwidth_used=$(( (final_bytes - initial_bytes) / 60 ))

    echo "Average bandwidth used: $bandwidth_used bytes/sec"


# Example


Example #5: Function to Calculate Factorial

This function calculates the factorial of a number.

factorial() {

    local num=$1

    local fact=1

    for ((i=1; i<=num; i++)); do

        fact=$((fact * i))


    echo "Factorial of $num is $fact"


# Example

factorial 5

Common Errors in Bash Arithmetic

Using the arithmetic-related commands in bash script can sometimes lead to errors, especially when the syntax or the nature of the values used isn’t quite right. We’ll now discuss some common errors you might encounter, along with examples and how to resolve them:

Error #1: “bash error: value too great for base”

This error pops up when dealing with a number so big that the system can’t handle it. It’s like trying to fit a large puzzle piece in a small space. To fix this, you might need to find a way to work with smaller numbers or split your task into smaller pieces.

It usually occurs when Bash interprets a number with a leading zero as an octal (base 8).



echo $((num + 1))


bash: 08: value too great for base (error token is "08")


Ensure numbers don’t have leading zeros unless they are meant to be octal.


echo $((num + 1))

Error #2: “syntax error: invalid arithmetic operator”

This error happens when the arithmetic expression has an incorrect operator or syntax.


echo $((3 ~ 2))


bash: syntax error: invalid arithmetic operator (error token is "~ 2")


Use valid arithmetic operators.

echo $((3 * 2))

Error #3: “bash error: integer expression expected”

This error is common when a script expects an integer but gets a different type, such as a string or a floating point.



if [ $val -eq 10 ]; then

    echo "Value is 10"



bash: [: abc: integer expression expected


Ensure the variable is an integer before using it in an arithmetic context.


if [ $val -eq 10 ]; then

    echo "Value is 10"


    echo "Value is not 10"


Error #4: Division by Zero

Attempting to divide by zero, mathematically undefined, leads to an error.


echo $((10 / 0))


bash: division by 0 (error token is "0")


Check for zero before division.


if [ $divisor -ne 0 ]; then

    echo $((10 / divisor))


    echo "Cannot divide by zero"


Error #5: Floating-Point Arithmetic in Integer Context

Bash does not support floating-point arithmetic in its standard arithmetic context.


echo $((3.5 + 2))


bash: 3.5: syntax error: invalid arithmetic operator (error token is ".5")


Use bc for floating-point arithmetic.

echo "$(echo "3.5 + 2" | bc)"


Mathematics in Bash scripting is a powerful tool for automating and simplifying computational tasks. For those running resource-intensive scripts or applications, a robust hosting solution like RedSwitches Bare Metal Server Hosting provides the reliability and performance necessary for efficient operations. Contact us now if you want to leverage your business with an instant dedicated server, 10 Gbps dedicated server, or dedicated servers hosting


Q. Is advanced mathematical knowledge required for Bash scripting?

No, basic arithmetic understanding is sufficient for most Bash scripting tasks.

Q. Can Bash perform complex mathematical functions like trigonometry?

Bash is limited in this regard, but commands like bc can be used for more complex mathematical operations.

Q. What are the most common arithmetic operations in bash?

The most common arithmetic operations in bash are addition (+), subtraction (), multiplication (*), and division (/).

Q. How do I perform arithmetic operations in bash?

You can perform arithmetic operations in bash using arithmetic operators or double brackets for more complex operations.

Q. How can I use double brackets for arithmetic operations in bash?

In bash, you can use double brackets for arithmetic operations by enclosing the expression within `(( )).`

Q. What is the significance of using expr for arithmetic operations in bash?

The `expr` command is used in bash to evaluate and perform arithmetic operations on given expressions.

Q. How can I create a bash shell script to perform arithmetic operations?

You can create a bash shell script using arithmetic operators, input variables, and appropriate control structures to perform arithmetic operations.

Q. Can I use the bash arithmetic expansion for floating-point number arithmetic?

Bash arithmetic expansion is primarily designed for integers and does not directly support floating-point number arithmetic.