*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->IRIX man pages -> bc (1)              


bc(1)									 bc(1)

NAME    [Toc]    [Back]

     bc	- An arbitrary precision calculator language

SYNTAX    [Toc]    [Back]

     bc	[ -lwsqvm ] [ long-options ] [	file ... ]

VERSION    [Toc]    [Back]

     This man page documents GNU bc version 1.04.

DESCRIPTION    [Toc]    [Back]

     bc	is a language that supports arbitrary precision	numbers	with
     interactive execution of statements.  There are some similarities in the
     syntax to the C programming language. A standard math library is
     available by command line option.	If requested, the math library is
     defined before processing any files.  bc starts by	processing code	from
     all the files listed on the command line in the order listed.  After all
     files have	been processed,	bc reads from the standard input.  All code is
     executed as it is read.  (If a file contains a command to halt the
     processor,	bc will	never read from	the standard input.)

     This version of bc	contains several extensions beyond traditional bc
     implementations and the POSIX draft standard.  Command line options can
     cause these extensions to print a warning or to be	rejected.  This
     document describes	the language accepted by this processor.  Extensions
     will be identified	as such.

   OPTIONS    [Toc]    [Back]

     -l	  Define the standard math library.

     -w	  Give warnings	for extensions to POSIX	bc.
	  Cannot be used in conjunction	with the -s option.

     -s	  Process exactly the POSIX bc language.

     -q	  Do not print the normal GNU bc welcome.

     -v	  Print	the version number and copyright and quit.

     -m	  Allow	multiple character variable names.
	  Cannot be used in conjunction	with the -s option.


	  Define the standard math library.

	  Give warnings	for extensions to POSIX	bc.
	  Cannot be used in conjunction	with the --standard option.

									Page 1

bc(1)									 bc(1)

	  Process exactly the POSIX bc language.

	  Do not print the normal GNU bc welcome.

	  Print	the version number and copyright and quit.

	  Allow	multiple character variable names.
	  Cannot be used in conjunction	with the --standard option.

   NUMBERS    [Toc]    [Back]
     The most basic element in bc is the number.  Numbers are arbitrary
     precision numbers.	 This precision	is both	in the integer part and	the
     fractional	part.  All numbers are represented internally in decimal and
     all computation is	done in	decimal.  (This	version	truncates results from
     divide and	multiply operations.)  There are two attributes	of numbers,
     the length	and the	scale.	The length is the total	number of significant
     decimal digits in a number	and the	scale is the total number of decimal
     digits after the decimal point.  For example:
	   .000001 has a length	of 6 and scale of 6.
	   1935.000 has	a length of 7 and a scale of 3.

   VARIABLES    [Toc]    [Back]
     Numbers are stored	in two types of	variables, simple variables and
     arrays.  Both simple variables and	array variables	are named.  Names
     begin with	a letter followed by any number	of letters, digits and
     underscores.  All letters must be lower case.  (Full alpha-numeric	names
     are an extension. In POSIX	bc all names are a single lower	case letter.)
     The type of variable is clear by the context because all array variable
     names will	be followed by brackets	([]).

     There are four special variables, scale, ibase, obase, and	last.  scale
     defines how some operations use digits after the decimal point.  The
     default value of scale is 0. ibase	and obase define the conversion	base
     for input and output numbers.  The	default	for both input and output is
     base 10.  last (an	extension) is a	variable that has the value of the
     last printed number.  These will be discussed in further detail where
     appropriate.  All of these	variables may have values assigned to them as
     well as used in expressions.

   COMMENTS    [Toc]    [Back]
     Comments in bc start with the characters /* and end with the characters
     */.  Comments may start anywhere and appear as a single space in the
     input.  (This causes comments to delimit other input items.  For example,
     a comment can not be found	in the middle of a variable name.)  Comments
     include any newlines (end of line)	between	the start and the end of the

									Page 2

