Reading this pages comments, I see a UNIX/Linux program called calc that does exactly what you want. If on Debian / Ubuntu / derivatives:

sudo apt-get install apcalc

then you can:

calc 236-192

and if you add an alias alias c='calc' to your .bashrc or /etc/bash.bashrc then it just becomes:

c 1+1

on the command line.

In zsh:

$ autoload zcalc # best in  ~/.zshrc

$ zcalc

1> 1+1

2

2> ^D

$ zcalc 5+5

1> 10

2>

The units program, whilst not intended to be used as a calculator, actually works fairly well as one.

$ units "236-192"

    Definition: 44

$ 

If there are spaces in the expression, then the expression must be quote-protected.

It supports exponentials and deep nesting of brackets

Shell

The simplest calc in CLI is the CLI (shell) itself (If IFS is default):

$ echo $(( 22 + 333 ))

355

Spaces could be omitted:

$ echo $((22*333))

7326

As it is part of POSIX almost all shells have it. And it includes most of C language math functionality (except that zsh has a different precedence, set C_PRECEDENCES to restore it to a compatible value):

$ echo $((22*333^2))

7324

And some shells have most of the C language math syntax (including comma):

$ echo $((a=22,b=333,c=a*b,c))

7326

But it is only integer math (and usually less than 2⁶³ in present day OSes) in some shells:

$ echo $((1234/3))

411



$ zsh -c 'echo $((2**63))'

-9223372036854775808

Some shells could do floating math:

$ ksh -c 'echo $((1234/3.0))'

411.333333333333333



$ ksh -c 'echo $((12345678901234567890123/3.0))'

4.11522630041152263e+21

Avoid zsh (zcalc has similar problems):

$ zsh -c 'echo $((12345678901234567890123 + 1))'

zsh:1: number truncated after 22 digits: 12345678901234567890123 + 1

-1363962815083169259

I recommend you to avoid expr, it needs weird escapes sometimes:

$ expr 22 * 333

7326

bc

At the next level is (also POSIX)bc (cousin of RPN dc)

$ echo '22*333' | bc

7326



$ echo '22 333 * p' | dc

7326

The dc was POSIX but got removed in 2017.

Shorter if your shell supports it:

$ bc <<<'22*333'

7326

Or even:

$ <<<'22*333' bc

7326

Both are arbitrary precision calculators with some internal math functions:

$ bc <<<2^200

1606938044258990275541962092341162602522202993782792835301376



$ echo 's(3.1415/2)' | bc -l        # sine function

.99999999892691403749

awk

After those really basic calc tools, you need to go up to other languages

$ awk "BEGIN {print (22*33)/7}"

103.714



$ perl -E "say 22*33/7"

103.714285714286



$ python3 -c "print(22*33/7)"

103.71428571428571



$ php -r 'echo 22*33/7,"n";'

103.71428571429

function

You may define a function of any of the above options:

c () 

{ 

    local in="$(echo " $*" | sed -e 's/[/(/g' -e 's/]/)/g')";

    gawk -M -v PREC=201 -M 'BEGIN {printf("%.60gn",'"${in-0}"')}' < /dev/null

}

And use:

$ c 22* 33 /7                   # spaces or not, it doesn't matter.

103.714285714285714285714285714285714285714285714285714285714

What I do in zsh is:

$ <<< $(( 236 - 192 ))

44

In bash, I'd have to explicitly mention cat:

$ cat <<< $(( 236 - 192 ))

44

If I wanted the result to include fractional digits (works in zsh, not in bash), I'd add a radix point to one of the operands

$ <<< $(( 236 / 128 )) 

1

$ <<< $(( 236. / 128 ))

1.84375

As remarked in a comment to an earlier reply, the standard shell (ba)sh allows to evaluate arithmetic expressions within $((...)). I could not double-check whether this is part of the POSIX standard, but I did check that it also works on Cygwin and the Mingw32 shell.

To see the result, you'd indeed have to type echo $((...)), which makes some characters more than (interactive use of) bc. However, to use the result in a script, this will most probably be shorter than the bc solution (which could be, e.g., `echo ...|bc`).

Concerning verbosity, the bc command allows the option -q which suppresses output of the "normal GNU bc welcome".

As a final, slightly borderline remark, let's note that bc is not just a calculator but rather a full-fledged programming language (including user defined functions, while & for loops, etc etc). Another fact that suggests to prefer the build-in arithmetic capabilities for such simple calculations, rather than an external program. That said, extracting the data for given partition number(s) and dealing with "M", "G" suffixes, as the original question seemed to ask for, might call for (g)awk rather than bc.

Sources: https://www.gnu.org/software/bc/manual/html_mono/bc.html
https://www.gnu.org/software/gawk/manual/html_node/Getting-Started.html

Personally, I like libqalculate (the command-line version of Qalculate).

$ qalc

> 236-192



  236 - 192 = 44

(Lib)qalculate is a powerful, full-fledged calculator. e.g.

> fibonacci(133) to hex



  fibonacci(133) = approx. 0x90540BE2616C26F81F876B9



> 100!



  factorial(100) = approx. 9.3326215E157



> sin(pi)



  sin(pi * radian) = 0

It also does useful things like tab completion, open/close parentheses when necessary, and prints its interpretation of the query.

> 18-2)/4



  (18 - 2) / 4 = 4

To exit, I simply press Ctrl+d.

For even quicker access, set it to something like alias ca='qalc'.

Python open in another tab?

Python 3.6.3 (v3.6.3:2c5fed8, Oct  3 2017, 17:26:49) [MSC v.1900 32 bit (Intel)] on 

win32

Type "help", "copyright", "credits" or "license" for more information.

>>> 3+3

6

>>>

dc -e '236 192-p'

... of course, if you're not familiar with dc and you require more than subtracting two numbers, you'll spend more time looking up how to use dc (and maybe RPN in general) than you'll save with more familiar methods.

If you have gradle installed then you have groovy...

If groovy is pathed correctly you should be able to use:

groovy -e "println 1+1"

This may seem a bit redundant with all the other examples, but:

• groovy is a powerful language


• possibly the best library support available


• powerful and simple math functions (Like arbitrary precision math)


• uses redirectable stdout for it's output so it is amazingly flexible (great to use inside batch files with backticks `` and the like).

If you don't have java installed it's probably not worth installing groovy & java--it's just an option if groovy is already available.

I ended up creating the script /usr/local/bin/c containing:

#!/bin/sh

IFS=' '               # to be on the safe side, some shells fail to reset IFS.

if [ "$#" -eq 0 ];  then

    echo "$(basename "$0"): a (very) simple calculator."

    echo "type $(basename "$0") expression to evaluate (uses bc internally)"

fi



printf '%sn' "$*" | bc -l  # safe for most shells

                            # we may use 'bc -l <<<"$*"` for ksh, bash, zsh

so: typing c 1+1 yields 2! :-)

Note 1: I used c because that command does not exist on any Unix system that I could find. If you would have aliased that to your c compiler, use anything else that is short and you don't use.
Note 2: Source