Bc (programming language)

bc, for "basic calculator" (often referred to as "bench calculator"), is "an arbitrary-precision 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 codice_1 on a Unix command prompt and entering a mathematical expression, such as , whereupon will be output. While bc can work with arbitrary precision, it actually defaults to zero digits after the decimal point, so the expression yields . This can surprise new bc users unaware of this fact. The 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 and was written by Robert Morris and Lorinda Cherry of Bell Labs. bc was preceded by dc, an earlier arbitrary-precision calculator written by the same authors. dc could do arbitrary-precision calculations, but its reverse Polish notation (RPN) syntax—much loved by many for evaluating algebraic formulas—proved inconvenient to its users when expressing flow control, and therefore bc was written as a front-end to dc. bc was a very simple compiler (a single yacc source file with a few hundred lines), which converted the new, C-like, bc syntax into dc's postfix 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 front-end 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 front-end to dc (it is a bytecode interpreter). The third is a re-implementation 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 single-letter variable, array and function names and most standard arithmetic operators, as well as the familiar control-flow constructs (codice_2, codice_3 and codice_4) from C. Unlike C, an codice_5 clause may not be followed by an codice_6.
Functions are defined using a codice_7 keyword, and values are returned from them using a codice_8 followed by the return value in parentheses. The codice_9 keyword (optional in C) is used to declare a variable as local to a function.
All numbers and variable contents are arbitrary-precision numbers whose precision (in decimal places) is determined by the global codice_10 variable.
The numeric base of input (in interactive mode), output and program constants may be specified by setting the reserved codice_11 (input base) and codice_12 (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 codice_13 and codice_14 (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, codice_15 and codice_16 behave exactly like their C counterparts only when the global codice_10 variable is set to 0, i.e. all calculations are integer-only. Otherwise the computation is done with the appropriate scale. codice_18 is defined as codice_19. Examples:
$ bc
bc 1.06
Copyright 1991-1994, 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 exclusive-or operators, but are in fact the bc integer exponentiation operators.
Of particular note, the use of the codice_20 operator with negative numbers does not follow the C operator precedence. codice_21 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.
Built-in functions.
The codice_22 function for calculating square roots is POSIX bc's only built-in mathematical function. Other functions are available in an external standard library.
The codice_23 function for determining the precision (as with the codice_10 variable) of its argument and the codice_25 function for determining the number of significant decimal digits in its argument are also built-in.
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.
The -l option changes the scale to 20, so things such as modulo may work unexpectedly. For example, writing codice_26 and then the command codice_27 outputs 0. But writing codice_28 after codice_26 and then the command codice_27 will output 1.
Plan 9 bc.
Plan 9 bc is identical to POSIX bc but for an additional codice_31 statement.
GNU bc.
GNU bc derives from the POSIX standard and includes many enhancements. It is entirely separate from dc-based 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 codice_5 clause may be followed by an codice_6.
Output is achieved either by deliberately not assigning a result of a calculation to a variable (the POSIX way) or by using the added codice_31 statement.
Furthermore, a codice_35 statement allows the interactive input of a number into a running calculation.
In addition to C-style comments, a codice_36 character will cause everything after it until the next new-line to be ignored.
The value of the last calculation is always stored within the additional built-in codice_37 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 codice_5 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 codice_20 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 floating-point 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, :
$ 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*q-const)
Using bc in shell scripts.
bc can be used non-interactively, 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 here-string idiom (in bash, ksh, csh):
$ bc -l «< "5*7/3"
11.66666666666666666666