How to do integer & float calculations, in bash or other languages/frameworks?

There are many ways to calculate. For simple expressions you can use bash itself:

echo $((20+5))

or expr:

expr 20 + 5

And for complex cases there is great tool bc:

echo "20+5" | bc

Btw, bc can calculate even very complex expression with roots, logarithms, cos, sin and so on.

The mentioned solutions are fine for very simple calculations, but very error-prone. Examples:

# without spaces 20+5 literally produces 20+5
expr 20+5
→ 20+5

# bc's result does't give the fractional part by default
bc <<<
9.0/2.0
→ 4

# expr does only integer
expr 9 / 2
→ 4

# same for echo
echo $((9/2))
→ 4

# echo chokes on floats
echo $((9.0/2.0))
→ bash: 9/2.0: syntax error: invalid arithmetic operator (error token is ".0")

# expr also has problems with floats
expr 9.0 / 2.0
→ expr: non-integer argument

A syntax error like the last ones never get unnoticed, but integer responses with a discarded float part can easily get unnoticed and lead to wrong results.

That's why I always use a scripting language like Lua for that. But you can choose any scripting language that you're familiar with. I just use Lua as an example. The advantages are

• a familiar syntax
• familiar functions
• familiar caveats
• flexible input
• spaces usually don't matter
• floating point output

Examples:

lua -e "print(9/2)"
→ 4.5

lua -e "print(9 / 2)"
→ 4.5

lua -e "print(9.0/2)"
→ 4.5

lua -e "print (9 /2.)"
→ 4.5

lua -e "print(math.sqrt(9))"
→ 3

You could use bc. E.g.,

$ echo "25 + 5" | bc
30

Alternatively bc <<< 25+5 will also work.

Or interactively, if you want to do more than just a single simple calculation:

$ 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'. 
25 + 5
30

bc -q will jump into bc right away without the header/copyright info. For more information see the bc man page

This page also shows how to set up an alias or function to do calculation like this:

c "25 + 5" 

and get the result

You can use calc:

If you just enter calc with no other arguments it enters an interactive mode where you can just keep doing math. You exit this by typing exit:

C-style arbitrary precision calculator (version 2.12.3.3)
Calc is open software. For license details type:  help copyright
[Type "exit" to exit, or "help" for help.]

; 2+4
6
; 3+5
8
; 3.4+5
8.4
; 2^4
16
; exit

Or you use it with the expression as an argument and it will provide the answer and then exit

$calc 2 + 4
    6
$

calc is similar to bc, I just like the way it behave as default better

Nobody has mentioned awk yet?

Using bash functions, and awk math power, just define this (one line) function:

calc(){ awk "BEGIN { print "$*"}"; }

Then just execute things like calc 1+1 or calc 5/2

Note: To make the function always available, add it to ~/.bashrc

Of course, a little script named "calc" with the following contents:

#!/bin/bash
awk "BEGIN { print $* }"

could also work.

