BC(1)							      General Commands Manual							     BC(1)

NAME

       bc - arbitrary-precision arithmetic language

SYNOPSIS

       bc [ -c ] [ -l ] [ file ... ]

DESCRIPTION

       Bc is an interactive processor for a language which resembles C but provides unlimited precision arithmetic.  It takes input from any files
       given, then reads the standard input.  The -l argument stands for the name of an arbitrary precision math library.  The syntax for bc  pro-
       grams is as follows; L means letter a-z, E means expression, S means statement.

       Comments
	     are enclosed in /* and */.

       Names
	     simple variables: L
	     array elements: L [ E ]
	     The words `ibase', `obase', and `scale'

       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 )

       Operators
	     +	-  *  /  %  ^ (% is remainder; ^ is power)
	     ++   --	     (prefix and postfix; apply to names)
	     ==  <=  >=  !=  <	>
	     =	=+  =-	=*  =/	=%  =^

       Statements
	     E
	     { S ; ... ; S }
	     if ( E ) S
	     while ( E ) S
	     for ( E ; E ; E ) S
	     null statement
	     break
	     quit

       Function definitions
	     define L ( L ,..., L ) {
		  auto L, ... , L
		  S; ... S
		  return ( E )
	     }

       Functions in -l math library
	     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.  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  is actually a preprocessor for dc(1), which it invokes automatically, unless the -c (compile only) option is present.  In this case the
       dc input is sent to the standard output instead.

FILES

       /usr/lib/lib.b mathematical library
       dc(1)	      desk calculator proper

SEE ALSO

       dc(1)
       L. L. Cherry and R. Morris, BC - An arbitrary precision desk-calculator language

BUGS

       No &&, ||, or ! operators.
       For statement must have all three E's.
       Quit is interpreted when read, not when executed.

																	     BC(1)