## Bash Arithmetic

Another possible solution is to add a simple function for Bash's builtin arithmetic. Put this in your `.bashrc`

file to try:

```
=() {
echo "$(($@))"
}
```

So now, you don't even need `$((...))`

anymore, just `=`

which seems natural enough.

### Replacement

Another thing if you want to be even faster: you can make it replace `p`

with `+`

and `x`

with `*`

. This will work for that:

```
=() {
local IFS=' '
local calc="${*//p/+}"
calc="${calc//x/*}"
echo "$(($calc))"
}
= 5 x 5 # Returns 25
= 50p25 # Returns 75
```

Now you don't even need `Shift` anymore, the only thing is `= `

in front of arithmetic.

### Hexadecimal output

Output can be displayed in both decimal and hexadecimal, if so desired. (**Note**: using `x`

substitution will conflict with the `0x...`

hex syntax)

```
=() {
local answer="$(($@))"
printf '%d (%#x)\n' "$answer" "$answer"
}
```

Example:

```
$ = 16 + 0x10
272 (0x110)
$ = 16**3 + 16**4
69632 (0x11000)
```

## Using `bc`

If you want slightly more advanced calculations, you can pipe it to `bc`

like so:

```
=() {
local IFS=' '
local calc="${*//p/+}"
calc="${calc//x/*}"
bc -l <<<"scale=10;$calc"
}
= 'sqrt(2)' # Returns 1.4142135623
= '4*a(1)' # Returns pi (3.1415926532)
```

The functions provided by `bc`

are as follows (and can be found from `man bc`

):

```
sqrt ( expression )
The value of the sqrt function is the square root of the expression.
If the expression is negative, a run time error is generated.
s (x) The sine of x, x is in radians.
c (x) The cosine of x, x is in radians.
a (x) The arctangent of x, arctangent returns radians.
l (x) The natural logarithm of x.
e (x) The exponential function of raising e to the value x.
j (n,x)
The Bessel function of integer order n of x.
```

It also supports `if`

, `for`

, `while`

and variables like a programming language though if it may be better to write to a file if you wanted that.

Keep in mind that it will substitute `p`

and `x`

in function/variable names. It may be better to just remove the replacements.

## Using `gcalccmd`

You can also make the function call `gcalccmd`

(from `gnome-calculator`

) like so:

```
=() {
local IFS=' '
local calc="$*"
# Uncomment the below for (p → +) and (x → *)
#calc="${calc//p/+}"
#calc="${calc//x/*}"
printf '%s\n quit' "$calc" | gcalccmd | sed 's:^> ::g'
}
= 'sqrt(2)' # Returns 1.4142135623
= '4^4' # Returns 256
```

The available functions seem to be (taken straight from the source code), `==`

denotes equivalent functions:

```
ln()
sqrt()
abs()
int()
frac()
sin()
cos()
tan()
sin⁻¹() == asin()
cos⁻¹() == acos()
tan⁻¹() == atan()
sinh()
cosh()
tanh()
sinh⁻¹() == asinh()
cosh⁻¹() == acosh()
tanh⁻¹() == atanh()
ones()
twos()
```

mightbe possible to hack something like that up with a kind of pre-hook; but that in itself can only be done in a really ugly and hackish way. No, I very much think it's not a good idea. Bash as a whole is meant as a plain IO scripting language, anything it does apart from that is more or less ad-hoc and doesn't work really well. Python on the other hand (or even e.g. Haskell) is a modern, all-purpose programming language with great syntax. So it would be just stupid not to use it.`command_not_found`

hook, and try feeding the command to`bc`

/`calc`

/whatever if it looks vaguely like maths. It still feels a bit dirty, though.without running a command?4more comments