bc(1)									 bc(1)

   EXPRESSIONS    [Toc]    [Back]
     The numbers are manipulated by expressions	and statements.	 Since the
     language was designed to be interactive, statements and expressions are
     executed as soon as possible.  There is no	"main" program.	 Instead, code
     is	executed as it is encountered.	(Functions, discussed in detail	later,
     are defined when encountered.)

     A simple expression is just a constant. bc	converts constants into
     internal decimal numbers using the	current	input base, specified by the
     variable ibase. (There is an exception in functions.)  The	legal values
     of	ibase are 2 through 16.	 Assigning a value outside this	range to ibase
     will result in a value of 2 or 16.	 Input numbers may contain the
     characters	0-9 and	A-F. (Note:  They must be capitals.  Lower case
     letters are variable names.)  Single digit	numbers	always have the	value
     of	the digit regardless of	the value of ibase. (i.e. A = 10.)  For
     multi-digit numbers, bc changes all input digits greater or equal to
     ibase to the value	of ibase-1.  This makes	the number FFF always be the
     largest 3 digit number of the input base.

     Full expressions are similar to many other	high level languages.  Since
     there is only one kind of number, there are no rules for mixing types.
     Instead, there are	rules on the scale of expressions.  Every expression
     has a scale.  This	is derived from	the scale of original numbers, the
     operation performed and in	many cases, the	value of the variable scale.
     Legal values of the variable scale	are 0 to the maximum number
     representable by a	C integer.

     In	the following descriptions of legal expressions, "expr"	refers to a
     complete expression and "var" refers to a simple or an array variable.  A
     simple variable is	just a
     and an array variable is specified	as
     Unless specifically mentioned the scale of	the result is the maximum
     scale of the expressions involved.

     - expr
	  The result is	the negation of	the expression.

     ++	var
	  The variable is incremented by one and the new value is the result
	  of the expression.

     --	var
	  The variable is decremented by one and the new value is the result
	  of the expression.

     var ++
	   The result of the expression	is the value of	the variable and then
	  the variable is incremented by one.

									Page 3

bc(1)									 bc(1)

     var --
	  The result of	the expression is the value of the variable and	then
	  the variable is decremented by one.

     expr + expr
	  The result of	the expression is the sum of the two expressions.

     expr - expr
	  The result of	the expression is the difference of the	two

     expr * expr
	  The result of	the expression is the product of the two expressions.

     expr / expr
	  The result of	the expression is the quotient of the two expressions.
	  The scale of the result is the value of the variable scale.

     expr % expr
	  The result of	the expression is the "remainder" and it is computed
	  in the following way.	 To compute a%b, first a/b is computed to
	  scale	digits.	 That result is	used to	compute	a-(a/b)*b to the scale
	  of the maximum of scale+scale(b) and scale(a).  If scale is set to
	  zero and both	expressions are	integers this expression is the
	  integer remainder function.

     expr ^ expr
	  The result of	the expression is the value of the first raised	to the
	  second. The second expression	must be	an integer.  (If the second
	  expression is	not an integer,	a warning is generated and the
	  expression is	truncated to get an integer value.)  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))).)  It should be noted that
	  expr^0 will always return the	value of 1.

     ( expr )
	  This alters the standard precedence to force the evaluation of the

     var = expr
	  The variable is assigned the value of	the expression.

     var <op>= expr
	  This is 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.

									Page 4

