Differences between revisions 1 and 82 (spanning 81 versions)
Revision 1 as of 2007-05-02 23:08:44
Size: 1939
Editor: redondos
Comment:
Revision 82 as of 2020-07-28 07:49:05
Size: 5200
Editor: geirha
Comment:
Deletions are marked like this. Additions are marked like this.
Line 1: Line 1:
[[Anchor(faq22)]] <<Anchor(faq22)>>
Line 3: Line 3:
["BASH"] does not have built-in floating point arithmetic: [[BASH]]'s builtin [[ArithmeticExpression|arithmetic]] uses integers only:
{{{
$ echo "$((10 / 3))"
3
}}}

For most operations involving non-integer numbers, an external program must be used, e.g. `bc`, [[AWK]] or `dc`:
{{{
$ echo 'scale=3; 10/3' | bc
3.333
}}}

The "scale=3" command notifies `bc` that three digits of precision after the decimal point are required.

Same example with `dc` (reverse polish calculator, lighter than `bc`):
{{{
$ echo '3 k 10 3 / p' | dc
3.333
}}}

`k` sets the precision to 3, and `p` prints the value of the top of the stack with a newline. The stack is not altered, though.

If you are trying to compare non-integer numbers (less-than or greater-than), and you have GNU `bc`, you can do this:
{{{
# Bash and GNU bc
if (( $(bc <<<'1.4 < 2.5') )); then
  echo '1.4 is less than 2.5.'
fi
}}}

However, ''x < y'' is not supported by all versions of `bc`:
{{{
# HP-UX 10.20.
imadev:~$ bc <<<'1 < 2'
syntax error on line 1,
}}}

If you want to be portable, you need something more subtle:
{{{
# POSIX
case $(echo '1.4 - 2.5' | bc) in
  -*) echo '1.4 is less than 2.5';;
esac
}}}

This example subtracts 2.5 from 1.4, and checks the sign of the result. If it is negative, the first number is less than the second. We aren't actually treating `bc`'s output as a number; we're treating it as a string, and only looking at the first character.

Legacy (Bourne) version:
{{{
# Bourne
case "`echo "1.4 - 2.5" | bc`" in
  -*) echo "1.4 is less than 2.5";;
esac
}}}

[[AWK]] can be used for calculations, too:
{{{
$ awk 'BEGIN {printf "%.3f\n", 10 / 3}'
3.333
}}}

There is a subtle but important difference between the {{{bc}}} and the {{{awk}}} solution here: {{{bc}}} reads commands and expressions from ''standard input''. {{{awk}}} on the other hand evaluates the expression as ''part of the program''. Expressions on standard input are ''not'' evaluated, i.e. {{{echo 10/3 | awk '{print $0}'}}} will print {{{10/3}}} instead of the evaluated result of the expression.

ksh93 and zsh have support for non-integers in shell arithmetic. Newer versions of ksh93 additionally have support for all C99 math.h functions {{{sin()}}} or {{{cos()}}} as well as user-defined math functions callable using C syntax. So many of these calculations can be done natively in ksh:
{{{
# ksh93/zsh
$ LC_NUMERIC=C; echo "$((3.00000000000/7))"
0.428571428571428571
}}}

(ksh93 is sensitive to locale. A dotted decimal used in locales where the decimal separator character is not ''dot'' will fail, like in German, Spanish, French locales...).

