Arithmetic

Bash does integer arithmetic natively. $(( expression )) evaluates an expression and expands to the result; (( expression )) evaluates it as a command, for its side effects and its exit status. The syntax inside both is borrowed from C: + - * / %, ** for powers, comparisons, && ||, bit operators, assignments like += and ++, and the ?: ternary.

$(( )) for values

$ a=17 b=5
> echo "sum $((a + b)), diff $((a - b)), product $((a * b))"
> echo "quotient $((a / b)), remainder $((a % b)), power $((b ** 3))"
> echo "negative division: $((-17 / 5)) remainder $((-17 % 5))"
> echo "precedence: $((2 + 3 * 4)) vs $(( (2 + 3) * 4 ))"

sum 22, diff 12, product 85
quotient 3, remainder 2, power 125
negative division: -3 remainder -2
precedence: 14 vs 20

Variable names inside an arithmetic expression are evaluated as expressions themselves. An unset or empty variable counts as 0, which is convenient for counters and dangerous for typos: $(( totl + 1 )) is silently 1. A variable holding text that is not a number or a valid name is an error.

(( )) for conditions and updates

(( )) is a command. It returns status 0 (true) when the expression's value is non-zero, and 1 (false) when it is zero. That makes numeric conditions read naturally, and it is how you update a counter without an assignment statement.

$ count=0
> for f in logs/*; do
>   (( count += 1 ))
> done
> echo "$count log files"
> if (( count > 2 && count < 10 )); then echo "a reasonable number"; fi
> load=7; (( load >= 5 )) && echo "high load: $load"

3 log files
a reasonable number
high load: 7

The (( count++ )) trap with set -e

Because a zero result means "false", an expression that evaluates to 0 makes (( )) return status 1. Post-increment returns the old value, so (( count++ )) when count is 0 is a failing command, and a script running with set -e exits on it.

#!/usr/bin/env bash
set -e
count=0
(( count++ ))
echo "count is $count"

$ bash count.sh; echo "exit status: $?"

exit status: 1

#!/usr/bin/env bash
set -e
a=0 b=0
b=$(( b + 1 ))
(( ++a ))
echo "a=$a b=$b"

$ bash count.sh

a=1 b=1

Leading zeros mean octal

A number written with a leading 0 is read as octal, 0x as hexadecimal, and base#digits in any base from 2 to 64. This bites when you compute with values like 08 from a date or a zero-padded file name: 8 is not an octal digit.

$ month=08
> echo "next month: $(( month + 1 ))"

/bin/bash: line 2: 08: value too great for base (error token is "08")

$ month=08
> echo "next month: $(( 10#$month + 1 ))"
> echo "hex ff = $((0xff)), binary 1010 = $((2#1010)), octal 755 = $((8#755))"
> printf '%02d\n' $(( 10#$month + 1 ))

next month: 9
hex ff = 255, binary 1010 = 10, octal 755 = 493
09

Integers only, 64-bit

Bash arithmetic uses signed 64-bit integers. There are no fractions, and overflow wraps around silently. For decimals, hand the calculation to a tool that does them: bc for arbitrary precision, awk for floating point, or printf to format the result.

$ echo "bash: $(( 7 / 2 ))"
> echo "3.5 + 1" | bc
> echo "scale=3; 7 / 2" | bc
> awk 'BEGIN { printf "%.2f\n", 7 / 2 }'
> echo $(( 1.5 + 1 ))

bash: 3
4.5
3.500
3.50
/bin/bash: line 5: 1.5 + 1 : syntax error: invalid arithmetic operator (error token is ".5 + 1 ")

$ max=9223372036854775807
> echo "max:   $max"
> echo "max+1: $(( max + 1 ))"
> echo "2**64: $(( 2 ** 64 ))"

max:   9223372036854775807
max+1: -9223372036854775808
2**64: 0

Assignments, the ternary and $RANDOM

Arithmetic expressions can assign (=, +=, *=, <<=...), and several can be joined with a comma; the value of the last one is the result. The ternary cond ? a : b picks between two numbers. $RANDOM gives an integer from 0 to 32767, fine for jitter and sampling, never for anything security-related.

$ total=405 parts=4
> (( each = total / parts, rest = total % parts ))
> echo "each $each, remainder $rest"
> files=$(ls | wc -l); echo "$files entries, $(( files > 10 ? 10 : files )) shown"
> delay=$(( RANDOM % 5 + 1 )); (( delay >= 1 && delay <= 5 )) && echo "delay in range"

each 101, remainder 1
11 entries, 10 shown
delay in range

Other spellings

let 'x = x + 1' and declare -i x (see Variables) are older ways to do the same arithmetic. expr 1 + 2 is an external program from before shells had arithmetic and is only needed for very old sh. POSIX sh supports $(( )) but not (( )), **, ++ or base#.