bc(1)									 bc(1)

      Relational expressions are a special kind	of expression that always
     evaluate to 0 or 1, 0 if the relation is false and	1 if the relation is
     true.  These 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.)  The relational
     operators are

     expr1 < expr2
	  The result is	1 if expr1 is strictly less than expr2.

     expr1 <= expr2
	  The result is	1 if expr1 is less than	or equal to expr2.

     expr1 > expr2
	  The result is	1 if expr1 is strictly greater than expr2.

     expr1 >= expr2
	  The result is	1 if expr1 is greater than or equal to expr2.

     expr1 == expr2
	  The result is	1 if expr1 is equal to expr2.

     expr1 != expr2
	  The result is	1 if expr1 is not equal	to expr2.

     Boolean operations	are also legal.	 (POSIX	bc does	NOT have boolean
     operations). The result of	all boolean operations are 0 and 1 (for	false
     and true) as in relational	expressions.  The boolean operators are:

	  The result is	1 if expr is 0.

     expr && expr
	  The result is	1 if both expressions are non-zero.

     expr || expr
	  The result is	1 if either expression is non-zero.

     The expression precedence is as follows: (lowest to highest)
	  || operator, left associative
	  && operator, left associative
	  ! operator, nonassociative
	  Relational operators,	left associative
	  Assignment operator, right associative
	  + and	- operators, left associative
	  *, / and % operators,	left associative
	  ^ operator, right associative
	  unary	- operator, nonassociative
	  ++ and -- operators, nonassociative

									Page 5

bc(1)									 bc(1)

     This precedence was chosen	so that	POSIX compliant	bc programs will run
     correctly.	This will cause	the use	of the relational and logical
     operators to have some unusual behavior when used with assignment
     expressions.  Consider the	expression:
	  a = 3	< 5

     Most C programmers	would assume this would	assign the result of "3	< 5"
     (the value	1) to the variable "a".	 What this does	in bc is assign	the
     value 3 to	the variable "a" and then compare 3 to 5.  It is best to use
     parenthesis when using relational and logical operators with the
     assignment	operators.

     There are a few more special expressions that are provided	in bc.	These
     have to do	with user defined functions and	standard functions.  They all
     appear as "name<b>(parameters<b>)".  See	the section on functions for user
     defined functions.	 The standard functions	are:

     length ( expression )
	  The value of the length function is the number of significant	digits
	  in the expression.

     read ( )
	  The read function (an	extension) will	read a number from the
	  standard input, regardless of	where the function occurs.   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.  The value of	the read
	  function is the number read from the standard	input using the
	  current value	of the variable	ibase for the conversion base.

     scale ( expression	)
	  The value of the scale function is the number	of digits after	the
	  decimal point	in the expression.

     sqrt ( expression )
	  The value of the sqrt	function is the	square root of the expression.
	  If the expression is negative, a run time error is generated.

   STATEMENTS    [Toc]    [Back]
     Statements	(as in most algebraic languages) provide the sequencing	of
     expression	evaluation.  In	bc statements are executed "as soon as
     possible."	 Execution happens when	a newline in encountered and there is
     one or more complete statements.  Due to this immediate execution,
     newlines are very important in bc.	In fact, both a	semicolon and a
     newline are used as statement separators.	An improperly placed newline
     will cause	a syntax error.	 Because newlines are statement	separators, it
     is	possible to hide a newline by using the	backslash character.  The
     sequence "\<nl>", where <nl> is the newline appears to bc as whitespace
     instead of	a newline.  A statement	list is	a series of statements
     separated by semicolons and newlines.  The	following is a list of bc
     statements	and what they do: (Things enclosed in brackets ([]) are

									Page 6

bc(1)									 bc(1)

     optional parts of the statement.)

	  This statement does one of two things.  If the expression starts
	  with "<variable> <assignment>	...", it is considered to be an
	  assignment statement.	 If the	expression is not an assignment
	  statement, the expression is evaluated and printed to	the output.
	  After	the number is printed, a newline is printed.  For example,
	  "a=1"	is an assignment statement and "(a=1)" is an expression	that
	  has an embedded assignment.  All numbers that	are printed are
	  printed in the base specified	by the variable	obase. The legal
	  values for obase are 2 through BC_BASE_MAX.  (See the	section
	  LIMITS.)  For	bases 2	through	16, the	usual method of	writing
	  numbers is used.  For	bases greater than 16, bc uses a multicharacter
 digit method of printing the numbers where each higher
	  base digit is	printed	as a base 10 number.  The multi-character
	  digits are separated by spaces.  Each	digit contains the number of
	  characters required to represent the base ten	value of "obase-1".
	  Since	numbers	are of arbitrary precision, some numbers may not be
	  printable on a single	output line.  These long numbers will be split
	  across lines using the "\" as	the last character on a	line.  The
	  maximum number of characters printed per line	is 70.	Due to the
	  interactive nature of	bc printing a number cause the side effect of
	  assigning the	printed	value the the special variable last. This
	  allows the user to recover the last value printed without having to
	  retype the expression	that printed the number.  Assigning to last is
	  legal	and will overwrite the last printed value with the assigned
	  value.  The newly assigned value will	remain until the next number
	  is printed or	another	value is assigned to last.  (Some
	  installations	may allow the use of a single period (.) which is not
	  part of a number as a	short hand notation for	for last.)

	  The string is	printed	to the output.	Strings	start with a double
	  quote	character and contain all characters until the next double
	  quote	character.  All	characters are take literally, including any
	  newline.  No newline character is printed after the string.

     print list
	  The print statement (an extension) 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	characters 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.

									Page 7

