bc (programming language)
Developer(s)  Robert Morris and Lorinda Cherry of Bell Labs 

Initial release  1975, 48–49 years ago 
Operating system  Unix, Unixlike, Plan 9, FreeDOS 
Platform  Crossplatform 
Type  Command 
bc, for basic calculator, is "an arbitraryprecision calculator language" with syntax similar to the C programming language. bc is typically used as either a mathematical scripting language or as an interactive mathematical shell.
Overview
A typical interactive usage is typing the command bc
on a Unix command prompt and entering a mathematical expression, such as (1 + 3) * 2
, whereupon 8 will be output. While bc can work with arbitrary precision, it actually defaults to zero digits after the decimal point, so the expression 2/3
yields 0 (results are truncated, not rounded). This can surprise new bc users unaware of this fact. The l
option to bc sets the default scale (digits after the decimal point) to 20 and adds several additional mathematical functions to the language.
History
bc first appeared in Version 6 Unix in 1975. It was written by Lorinda Cherry of Bell Labs as a front end to dc, an arbitraryprecision calculator written by Robert Morris and Cherry. dc performed arbitraryprecision computations specified in reverse Polish notation. bc provided a conventional programminglanguage interface to the same capability via a simple compiler (a single yacc source file comprising a few hundred lines of code), which converted a Clike syntax into dc notation and piped the results through dc.
In 1991, POSIX rigorously defined and standardized bc. Three implementations of this standard survive today: The first is the traditional Unix implementation, a frontend to dc, which survives in Unix and Plan 9 systems. The second is the free software GNU bc, first released in 1991 by Philip A. Nelson. The GNU implementation has numerous extensions beyond the POSIX standard and is no longer a frontend to dc (it is a bytecode interpreter). The third is a reimplementation by OpenBSD in 2003.
Implementations
POSIX bc
The POSIX standardized bc language is traditionally written as a program in the dc programming language to provide a higher level of access to the features of the dc language without the complexities of dc's terse syntax.
In this form, the bc language contains singleletter variable, array and function names and most standard arithmetic operators, as well as the familiar controlflow constructs (if(cond)...
, while(cond)...
and for(init;cond;inc)...
) from C. Unlike C, an if
clause may not be followed by an else
.
Functions are defined using a define
keyword, and values are returned from them using a return
followed by the return value in parentheses. The auto
keyword (optional in C) is used to declare a variable as local to a function.
All numbers and variable contents are arbitraryprecision numbers whose precision (in decimal places) is determined by the global scale
variable.
The numeric base of input (in interactive mode), output and program constants may be specified by setting the reserved ibase
(input base) and obase
(output base) variables.
Output is generated by deliberately not assigning the result of a calculation to a variable.
Comments may be added to bc code by use of the C /*
and */
(start and end comment) symbols.
Mathematical operators
Exactly as C
The following POSIX bc operators behave exactly like their C counterparts:
+  * / += = *= /= ++  < > == != <= >= ( ) [ ] { }
Similar to C
The modulus operators, %
and %=
behave exactly like their C counterparts only when the global scale
variable is set to 0, i.e. all calculations are integeronly. Otherwise the computation is done with the appropriate scale. a%b
is defined as a(a/b)*b
. Examples:
$ bc bc 1.06 Copyright 19911994, 1997, 1998, 2000 Free Software Foundation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. scale=0; 5%3 2 scale=1; 5%3 .2 scale=20; 5%3 .00000000000000000002
Conflicting with C
The operators
^ ^=
superficially resemble the C bitwise exclusiveor operators, but are in fact the bc integer exponentiation operators.
Of particular note, the use of the ^
operator with negative numbers does not follow the C operator precedence. 2^2
gives the answer of 4 under bc rather than −4.
"Missing" operators relative to C
The bitwise, boolean and conditional operators:
&  ^ &&  &= = ^= &&= = << >> <<= >>= ?:
are not available in POSIX bc.
Builtin functions
The sqrt()
function for calculating square roots is POSIX bc's only builtin mathematical function. Other functions are available in an external standard library.
The scale()
function for determining the precision (as with the scale
variable) of its argument and the length()
function for determining the number of significant decimal digits in its argument are also builtin.
Standard library functions
bc's standard math library (defined with the l option) contains functions for calculating sine, cosine, arctangent, natural logarithm, the exponential function and the two parameter Bessel function J. Most standard mathematical functions (including the other inverse trigonometric functions) can be constructed using these. See external links for implementations of many other functions.
bc command  Function  Description 

s(x)

Sine  Takes x, an angle in radians 
c(x)

Cosine  Takes x, an angle in radians 
a(x)

Arctangent  Returns radians 
l(x)

Natural logarithm  
e(x)

Exponential function  
j(n,x)

