Arithmetic in

About Arithmetic

Bash can do arithmetic but only with integers. If you need to do floating-point math, you'll need to call out to some external program (like awk or bc).

The arithmetic operators are listed (in order of precedence) in the manual: Shell Arithmetic.

Additionally, Bash only performs arithmetic in certain places (known as arithmetic "contexts").

Arithmetic Expansion

Arithmetic expansion looks like command substitution, but with double parentheses.

$(( expression ))

This syntax expands to the result of evaluating the expression. It is commonly used to capture the result in a variable:

x=$(( 3 + 4 ))

x=$(( 3 + 4 ))
y=$((5+6))

Arithmetic Conditional

The arithmetic conditional is performed within double parentheses without the leading $:

(( expression ))

This does not expand to the result. However it produces an exit status.

• The exit status is 0 (success) if the expression's result is non-zero.
• The exit status is 1 (failure) if the expression's result is zero.

This syntax is typically used in two places:

1. as the COMMAND part of an if statement or a while loop.

   if (( x == y - 1 )); then ...
   while (( y > 0 )); do ...
   

2. as a standalone command to modify a variable's value.

   (( x = x + 1 ))
   echo "new value for x is $x"
   

   Caution

   Be careful using arithmetic this way combined with set -e. If the expression evaluates to zero, the exit status will be non-zero and Bash will terminate.

   x=0
   (( x++ ))
   echo "you will see this"
   
   set -e
   x=0
   (( x++ ))
   echo "shell exits on the previous line; you won't see this"
   

   For a more thorough discussion about the ++ operator, see this article on Postincrement vs Preincrement

Other Places With Arithmetic Context

There are a few other places that are arithmetic contexts:

• The arithmetic for-loop.

  for (( i = 0; i < 10; i++ )); do
      echo "$i"
  done
  

• The index part of a numerically-indexed array.

  echo "The next element is ${array[x + 1]}"
  # ................................^^^^^
  

  For more about arrays, read the Arrays concept document.

• The offset and length parts of the ${var:offset:length} expansion.

• The let builtin command.

  • Note that (( expression )) is preferred over let "expresson". Unlike the arithmetic conditional construct, the let expression is subject to filename-expansion and word-splitting, and it requires quoting.

• Variable assignment, when the variable has the "integer attribute".

  # variable x does not have the integer attribute
  x="3 + 4"
  declare -p x      # => declare -- x="3 + 4"
  
  # variable y has the integer attribute
  declare -i y
  y="4 + 5"
  declare -p y      # => declare -i y="9"
  

  Note

  It is the author's opinion that declare -i has limited usage. It's main benefit is to allow "bare" arithmetic (without the arithmetic expression syntax). This can cause confusion for readers of your code, where arithmetic expressions are evaluated in unexpected places.

Using Variables in an Arithmetic Expressions

Here is one aspect of arithmetic contexts that improves readability.

height=10
width=20
area=$(( height * width ))

Did you notice that the $ dollar signs are missing from the variables in the arithmetic expression? Bash lets you do that. It makes expressions much easier to read.

The manual says,

Within an expression, shell variables may also be referenced by name without using the parameter expansion syntax.

It even works for array elements:

point1=(10 15)  # these are (x, y) coordinates
point2=(20 7)
distance_squared=$(( (point1[0] - point2[0])**2 + (point1[1] - point2[1])**2 ))

But other parameter expressions need to use their special syntax. For example, doubling the length of a string:

s="hello world"
len=$(( ${#s} * 2 ))

And positional paremeters have to as well. If the first two positional parameters represent width and height:

area=$(( $1 * $2 ))