Numeric operations on Linux

Linux systems provide numerous ways to work with numbers on the command line – from doing calculations to using commands that generate a range of numbers. This post details some of the more helpful commands and how they work.

The expr command

One of the most commonly used commands for doing calculations on Linux is expr. This command lets you use your terminal window as a calculator and to write scripts that include calculations of various types. Here are some examples:

$ expr 10 + 11 + 12
33
$ expr 99 - 102
-3
$ expr 7 * 21
147

Notice that the multiplication symbol  * in the command above requires a backslash to ensure the symbol isn’t interpreted as a wildcard. Here are some more examples:

$ expr 147 / 7
21
$ expr 81 % 10
1

The two calculations above do a division and provide a modulus (the number that remains after 81 is divided by 10).

Using double parentheses

You can also do a lot of calculations using double parentheses. Here’s an example:

$ sum=$(( 1 + 10 ))
$ echo $sum
11

Other calculations using double parentheses (multiplication, subtraction, division and modulus) are shown below.

$ num=$(( 3 * 17 ))
$ echo $num
51
$ num=$(( 124 - 37 ))
$ echo $num
87
$ num=$(( 124 / 37 ))
$ echo $num
3
$ num=$(( 124 % 37 ))
$ echo $num
13

You can also combine parentheses and expr commands like this:

$ num=5
$ num=$(expr $num + 11)
$ echo $num
16

Alternately, you can use backticks like this:

$ num=5
$ num=`expr $num + 11`
$ echo $num
16

Using bc

The bc command provides a precision calculator that allows you to do calculations and even specify how many decimal places you want to see when the results are not whole numbers.

$ echo "26/3" | bc
8
$ echo "scale=3;26/3" | bc
8.666

You can also calculate factorials with commands like the one shown below. Just in case you haven’t thought about factorials in many years, they involve multiplying all whole numbers from the chosen number down to one. For example, 3! (factorial 3) would be 6 (3 x 2 x 1). The command below calculates the value of 10! by using the seq command to generate the list of numbers (10 9 8 etc.) and then passing them to bc to do the multiplication.

$ seq -s "*" 1 10 | bc
3628800
$ expr 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1
3628800

I included the expr command to verify that the seq output sent to the bc command is generating the correct output.

Using awk

Even awk can help with math. Here are two examples of commands you can try on the command line:

$ awk 'BEGIN { a = 76; b = 42; print "(a + b) =", (a + b) }'
(a + b) = 118

$ echo 66 77 90 | awk '{ sum = $1 + $2 + $3 ; avg = sum /3; print avg }'
77.6667

Using the factor command

The factor command is used to print the prime factors of given numbers. Here’s an example in which the number 111 is factored:

$ factor 111
111: 3 37

As you can see, the two factors for 111 are 3 and 37. You can verify this if you’re so inclined by multiplying those numbers and seeing that the result is indeed 111.

$ expr 3 * 37
111

If you make the starting number one larger, you will see a much longer list of factors:

$ factor 112
112: 2 2 2 2 7

Clearly the multipliers required to get to 112 are much more significant. Remember that all of the factors need to be prime numbers or we would be seeing just 16 and 17.

$ expr 2 * 2 * 2 * 2 * 7
112

Numeric operators

The table below displays the numeric operators that you can use with most numeric commands. Just remember to use a backslash before an *.

Numeric comparisons

You can also compare numbers with operations that test whether numeric variables are equal, unequal, greater or smaller than some other variables. Here’s one example:

$ num=11
$ if [ $num == 11 ]; then echo eleven; else echo oops; fi
eleven

To test whether numbers are equal to, greater or equal to or equal to come value, use a command like one of these:

$ if [ $num -ge 11 ]; then echo ok; else echo oops; fi
ok
$ if [ $num -gt 11 ]; then echo wow; else echo ok; fi
ok
$ if [ $num -lt 9 ]; then echo wow; else echo ok; fi
ok
$ if [ $num != 11 ]; then echo wow; else echo ok; fi
ok

The table below lists the numeric comparisons.

Generating number lists

You can generate lists of numbers using the jot or seq commands (depending on which version of Linux you are using).

$ jot 5
1
2
3
4
5

$ seq 1 5
1
2
3
4
5

In fact, there’s no requirement that you start with 1.

$ seq 27 33
27
28
29
30
31
32
33

You also don’t have to list every number in the specified range. The seq command below starts with 10, increments each number by 4 and then stops when it reaches the last increment in the range (24 in this case).

$ seq 10 4 24
10
14
18
22

Wrap-up

Doing math on the command line can be fun and often quite helpful when you need to calculate values. If you’d like to see a post I wrote five or so years ago on doing math on the command, check this one out:

How to do math on the Linux command line