I like to fire up Python and use it as an interactive calculator (but then again, I'm a Python programmer).

Since no-one else has mentioned it, and though it's not strictly a calculator (but neither are all these general-purpose scripting languages), I'd like to mention units:

$ units "1 + 1"
        Definition: 2
$ units "1 lb" "kg"
        * 0.45359237
         / 2.2046226

Or, for less output so you can get just the number to use in $() to assign to something:

$ units -t "1 + 1"
2
$ units -t "1 lb" "kg"
0.4539237

And it even does temperature conversions

$ units -t "tempC(20)" "tempF"
68

To get the temperature conversion in an expression for further calculation, do this:

$ units -t "~tempF(tempC(20))+1"
68.1

$> ghc -e '20 + 5'
25
it :: Integer

Also ghci, that is the Glasgow-Haskell Compiler in interactive mode (ghc --interactive, as opposed to it evaluating an expression with -e), makes for a fascinating "calculator":

$>ghci
GHCi, version 7.8.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> pi
3.141592653589793
Prelude> ceiling pi
4
Prelude> compare 1 2
LT

I use a little python script that will evaluate a python expression and print the result, then I can run something like

$ pc '[i ** 2 for i in range(10)]'
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

the script is:

#!/usr/local/bin/python3

import sys
import traceback
from codeop import CommandCompiler

compile = CommandCompiler()
filename = "<input>"
source = ' '.join(sys.argv[1:]) + '\n'

try:
    code = compile(source, filename) 
except (OverflowError, SyntaxError, ValueError):
    type, value, sys.last_traceback = sys.exc_info()
    sys.last_type = type
    sys.last_value = value
    if filename and type is SyntaxError:
        # Work hard to stuff the correct filename in the exception
        try:
            msg, (dummy_filename, lineno, offset, line) = value.args
        except ValueError:
            # Not the format we expect; leave it alone
            pass
        else:
            # Stuff in the right filename
            value = SyntaxError(msg, (filename, lineno, offset, line))
            sys.last_value = value
    lines = traceback.format_exception_only(type, value)
    print(''.join(lines))
else:
    if code:
        exec(code)
    else:
        print('incomplete')

Unfortunately I don't remember where I borrowed most of the code from, so I can't cite it.

For console calculations, I use concalc. (sudo aptitude install concalc)

After that, just type concalc and hit enter. It won't supply a prompt, but just type in the your calculation (no spaces) and hit enter, and on the next line, it'll give you the numeric value.

I can't believe to read "the power of JavaScript" (but I had to upvote the answer for the other parts, except perl of course.

Practically, for the simple cases where integer arithmetic is sufficient, I use the buildin $((...)) and recommend it. Else, in almost all cases echo "..." | bc is sufficient.

For some arithmetic operations like statistics, matrix operations and more R is the better tool:

echo 25 + 5 | R --vanilla

and for small datasets and graphical throw away results, oocalc is a nice utility.

Gnuplot

gnuplot - an interactive plotting program
Follow the above link or type gnuplot form the prompt then help inside the gnuplot interpreter.
Gnuplot is a program born to plot data, but can be used for calculation too. It offer the advantage that you can define functions and or use the built-in ones.

echo  "pr 20+5/2"  |  gnuplot          #  Lazy-note `pr` instead of print
22                                     #  Integer calculation & result
echo  "pr 20.+5/2"  |  gnuplot         #  Lazy-note `pr` instead of print
22.0                                   #  Floating point result
echo  "pr sin(2*pi/3.)"  |  gnuplot    #  Some functions ...
0.866025403784439

Root (or some other C interpreter)

The ROOT system provides a set of OO frameworks with all the functionality needed to handle and analyze large amounts of data in a very efficient way...

You can use it as C interpreter, CINT, or you can use one of the many many other C interpreters . IMHO, it's huge, complex, powerful, and not always friendly but can give big satisfaction too.

If you really do not want to listen the little voice inside you that cites Confucio and you are ready to break a (butter)fly on the wheel you can use root. In this case -l is mandatory to avoid to show splash screen...

echo  "20+5/2"   | root -l
(const int)22
echo  "20+5/2."  | root -l
(const double)2.25000000000000000e+01

echo  "cout<< 20+5/2 << endl;"   | root -l
22

SQLite:

echo 'select 1 + 1;' | sqlite3 

MySQL:

mysql -e 'select 1 + 1 from dual;'

PostgreSQL:

psql -c 'select 1 + 1 as sum;'

Use the GNU Multiple Precision Arithmetic Library through the supplied run-expr program:

• Download and extract(you will need lzip): tar -xvf gmp-5.1.3.tar.lz
• In the top directory, ./configure and make (no need to install)
• In demos/expr, make run-expr
• I like to create a symbolic link to it in my ~/bin directory: ln -s /path/to/gmp/demos/expr/run-expr ~/bin/run-expr
• Add an alias for easy use; for instance alias calcf='run-expr -f' for floating point evaluation

Output:

# calcf '2/3'
"2/3" base 0: result 0.666666666666666666667e0

From the run-expr.c file:

Usage: ./run-expr [-z] [-q] [-f] [-p prec] [-b base] expression...

   Evaluate each argument as a simple expression.  By default this is in mpz
   integers, but -q selects mpq or -f selects mpf.  For mpf the float
   precision can be set with -p.  In all cases the input base can be set
   with -b, or the default is "0" meaning decimal with "0x" allowed.

See the manual for function classes differences and details.

In bash & fish use awk

With zero configuration:

$ awk "BEGIN {print 10/3}"
3.33333

or after configuring your shell (note 2,3):

$ calc 10/3
3.33333

awk is probably preinstalled in all Unix-like OSes. For other reasons awk is a good choice see note 1

In zsh use echo

$ echo $((10/3))
3.3333333333333333

Note 1: awk Pros and Cons

♥ available in almost all Unix-es, ♥ reasonably light, ♥ produces expectable results by default with both integers and decimals, ♥ very flexible.

☹ it's not built-in to bash or any other shell so it's not super-light, ☹ you need to tweak the command to get more decimal digits, ☹ no fancy mathematical operations.

Note 2: How to use the simplified syntax in bash

Add this bash function to your ~/.bashrc:

calc(){ awk "BEGIN { print "$*"}"; }

Note 3: How to use the simplified syntax in fish

Create a calc fish function (i.e. a text file named /home/ndemou/.config/fish/functions/calc.fish):

function calc
    awk "BEGIN{ print $argv }" ;
end