ultrix man page for bc

bc(1)							      General Commands Manual							     bc(1)

Name
       bc - interactive arithmetic language processor

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

Description
       The command provides 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 syn-
       tax for programs 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 new lines may
       separate statements.  Assignment to scale influences the number of digits to be retained on arithmetic operations in the manner of  Assign-
       ments 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.

       The following example defines a function to compute an approximate value of the exponential function:
       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
	    }
       }

       The following command line then prints approximate values of the exponential function of the first ten integers:
	    for(i=1; i<=10; i++) e(i)

       The  command  is  actually a preprocessor for which it invokes automatically, unless the -c (compile only) option is present.  In this case
       the input is sent to the standard output instead.

Options
       -c		   Compiles input only.

       -l		   Names arbitrary precision math library.

Restrictions
       The for statement must have all three E's.

       Quit is interpreted when read, not when executed.

       Variables must be a single lower case letter.  Upper case letters are used only as digits for bases greater than 10.

Files
       mathematical library

See Also
       dc(1)
       ``BC - An arbitrary precision desk-calculator language'' ULTRIX Supplementary Documents Vol. 1: General User

																	     bc(1)