# bc: A Handy Utility

## Embedded

by Alasdair McAndrew

Linux, as with almost all UNIX systems, contains a vast number of little utilities tucked away in such places as /usr/bin and /usr/local/bin. One of these is the GNU utility bc.

bc is an arbitrary precision calculator language. It can perform arithmetic (both integer and real) to arbitrary precision, and it supports simple programming. It is started by the command:

```bc -l files
```

The optional -l flag loads a mathematics library, and files (also optional) is a list of files containing bc commands. There are some other flags, but they do not greatly change the functionality. The mathematics library makes the following functions available to bc:

• s(x): the sine of x in radians

• c(x): the cosine of x in radians

• a(x): the inverse tangent of x (The result is returned in radians.)

• l(x): the natural logarithm of x

• e(x): the exponential function ex

• j(n,x): the Bessel function of order n of x

I used version 1.04 of GNU bc to generate all the examples below. Other versions of bc may be restricted in their capabilities.
Basic Usage

Let's look at a few examples of bc in action, assuming it has been started with the -l flag:

```2^400
2582249878086908589655919172003011874329705792829\
2235128306593565406476220168411946296453532801378\
31435903171972747493376
scale=50
pi=4*a(1)
e(pi*sqrt(163))
262537412640768743.999999999999250072597198185688\
78393709875517366778
scale=100
l(2)
.693147180559945309417232121458176568075500134360\
2552541206800094933936219696947156058633269964186\
875
```

The value scale is one of bc's internal variables: it gives the number of figures to the right of the decimal point. Other versions of bc do not allow arbitrary values for scale. We could easily use 1000 instead of 10 in the following example, if we wanted more decimal places.

```scale=10
4*a(1)
3.1415926532
```
On my computer, a Pentium 133, calculating pi to 1000 places takes about one and a half minutes to complete.

bc provides most of the standard arithmetic operations:

```scale=0
920^17%2773
948
.^157%2773
920
```

The period (.) is shorthand for the last result. The percentage sign % is the remainder function; it produces the standard integer remainder if scale is set to zero. When bc is invoked with the -l flag, the value of scale is set to 20.

Programming

Statements in bc are computed as quickly as possible. Thus, when using bc interactively, as shown above, statements are evaluated as soon as they are typed. A program in bc is simply a list of statements to be evaluated. The programming language provides loops, branches and recursion, and its syntax is similar to that of C. A simple example (from the man page) is the factorial function:

```define f(x) {
if (x <= 1) return (1);
return (x*f(x-1));
}
```

It is convenient to place such definitions in a file (called, say things.b), and read them into bc with the command:

```bc -l things.b
```
Then, the output from bc is:
```f(150)
```
```5713383956445854590478932865261054003189553578601\
1264182548375833179829124845398393126574488675311\
1453771078787468542041626662501986845044663559491\
9592206657494259209573577892932535729044496247240\
5416790722118445437122269675520000000000000000000\
000000000000000000
```
We can easily write little programs to calculate binomial coefficients:
```define b1(n,k) {
if (k==0 || k==n) return (1);
return (b1(n-1,k)+b1(n-1,k-1));
}
```
This is a rather inefficient program. The solution:
```b1(20,10)
184756
```
takes some time to compute. We can, of course, write a much faster program:
```define b2(n,k) {
auto temp
temp=1;
if (k==0) return (1);
for(i=1; i<=k; i++) temp=temp*(n+1-i)/i;
return (temp);
}
```
Here auto is a list of variables which are local to the current program. It is instructive to play with these two implementations of computing binomial coefficients: b2 gives the result almost immediately, whereas b1 is very slow for all but very small values of n and k. bc also supports arrays; here we use arrays to compute the first 100 values of Hofstadter's chaotic function:
```h=1
h=1
for (i=3;i<=100;i++)
h[i]=h[i-h[i-1]]+h[i-h[i-2]]
h
6
h
25
```
We can then print out all these values:
```for (i=1; i<=100; i++) {
print h[i],"       ";
if (i%10==0) print "\n;"
}
1    1    2    3    3    4    5    5    6    6
6    8    8    8    10   9    10   11   11   12
12   12   12   16   14   14   16   16   16   16
20   17   17   20   21   19   20   22   21   22
23   23   24   24   24   24   24   32   24   25
30   28   26   30   30   28   32   30   32   32
32   32   40   33   31   38   35   33   39   40
37   38   40   39   40   39   42   40   41   43
44   43   43   46   44   45   47   47   46   48
48   48   48   48   48   64   41   52   54   56
```
We see that bc is particularly well suited to prototyping simple numerical algorithms. To give two final examples: computing amicable numbers, and Simpson's rule for numerical integration. First, two integers are amicable if each is equal to the sum of the divisors of the other:
```scale=0
define sf(n) {
auto sum,s;
sum=1;
s=sqrt(n);
for (i=2;i<=s;i++)
if (n%i==0) sum=sum+i+n/i;
if (s*s==n) sum=sum-s;
return (sum);
}
define amicable(m) {
for (j=1;j<=m;j++)
if (sf(sf(j))==j && sf(j)!=j && j<sf(j)) print
j,"        ",sf(j),"\n";
print "Done.\n";
}
```
Then, the command amicable(2000) will list all pairs of amicable numbers, at least one of which is below 2000.

Second, Simpson's rule for numerical integration:

```define simpson(a,b,n) {
auto h,sum_even,sum_odd;
h=(b-a)/(2*n);
sum_even=0;
sum_odd=0;
for (i=1;i<=n;i++) sum_odd=sum_odd+f(a+(2*i-1)*h);
for(i=1;i<n;i++) sum_even=sum_even+f(a+2*i*h);
return ((f(a)+f(b)+4*sum_odd+2*sum_even)*h/3);
}
```

Defining a function f(x) by, say:

```define f(x) {
return (e(-(x^2)));
}
```
and then the command:
```simpson(0,1,10)
```
returns the result of Simpson's rule for the integral of f(x) between 0 and 1, using 20=2*10 subintervals. (The result is .74682418387591474980, which is correct to six decimal places.)
Conclusion

In my opinion, bc is a real find: it is small, efficient, self-contained and an extremely useful utility. It is not to be considered a replacement for a good fast programming language such as C, C++ or FORTRAN. But as a means for quickly prototyping numerical algorithms before coding them in a high-level language, it is excellent.

Resources Alasdair McAndrew lives in Melbourne, Australia, with his wife, three young children and a grumpy cat. He is a Senior Lecturer at Victoria University of Technology, where he teaches mathematics and computing. He is an enthusiastic and satisfied user of Linux, and has been since kernel 0.99; currently he is running Linux on both a desktop and a laptop. He enjoys trawling the Internet for Linux software suitable for children, and when he has time, playing the viola da gamba.