bc [ lwsqv ] [longoptions] [ file ... ]
bc
supports arbitrary precision numbers with interactive execution of statements,
starts executing code from files on the command line, then reads from the standard input.
warn w  Give warnings for extensions to POSIX bc. 
standard s  POSIX 
quiet q  Do not print the welcome.
bc 1.06 Copyright 19911994, 1997, 1998, 2000 Free Software Foundation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type `warranty'. 
version v  Display version number, short copyright and quits, see warranty. 
mathlib l  Set scale=20 Define the math library.

In .profile
set up alias bc='/usr/bin/bc q ~/.bin/bc.ini' and
create ~/.bin/bc.ini
containing :scale=2
then echo 5/6bc
will output .83
length
: number of significant digits
scale
: number of digits after the dot. Default:0̸!1.23456
has a length of 6 and scale of 5. 1234.567
has a length of 7 and a scale of 3.
9
,A
F
. NOT lowercase, which are variables.
ibase
. (i.e. A = 10̸.)ibase
, are assigned the value of ibase
1 to each digit,num=FF8CB
assigns 99899
to num.
index23
, loop_counter
, x
[ ]
.
scale
defines how some operations use digits after the dot. Default 0̸.
0̸ to the maximum number representable by a integer. ibase
and obase
define the conversion base for input and output numbers. Default base 10.ibase
are 2 through 16. Attempting to assign a value less than 2 assigns 2 and
attempting to assign a value greater than 16 assigns 16. obase=F+1
always sets obase
to hexadecimalibase
is 16, ibase=10
_{16} sets ibase
to 16! ibase
is 2, ibase=10
_{2} sets ibase
to 2!ibase=A
always sets ibase
to 10.obase
is not automatically changed to synchronize with ibase
, obase=2;binary=9;binary
will display 1001
!
For bases 2 through 16, the usual method of writing numbers is used.
For bases greater than 16,
a multicharacter digit method of outputing the numbers is used
where each higher base digit is printed as a base 10 number.
The multicharacter digits are separated by spaces. Each digit
contains the number of characters required to represent the base ten value of "obase1
".
last
has the value of the last output number. (extension)
history
size of readline history, 1 max, not retaind across sesssions.
/*
and */
surround a comment, may start anywhere, appear as a single space in the input,
delimit other input items, can include any newlines (end of line) but can not be in the middle of a variable name .#
begins a comment which continues to the end of line. The endofline character is not part of the comment and is processed normally.
ibase.
(There is an exception in functions.) scale
. expr
refers to a complete expression and var
refers to a simple or an array variable.
A simple variable is a name and an array variable is specified as name[expr]
The scale of the result is the maximum scale of the expressions involved, unless specifically mentioned.
 expr  negation of expr .

++var  incremented by one, the new value is the result of the expression. 
var  decremented by one, the new value is the result of the expression. 
var++  The result of the expression is the value of var , then var is incremented by one. 
var  The result of the expression is the value of var , then var is decremented by one. 
expr + expr  sum 
expr  expr  difference 
expr * expr  product 
expr / expr  divide. The scale of the result is scale !

expr1 % expr2  remainder computed by:

exprn ^ Iexprx  exprn raised to the integer Iexprx . The scale of the result is scale if the exponent is negative. If the exponent is positive the scale of the result is the minimum of the scale of the first expression times the value of the exponent and the maximum of scale and the scale of the first expression. (e.g. scale(a^b) = min(scale(a)*b, max( scale, scale(a))).) exprn^0 returns 1

( expr )  alters precedence 
var = expr  assignment 
var op= expr example: sum += entry  equivalent to "var = var op expr" with the exception
that the "var" part is evaluated only once. This can make a difference if "var" is an array.

Relational expressions may appear in any legal expression.
(POSIX bc requires that relational expressions are used only in if, while, and for statements and that only one relational test may be done in them.)
Relational operators  
result is 1 (true) if  
expr1 < expr2  expr1 is strictly less than expr2. 
expr1 <= expr2  expr1 is less than or equal to expr2. 
expr1 > expr2  expr1 is strictly greater than expr2. 
expr1 >= expr2  expr1 is greater than or equal to expr2. 
 expr1 is equal to expr2. 
 expr1 is not equal to expr2. 
Boolean operators (POSIX bc does NOT have boolean operations).  
!expr  if expr is 0. 
expr && expr  both expressions are nonzero. 
expr  expr  either expression is nonzero. 
The expression precedence is: (HIGHEST to lowest)
++ and   nonassociative  
unary   nonassociative 

^  right associative  
* / and %  left associative  
+ and   left associative  
assignment ^{†}  right associative ^{†}  
relational^{†}  left associative ^{†}  
!  nonassociative  
&&  left associative  
  left associative (lowest precedence) 
Using relational and logical operators with assignment expressions evaluate differently than many other languages.
Consider the expression:
a = 3 < 5
This assigns the value 3 to a
and then compare 3 to 5.
Most C programmers would expect this would assign the result of "3 < 5"
(the value 1true) to a
.
Use parenthesis when using relational and logical operators with the assignment operators.
The standard functions are:
read ( )  will read a number from the
standard input, regardless of where the function occurs. The value is the number read from the standard input using the current value of the variable ibase for the conversion base. Beware, this can cause problems with the mixing of data and program in the standard input. The best use for this function is in a previously written program that needs input from the user, but never allows program code to be input from the user. (an extension) 
 number of significant digits in the expression. 
scale ( expression )  number of digits after the dot in the expression (same as special variable scale ).scale=5 1/2 .50000 scale(1/2) 5 scale(1/3) 5 scale(.5) 1 
sqrt ( expression )  square root. If the expression is negative, a run time error is generated.Runtime error (func=(main), adr=4): Square root of a negative number 
\
,
(where  is the newline) appears as whitespace instead of a newline. []
) .
expression 
 
string  string is output. Strings start with a quote and contain all characters until the next
quote character. All characters are take literally, including any newline. No newline is output after the string.  
print list  provides another method of output. The "list" is a list of strings and expressions separated by commas. Each string or expression is printed in the order of the list. No terminating newline is printed. Expressions are evaluated and their value is printed and assigned the the variable last. Strings in the print statement are printed to the output and may contain special characters. Special characters start with the backslash character (\). The special char acters recognized by bc are "a" (alert or bell), "b" (backspace), "f" (form feed), "n" (newline), "r" (carriage return), "q" (double quote), "t" (tab), and "\" (backslash). Any other character following the backslash will be ignored. (an extension)  
{ statement_list }  
This is the compound statement. It allows multiple statements
to be grouped together for execution.  
if ( expression ) statement1 [else statement2]
 
evaluates the expression and executes statement1 or statement2 depending on the value of the expression. If the expression is nonzero, statement1 is executed. If statement2 is present and the value of the expression is 0, then statement2 is executed. (The else clause is an extension.)  
while ( expression ) statement  
execute statement while the expression is nonzero. It evaluates the expression before each execution of the statement. Termination of the loop is caused by
a zero expression value or the execution of a break statement.  
for ( [expression1] ; [expression2] ; [expression3] ) statement
 
controls repeated execution of statement. Expression1 is evaluated before the loop. Expression2 is evaluated before each execution of the statement, if nonzero, statement is evaluated. If it is zero, the loop is terminated. After each execution of the statement, expression3 is
evaluated before the reevaluation of expression2. If expression1 or expression3 are missing, nothing is evaluated at the point they would be evaluated. If expression2 is missing, it is the same as substituting the value 1 for expression2. (The optional expressions are an extension. POSIX bc requires all three expressions.) The following is equivalent code for the for statement:  
break  exits the most recent enclosing while or for .  
continue  causes the most recent
enclosing for statement to start the next iteration. (an extension)  
halt  causes bc to quit Note: if (0 == 1) halt will not cause bc to terminate
because the halt is not executed. (an extension)  
 Return the value of the expression from a function default 0̸ . (See functions.)
 
PSEUDO STATEMENTS Are not executed statements, performed at "compile" (i.e. as they are entered) time.  

limits  limits of the local version . an extension. BC_BASE_MAX = 2147483647 BC_DIM_MAX = 65535 BC_SCALE_MAX = 2147483647 BC_STRING_MAX = 2147483647 MAX Exponent = 9223372036854775807 Number of vars = 32767  
quit  
warranty  outputs version and a long nonwarranty notice. an extension. 
Return
statements cause the termination of a function and the return of a value default being 0.
A function is defined as :define name ( [parameters] ) { 
auto_list statement_list }
A function call is of the form "name(parameters)
".
Parameters can be numbers or arrays. Numbers are call by value . Arrays
are only call by variable. Arrays are specified in the parameter definition by the notation "name[]
". In the function call, parameters are full expressions for number parameters. The same notation is
used for passing arrays as for defining array parameters. The named
array is passed by variable to the function.
Normally variables are global i.e. function B can access variables in the main as well as in function A.
The auto_list is a list of variables that are for "local"
use. The syntax of the auto list is "auto name, … ;
".
Auto variables have their current values pushed onto a stack at
the start of the function, initialized to zero
and used throughout the execution of the function. At function exit,
these variables are popped so that the original value (at the time of
the function call) of these variables are restored. ( The parameters are
auto variables that are initialized to a value provided in the
function call.) Auto variables are different than traditional local
variables in the fact that if function A calls function B, B may access
function A's auto variables by just using the same name, unless
function B has called them auto variables. Due to the fact that auto
variables and parameters are pushed onto a stack, bc supports recursive functions.
Functions change the usage of the variable ibase
. All constants
in the function body will be converted using the value of ibase
at the
time of the function call. Changes of ibase
will be ignored during the
execution of the function except for the standard function read()
, which
will always use the current value of ibase
for conversion of numbers.
Function definitions are "dynamic" i.e a function is undefined until a definition is encountered in the input.
That definition is then used until another definition function for the
same name is encountered. The new definition then replaces the older definition.
l
, a math library is preloaded and
the default scale
is set to 20. s (r)
sine of r, r is in radians. c (r)
cosine of r, r is in radians. a (x)
arctangent of x, arctangent returns radians. l (x)
natural logarithm of x. e (x)
exponential function of raising e to the value x. j (n,x)
bessel function of integer order n of x. pi
using acrtan of 1.
The exponential function used in the math library, written in POSIX bc.
scale = 20 /* Uses the fact that e^x = (e^(x/2))^2 When x is small enough, we use the series: e^x = 1 + x + x^2/2! + x^3/3! + ...
*/ define e(x) { auto a, d, e, f, i, m, v, z /* Check the sign of x. */ if (x<0) { m = 1 x = x } /* Precondition x. */ z = scale; scale = 4 + z + .44*x; while (x > 1) { f += 1; x /= 2; } /* Initialize the variables. */ v = 1+x a = x d = 1 for (i=2; 1; i++) { e = (a *= x) / (d *= i) if (e == 0) { if (f>0) while (f) v = v*v; scale = z if (m) return (1/v); return (v/1); } v += e } }
scale=2 print "\nCheck book program!\n" print " Remember, deposits are negative transactions.\n" print " Exit by a 0 transaction.\n\n" print "Initial balance? "; bal = read() bal /= 1 print "\n" while (1) { "current balance = "; bal "transaction? "; trans = read() if (trans == 0) break; bal = trans bal /= 1 } quitThe following is the definition of the recursive factorial function.
define f (x) { if (x <= 1) return (1); return (f(x1) * x); }
history
is the number of lines of
history retained. The default, 1 unlimited, 0 disables the history.
Differences & extensions
A single process which parses and runs a byte code translation of the program. Option c outputs the byte code, for debugging the parser and preparing the math library.  
LANG  not conform POSIX processing of the LANG environment variable and all environment
variables starting with LC_ . 
names  Traditional and POSIX bc have single letter names for functions,
variables and arrays. They have been extended to be multicharacter names that start with a letter and may contain letters,
numbers and the underscore character. 
Strings  Strings are not allowed to contain NUL characters. POSIX: all characters must be included in strings. 
last  POSIX bc does not have a last variable. Some implementations use the period (.) .

comparisons 
POSIX allows comparisons only in the if and while
statements, and the second expression of the for statement. Only one relational operation is allowed in each of those statements. 
if statement, else clause  POSIX bc does not have an else clause. 
for statement  POSIX bc requires all expressions to be present in the for statement. 
&&, , !  POSIX bc does not have logical operators. , read function, print or continue statement 
array parameters  POSIX bc does not (currently) support array parameters in full. The POSIX grammar allows for arrays in function definitions, but does not provide a method to specify an array as a parameter. Traditional implementations of bc have only call by value array parameters. 
=+, =, =*, =/, =%, =^ 
POSIX bc does not require these "old style" assignment operators
to be defined. This version may allow these "old style" assignments. Use the limits statement to see if the installed version
supports them. If it does support the "old style" assignment
operators, the statement "a = 1" will decrement a by 1 instead of setting a to the value 1. 
spaces in numbers  Not allowed. In some implementations, "x=1 3" assigns 13 to x. 
errors and execution 
The code will be executed when syntax and other errors are found in the program. If a syntax error is found in a function definition, error recovery tries to find the beginning of a statement and continue to parse the function. Once a syntax error is found in the function, the function will not be callable and becomes undefined. Syntax errors in the interactive execution code will invalidate the current execution block. The execution block is terminated by an end of line that appears after a complete sequence of statements. For example, a = 1 b = 2has two execution blocks and { a = 1 b = 2 }has one execution block. Any runtime error will terminate the execution of the current execution block. A runtime warning will not terminate the current execution block. 
limits
statment:
BC_BASE_MAX = 2147483647 0x7FFFFFF BC_DIM_MAX = 65535 BC_SCALE_MAX = 2147483647 BC_STRING_MAX = 2147483647 MAX Exponent = 9223372036854775807 Number of vars = 32767
BC_BASE_MAX  maximum output base is currently set at 999. The maximum input base is 16. 
BC_DIM_MAX  arbitrary limit of 65535 as distributed. 
BC_SCALE_MAX  number of digits after the dot is limited to INT_MAX digits.
The number of digits before the dot is limited to INT_MAX digits.

BC_STRING_MAX  limit on the number of characters in a string is INT_MAX characters. 
exponent  value of the exponent in the raise operation (^) is limited to LONG_MAX. 
multiply  multiply routine may yield incorrect results if a number has more than LONG_MAX / 90 total digits. For 32 bit longs, this number is 23,860,929 digits. 
code size  Each function and the "main" program are limited to 16384 bytes of compiled byte code each. BC_MAX_SEGS can be changed to have more than 16 segments of 1024 bytes. 
variable names  unique names for each of simple variables, arrays and functions. 
POSIXLY_CORRECT  same as s

BC_ENV_ARGS
Format is the same as the command line arguments. These arguments are processed first, so any files listed in the environent arguments
are processed before any command line argument files. This
allows the user to set up "standard" options and files to be
processed at every invocation. Files in the environment variables typically contain frequently used, custom function definitions.  
BC_LINE_LENGTH
Length of an output line for numbers. includes the backslash and new line characters for long numbers. 
/usr/local/lib/libmath.b.
may be /lib/libmath.b.
)