Comparing two non-integer numbers for ''equality'' is potentially an unwise thing to do. Similar calculations that are mathematically equivalent and which you would expect to give the same result on paper may give ever-so-slightly-different non-integer numeric results due to rounding/truncation and other issues. If you wish to determine whether two non-integer numbers are "the same", you may either:

 * Round them both to a desired level of precision, and then compare the rounded results for equality; or
 * Subtract one from the other and compare the absolute value of the difference against an ''epsilon'' value of your choice.
 * Be sure to output adequate precision to fully express the actual value. Ideally, use [[http://www.exploringbinary.com/hexadecimal-floating-point-constants/|hex float literals]], which are supported by Bash.
Line 6: Line 82:
    $ echo $((10/3))
    3
 $ ksh -c 'LC_NUMERIC=C printf "%-20s %f %.20f %a\n" "error accumulation:" .1+.1+.1+.1+.1+.1+.1+.1+.1+.1{,,} constant: 1.0{,,}'
error accumulation: 1.000000 1.00000000000000000011 0x1.0000000000000002000000000000p+0
constant: 1.000000 1.00000000000000000000 0x1.0000000000000000000000000000p+0
Line 10: Line 87:
For better precision, an external program must be used, e.g. {{{bc}}}, {{{awk}}} or {{{dc}}}:
One of the very few things that Bash actually ''can'' do with non-integer numbers is round them, using `printf`:
Line 13: Line 89:
    $ echo "scale=3; 10/3" | bc
    3.333
# Bash 3.1
# See if a and b are close to each other.
# Round each one to two decimal places and compare results as strings.
a=3.002 b=2.998
printf -v a1 %.2f "$a"
printf -v b1 %.2f "$b"
if [[ $a1 = "$b1" ]]; then
    echo 'a and b are roughly the same'
fi
Line 17: Line 100:
The "scale=3" command notifies {{{bc}}} that three digits of precision after the decimal point are required.

If you are trying to compare floating point numbers, be aware that a simple ''x < y'' is not supported by all versions of {{{bc}}}. Alternatively, you could use this:
Many problems that look like non-integer arithmetic can in fact be solved using integers only, and thus do not require these tools -- e.g., problems dealing with rational numbers. For example, to check whether two numbers {{{x}}} and {{{y}}} are in a ratio of 4:3 or 16:9 you may use something along these lines:
Line 22: Line 102:
    if [[ $(bc <<< "1.4 - 2.5") = -* ]]; then
        echo "1.4 is less than 2.5."
    fi
# Bash
# Variables x and y are integers
if (( (x * 9 - y * 16) == 0 )) ; then
   echo 16:9.
elif (( (x * 3 - y * 4) == 0 )) ; then
   echo 4:3.
else
   echo 'Neither 16:9 nor 4:3.'
fi
Line 27: Line 113:
This example substracts 2.5 from 1.4, and checks the sign of the result. If it is negative, the former number is less than the latter. A more elaborate test could tell if the ratio is closest to 4:3 or 16:9 without using non-integer arithmetic. Note that this very simple example that apparently involves non-integer numbers and division is solved with integers and no division. If possible, it's usually more efficient to convert your problem to integer arithmetic than to use non-integer arithmetic.
Line 29: Line 115:
{{{awk}}} can be used for calculations, too:

{{{
    $ awk 'BEGIN {printf "%.3f\n", 10 / 3}' /dev/null
    3.333
}}}

There is a subtle but important difference between the {{{bc}}} and the {{{awk}}} solution here: {{{bc}}} reads commands and expressions ''from standard input''. {{{awk}}} on the other hand evaluates the expression as ''part of the program''. Expressions on standard input are ''not'' evaluated, i.e. {{{echo 10/3 | awk '{print $0}'}}} will print {{{10/3}}} instead of the evaluated result of the expression.

This explains why the example uses {{{/dev/null}}} as an input file for {{{awk}}}: the program evaluates the {{{BEGIN}}} action, evaluating the expression and printing the result. Afterwards the work is already done: it reads its standard input, gets an end-of-file indication, and terminates. If no file had been specified, {{{awk}}} would wait for data on standard input.

Newer versions of KornShell93 have built-in floating point arithmetic, together with mathematical functions like {{{sin()}}} or {{{cos()}}} .
----
CategoryShell

How can I calculate with floating point numbers instead of just integers?

BASH's builtin arithmetic uses integers only:

$ echo "$((10 / 3))"
3

For most operations involving non-integer numbers, an external program must be used, e.g. bc, AWK or dc:

$ echo 'scale=3; 10/3' | bc
3.333

The "scale=3" command notifies bc that three digits of precision after the decimal point are required.

Same example with dc (reverse polish calculator, lighter than bc):

$ echo '3 k 10 3 / p' | dc
3.333

k sets the precision to 3, and p prints the value of the top of the stack with a newline. The stack is not altered, though.

If you are trying to compare non-integer numbers (less-than or greater-than), and you have GNU bc, you can do this:

# Bash and GNU bc
if (( $(bc <<<'1.4 < 2.5') )); then
  echo '1.4 is less than 2.5.'
fi

However, x < y is not supported by all versions of bc:

# HP-UX 10.20.
imadev:~$ bc <<<'1 < 2'
syntax error on line 1,

If you want to be portable, you need something more subtle:

# POSIX
case $(echo '1.4 - 2.5' | bc) in
  -*) echo '1.4 is less than 2.5';;
esac

This example subtracts 2.5 from 1.4, and checks the sign of the result. If it is negative, the first number is less than the second. We aren't actually treating bc's output as a number; we're treating it as a string, and only looking at the first character.

Legacy (Bourne) version:

# Bourne
case "`echo "1.4 - 2.5" | bc`" in
  -*) echo "1.4 is less than 2.5";;