bc(1)									 bc(1)

     { statement_list }
	  This is the compound statement.  It allows multiple statements to be
	  grouped together for execution.

     if	( expression ) statement1 [else	statement2]
	  The if statement evaluates the expression and	executes statement1 or
	  statement2 depending on the value of the expression.	If the
	  expression is	non-zero, 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
	  The while statement will execute the statement while the expression
	  is non-zero.	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
	  The for statement controls repeated execution	of the statement.
	  Expression1 is evaluated before the loop.  Expression2 is evaluated
	  before each execution	of the statement.  If it is non-zero, the
	  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:
	  while	(expression2) {

	  This statement causes	a forced exit of the most recent enclosing
	  while	statement or for statement.

	  The continue statement (an extension)	 causes	the most recent
	  enclosing for	statement to start the next iteration.

     halt The halt statement (an extension) is an executed statement that
	  causes the bc	processor to quit only when it is executed.  For
	  example, "if (0 == 1)	halt" will not cause bc	to terminate because
	  the halt is not executed.

	  Return the value 0 from a function.  (See the	section	on functions.)

									Page 8

bc(1)									 bc(1)

     return ( expression )
	  Return the value of the expression from a function.  (See the
	  section on functions.)

   PSEUDO STATEMENTS    [Toc]    [Back]
     These statements are not statements in the	traditional sense.  They are
     not executed statements.  Their function is performed at "compile"	time.

	  Print	the local limits enforced by the local version of bc.  This is
	  an extension.

     quit When the quit	statement is read, the bc processor is terminated,
	  regardless of	where the quit statement is found.  For	example, "if
	  (0 ==	1) quit" will cause bc to terminate.

	  Print	a longer warranty notice.  This	is an extension.

   FUNCTIONS    [Toc]    [Back]
     Functions provide a method	of defining a computation that can be executed
     later.  Functions in bc always compute a value and	return it to the
     caller.  Function definitions are "dynamic" in the	sense that 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.  A function is	defined	as follows:
	  define name <b>(	parameters <b>) { newline
	      auto_list	  statement_list <b>}
     A function	call is	just an	expression of the form "name<b>(parameters<b>)".

     Parameters	are numbers or arrays (an extension).  In the function
     definition, zero or more parameters are defined by	listing	their names
     separated by commas.  Numbers are only call by value parameters.  Arrays
     are only call by variable.	 Arrays	are specified in the parameter
     definition	by the notation	"name<b>[]".   In the function call, actual
     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.  Since function definitions
     are dynamic, parameter numbers and	types are checked when a function is
     called.  Any mismatch in number or	types of parameters will cause a
     runtime error.  A runtime error will also occur for the call to an
     undefined function.

     The auto_list is an optional list of variables that are for "local" use.
     The syntax	of the auto list (if present) is "auto name, ... ;".  (The
     semicolon is optional.)  Each name	is the name of an auto variable.
     Arrays may	be specified by	using the same notation	as used	in parameters.
     These variables have their	values pushed onto a stack at the start	of the
     function.	The variables are then 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

									Page 9

bc(1)									 bc(1)

     these variables are restored.  The	parameters are really 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.

     The function body is a list of bc statements.  Again, statements are
     separated by semicolons or	newlines.  Return statements cause the
     termination of a function and the return of a value.  There are two
     versions of the return statement.	The first form,	"return", returns the
     value 0 to	the calling expression.	 The second form, "return ( expression
     )", computes the value of the expression and returns that value to	the
     calling expression.  There	is an implied "return (0)" at the end of every
     function.	This allows a function to terminate and	return 0 without an
     explicit return statement.

     Functions also 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.

     If	bc is invoked with the -l option, a math library is preloaded and the
     default scale is set to 20.   The math functions will calculate their
     results to	the scale set at the time of their call. The math library
     defines the following functions:

     s (x)
	  The sine of x, x is in radians.

     c (x)
	  The cosine of	x, x is	in radians.

     a (x)
	  The arctangent of x, arctangent returns radians.

     l (x)
	  The natural logarithm	of x.

     e (x)
	  The exponential function of raising e	to the value x.

     j (n,x)
	  The bessel function of integer order n of x.

   EXAMPLES    [Toc]    [Back]
     In	/bin/sh,  the following	will assign the	value of "pi" to the shell
     variable pi.

								       Page 10

