ARITHMETIC

We’ve seen that bash variables can but integer (i=5) but real (aka. floating point) numbers (a=5.27) are treated as STRINGS.

Can we do arithmetic inside bash scripts?

INTEGER MATH

We can use let or $(( )) to tell bash to evalute math operations.

prompt> a=5
prompt> b=10

## Addition/Subtraction
prompt> let add=$a+$b
prompt> echo $add
15
prompt> add_p=$(( $a + $b ))
prompt> echo $add_p
15

prompt> let subt=$a-$b
prompt> echo $subt
-5
prompt> subt_p=$(( $a - $b ))
prompt> echo $subt_p
-5

## Multiplication/Division
prompt> let mult=$a*$b
prompt> echo $mult
50
prompt> mult_p=$(( $a * $b ))
prompt> echo $mult_p
50
prompt> let div_ab=$a/$b
prompt> let div_ba=$b/$a
prompt> divp_ab=$(( $a / $b ))
prompt> divp_ba=$(( $b / $a ))
prompt> echo $div_ab
0
prompt> echo $div_ba
2
prompt> echo $divp_ab
0
prompt> echo $divp_ba
2

## Modulus
prompt> echo 8 % 7 = $((8 % 7))
8 % 7 = 1

## Exponentiation
prompt> echo 2 ^ 8 = $[ 2 ** 8 ]
2 ^ 8 = 256

Exercise

We’ve repeated several steps in the above. Can we make a batch calculator?

prompt> vi int_math.sh

#!/bin/bash

# $1 and $2 are command line arguments that grab the nth command line values

ADD12=$(( $1 + $2 )) ; echo "${1} + ${2} =" ${ADD12}
SUB12=$(( $1 - $2 )) ; echo "${1} - ${2} =" ${SUB12}
MUL12=$(( $1 * $2 )) ; echo "${1} * ${2} =" ${MUL12}
DIV12=$(( $1 / $2 )) ; echo "${1} / ${2} =" ${DIV12}
MOD12=$(( $1 % $2 )) ; echo "${1} % ${2} =" ${MOD12}
EXP12=$(( $1 ** $2 )) ; echo "${1} ^ ${2} =" ${EXP12}

Save: <ESC>:wq
Make the script executable: chmod +x int_math.sh
run:

prompt> ./int_math.sh 5 10
+ 10 = 15
- 10 = -5
* 10 = 50
/ 10 = 0
% 10 = 5
^ 10 = 9765625

Increment/Decrement

A very common operation is to count up or down. We’ll encounter this a great deal during looping.

While we could write:

prompt> a=5 ; a=$(( $a + 1 )) ; echo $a
6

bash has provided the ++var, var++, --var, and var-- functions to add or subtract 1. The order indicates whether the increment/decrement is evaluated before or after the value of the value is supplied.

prompt> a=5 ; echo  $(( a++ )) $(( ++a )) ${a}
5 7 7

If you wish to incre/decrement by more than 1 you can use var+=value or var-=value:

prompt> a=5 ; echo $a $(( a+=23 )) $a
5 28 28
prompt> a=57 ; echo $a $(( a-=23 )) $a
57 34 34

FLOATING POINT MATH

We’ve seen that bash treats floating point (FP) values as strings:

prompt> a=57.2 ; b=27.5 ; echo $(( $a * $b ))
-bash: 57.2 * 27.5 : syntax error: invalid arithmetic operator (error token is ".2 * 27.5 ")

Is there a way to do FP math?

Yes, but we have to use external programs, such as the bc program and some redirect tricks.

prompt> a=57.27 ; b=27.34
prompt> bc -l << EOF
> $a * $b
> EOF
1565.7618
prompt> c=$( bc -l << EOF
> $a * $b
> EOF
> )
prompt> echo $c
1565.7618
prompt> d=$( bc -l << EOF
$a / $b
EOF
)
prompt> echo $d
2.09473299195318215069

EXERCISE: Can we rewrite our batch calculator?

prompt> cp int_math.sh fp_math.sh

#!/bin/bash

# $1 and $2 are command line arguments that grab the nth command line values
# use a "#" to comment out the previous Lines

#ADD12=$(( $1 + $2 )) ; echo "${1} + ${2} =" ${ADD12}
#SUB12=$(( $1 - $2 )) ; echo "${1} - ${2} =" ${SUB12}
#MUL12=$(( $1 * $2 )) ; echo "${1} * ${2} =" ${MUL12}
#DIV12=$(( $1 / $2 )) ; echo "${1} / ${2} =" ${DIV12}
#MOD12=$(( $1 % $2 )) ; echo "${1} % ${2} =" ${MOD12}
#EXP12=$(( $1 ** $2 )) ; echo "${1} ^ ${2} =" ${EXP12}

# use the "bc" trick to do the same math as above but with "bc"
ADD12=$( bc -l << EOF
$1 + $2
EOF
)
echo "${1} + ${2} =" ${ADD12}

SUB12=$( bc -l << EOF
$1 - $2
EOF
)
echo "${1} - ${2} =" ${SUB12}

MUL12=$( bc -l << EOF
$1 * $2
EOF
)
echo "${1} * ${2} =" ${MUL12}

DIV12=$( bc -l << EOF
$1 / $2
EOF
)
echo "${1} / ${2} =" ${DIV12}

MOD12=$( bc -l << EOF
$1 % $2
EOF
)
echo "${1} % ${2} =" ${MOD12}

POW12=$( bc -l << EOF
$1 ** $2
EOF
)
echo "${1} ^ ${2} =" ${EXP12}

Save: <ESC>:wq
run:

prompt> ./fp_math.sh 57.27 27.34
27 + 27.34 = 84.61
27 - 27.34 = 29.93
27 * 27.34 = 1565.7618
27 / 27.34 = 2.09473299195318215069
27 % 27.34 = .0000000000000000001354
(standard_in) 1: parse error
27 ^ 27.34 =

It turns our bc doesn’t like to fractionally exponentiate.