Can you do math on the Linux command line? You sure can! In fact, there are quite a few commands that can make the process easy and some you might even find interesting. Let's look at some very useful commands and syntax for command line math.

## expr

First and probably the most obvious and commonly used command for performing mathematical calculations on the command line is the **expr** (expression) command. It can manage addition, subtraction, division, and multiplication. It can also be used to compare numbers. Here are some examples:

#### Incrementing a variable

$ count=0 $ count=`expr $count + 1` $ echo $count 1

#### Performing a simple calculations and comparisons

$ expr 11 + 123 134 $ expr 134 / 11 12 $ expr 134 - 11 123 $ expr 11 * 123 expr: syntax error <== oops! $ expr 11 \* 123 1353 $ expr 20 % 3 2 $ expr 11 \> 10 1 $ expr 11 \> 17 0

Notice that you have to use a \ character in front of * to keep the shell from interpreting the asterisk as a reference to all files in the current directory and in front of > to keep it from being used to redirect the command's output. The % operator is for modulo calculations.

Here's a slightly more complex example:

participants=11 total=156 share=`expr $total / $participants` remaining=`expr $total - $participants \* $share` echo $share 14 echo $remaining 2

If we have 11 participants in some event and 156 prizes to distribute, each participant's fair share of the take is 14, leaving 2 in the pot.

#### Making comparisons

Now let's look at the logic for comparisons. These statements may look a little odd at first. They are not setting values, but only comparing the numbers. What **expr** is doing in the examples below is determining whether the statements are true. If the result is 1, the statement is true; otherwise, it's false.

$ expr 11 = 11 1 $ expr 11 = 12 0

Read them as "Does 11 equal 11?" and "Does 11 equal 12?" and you'll get used to how this works. Of course, no one would be asking if 11 equals 11 on the command line, but they might ask if $age equals 11.

$ age=11 $ expr $age = 11 1

Putting the numbers in quotes doesn't mean that you'd actually be doing a string comparison rather than a numeric one -- unless one of the arguments is clearly a string.

$ expr "11" = "11" 1

$ expr "11" = "011"

1 $ expr "eleven" = "11" 0

In the following examples, we're asking whether 10 is greater than 5 and, then, whether it's greater than 99.

$ expr 10 \> 5 1 $ expr 10 \> 99 0

Of course, having true comparisons resulting in 1 and false resulting in 0 goes against what we generally expect on Linux systems. The example below shows that using **expr** in this kind of context doesn't work because **if** works with the opposite orientation (0=true).

#!/bin/bash echo -n "Cost to us> " read cost echo -n "Price we're asking> " read price if [ `expr $price \> $cost` ]; then echo "We make money" else echo "Don't sell it" fi

Now, let's run this script:

$ ./checkPrice Cost to us> 11.50 Price we're asking> 6 We make money

That sure isn't going to help with sales! With a small change, this would work as we'd expect:

#!/bin/bash echo -n "Cost to us> " read cost echo -n "Price we're asking> " read price if [ `expr $price \> $cost` == 1 ]; then echo "We make money" else echo "Don't sell it" fi

## factor

The **factor** command works just like you'd probably expect. You feed it a number, and it tells you what its factors are.

$ factor 111 111: 3 37 $ factor 134 134: 2 67 $ factor 17894 17894: 2 23 389 $ factor 1987 1987: 1987

NOTE: The factor command didn't get very far on factoring that last value because 1987 is a **prime number**.

## jot

The **jot** command allows you to create a list of numbers. Provide it with the number of values you want to see and the number that you want to start with.

$ jot 8 10 10 11 12 13 14 15 16 17

You can also use **jot** like this. Here we're asking it to decrease the numbers by telling it we want to stop when we get to 2:

$ jot 8 10 2 10 9 8 7 5 4 3 2

The** jot** command can be useful if you want to iterate through a series of numbers to create a list for some other purpose.

$ for i in `jot 7 17`; do echo April $i; done April 17 April 18 April 19 April 20 April 21 April 22 April 23

## bc

The **bc** command is probably one of the best tools for doing calculations on the command line. Enter the calculation that you want performed, and pipe it to the command like this:

$ echo "123.4+5/6-(7.89*1.234)" | bc 113.664

Notice that **bc** doesn't shy away from precision and that the string you need to enter is fairly straightforward. It can also make comparisons, handle Booleans, and calculate square roots, sines, cosines, tangents, etc.

$ echo "sqrt(256)" | bc 16 $ echo "s(90)" | bc -l .89399666360055789051

In fact, **bc** can even calculate pi. You decide how many decimal points you want to see:

$ echo "scale=5; 4*a(1)" | bc -l 3.14156 $ echo "scale=10; 4*a(1)" | bc -l 3.1415926532 $ echo "scale=20; 4*a(1)" | bc -l 3.14159265358979323844 $ echo "scale=40; 4*a(1)" | bc -l 3.1415926535897932384626433832795028841968

And **bc** isn't just for receiving data through pipes and sending answers back. You can also start it interactively and enter the calculations you want it to perform. Setting the scale (as shown below) determines how many decimal places you'll see.

$ bc bc 1.06.95 Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. scale=2 3/4 .75 2/3 .66 quit

Using **bc**, you can also convert numbers between different bases. The **obase** setting determines the output base.

$ bc bc 1.06.95 Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. obase=16 16 <=== entered 10 <=== response 256 <=== entered 100 <=== response quit

One of the easiest ways to convert between hex and decimal is to use **bc** like this:

$ echo "ibase=16; F2" | bc 242 $ echo "obase=16; 242" | bc F2

In the first example above, we're converting from hex to decimal by setting the input base (ibase) to hex (base 16). In the second, we're doing the reverse by setting the outbut base (obase) to hex.

## Easy bash math

With sets of double-parentheses, we can do some easy math in bash. In the examples below, we create a variable and give it a value and then perform addition, decrement the result, and then square the remaining value.

$ ((e=11)) $ (( e = e + 7 )) $ echo $e 18 $ ((e--)) $ echo $e 17 $ ((e=e**2)) $ echo $e 289

The arithmetic operators allow you to:

+ - Add and subtract ++ -- Increment and decrement * / % Multiply, divide, find remainder ** Get exponent

You can also use both logical and boolean operators:

$ ((x=11)); ((y=7)) $ if (( x > y )); then > echo "x > y" > fi x > y

$ ((x=11)); ((y=7)); ((z=3)) $ if (( x > y )) >> (( y > z )); then > echo "letters roll downhill" > fi letters roll downhill

or if you prefer ...

$ if [ x > y ] << [ y > z ]; then echo "letters roll downhill"; fi letters roll downhill

Now let's raise 2 to the 3rd power:

$ echo "2 ^ 3" 2 ^ 3 $ echo "2 ^ 3" | bc 8

## Wrap-up

There are sure a lot of different ways to work with numbers and perform calculations on the command line on Linux systems. I hope you picked up a new trick or two by reading this post.