bc - arbitrary-precision arithmetic language

       No or operators.

       A statement must have all three

       A is interpreted when read, not when executed.

                                                                                                      BC(1plan9)

Bc  is  an  interactive  processor  for a language that resembles C but provides arithmetic on numbers of
       arbitrary length with up to 100 digits right of the decimal point.  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 -s argument suppresses the automatic display of calculation results; all output is via  the
       print command.

       The  following  syntax for bc programs is like that of C; L means letter a-z, E means expression, S means
       statement.

       Lexical

              comments are enclosed in /**/

              newlines end statements

       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)
                     function call

       Operators

              +-*/%^  (% is remainder; ^ is power)

              ++--==<=>=!=<>=+=-=*=/=%=^=

       Statements
              E{S; ...  ;S}printEif(E)Swhile(E)Sfor(E;E;E)S
              null statement
              breakquit
              "text"

       Function definitions
              defineL(L, ...  ,L){autoL, ...  ,LS; ...  ;SreturnE}
       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 an expression at the top level is printed unless the main operator is an assignment  or  the
       -s  command  line  argument  is  given.   Text  in quotes, which may include newlines, is always printed.
       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.  Automatic variables are pushed down during function calls.  In a declaration
       of an array as a function argument or automatic variable 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.

       Define a function to compute an approximate value of the exponential.  Use it to print 10  values.   (The
       exponential function in the library gives better answers.)

       scale = 20
       define e(x) {
            auto a, b, c, i, s
            a = 1
            b = 1
            s = 1
            for(i=1; 1; i++) {
                 a *= x
                 b *= i
                 c = a/b
                 if(c == 0) return s
                 s += c
            }
       }
       for(i=1; i<=10; i++) print e(i)

/lib/bclib mathematical library

       bc - arbitrary-precision arithmetic language

dc(1), hoc(1)

/src/cmd/bc.y

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