I'm using a serial terminal to provide input into our lab experiment. I found that using

```
$ echo "5X5"
```

just returns a string of `"5X5"`

. Is there a command to execute a multiplication operation?

This question is related to
`bash`

`unix`

`command-line`

Yes, you can use bash's built-in Arithmetic Expansion `$(( ))`

to do some simple maths

```
$ echo "$((5 * 5))"
25
```

Check the Shell Arithmetic section in the Bash Reference Manual for a complete list of operators.

For sake of completeness, as other pointed out, if you need arbitrary precision, `bc`

or `dc`

would be better.

The classical solution is:

```
expr 5 \* 5
```

`expr`

will only work with integer operands. Another nice option is:

```
echo 5 5\*p | dc
```

`dc`

can be made to work with non-integer operands.

If you like python and have an option to install a package, you can use this utility that I made.

```
# install pythonp
python -m pip install pythonp
pythonp "5*5"
25
pythonp "1 / (1+math.exp(0.5))"
0.3775406687981454
# define a custom function and pass it to another higher-order function
pythonp "n=10;functools.reduce(lambda x,y:x*y, range(1,n+1))"
3628800
```

I have a simple script I use for this:

`me@mycomputer:~$ cat /usr/local/bin/c`

```
#!/bin/sh
echo "$*" | sed 's/x/\*/g' | bc -l
```

It changes `x`

to `*`

since `*`

is a special character in the shell. Use it as follows:

`c 5x5`

`c 5-4.2 + 1`

`c '(5 + 5) * 30'`

(you still have to use quotes if the expression contains any parentheses).

For more advanced and precise math consider using bc(1).

```
echo "3 * 2.19" | bc -l
6.57
```

I use this function which uses `bc`

and thus supports floating point calculations:

```
c () {
local a
(( $# > 0 )) && a="$@" || read -r -p "calc: " a
bc -l <<< "$a"
}
```

Example:

```
$ c '5*5'
25
$ c 5/5
1.00000000000000000000
$ c 3.4/7.9
.43037974683544303797
```

Bash's arithmetic expansion doesn't support floats (but Korn shell and zsh do).

Example:

```
$ ksh -c 'echo "$((3.0 / 4))"'
0.75
```

Bash supports arithmetic expansion with `$(( expression ))`

. For example:

```
$ echo $(( 5 * 5 ))
25
```

A number of utilities provide arithmetic, including *bc* and *expr*.

```
$ echo '5 * 5' | /usr/bin/bc
25
$ /usr/bin/expr 5 \* 5
25
```

A simple shell function (no sed needed) should do the trick of interpreting '5X5'

```
$ function calc { bc -l <<< ${@//[xX]/*}; };
$ calc 5X5
25
$ calc 5x5
25
$ calc '5*5'
25
```

Source: Stackoverflow.com