Arithmetic

(( )) is bash's built-in arithmetic evaluation syntax. It supports C-style operators. If the result is non-zero, the exit status is 0 (success); if the result is zero, the exit status is 1 (failure), so it can also be used as a condition in if statements and while loops.

(( )) supports the same increment and decrement operators as C. Prefix (++i) and postfix (i++) differ in the timing of evaluation.

let is a bash built-in arithmetic evaluation command. It has the same functionality as (( )) but is written as a command invocation. Multiple expressions can be placed on one line.

(( )) is more readable and modern than let. Prefer (( )) in new scripts.

expr is an external command. It is POSIX-standard and works in sh environments, but the syntax becomes verbose due to mandatory space-separated arguments and the need to escape *. In bash environments, prefer $(( )).

$(( expr )) expands the result of an arithmetic expression as a string. It can be embedded directly wherever a value is needed, such as in arguments to echo or variable assignments. Where (( )) is for "evaluation (run for side effects)", $(( )) is for "expansion (extract a value)".

dragon_ball_power.sh

#!/bin/bash
# -----------------------------------------------
#  A script that uses arithmetic operations to
#  calculate the power levels of Dragon Ball characters
# -----------------------------------------------

# -----------------------------------------------
#  1. Basics of (( )) — evaluation and assignment
# -----------------------------------------------

# Set the base power level for each character
goku_power=9000
vegeta_power=8500
piccolo_power=3500
gohan_power=2800
krillin_power=1770

echo "=== Initial Power Levels ==="
echo "Goku:    ${goku_power}"
echo "Vegeta:  ${vegeta_power}"
echo "Piccolo: ${piccolo_power}"
echo "Gohan:   ${gohan_power}"
echo "Krillin: ${krillin_power}"
echo ""

# Assign a calculated result to a variable using (( ))
(( total = goku_power + vegeta_power + piccolo_power + gohan_power + krillin_power ))
echo "Combined power of 5 fighters: ${total}"

# Conditional with (( )) — check if Goku's power exceeds 9000
if (( goku_power > 9000 )); then
    echo "Goku's power level is over 9000!"
else
    echo "Goku's power level is exactly 9000."
fi
echo ""

# -----------------------------------------------
#  2. Increment and decrement
# -----------------------------------------------

echo "=== Power-up through Training ==="

# Use postfix increment to advance Goku's training level
level=1
echo "Training level (start): ${level}"

(( level++ ))
echo "Training level (after +1): ${level}"

(( ++level ))
echo "Training level (after prefix ++): ${level}"

# Use compound assignment to increase power
(( goku_power += 1000 ))
echo "Goku's new power (+1000): ${goku_power}"

(( vegeta_power *= 2 ))
echo "Vegeta's new power (x2): ${vegeta_power}"

echo ""

# -----------------------------------------------
#  3. let — arithmetic evaluation command
# -----------------------------------------------

echo "=== Calculation with let ==="

# Use let to calculate the power difference between Vegeta and Goku
let "diff = vegeta_power - goku_power"
echo "Power difference between Vegeta and Goku: ${diff}"

# Use let to evaluate multiple expressions at once
let "piccolo_power += 500" "gohan_power += 200"
echo "Piccolo after training: ${piccolo_power}"
echo "Gohan after training:   ${gohan_power}"

echo ""

# -----------------------------------------------
#  4. expr — arithmetic via external command
# -----------------------------------------------

echo "=== Calculation with expr ==="

# Addition with expr (spaces between operands are required)
result=$(expr ${krillin_power} + 230)
echo "Krillin's power after training: ${result}"

# Multiplication with expr (* must be escaped)
double=$(expr ${krillin_power} \* 2)
echo "Krillin's power doubled: ${double}"

# Modulo with expr
remainder=$(expr ${goku_power} % 1000)
echo "Goku's power mod 1000: ${remainder}"

echo ""

# -----------------------------------------------
#  5. $(( )) — arithmetic expansion
# -----------------------------------------------

echo "=== Output via Arithmetic Expansion ==="

# Embed arithmetic expansion inside a string
echo "Average power of Goku and Vegeta: $(( (goku_power + vegeta_power) / 2 ))"

# Exponentiation (2 to the power of 10)
echo "2 to the power of 10: $(( 2 ** 10 ))"

# Use modulo for odd/even check
for power in ${goku_power} ${vegeta_power} ${piccolo_power}; do
    if (( power % 2 == 0 )); then
        echo "  ${power} -> even power level."
    else
        echo "  ${power} -> odd power level."
    fi
done

echo ""

# -----------------------------------------------
#  6. Arithmetic condition in a while loop
# -----------------------------------------------

echo "=== Goku's Training Count ==="

# Use (( )) as the while condition
count=1
while (( count <= 5 )); do
    echo "  Training session ${count}: power +$(( count * 100 ))"
    (( count++ ))
done

echo ""
echo "=== Script complete ==="

chmod +x dragon_ball_power.sh
./dragon_ball_power.sh
=== Initial Power Levels ===
Goku:    9000
Vegeta:  8500
Piccolo: 3500
Gohan:   2800
Krillin: 1770

Combined power of 5 fighters: 25570
Goku's power level is exactly 9000.

=== Power-up through Training ===
Training level (start): 1
Training level (after +1): 2
Training level (after prefix ++): 3
Goku's new power (+1000): 10000
Vegeta's new power (x2): 17000

=== Calculation with let ===
Power difference between Vegeta and Goku: 7000
Piccolo after training: 4000
Gohan after training:   3000

=== Calculation with expr ===
Krillin's power after training: 2000
Krillin's power doubled: 3540
Goku's power mod 1000: 0

=== Output via Arithmetic Expansion ===
Average power of Goku and Vegeta: 13500
2 to the power of 10: 1024
  10000 -> even power level.
  17000 -> even power level.
  4000 -> even power level.

=== Goku's Training Count ===
  Training session 1: power +100
  Training session 2: power +200
  Training session 3: power +300
  Training session 4: power +400
  Training session 5: power +500

=== Script complete ===

Shell scripts offer four main ways to perform integer arithmetic. (( )) is bash's built-in arithmetic evaluation syntax with C-style operators (increment ++, decrement --, compound assignment +=, etc.). It can also be used as a condition in if (( expr )) and while (( expr )), enabling highly readable scripts. $(( expr )) is arithmetic expansion, used when you need to extract the result of an expression as a string. let is equivalent to (( )) but (( )) is the mainstream choice in modern scripts. expr is an external command that also works in POSIX sh, but its syntax can be verbose due to operator escaping requirements. In bash environments, it is best practice to standardize on $(( )) or (( )). See also Variables for information on declaring variables.