# Arithmetic in the Shell

I remember the first time I tried to use the shell. It was weird that I had to type in things and not just click around to get things done. But gradually I got used to it, and after a while it became my primary way to interact with my computer.

It didn’t pass much time till I figured out that the commands that I am typing in are actually part of a programming language named Bash. That of course changed everything! Starting from that moment I could combine the thing I love ( programming ) with the boring chore of keeping my system in a sane condition. That moment a new kind of passion for computers was born in my hearth.

But wait! If Bash is a programming language it must be able to count and do basic arithmetic. This article is precisely about that — calculations in the shell.

## Expr

This task is actually really simple, but there are as always
in Unix, several ways to do it. The oldest method is to use
`expr`

to evaluate expressions. For example to add 2 and 4
we can write the following:

```
$ expr 2 + 4
6
```

This seems really easy, but there is a catch. If you try to
multiply numbers using `*`

Bash will throw you back an error:

```
$ expr 2 * 4
expr: syntax error
```

In this case Bash sees `*`

as wildcard operator so you must
use a backslash before the asterisk sign:

```
$ expr 2 \* 4
8
```

At this point you will probably try to surround the expression with quotes, but that will also fail:

```
$ expr "2 * 4"
2 * 4
$ expr '2 * 4'
2 * 4
```

Apart from this little annoyance, `expr`

is quite powerful. It can
even do boolean arithmetic:

```
$ expr 2 \< 4
1
$ expr 4 \< 2
0
```

## Arithmetic expansion

There exists a better alternative for `expr`

but is unfortunately
not available in the original Bourne Shell only in the POSIX
compliant one — arithmetic expansion.

It can also, like `expr`

, take an arithmetic expression, but
instead of printing out the result, it will substitute itself with the
resulting value. To print out the result we must use `echo`

or `print`

. For
example to multiply 2 and 4 we can write the following:

```
$ echo $(( 4 * 2 ))
8
```

Without an `echo`

this command would fail with:

```
$ $(( 4 * 2 ))
sh: 1: 8: not found
```

As you can see in the above example, Bash tried to execute the result of the expression as a standard command.

Note: There is an older variant of arithmetic expansion that uses the
following less verbose form `$[ 1 + 4 ]`

but is now deprecated.

## Euclid’s Algorithm in the Shell

Now let’s do something more challenging and try to implement Euclid’s greatest common divisor algorithm in a shell script.

Note: This part will be a little bit advanced and will require you to be familiar with other common things in Bash like loops and variables.

Let’s start by creating a shell script and giving it executable permissions:

```
$ touch gcd.sh
$ chmod +x gcd.sh
```

My goal is to invoke my script with two command line arguments and expect it to print out the greatest common divisor like this:

```
$ ./gcd.sh 14 4
2
```

To achieve this we will first need to capture the two incoming numbers
with `$1`

and `$2`

:

```
#!/bin/sh
a=$1
b=$2
```

The remainder of the script is the basic implementation of the Euclid’s algorithm that I presume every programmer recognizes:

```
#!/bin/sh
a=$1
b=$2
while [ $b -ne 0 ]; do
remainder=$(( $a % $b ))
a=$b
b=$remainder
done
echo $a
```

Note: Shame on you if you don’t recognize the following algorithm, go and Google it. This is probably the most basic algorithm out there. Also, sorry for the harsh words :3

## Final words

I hope you enjoyed this article and also that I have shown you something new and exciting.

Stay awesome!

By the way, I started using drawing tablet instead of the old paper + photo + gimp approach. I hope you like this new art style.