man(1) Manual page archive

     BC(1)                                                       BC(1)

          bc - arbitrary-precision arithmetic language

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

          Bc is an interactive processor for a language which resem-
          bles 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 pro-
          grams is like that of C; L means letter a-z, E means expres-
          sion, S means statement.

                are enclosed in /* and */.

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

          Other operands
                arbitrarily long numbers with optional sign and deci-
                mal point.
                ( E )
                sqrt ( E )
                length ( E )   number of significant decimal digits
                scale ( E )    number of digits right of decimal point
                L ( E , ... , E )

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

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

          Function definitions
                define L ( L , ... , L ) {

     BC(1)                                                       BC(1)

                     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 semi-
          colons 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 respec-

          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 func-
          tion 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 pre-
          sent.  In this case the dc input is sent to the standard
          output instead.

          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

     BC(1)                                                       BC(1)

          exponential function and

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

          prints approximate values of the exponential function of the
          first ten integers.

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

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

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