BC(1)                   COMMAND REFERENCE                   BC(1)



NAME
     bc - arbitrary-precision arithmetic language

SYNOPSIS
     bc [ -c ] [ -f ] [ -l ] [ filename ... ]

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, unless the -f option is given.

     The syntax for bc programs is as follows: L means letters
     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



Printed 4/6/89                                                  1

BC(1)                   COMMAND REFERENCE                   BC(1)



        return ( E )
        }

     Functions in -l math library
        s(x) sine
        c(x) cosine
        e(x) exponential
        l(x) natural log (log base e)
        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, as a function, and
     as 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.

     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.

     Error messages are always sent to the standard output to be
     printed by dc. If the -c option is given, error messages
     about running out of space are also sent to standard error.

OPTIONS
     -c Compile only - does not invoke dc.  Dc input sent to
        standard output.

     -f Don't read from standard input.

     -l Uses an arbitrary precision math library.

EXAMPLES
     The following defines a function to compute an approximate
     value of the exponential function:

          scale = 20
          define e(x){
          auto a, b, c, i, s



Printed 4/6/89                                                  2

BC(1)                   COMMAND REFERENCE                   BC(1)



          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
          }
          }

     This next example prints approximate values of the
     exponential function of the first ten integers:

          for(i=1; i<=10; i++) e(i)

FILES
     /usr/lib/lib.b
                  Mathematical library

RETURN VALUE
     [NO_ERRS]      Command completed without error.

     [USAGE]        Incorrect command line syntax. Execution
                    terminated.

     [NP_WARN]      An error warranting a warning message
                    occurred. Execution continues.

     [NP_ERR]       An error occurred that was not a system
                    error.  Execution terminated.

     [P_ERR]        A system error occurred. Execution
                    terminated.  See intro(2) for more
                    information on system errors.

CAVEATS
     No &&, ||, or ! operators.

     For statement must have all three E's.

     Quit is interpreted when read, not when executed.

     If the scale factor is greater than 63, the error in
     multiplication can be as big as 199.

SEE ALSO
     dc(1).






Printed 4/6/89                                                  3

%%index%%
na:192,96;
sy:288,232;
de:520,1463;2247,1597;
op:3844,357;
ex:4201,267;4732,354;
fi:5086,136;
rv:5222,665;
ca:5887,327;
se:6214,100;
%%index%%000000000166