Calculating rounded percentage in Shell Script without using "bc"

Question

I'm trying to calculate percentage of certain items in Shell Script. I would like to round off the value, that is, if the result is 59.5, I should expect 60 and not 59.

item=30
total=70
percent=$((100*$item/$total))

echo $percent

This gives 42.

But actually, the result is 42.8 and I would to round it off to 43. "bc" does the trick, is there a way without using "bc" ?

I'm not authorized to install any new packages. "dc" and "bc" are not present in my system. It should be purely Shell, cannot use perl or python scripts either

Answer 1

Use AWK (no bash-isms):

item=30
total=70
percent=$(awk "BEGIN { pc=100*${item}/${total}; i=int(pc); print (pc-i<0.5)?i:i+1 }")

echo $percent
43

Answer 2

Taking 2 * the original percent calculation and getting the modulo 2 of that provides the increment for rounding.

item=30
total=70
percent=$((200*$item/$total % 2 + 100*$item/$total))

echo $percent
43

(tested with bash, ash, dash and ksh)

This is a faster implementation than firing off an AWK coprocess:

$ pa() { for i in `seq 0 1000`; do pc=$(awk "BEGIN { pc=100*${item}/${total}; i=int(pc); print (pc-i<0.5)?i:i+1 }"); done; }
$ time pa

real    0m24.686s
user    0m0.376s
sys     0m22.828s

$ pb() { for i in `seq 0 1000`; do pc=$((200*$item/$total % 2 + 100*$item/$total)); done; }
$ time pb

real    0m0.035s
user    0m0.000s
sys     0m0.012s

Answer 3

A POSIX-compliant shell script is only required to support integer arithmetic using the shell language ("only signed long integer arithmetic is required"), so a pure shell solution must emulate floating-point arithmetic^[1]:

item=30
total=70

percent=$(( 100 * item / total + (1000 * item / total % 10 >= 5 ? 1 : 0) ))

• 100 * item / total yields the truncated result of the integer division as a percentage.
• 1000 * item / total % 10 >= 5 ? 1 : 0 calculates the 1st decimal place, and if it is equal to or greater than 5, adds 1 to the integer result in order to round it up.
• Note how there's no need to prefix variable references with $ inside an arithmetic expansion $((...)).

---

If - in contradiction to the premise of the question - use of external utilities is acceptable:

---

• awk offers a simple solution, which, however, comes with the caveat that it uses true double-precision binary floating point values and may therefore yield unexpected results in decimal representation - e.g., try printf '%.0f\n' 28.5, which yields 28 rather than the expected 29):

awk -v item=30 -v total=70 'BEGIN { printf "%.0f\n", 100 * item / total }'

• Note how -v is used to define variables for the awk script, which allows for a clean separation between the single-quoted and therefore literal awk script and any values passed to it from the shell.

---

• By contrast, even though bc is a POSIX utility (and can therefore be expected to be present on most Unix-like platforms) and performs arbitrary-precision arithmetic, it invariably truncates the results, so that rounding must be performed by another utility; printf, however, even though it is a POSIX utility in principle, is not required to support floating-point format specifiers (such as used inside awk above), so the following may or may not work (and is not worth the trouble, given the simpler awk solution, and given that precision problems due to floating-point arithmetic are back in the picture):

# !! This MAY work on your platform, but is NOT POSIX-compliant:
# `-l` tells `bc` to set the precision to 20 decimal places, `printf '%.0f\n'`
# then performs the rounding to an integer.
item=20 total=70
printf '%.0f\n' "$(bc -l <<EOF
100 * $item / $total
EOF
)"

---

^{[1] However, POSIX allows non-integer support "The shell may use a real-floating type instead of signed long as long as it does not affect the results in cases where there is no overflow." In practice, ksh and zsh. support floating-point arithmetic if you request it, but not bash and dash. If you want to be POSIX-compliant (run via /bin/sh), stick with integer arithmetic. Across all shells, integer division works as usual: the quotient is returned, that is the result of the division with any fractional part truncated (removed).}

Answer 4

The following is based upon my second answer, but with expr and back-ticks -- which (while perhaps abhorrent to most) can be adapted to work in even the most archaic shells natively:

item=30
total=70
percent=`expr 200 \* $item / $total % 2 + 100 \* $item / $total`

echo $percent
43

Answer 5

With a natural restriction to positive percentage (which cover almost all applications), we have a much simpler solution:

echo $(( ($item*1000/$total+5)/10 ))

It uses the automatic truncation toward 0 that is done by the shell instead of an explicit modulo 2 as in the second answer of Michael Back, which I have upvoted.

BTW, it might be obvious to many, but it was not obvious to me at first that the truncation toward 0 done in evaluating this code is fixed in POSIX, which says that it must respect the C standard for integer arithmetic

Arithmetic operators and control flow keywords shall be implemented as equivalent to those in the cited ISO C standard section, as listed in Selected ISO C Standard Operators and Control Flow Keywords. -- see https://pubs.opengroup.org/onlinepubs/9699919799/

For the C standard, see https://mc-stan.org/docs/2_21/functions-reference/int-arithmetic.html or section 6.3.1.4 in http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf. The first reference is for C++, but it, of course, defines the same integer arithmetic as the second reference which refers to the C99 ISO C standard.

Note that a restriction to positive percentage do not mean that we cannot have a percentage of, say 80%, which is a decrease of 20%. A negative percentage corresponds to a decrease of more than 100%. Of course, it can happen, but not in typical applications.

In accordance with the C standard, to cover negative percentages, we must test if the intermediary value item*1000/$total is negative and, in that case, substract 5, instead of adding 5, but we lose the simplicity.

Answer 6

Here is an answer without modulo 2 and pure bash, which works with negative percentage:

echo "$(( 200*item/total - 100*item/total ))"

We could define a generic integer division that rounds to the nearest integer and then apply it.

function rdiv {
   echo $((  2 * "$1"/"$2" - "$1"/"$2" ))
}
rdiv "$((100 * $item))" "$total"

In general, to compute the nearest integer using float to int conversion, one can use, say in Java : n = (int) (2 * x) - (int) x;

Explanation (based on binary expansion):

Let fbf(x) be the first bit of the fractional part of x, keeping the sign of x. Let int(x) be the integer part, which is x truncated toward 0, again keeping the sign of x. Rounding to the nearest integer is

round(x) = fbf(x) + int(x).

For example, if x = 100*-30/70 = -42.857, then fbf(x) = -1 and int(x) = -42.

We can now understand the second answer of Michael Back, which is based on modulo 2, because:

fbf(x) = int(2*x) % 2 

We can understand the answer here, because:

fbf(x) = int(2*x) - 2*(int(x))

An easy way to look at this formula is to see a multiplication by 2 as shifting the binary representation to the left. When we first shift x, then truncate, we keep the fbf(x) bit that we lose if we first truncate, then shift.

The key point is that, in accordance with Posix and the C standard, a shell does a "rounding" toward 0, but we want a rounding toward the closest integer. We just need to find a trick to do that and there is no need for modulo 2.