bc is "an arbitrary precision calculator
language" with syntax similar to the C
programming language. It is generally used by typing the
command bc
on a Unix
command prompt and entering a mathematical
expression, such as (1 + 3) * 2, whereupon 8 will
be output.
There are currently two main dialects: the rigorously defined POSIX bc, and its direct descendant, the much expanded GNU bc (also, GNU bc is available for a wider range of platforms, such as Microsoft Windows). A more recent dialect, Plan 9 bc, is a superset of the former and subset of the latter.
All three forms of bc can be executed as either a mathematical scripting language or as an interactive mathematical shell.
Contents 
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,
(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 arbitrary precision 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.
The following POSIX bc operators behave exactly like their C counterparts:
+  * /
+= = *= /=
++  < >
== != <= >=
( ) [ ] { }
The modulus operators:
% %=
... behave exactly like their C counterparts only when the
global scale
variable is set to 0,
i.e. all calculations are integeronly. When
scale
is greater than 0 the modulus
is calculated relative to the smallest positive value greater than
zero.
The operators:
^ ^=
... resemble the C bitwise exclusiveor operators, but are in fact the bc integer exponentiation operators.
The bitwise, boolean and conditional operators:
&  ^ &&  ^^
&= = ^= &&= = ^^=
<< >>
<<= >>=
?:
... are not available in POSIX bc.
The sqrt()
function for
calculating square
roots is POSIX bc's only builtin mathematical function. Other
functions are available in an external standard library.
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.
Please, note that the scale changes with the l option to 20 (source). So things such as modulo may work unexpectedly. For example, write "bc l" and then the command "print 3%2" outputs 0, instead of 1. But if you do it like "bc l", "scale=0" and then the command "print 3%2" has 1 as output.
Plan 9 bc is just like POSIX bc but for an additional
print
statement.
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.
The following logical operators are additional to those in POSIX bc:
&&  !
... and 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.
All functions available in GNU bc are inherited from POSIX. No further functions are provided as standard with the GNU distribution.
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 floating point
exponent. Both of the below assume the standard library has been
included:
/* 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) ) ) }
# A function to return the integer part of a number define int(number) { auto oldscale oldscale = scale scale = 0 number /= 1 /* round number down */ scale = oldscale return number } # Use the fact that number^exponent == e^(exponent*log(number)) define power(number,exponent) { if (exponent == int(exponent)) { return number ^ exponent } else { return e( exponent * l(number) ) } }
$ bc l q scale = 10000; (12*a(1/49)+32*a(1/57)5*a(1/239)+12*a(1/110443))*4
Because the syntax of bc is very similar to that of C, published algorithms 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 a few minutes of work, this can be translated to the following GNU bc code:
define normal(x) { auto s,t,b,q,i,const; const=0.5*l(8*a(1)); s=x; t=0; b=x; q=x*x; i=1; while(s!=t) {s=(t=s)+(b*=q/(i+=2))}; return .5+s*e(.5*qconst); }
bc can be used noninteractively, with input via 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