bc(1)									 bc(1)

	  pi=$(echo "scale=10; 4*a(1)" | bc -l)

     The following is the definition of	the exponential	function used in the
     math library.  This function is 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

     The following is code that	uses the extended features of bc to implement
     a simple program for calculating checkbook	balances.  This	program	is
     best kept in a file so that it can	be used	many times without having to
     retype it at every	use.

								       Page 11

bc(1)									 bc(1)

	  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

     The following is the definition of	the recursive factorial	function.

	  define f (x) {
	    if (x <= 1)	return (1);
	    return (f(x-1) * x);

   DIFFERENCES    [Toc]    [Back]
     This version of bc	was implemented	from the POSIX P1003.2/D11 draft and
     contains several differences and extensions relative to the draft and
     traditional implementations.  It is not implemented in the	traditional
     way using dc(1). This version is a	single process which parses and	runs a
     byte code translation of the program.  There is an	"undocumented" option
     (-c) that causes the program to output the	byte code to the standard
     output instead of running it.  It was mainly used for debugging the
     parser and	preparing the math library.

     A major source of differences is extensions, where	a feature is extended
     to	add more functionality and additions, where new	features are added.
     The following is the list of differences and extensions.

     LANG This version does not	conform	to the POSIX standard in the
	  processing of	the LANG environment variable and all environment
	  variables starting with LC_.

	  Traditional and POSIX	bc have	single letter names for	functions,
	  variables and	arrays.	 They have been	extended to be multi-character
	  names	that start with	a letter and may contain letters, numbers and
	  the underscore character.

								       Page 12

bc(1)									 bc(1)

	  Strings are not allowed to contain NUL characters.  POSIX says all
	  characters must be included in strings.

     last POSIX	bc does	not have a last	variable.  Some	implementations	of bc
	  use the period (.) in	a similar way.

	  POSIX	bc allows comparisons only in the if statement,	the while
	  statement, and the second expression of the for statement.  Also,
	  only one relational operation	is allowed in each of those

     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

     &&, ||, !
	  POSIX	bc does	not have the logical operators.

     read function
	  POSIX	bc does	not have a read	function.

     print statement
	  POSIX	bc does	not have a print statement .

     continue statement
	  POSIX	bc does	not have a 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 an actual	parameter.
	  (This	is most	likely an oversight in the grammar.)  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
	  Other	implementations	of bc allow spaces in numbers.	For example,
	  "x=1 3" would	assign the value 13 to the variable x.	The same
	  statement would cause	a syntax error in this version of bc.

								       Page 13

bc(1)									 bc(1)

     errors and	execution
	  This implementation varies from other	implementations	in terms of
	  what 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 = 2
     has 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.

	  During an interactive	session, the SIGINT signal (usually generated
	  by the control-C character from the terminal)	will cause execution
	  of the current execution block to be interrupted.  It	will display a
	  "runtime" error indicating which function was	interrupted.  After
	  all runtime structures have been cleaned up, a message will be
	  printed to notify the	user that bc is	ready for more input.  All
	  previously defined functions remain defined and the value of all
	  non-auto variables are the value at the point	of interruption.  All
	  auto variables and function parameters are removed during the	clean
	  up process.  During a	non-interactive	session, the SIGINT signal
	  will terminate the entire run	of bc.

   LIMITS    [Toc]    [Back]
     The following are the limits currently in place for this bc processor.
     Some of them may have been	changed	by an installation.  Use the limits
     statement to see the actual values.

	  The maximum output base is currently set at 999.  The	maximum	input
	  base is 16.

	  This is currently an arbitrary limit of 65535	as distributed.	 Your
	  installation may be different.

	  The number of	digits after the decimal point is limited to INT_MAX
	  digits.  Also, the number of digits before the decimal point is
	  limited to INT_MAX digits.

								       Page 14

bc(1)									 bc(1)

	  The limit on the number of characters	in a string is INT_MAX

	  The value of the exponent in the raise operation (^) is limited to

	  The 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.  This limit (BC_MAX_SEGS) can be easily
	  changed to have more than 16 segments	of 1024	bytes.

     variable names
	  The current limit on the number of unique names is 32767 for each of
	  simple variables, arrays and functions.


     The following environment variables are processed by bc:

	  This is the same as the -s option.

	  This is another mechanism to get arguments to	bc.  The format	is the
	  same as the command line arguments.  These arguments are processed
	  first, so any	files listed in	the enviroment 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
	  of bc.  The files in the environment variables would typically
	  contain function definitions for functions the user wants defined
	  every	time bc	is run.

	  This should be an integer specifying the number of characters	in an
	  output line for numbers. This	includes the backslash and newline
	  characters for long numbers.

FILES    [Toc]    [Back]

     In	most installations, bc is completely self-contained.  Where executable
     size is of	importance or the C compiler does not deal with	very long
     strings, bc will read the standard	math library from the file
     /usr/local/lib/libmath.b.	(The actual location may vary.	It may be

								       Page 15

bc(1)									 bc(1)

DIAGNOSTICS    [Toc]    [Back]

     If	any file on the	command	line can not be	opened,	bc will	report that
     the file is unavailable and terminate.  Also, there are compile and run
     time diagnostics that should be self-explanatory.

BUGS    [Toc]    [Back]

     Error recovery is not very	good yet.

AUTHOR    [Toc]    [Back]

     Philip A. Nelson


     The author	would like to thank Steve Sommars (Steve.Sommars@att.com) for
     his extensive help	in testing the implementation.	Many great suggestions
     were given.  This is a much better	product	due to his involvement.

								       PPPPaaaaggggeeee 11116666
[ Back ]
 Similar pages
Name OS Title
bc OpenBSD arbitrary-precision arithmetic language and calculator
dc IRIX an arbitrary precision calculator
dc FreeBSD an arbitrary precision calculator
dc Tru64 Provides an interactive desk calculator for arbitrary precision integer arithmetic
bc HP-UX arbitrary-precision arithmetic language
bc Tru64 Provides a processor for arbitrary-precision arithmetic language
dprod IRIX FORTRAN double precision and quad precision product intrinsic functions
xcalc IRIX scientific calculator for X
dc HP-UX desk calculator
dc OpenBSD desk calculator
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service