glenda.party
term% ls -F
term% pwd
$home/manuals/unix_v8/1/bc
term% cat index.txt
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 following syntax  for
       bc  programs is like that of C; 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 sep‐
       arate statements.  Assignment to scale influences the number of  digits
       to  be  retained  on arithmetic operations in the manner of dc(1).  As‐
       signments to ibase or obase set the input and output number  radix  re‐
       spectively.

       The same letter may be used as an array, a function, and a simple vari‐
       able 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.

       Bc  is  actually  a  preprocessor for dc(1), which it invokes automati‐
       cally, unless the -c (compile only) option is present.   In  this  case
       the dc input is sent to the standard output instead.

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.

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

SEE ALSO
       dc(1), hoc(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)