esac

AWK can be used for calculations, too:

$ awk 'BEGIN {printf "%.3f\n", 10 / 3}'
3.333

There is a subtle but important difference between the bc and the awk solution here: bc reads commands and expressions from standard input. awk on the other hand evaluates the expression as part of the program. Expressions on standard input are not evaluated, i.e. echo 10/3 | awk '{print $0}' will print 10/3 instead of the evaluated result of the expression.

ksh93 and zsh have support for non-integers in shell arithmetic. Newer versions of ksh93 additionally have support for all C99 math.h functions sin() or cos() as well as user-defined math functions callable using C syntax. So many of these calculations can be done natively in ksh:

# ksh93/zsh
$ LC_NUMERIC=C; echo "$((3.00000000000/7))"
0.428571428571428571

(ksh93 is sensitive to locale. A dotted decimal used in locales where the decimal separator character is not dot will fail, like in German, Spanish, French locales...).

Comparing two non-integer numbers for equality is potentially an unwise thing to do. Similar calculations that are mathematically equivalent and which you would expect to give the same result on paper may give ever-so-slightly-different non-integer numeric results due to rounding/truncation and other issues. If you wish to determine whether two non-integer numbers are "the same", you may either:

  • Round them both to a desired level of precision, and then compare the rounded results for equality; or
  • Subtract one from the other and compare the absolute value of the difference against an epsilon value of your choice.

  • Be sure to output adequate precision to fully express the actual value. Ideally, use hex float literals, which are supported by Bash.

 $ ksh -c 'LC_NUMERIC=C printf "%-20s %f %.20f %a\n" "error accumulation:" .1+.1+.1+.1+.1+.1+.1+.1+.1+.1{,,} constant: 1.0{,,}'
error accumulation:  1.000000 1.00000000000000000011 0x1.0000000000000002000000000000p+0
constant:            1.000000 1.00000000000000000000 0x1.0000000000000000000000000000p+0

One of the very few things that Bash actually can do with non-integer numbers is round them, using printf:

# Bash 3.1
# See if a and b are close to each other.
# Round each one to two decimal places and compare results as strings.
a=3.002 b=2.998
printf -v a1 %.2f "$a"
printf -v b1 %.2f "$b"
if [[ $a1 = "$b1" ]]; then
    echo 'a and b are roughly the same'
fi

Many problems that look like non-integer arithmetic can in fact be solved using integers only, and thus do not require these tools -- e.g., problems dealing with rational numbers. For example, to check whether two numbers x and y are in a ratio of 4:3 or 16:9 you may use something along these lines:

# Bash
# Variables x and y are integers
if (( (x * 9 - y * 16) == 0 )) ; then
   echo 16:9.
elif (( (x * 3 - y * 4) == 0 )) ; then
   echo 4:3.
else
   echo 'Neither 16:9 nor 4:3.'
fi

A more elaborate test could tell if the ratio is closest to 4:3 or 16:9 without using non-integer arithmetic. Note that this very simple example that apparently involves non-integer numbers and division is solved with integers and no division. If possible, it's usually more efficient to convert your problem to integer arithmetic than to use non-integer arithmetic.


CategoryShell

BashFAQ/022 (last edited 2021-09-01 06:31:58 by geirha)