Bessel function  Returns the ordern Bessel function of x. 
The l option changes the scale to 20,^{[1]} so things such as modulo may work unexpectedly. For example, writing bc l
and then the command print 3%2
outputs 0. But writing scale=0
after bc l
and then the command print 3%2
will output 1.
Plan 9 bc
Plan 9 bc is identical to POSIX bc but for an additional print
statement.
GNU bc
GNU bc derives from the POSIX standard and includes many enhancements. It is entirely separate from dcbased implementations of the POSIX standard and is instead written in C. Nevertheless, it is fully backwards compatible as all POSIX bc programs will run unmodified as GNU bc programs.
GNU bc variables, arrays and function names may contain more than one character, some more operators have been included from C, and notably, an if
clause may be followed by an else
.
Output is achieved either by deliberately not assigning a result of a calculation to a variable (the POSIX way) or by using the added print
statement.
Furthermore, a read
statement allows the interactive input of a number into a running calculation.
In addition to Cstyle comments, a #
character will cause everything after it until the next newline to be ignored.
The value of the last calculation is always stored within the additional builtin last
variable.
Extra operators
The following logical operators are additional to those in POSIX bc:
&&  !
They are available for use in conditional statements (such as within an if
statement). Note, however, that there are still no equivalent bitwise or assignment operations.
Functions
All functions available in GNU bc are inherited from POSIX. No further functions are provided as standard with the GNU distribution.
Example code
Since the bc ^
operator only allows an integer power to its right, one of the first functions a bc user might write is a power function with a floatingpoint exponent. Both of the below assume the standard library has been included:
A "power" function in POSIX bc
/* A function to return the integer part of x */ define i(x) { auto s s = scale scale = 0 x /= 1 /* round x down */ scale = s return (x) } /* Use the fact that x^y == e^(y*log(x)) */ define p(x,y) { if (y == i(y)) { return (x ^ y) } return ( e( y * l(x) ) ) }
Calculating π to 10000 digits
Calculate pi using the builtin arctangent function, a():
$ bc lq scale=10000 4*a(1) # The atan of 1 is 45 degrees, which is pi/4 in radians. # This may take several minutes to calculate.
A translated C function
Because the syntax of bc is similar to that of C, published numerical functions written in C can often be translated into bc quite easily, which immediately provides the arbitrary precision of bc. For example, in the Journal of Statistical Software (July 2004, Volume 11, Issue 5), George Marsaglia published the following C code for the cumulative normal distribution:
double Phi(double x) { long double s=x,t=0,b=x,q=x*x,i=1; while(s!=t) s=(t=s)+(b*=q/(i+=2)); return .5+s*exp(.5*q.91893853320467274178L); }
With some necessary changes to accommodate bc's different syntax, and realizing that the constant "0.9189..." is actually log(2*PI)/2, this can be translated to the following GNU bc code:
define phi(x) { auto s,t,b,q,i,const s=x; t=0; b=x; q=x*x; i=1 while(s!=t) s=(t=s)+(b*=q/(i+=2)) const=0.5*l(8*a(1)) # 0.91893... return .5+s*e(.5*qconst) }
Using bc in shell scripts
bc can be used noninteractively, with input through a pipe. This is useful inside shell scripts. For example:
$ result=$(echo "scale=2; 5 * 7 /3;"  bc) $ echo $result 11.66
In contrast, note that the bash shell only performs integer arithmetic, e.g.:
$ result=$((5 * 7 /3)) $ echo $result 11
One can also use the herestring idiom (in bash, ksh, csh):
$ bc l <<< "5*7/3" 11.66666666666666666666
See also
References
 ↑ ^{1.0} ^{1.1} The Single UNIX Specification, Issue 7 from The Open Group : arbitraryprecision arithmetic language – Commands & Utilities Reference,
 The Single UNIX Specification, Issue 7 from The Open Group : arbitraryprecision arithmetic language – Commands & Utilities Reference,
 GNU bc manual page
 POSIX bc manual page
 Plan 9 Programmer's Manual, Volume 1 –
 7th Edition Unix bc manual page
 A comp.compilers article on the design and implementation of Cbc
 6th Edition Unix bc source code, the first release of bc, from May 1975, compiling bc syntax into dc syntax
 GNU bc source code
External links
 Dittmer, I. 1993. Error in Unix commands dc and bc for multipleprecisionarithmetic. SIGNUM Newsl. 28, 2 (Apr. 1993), 8–11.
 Collection of useful GNU bc functions
 GNU bc (and an alpha version) from the Free Software Foundation
 bc for Windows from GnuWin32
 Gavin Howard bc  another open source implementation of bc by Gavin Howard with GNU and BSD extensions
 Xbc  A Graphical User Interface to bc
 extensions.bc  contains functions of trigonometry, exponential functions, functions of number theory and some mathematical constants
 scientific_constants.bc  contains particle masses, basic constants, such as speed of light in the vacuum and the gravitational constant
Original source: https://en.wikipedia.org/wiki/Bc (programming language).
Read more 