MirOS Manual: bc(1)

BC(1)                        BSD Reference Manual                        BC(1)

NAME

     bc - arbitrary-precision arithmetic language and calculator

SYNOPSIS

     bc [-cl] [-e expression] [file ...]

DESCRIPTION

     bc is an interactive processor for a language which resembles C but pro-
     vides unlimited precision arithmetic. It takes input from any expressions
     on the command line and any files given, then reads the standard input.

     Options available:

     -c      bc is actually a preprocessor for dc(1), which it invokes au-
             tomatically, unless the -c (compile only) option is present. In
             this case the generated dc(1) instructions are sent to the stan-
             dard output, instead of being interpreted by a running dc(1) pro-
             cess.

     -e expression
             Evaluate expression. If multiple -e options are specified, they
             are processed in the order given, separated by newlines.

     -l      Allow specification of an arbitrary precision math library. The
             definitions in the library are available to command line expres-
             sions.

     The syntax for bc programs is as follows: 'L' means letter a-z; 'E' means
     expression; 'S' means statement. As a non-portable extension, it is pos-
     sible to use long names in addition to single letter names. A long name
     is a sequence starting with a lowercase letter followed by any number of
     lowercase letters and digits. The underscore character ('_') counts as a
     letter.

     Comments
           are enclosed in /* and */
           are enclosed in # and the next newline

     The newline is not part of the line comment, which in itself is a non-
     portable extension.

     Names
           simple variables: L
           array elements: L [ E ]
           The words 'ibase', 'obase', and 'scale'
           The word 'last' or a single dot

     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 )

     The sequence '\<newline><whitespace>' is ignored within numbers.

     Operators

     The following arithmetic and logical operators can be used. The semantics
     of the operators is the same as in the C language. They are listed in
     order of decreasing precedence. Operators in the same group have the same
     precedence.

           Operator               Associativity    Description
           ++ --                  none             increment, decrement
           -                      none             unary minus
           ^                      right            power
           * / %                  left             multiply, divide, modulus
           + -                    left             plus, minus
           = += -= *= /= %= ^=    right            assignment
           == <= >= != < >        none             relational
           !                      none             boolean not
           &&                     left             boolean and
           ||                     left             boolean or

     Note the following:

           •   The relational operators may appear in any expression. The IEEE
               Std 1003.2 ("POSIX.2") standard only allows them in the condi-
               tional expression of an 'if', 'while' or 'for' statement.

           •   The relational operators have a lower precedence than the as-
               signment operators. This has the consequence that the expres-
               sion a = b < c is interpreted as (a = b) < c, which is probably
               not what the programmer intended.

           •   In contrast with the C language, the relational operators all
               have the same precedence, and are non-associative. The expres-
               sion a < b < c will produce a syntax error.

           •   The boolean operators (!, && and ||) are non-portable exten-
               sions.

           •   The boolean not (!) operator has much lower precedence than the
               same operator in the C language. This has the consequence that
               the expression !a < b is interpreted as !(a < b). Prudent pro-
               grammers use parentheses when writing expressions involving
               boolean operators.

     Statements
           E
           { S ; ... ; S }
           if ( E ) S
           if ( E ) S else S
           while ( E ) S
           for ( E ; E ; E ) S
           null statement
           break
           continue
           quit
           a string of characters, enclosed in double quotes
           print E ,..., E

     A string may contain any character, except double quote. The if statement
     with an else branch is a non-portable extension. All three E's in a for
     statement may be empty. This is a non-portable extension. The continue
     and print statements are also non-portable extensions.

     The print statement takes a list of comma-separated expressions. Each ex-
     pression in the list is evaluated and the computed value is printed and
     assigned to the variable 'last'. No trailing newline is printed. The ex-
     pression may also be a string enclosed in double quotes. Within these
     strings the following escape sequences may be used: '\a' for bell
     (alert), '\b' for backspace, '\f' for formfeed, '\n' for newline, '\r'
     for carriage return, '\t' for tab, '\q' for double quote and '\\' for
     backslash. Any other character following a backslash will be ignored.
     Strings will not be assigned to 'last'.

     Function definitions

           define L ( L ,..., L ) {
                auto L, ... , L
                S; ... S
                return ( E )
           }

     As a non-portable extension, the opening brace of the define statement
     may appear on the next line. The return statement may also appear in the
     following forms:

           return
           return ()
           return E

     The first two are equivalent to the statement "return 0". The last form
     is a non-portable extension. Not specifying a return statement is
     equivalent to writing "return (0)".

     Functions available in the math library, which is loaded by specifying
     the -l flag on the command line

           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. The value printed is assigned to the special
     variable 'last'. This is a non-portable extension. A single dot may be
     used as a synonym for 'last'. Either semicolons or newlines may separate
     statements. Assignment to scale influences the number of digits to be re-
     tained 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 vari-
     able simultaneously. All variables are global to the program. When using
     arrays as function arguments or defining them as automatic variables,
     empty square brackets must follow the array name.

     For 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.

           $ bc -l -e 'scale = 500; 2 * a(2^10000)' -e quit

     prints an approximation of pi.

FILES

     /usr/share/misc/bc.library  math library, read when the -l option is
                                 specified on the command line.

SEE ALSO

     dc(1)

     "BC - An Arbitrary Precision Desk-Calculator Language",
     /usr/share/doc/usd/06.bc/.

STANDARDS

     The bc utility is expected to conform to the IEEE Std 1003.2 ("POSIX.2")
     specification.

HISTORY

     The bc first command appeared in Version 6 AT&T UNIX. A complete rewrite
     of the bc command first appeared in OpenBSD 3.5.

AUTHORS

     The original version of the bc command was written by Robert Morris and
     Lorinda Cherry. The current version of the bc utility was written by
     Otto Moerbeek.

BUGS

     'Quit' is interpreted when read, not when executed.

     Some non-portable extensions, as found in the GNU version of the bc util-
     ity are not implemented (yet).

                                August 8, 1991                               3

Generated on 2014-07-04 21:17:45 by $MirOS: src/scripts/roff2htm,v 1.79 2014/02/10 00:36:11 tg Exp $

These manual pages and other documentation are copyrighted by their respective writers; their source is available at our CVSweb, AnonCVS, and other mirrors. The rest is Copyright © 2002‒2014 The MirOS Project, Germany.
This product includes material provided by Thorsten Glaser.

This manual page’s HTML representation is supposed to be valid XHTML/1.1; if not, please send a bug report – diffs preferred.