Round/truncate digit in string in zsh (or with external tool)

Question

I'm trying to do an interface to bc so it can be used intuitively and without the annoyance of getting "stuck" in it. I haven't got around to test it that much, because I got stuck on another detail, namely how to present the result (which is, I think, a string).

Rounding or truncating does not matter, either one is fine. Take a look below, and you'll understand immediately. I use zsh but an external tool will be just fine as I won't use this in any time or otherwise critical context, it's just a desktop tool.

calc () {
    result=`bc <<EOF
    scale=3;
    $@
    EOF`
    echo ${result//%0/} # doesn't work; will only remove one zero
                        # also, if there are only zeroes, should
                        # remove dot as well - what about .333, etc.?
}

Edit

I'm very impressed by the below solution, especially how the noglob gets away with the quotes!

But, the use of a dot to force floating point calculation is something I'll never remember (you don't use a normal calculator like that). And it is even a bit risky, especially for calculations when it's not obvious that floating point would yield an altogether different result (most likely the one you wanted).

Also, the calculations below show some un-pretty output (the too long real, and the trailing dot).

Perhaps I should combine this (some of it) with the output formatting of @Gille's answer below? When I get it to work perfectly, I'll post the result here. (Edit: The accepted answer works great. Be sure to read the comments to that answer, as well.)

calc () {
  echo $(($*));
}
alias calc='noglob calc'

calc 1./3
0.33333333333333331
calc 7.5 - 2.5
5.

Answer 1

Using zsh's own arithmetic, you could do:

calc() printf '%.6g\n' $(($*))
alias 'calc=noglob calc'

But that would mean you'd need to enter numbers as 123. for them to be taken as floating point and trigger a floating point calculation.

You could work around that by appending . to any sequence of decimal digits that is not otherwise part of a hex number (or number in another base) or of a variable name or 12e-20 type numbers like:

setopt extendedglob
calc() printf '%.6g\n' $((${*//(#bm)(([0-9.]##[eE][-+][0-9]##|[[:alnum:]_#]#[.#_[:alpha:]][[:alnum:]_#]#)|([0-9]##))/$MATCH${match[3]:+.}}))
alias 'calc=noglob calc'

By which time you may think it easier to use bc and trim the trailing 0s.

See also awk:

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

which supports fewer operators and math functions but might be enough for you.

Answer 2

If I understood correctly, you want to delete trailing zeroes and a trailing dot. In that case, if EXTENDED_GLOB is set, you can use

${result//%.#0##/}

That is: at the end of the string (%) match zero or more dots (.#) followed by one or more zeroes (0##).

But this will return "" if result is 0. You can do another substitution around the first one, to restore the return value to 0:

${${result//%.#0##/}:-0}

Answer 3

bc can either print results as long integers or as decimals. Here's a script that joins long integers split into multiple lines together, and removes trailing zeroes after the decimal points in decimals.

calc () {
  emulate -L zsh; setopt extended_glob
  local line
  bc <<EOF |
scale=3
$@
EOF
    while read line; do
      if [[ $line = *.* ]]; then
        print -r -- ${${${line%%0##}/#%0#./0}%.}
      else
        print -r -- $line
      fi
    done
}

The way it's written is more of an exercise in text manipulation with parameter substitutions than a really clear way of pretty-printing decimals.

• ${…%%0##} removes the longest suffix matching 0##, i.e. trailing zeroes.
• ${…/#%0#./0} sets the string to 0 if it consists solely (#% prefix to the pattern in ${VAR/PATTERN/REPLACEMENT}) of optional leading zeroes (0#) and .
• ${…%.} strips off a trailing . if any.

I think splitting the steps is clearer.

if [[ $line = *.* ]]; then line=${line%%0##}; fi
if [[ $line = . ]]; then line=0; else line=${line%.}
print -r -- $line

Answer 4

Try zcalc in zsh; if you're not already autoloading all the functions that come with zsh, you'll need to autoload zcalc first. Does away with bc, has prompting, $output back-references, command-history, scientific functions, the ability to define more functions, etc.

Documented in zshcontrib(1).

Downside: still has the "ints by default" issue, thus 3./5 != 3/5

Answer 5

We can use the same technique as asm.js to do this without string manipulation or subprocesses:

echo $((123.45|0))  # prints 123

It takes advantage of the fact that certain operators, such as bitwise-or, can only be performed on integers.