Arithmetic Expansion

Arithmetic expansion is a shell parsing mechanism that evaluates a mathematical expression and replaces the expression with its calculated integer result. It utilizes the shell’s internal arithmetic evaluator, treating the enclosed contents as a C-language expression.

Syntax

The primary syntax for arithmetic expansion uses double parentheses preceded by a dollar sign:

$(( expression ))

When the result does not need to be substituted into a command or assigned to a variable, the evaluation command syntax omits the dollar sign:

(( expression ))

Evaluation Mechanics

1. Integer Arithmetic: Bash arithmetic operates exclusively on fixed-width integers (typically 64-bit, depending on the architecture). Floating-point numbers are not supported and will trigger a syntax error.
2. Expansion Order: The shell performs parameter expansion, command substitution, and quote removal on the expression before evaluating it arithmetically.
3. Variable Dereferencing: Within the (( )) or $(( )) context, the $ prefix is optional for standard variables. Variables referenced without a $ are evaluated as arithmetic expressions, not strictly cast to integers. For example, if var="5+5", $((var)) evaluates the underlying expression and returns 10.
4. Null and Unset Variables: Any unset variable or variable containing a null value evaluates to 0 within the arithmetic context.
5. String Evaluation: If a variable contains a string, Bash attempts to evaluate it recursively as an arithmetic expression or variable name. If the string does not form a valid arithmetic expression or valid variable name (e.g., var="hello world" or var="1/0"), Bash will throw a syntax error or math error. It only evaluates to 0 if the string resolves to a valid identifier (variable name) that is unset or null.

Supported Operators

Bash supports standard C-style operators, evaluated with standard C precedence rules.

• Post/Pre-increment and decrement: id++, id--, ++id, --id
• Unary: -, +
• Logical/Bitwise Negation: !, ~
• Exponentiation: **
• Multiplication, Division, Remainder: *, /, %
• Addition, Subtraction: +, -
• Bitwise Shifts: <<, >>
• Relational: <=, >=, <, >
• Equality: ==, !=
• Bitwise AND, XOR, OR: &, ^, |
• Logical AND, OR: &&, ||
• Ternary Operator: expr ? expr : expr
• Assignment: =, *=, /=, %=, +=, -=, <<=, >>=, &=, ^=, |=
• Comma (Sequential Evaluation): expr1 , expr2 (evaluates both, returns the value of expr2)

Radix and Base Representation

By default, numbers are evaluated as base 10. Bash supports arbitrary bases from 2 to 64 using the base#number notation.

$(( 2#1010 ))    # Binary
$(( 8#77 ))      # Octal
$(( 16#FF ))     # Hexadecimal
$(( 64#@a ))     # Base 64

Additionally, Bash recognizes standard C-style prefixes for specific bases:

• 0x or 0X: Hexadecimal (base 16)
• 0: Octal (base 8)

Octal Padding Caveat: Because a leading 0 forces octal evaluation, zero-padded numbers containing the digits 8 or 9 (e.g., 08 or 09) are invalid in base 8 and will trigger a “value too great for base” syntax error. To safely perform arithmetic on zero-padded decimal strings, explicitly force base 10 evaluation using the 10# prefix:

$(( 10#08 ))     # Forces base 10, evaluates to 8

Exit Status

When using the standalone arithmetic evaluation command (( expression )), the shell’s exit status ($?) is determined by the boolean truth of the evaluated expression:

• If the expression evaluates to a non-zero value, the exit status is 0 (True/Success).
• If the expression evaluates to zero, the exit status is 1 (False/Failure).

When using arithmetic expansion $(( expression )) as part of a larger command, the exit status is determined by the execution of the resulting command, not the arithmetic evaluation itself.

Master Bash with Deep Grasping Methodology!

Learn More