DragonFly On-Line Manual Pages
BC(1) DragonFly General Commands Manual BC(1)
NAME
bc - arbitrary-precision arithmetic language and calculator
SYNOPSIS
bc [-cl] [-e expression] [file ...]
DESCRIPTION
bc is an interactive processor for a language which resembles C but
provides unlimited precision arithmetic. It takes input from any
expressions on the command line and any files given, then reads the
standard input.
Options available:
-c bc is actually a preprocessor for dc(1), which it invokes
automatically, unless the -c (compile only) option is present.
In this case the generated dc(1) instructions are sent to the
standard output, instead of being interpreted by a running dc(1)
process.
-e expression
Evaluate expression. If multiple -e options are specified, they
are processed in the order given, separated by newlines.
-l Allow specification of an arbitrary precision math library. The
definitions in the library are available to command line
expressions.
The syntax for bc programs is as follows: `L' means letter a-z; `E' means
expression; `S' means statement. As a non-portable extension, it is
possible to use long names in addition to single letter names. A long
name is a sequence starting with a lowercase letter followed by any
number of lowercase letters and digits. The underscore character (`_')
counts as a letter.
Comments
are enclosed in /* and */
are enclosed in # and the next newline
The newline is not part of the line comment, which in itself is a non-
portable extension.
Names
simple variables: L
array elements: L [ E ]
The words `ibase', `obase', and `scale'
The word `last' or a single dot
Other operands
arbitrarily long numbers with optional sign and decimal point
( E )
sqrt ( E )
length ( E ) number of significant decimal digits
scale ( E ) number of digits right of decimal point
L ( E , ... , E )
The sequence `\<newline><whitespace>' is ignored within numbers.
Operators
The following arithmetic and logical operators can be used. The
semantics of the operators is the same as in the C language. They are
listed in order of decreasing precedence. Operators in the same group
have the same precedence.
Operator Associativity Description
++ -- none increment, decrement
- none unary minus
^ right power
* / % left multiply, divide, modulus
+ - left plus, minus
= += -= *= /= %= ^= right assignment
== <= >= != < > none relational
! none boolean not
&& left boolean and
|| left boolean or
Note the following:
* The relational operators may appear in any expression. The
IEEE Std 1003.2 ("POSIX.2") standard only allows them in the
conditional expression of an `if', `while' or `for' statement.
* The relational operators have a lower precedence than the
assignment operators. This has the consequence that the
expression a = b < c is interpreted as (a = b) < c, which is
probably not what the programmer intended.
* In contrast with the C language, the relational operators all
have the same precedence, and are non-associative. The
expression a < b < c will produce a syntax error.
* The boolean operators (!, && and ||) are non-portable
extensions.
* The boolean not (!) operator has much lower precedence than the
same operator in the C language. This has the consequence that
the expression !a < b is interpreted as !(a < b). Prudent
programmers use parentheses when writing expressions involving
boolean operators.
Statements
E
{ S ; ... ; S }
if ( E ) S
if ( E ) S else S
while ( E ) S
for ( E ; E ; E ) S
null statement
break
continue
quit
a string of characters, enclosed in double quotes
print E ,..., E
A string may contain any character, except a double quote. The if
statement with an else branch is a non-portable extension. All three E's
in a for statement may be empty. This is a non-portable extension. The
continue and print statements are also non-portable extensions.
The print statement takes a list of comma-separated expressions. Each
expression in the list is evaluated and the computed value is printed and
assigned to the variable `last'. No trailing newline is printed. The
expression may also be a string enclosed in double quotes. Within these
strings the following escape sequences may be used: `\a' for bell
(alert), `\b' for backspace, `\f' for formfeed, `\n' for newline, `\r'
for carriage return, `\t' for tab, `\q' for double quote and `\\' for
backslash. Any other character following a backslash will be ignored.
Strings will not be assigned to `last'.
Function definitions
define L ( L ,..., L ) {
auto L, ... , L
S; ... S
return ( E )
}
As a non-portable extension, the opening brace of the define statement
may appear on the next line. The return statement may also appear in the
following forms:
return
return ()
return E
The first two are equivalent to the statement "return 0". The last form
is a non-portable extension. Not specifying a return statement is
equivalent to writing "return (0)".
Functions available in the math library, which is loaded by specifying
the -l flag on the command line
s(x) sine
c(x) cosine
e(x) exponential
l(x) log
a(x) arctangent
j(n,x) Bessel function
All function arguments are passed by value.
The value of a statement that is an expression is printed unless the main
operator is an assignment. The value printed is assigned to the special
variable `last'. This is a non-portable extension. A single dot may be
used as a synonym for `last'. Either semicolons or newlines may separate
statements. Assignment to scale influences the number of digits to be
retained on arithmetic operations in the manner of dc(1). Assignments to
ibase or obase set the input and output number radix respectively.
The same letter may be used as an array, a function, and a simple
variable simultaneously. All variables are global to the program.
`Auto' variables are pushed down during function calls. When using
arrays as function arguments or defining them as automatic variables,
empty square brackets must follow the array name.
For example
scale = 20
define e(x){
auto a, b, c, i, s
a = 1
b = 1
s = 1
for(i=1; 1==1; i++){
a = a*x
b = b*i
c = a/b
if(c == 0) return(s)
s = s+c
}
}
defines a function to compute an approximate value of the exponential
function and
for(i=1; i<=10; i++) e(i)
prints approximate values of the exponential function of the first ten
integers.
$ bc -l -e 'scale = 500; 2 * a(2^10000)' -e quit
prints an approximation of pi.
FILES
/usr/share/misc/bc.library math library, read when the -l option is
specified on the command line.
SEE ALSO
dc(1)
Lorinda Cherry and Robert Morris, "BC - An Arbitrary Precision Desk-
Calculator Language", 4.4BSD Users's Supplementary Documents (USD).
STANDARDS
The bc utility is compliant with the IEEE Std 1003.1-2004 ("POSIX.1")
specification.
The flags [-ce] are extensions to that specification.
HISTORY
The bc command first appeared in Version 6 AT&T UNIX. A complete rewrite
of the bc command first appeared in OpenBSD 3.5.
AUTHORS
The original version of the bc command was written by Robert Morris and
Lorinda Cherry. The current version of the bc utility was written by
Otto Moerbeek.
BUGS
`Quit' is interpreted when read, not when executed.
Some non-portable extensions, as found in the GNU version of the bc
utility are not implemented (yet).
DragonFly 5.9-DEVELOPMENT November 14, 2009 DragonFly 5.9-DEVELOPMENT