Provided by: manpages-posix_2.16-1_all bug

NAME

       bc - arbitrary-precision arithmetic language

SYNOPSIS

       bc [-l] [file ...]

DESCRIPTION

       The  bc  utility shall implement an arbitrary precision calculator.  It
       shall take input from any files given,  then  read  from  the  standard
       input.  If the standard input and standard output to bc are attached to
       a terminal, the invocation of bc shall be considered to be interactive,
       causing behavioral constraints described in the following sections.

OPTIONS

       The  bc  utility  shall  conform  to  the  Base  Definitions  volume of
       IEEE Std 1003.1-2001, Section 12.2, Utility Syntax Guidelines.

       The following option shall be supported:

       -l     (The letter ell.) Define the math functions and initialize scale
              to 20, instead of the default zero; see the EXTENDED DESCRIPTION
              section.

OPERANDS

       The following operand shall be supported:

       file   A pathname of a text  file  containing  bc  program  statements.
              After  all  files  have  been  read,  bc shall read the standard
              input.

STDIN

       See the INPUT FILES section.

INPUT FILES

       Input files shall be text files  containing  a  sequence  of  comments,
       statements, and function definitions that shall be executed as they are
       read.

ENVIRONMENT VARIABLES

       The following environment variables shall affect the execution of bc:

       LANG   Provide a default value for the  internationalization  variables
              that  are  unset  or  null.  (See the Base Definitions volume of
              IEEE Std 1003.1-2001,    Section    8.2,    Internationalization
              Variables  for  the precedence of internationalization variables
              used to determine the values of locale categories.)

       LC_ALL If set to a non-empty string value, override the values  of  all
              the other internationalization variables.

       LC_CTYPE
              Determine  the  locale  for  the  interpretation of sequences of
              bytes of text data as characters (for  example,  single-byte  as
              opposed  to multi-byte characters in arguments and input files).

       LC_MESSAGES
              Determine the locale that should be used to  affect  the  format
              and contents of diagnostic messages written to standard error.

       NLSPATH
              Determine the location of message catalogs for the processing of
              LC_MESSAGES .

ASYNCHRONOUS EVENTS

       Default.

STDOUT

       The output of the bc utility shall be controlled by the  program  read,
       and  consist of zero or more lines containing the value of all executed
       expressions without assignments. The radix and precision of the  output
       shall be controlled by the values of the obase and scale variables; see
       the EXTENDED DESCRIPTION section.

STDERR

       The standard error shall be used only for diagnostic messages.

OUTPUT FILES

       None.

EXTENDED DESCRIPTION

   Grammar
       The grammar  in  this  section  and  the  lexical  conventions  in  the
       following  section  shall together describe the syntax for bc programs.
       The general conventions for this style  of  grammar  are  described  in
       Grammar  Conventions  .  A valid program can be represented as the non-
       terminal symbol program in the grammar. This formal syntax  shall  take
       precedence over the text syntax description.

              %token    EOF NEWLINE STRING LETTER NUMBER

              %token    MUL_OP
              /**,/,%*/

              %token    ASSIGN_OP
              /*=,+=,-=,*=,/=,%=,^=*/

              %token    REL_OP
              /*==,<=,>=,!=,<,>*/

              %token    INCR_DECR
              /*++,--*/

              %token    Define    Break    Quit    Length
              /*define,break,quit,length*/

              %token    Return    For    If    While    Sqrt
              /*return,for,if,while,sqrt*/

              %token    Scale    Ibase    Obase    Auto
              /*scale,ibase,obase,auto*/

              %start    program

              %%

              program              : EOF
                                   | input_item program
                                   ;

              input_item           : semicolon_list NEWLINE
                                   | function
                                   ;

              semicolon_list       : /* empty */
                                   | statement
                                   | semicolon_list;statement
                                   | semicolon_list;;

              statement_list       : /* empty */
                                   | statement
                                   | statement_list NEWLINE
                                   | statement_list NEWLINE statement
                                   | statement_list;| statement_list;statement
                                   ;

              statement            : expression
                                   | STRING
                                   | Break
                                   | Quit
                                   | Return
                                   | Return(return_expression)| For(expression;relational_expression;expression)statement
                                   | If(relational_expression)statement
                                   | While(relational_expression)statement
                                   |{statement_list};

              function             : Define LETTER(opt_parameter_list)’
                                         ’{NEWLINE opt_auto_define_list
                                         statement_list};

              opt_parameter_list   : /* empty */
                                   | parameter_list
                                   ;

              parameter_list       : LETTER
                                   | define_list,LETTER
                                   ;

              opt_auto_define_list : /* empty */
                                   | Auto define_list NEWLINE
                                   | Auto define_list;;

              define_list          : LETTER
                                   | LETTER[’ ’]| define_list,LETTER
                                   | define_list,LETTER[’ ’];

              opt_argument_list    : /* empty */
                                   | argument_list
                                   ;

              argument_list        : expression
                                   | LETTER[’ ’]’ ’,argument_list
                                   ;

              relational_expression : expression
                                   | expression REL_OP expression
                                   ;

              return_expression    : /* empty */
                                   | expression
                                   ;

              expression           : named_expression
                                   | NUMBER
                                   |(expression)| LETTER(opt_argument_list)|-expression
                                   | expression+expression
                                   | expression-expression
                                   | expression MUL_OP expression
                                   | expression^expression
                                   | INCR_DECR named_expression
                                   | named_expression INCR_DECR
                                   | named_expression ASSIGN_OP expression
                                   | Length(expression)| Sqrt(expression)| Scale(expression);

              named_expression     : LETTER
                                   | LETTER[expression]| Scale
                                   | Ibase
                                   | Obase
                                   ;

   Lexical Conventions in bc
       The  lexical conventions for bc programs, with respect to the preceding
       grammar, shall be as follows:

        1. Except as noted, bc shall recognize the longest possible  token  or
           delimiter beginning at a given point.

        2. A  comment  shall  consist of any characters beginning with the two
           adjacent characters "/*" and terminated by the next  occurrence  of
           the  two  adjacent  characters "*/" . Comments shall have no effect
           except to delimit lexical tokens.

        3. The <newline> shall be recognized as the token NEWLINE.

        4. The token STRING  shall  represent  a  string  constant;  it  shall
           consist of any characters beginning with the double-quote character
           ( ’ )’ and terminated by another  occurrence  of  the  double-quote
           character.  The  value  of  the  string  is  the  sequence  of  all
           characters  between,  but  not  including,  the  two   double-quote
           characters. All characters shall be taken literally from the input,
           and there is no way to specify a string containing  a  double-quote
           character.  The length of the value of each string shall be limited
           to {BC_STRING_MAX} bytes.

        5. A <blank> shall have no effect except as an ordinary  character  if
           it  appears  within  a  STRING token, or to delimit a lexical token
           other than STRING.

        6. The combination of a backslash character immediately followed by  a
           <newline> shall have no effect other than to delimit lexical tokens
           with the following exceptions:

            * It shall be interpreted as the character  sequence  "\<newline>"
              in STRING tokens.

            * It shall be ignored as part of a multi-line NUMBER token.

        7. The  token  NUMBER  shall represent a numeric constant. It shall be
           recognized by the following grammar:

           NUMBER  : integer
                   |.integer
                   | integer.| integer.integer
                   ;

           integer : digit
                   | integer digit
                   ;

           digit   : 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7
                   | 8 | 9 | A | B | C | D | E | F
                   ;

        8. The value of a NUMBER token shall be interpreted as  a  numeral  in
           the  base  specified  by  the  value of the internal register ibase
           (described below). Each of the  digit  characters  shall  have  the
           value  from  0  to  15  in  the  order  listed here, and the period
           character  shall  represent  the  radix  point.  The  behavior   is
           undefined  if  digits  greater  than or equal to the value of ibase
           appear in the token. However, note the exception  for  single-digit
           values  being assigned to ibase and obase themselves, in Operations
           in bc .

        9. The following keywords shall be recognized as tokens:

                        auto     ibase   length   return   while
                        break    if      obase    scale
                        define   for     quit     sqrt

       10. Any of the following characters occurring anywhere except within  a
           keyword shall be recognized as the token LETTER:

           a b c d e f g h i j k l m n o p q r s t u v w x y z

       11. The following single-character and two-character sequences shall be
           recognized as the token ASSIGN_OP:

           =   +=   -=   *=   /=   %=   ^=

       12. If an ’=’ character, as the beginning of a token, is followed by  a
           ’-’  character  with  no  intervening  delimiter,  the  behavior is
           undefined.

       13. The following single-characters shall be recognized  as  the  token
           MUL_OP:

           *   /   %

       14. The following single-character and two-character sequences shall be
           recognized as the token REL_OP:

           ==   <=   >=   !=   <   >

       15. The following two-character sequences shall be  recognized  as  the
           token INCR_DECR:

           ++   --

       16. The following single characters shall be recognized as tokens whose
           names are the character:

           <newline>  (  )  ,  +  -  ;  [  ]  ^  {  }

       17. The token EOF is returned when the end of input is reached.

   Operations in bc
       There are three  kinds  of  identifiers:  ordinary  identifiers,  array
       identifiers,  and  function  identifiers.  All  three  types consist of
       single lowercase letters. Array identifiers shall be followed by square
       brackets ( "[]" ). An array subscript is required except in an argument
       or auto list. Arrays are singly  dimensioned  and  can  contain  up  to
       {BC_DIM_MAX}  elements.  Indexing  shall  begin  at zero so an array is
       indexed from 0 to {BC_DIM_MAX}-1.  Subscripts  shall  be  truncated  to
       integers.  The  application  shall ensure that function identifiers are
       followed by parentheses, possibly enclosing arguments. The three  types
       of identifiers do not conflict.

       The   following   table   summarizes   the  rules  for  precedence  and
       associativity of all operators. Operators on the same line  shall  have
       the same precedence; rows are in order of decreasing precedence.

                               Table: Operators in bc

                      Operator                    Associativity
                      ++, --                      N/A
                      unary -                     N/A
                      ^                           Right to left
                      *, /, %                     Left to right

                      +, binary -                 Left to right
                      =, +=, -=, *=, /=, %=, ^=   Right to left
                      ==, <=, >=, !=, <, >        None

       Each expression or named expression has a scale, which is the number of
       decimal digits that shall be maintained as the  fractional  portion  of
       the expression.

       Named expressions are places where values are stored. Named expressions
       shall be valid on the left side of an assignment.  The value of a named
       expression  shall  be  the  value  stored  in  the  place named. Simple
       identifiers and array elements are  named  expressions;  they  have  an
       initial value of zero and an initial scale of zero.

       The   internal   registers  scale,  ibase,  and  obase  are  all  named
       expressions. The scale of an expression consisting of the name  of  one
       of  these  registers  shall  be  zero;  values assigned to any of these
       registers are truncated to integers. The scale register shall contain a
       global  value  used in computing the scale of expressions (as described
       below).  The value of the register scale is limited to 0  <=  scale  <=
       {BC_SCALE_MAX}  and  shall  have a default value of zero. The ibase and
       obase registers are the input and output  number  radix,  respectively.
       The value of ibase shall be limited to:

              2 <= ibase <= 16

       The value of obase shall be limited to:

              2 <= obase <= {BC_BASE_MAX}

       When  either  ibase  or obase is assigned a single digit value from the
       list in Lexical Conventions in bc ,  the  value  shall  be  assumed  in
       hexadecimal.  (For example, ibase=A sets to base ten, regardless of the
       current ibase value.) Otherwise, the behavior is undefined when  digits
       greater  than  or equal to the value of ibase appear in the input. Both
       ibase and obase shall have initial values of 10.

       Internal computations shall be conducted as if in  decimal,  regardless
       of  the  input  and  output  bases,  to the specified number of decimal
       digits.  When  an  exact  result  is   not   achieved   (for   example,
       scale=0; 3.2/1), the result shall be truncated.

       For    all    values   of   obase   specified   by   this   volume   of
       IEEE Std 1003.1-2001, bc shall output numeric values by performing each
       of the following steps in order:

        1. If the value is less than zero, a hyphen ( ’-’ ) character shall be
           output.

        2. One of the following is output, depending on the numerical value:

            * If the absolute value of the numerical value is greater than  or
              equal  to  one, the integer portion of the value shall be output
              as a series of digits appropriate to obase (as described below),
              most  significant  digit  first.  The  most significant non-zero
              digit shall be output next, followed by each  successively  less
              significant digit.

            * If  the  absolute  value of the numerical value is less than one
              but greater than zero and the scale of the  numerical  value  is
              greater  than zero, it is unspecified whether the character 0 is
              output.

            * If the numerical value is zero, the character 0 shall be output.

        3. If  the  scale  of  the  value is greater than zero and the numeric
           value is not zero, a period character shall be output, followed  by
           a  series  of  digits  appropriate  to  obase  (as described below)
           representing the most significant portion of the fractional part of
           the value. If s represents the scale of the value being output, the
           number of digits output shall be s if obase is  10,  less  than  or
           equal to s if obase is greater than 10, or greater than or equal to
           s if obase is less than 10. For obase values other  than  10,  this
           should  be  the number of digits needed to represent a precision of
           10**s.

       For obase values from 2 to 16, valid digits are the first obase of  the
       single characters:

              0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F

       which represent the values zero to 15, inclusive, respectively.

       For  bases  greater  than 16, each digit shall be written as a separate
       multi-digit decimal number. Each  digit  except  the  most  significant
       fractional digit shall be preceded by a single <space>.  For bases from
       17 to 100, bc shall write two-digit decimal numbers; for bases from 101
       to  1000,  three-digit  decimal  strings,  and  so on. For example, the
       decimal number 1024 in base 25 would be written as:

               01 15 24

       and in base 125, as:

               008 024

       Very large numbers shall be split across lines with 70  characters  per
       line  in  the  POSIX  locale;  other  locales  may  split  at different
       character boundaries.  Lines  that  are  continued  shall  end  with  a
       backslash ( ’\’ ).

       A   function  call  shall  consist  of  a  function  name  followed  by
       parentheses containing a comma-separated list of expressions, which are
       the  function  arguments.  A whole array passed as an argument shall be
       specified by the array name followed  by  empty  square  brackets.  All
       function  arguments shall be passed by value. As a result, changes made
       to the formal parameters shall have no effect on the actual  arguments.
       If  the  function terminates by executing a return statement, the value
       of the function shall be the value of the expression in the parentheses
       of  the  return statement or shall be zero if no expression is provided
       or if there is no return statement.

       The result of sqrt(  expression)  shall  be  the  square  root  of  the
       expression.  The  result  shall  be  truncated in the least significant
       decimal place. The scale of the  result  shall  be  the  scale  of  the
       expression or the value of scale, whichever is larger.

       The  result  of  length(  expression)  shall  be  the  total  number of
       significant decimal digits in the expression. The scale of  the  result
       shall be zero.

       The  result of scale( expression) shall be the scale of the expression.
       The scale of the result shall be zero.

       A numeric constant shall be an  expression.  The  scale  shall  be  the
       number  of digits that follow the radix point in the input representing
       the constant, or zero if no radix point appears.

       The sequence ( expression ) shall be an expression with the same  value
       and  scale  as  expression.  The  parentheses  can be used to alter the
       normal precedence.

       The semantics of the unary and binary operators are as follows:

       -expression

              The result shall be the negative of the expression. The scale of
              the result shall be the scale of expression.

       The  unary increment and decrement operators shall not modify the scale
       of the named expression upon which  they  operate.  The  scale  of  the
       result shall be the scale of that named expression.

       ++named-expression

              The  named  expression  shall  be incremented by one. The result
              shall be the value of the named expression after incrementing.

       --named-expression

              The named expression shall be decremented  by  one.  The  result
              shall be the value of the named expression after decrementing.

       named-expression++

              The  named  expression  shall  be incremented by one. The result
              shall be the value of the named expression before  incrementing.

       named-expression--

              The  named  expression  shall  be decremented by one. The result
              shall be the value of the named expression before  decrementing.

       The  exponentiation  operator,  circumflex ( ’^’ ), shall bind right to
       left.

       expression^expression

              The result shall be the first expression raised to the power  of
              the  second  expression.  If  the  second  expression  is not an
              integer, the behavior is undefined. If a is  the  scale  of  the
              left  expression  and  b  is  the  absolute  value  of the right
              expression, the scale of the result shall be:

              if b >= 0 min(a * b, max(scale, a)) if b < 0 scale

       The multiplicative operators ( ’*’ , ’/’ , ’%’ )  shall  bind  left  to
       right.

       expression*expression

              The result shall be the product of the two expressions. If a and
              b are the scales of the two expressions, then the scale  of  the
              result shall be:

              min(a+b,max(scale,a,b))

       expression/expression

              The  result  shall  be  the quotient of the two expressions. The
              scale of the result shall be the value of scale.

       expression%expression

              For expressions a and b, a% b shall be evaluated  equivalent  to
              the steps:

               1. Compute a/ b to current scale.

               2. Use the result to compute:

                  a - (a / b) * b

              to scale:

                     max(scale + scale(b), scale(a))

       The scale of the result shall be:

              max(scale + scale(b), scale(a))

       When  scale  is  zero,  the  ’%’ operator is the mathematical remainder
       operator.

       The additive operators ( ’+’ , ’-’ ) shall bind left to right.

       expression+expression

              The result shall be the sum of the two expressions. The scale of
              the   result   shall  be  the  maximum  of  the  scales  of  the
              expressions.

       expression-expression

              The result shall be the difference of the two  expressions.  The
              scale  of  the  result shall be the maximum of the scales of the
              expressions.

       The assignment operators ( ’=’ , "+=" , "-=" , "*=" ,  "/="  ,  "%="  ,
       "^=" ) shall bind right to left.

       named-expression=expression

              This  expression  shall  result  in  assigning  the value of the
              expression on the right to the named expression on the left. The
              scale  of  both the named expression and the result shall be the
              scale of expression.

       The compound assignment forms:

              named-expression <operator>= expression

       shall be equivalent to:

              named-expression=named-expression <operator> expression

       except that the named-expression shall be evaluated only once.

       Unlike all other operators, the relational operators ( ’<’ , ’>’ , "<="
       ,  ">="  ,  "=="  ,  "!=" ) shall be only valid as the object of an if,
       while, or inside a for statement.

       expression1<expression2

              The relation shall be  true  if  the  value  of  expression1  is
              strictly less than the value of expression2.

       expression1>expression2

              The  relation  shall  be  true  if  the  value of expression1 is
              strictly greater than the value of expression2.

       expression1<=expression2

              The relation shall be true if the value of expression1  is  less
              than or equal to the value of expression2.

       expression1>=expression2

              The  relation  shall  be  true  if  the  value of expression1 is
              greater than or equal to the value of expression2.

       expression1==expression2

              The relation shall be true if  the  values  of  expression1  and
              expression2 are equal.

       expression1!=expression2

              The  relation  shall  be  true  if the values of expression1 and
              expression2 are unequal.

       There are only two storage classes in bc: global and automatic (local).
       Only identifiers that are local to a function need be declared with the
       auto command. The arguments  to  a  function  shall  be  local  to  the
       function.  All other identifiers are assumed to be global and available
       to all functions. All  identifiers,  global  and  local,  have  initial
       values  of  zero.   Identifiers  declared as auto shall be allocated on
       entry to the function and released on returning from the function. They
       therefore  do  not  retain  values  between function calls. Auto arrays
       shall be specified by the array name followed by empty square brackets.
       On  entry  to  a  function,  the old values of the names that appear as
       parameters and as automatic variables shall be  pushed  onto  a  stack.
       Until  the  function returns, reference to these names shall refer only
       to the new values.

       References to any of these names from other functions that  are  called
       from  this  function  also  refer  to  the new value until one of those
       functions uses the same name for a local variable.

       When a statement is an expression,  unless  the  main  operator  is  an
       assignment,  execution  of  the  statement shall write the value of the
       expression followed by a <newline>.

       When a statement is a string, execution of the  statement  shall  write
       the value of the string.

       Statements  separated  by  semicolons  or  <newline>s shall be executed
       sequentially. In an interactive invocation of bc, each time a <newline>
       is read that satisfies the grammatical production:

              input_item : semicolon_list NEWLINE

       the sequential list of statements making up the semicolon_list shall be
       executed immediately and any output produced by that execution shall be
       written without any delay due to buffering.

       In  an  if statement ( if( relation) statement), the statement shall be
       executed if the relation is true.

       The while statement ( while( relation) statement) implements a loop  in
       which  the  relation  is  tested;  each  time the relation is true, the
       statement shall  be  executed  and  the  relation  retested.  When  the
       relation is false, execution shall resume after statement.

       A  for  statement(  for(  expression;  relation; expression) statement)
       shall be the same as:

              first-expressionwhile (relation) {
                  statement    last-expression}
       The application shall ensure that all three expressions are present.

       The  break  statement  shall  cause  termination  of  a  for  or  while
       statement.

       The  auto  statement ( auto identifier [, identifier ] ...) shall cause
       the values of the identifiers to be pushed down. The identifiers can be
       ordinary  identifiers  or array identifiers. Array identifiers shall be
       specified by following the array name by  empty  square  brackets.  The
       application shall ensure that the auto statement is the first statement
       in a function definition.

       A define statement:

              define LETTER ( opt_parameter_list ) {
                  opt_auto_define_list    statement_list}

       defines a function  named  LETTER.  If  a  function  named  LETTER  was
       previously  defined,  the  define  statement shall replace the previous
       definition. The expression:

              LETTER ( opt_argument_list )

       shall invoke the function named LETTER. The behavior  is  undefined  if
       the  number of arguments in the invocation does not match the number of
       parameters in the definition. Functions shall be  defined  before  they
       are  invoked.  A  function shall be considered to be defined within its
       own body, so recursive calls are valid. The values of numeric constants
       within  a  function  shall  be interpreted in the base specified by the
       value of the ibase register when the function is invoked.

       The return statements ( return and  return(  expression))  shall  cause
       termination   of  a  function,  popping  of  its  auto  variables,  and
       specification of the result of the function. The first  form  shall  be
       equivalent  to return(0). The value and scale of the result returned by
       the function shall be the value and scale of the expression returned.

       The quit statement ( quit) shall stop execution of a bc program at  the
       point  where  the statement occurs in the input, even if it occurs in a
       function definition, or in an if, for, or while statement.

       The following  functions  shall  be  defined  when  the  -l  option  is
       specified:

       s( expression )

              Sine of argument in radians.

       c( expression )

              Cosine of argument in radians.

       a( expression )

              Arctangent of argument.

       l( expression )

              Natural logarithm of argument.

       e( expression )

              Exponential function of argument.

       j( expression, expression )

              Bessel function of integer order.

       The  scale of the result returned by these functions shall be the value
       of the scale register at the time the function is invoked. The value of
       the scale register after these functions have completed their execution
       shall be the same  value  it  had  upon  invocation.  The  behavior  is
       undefined if any of these functions is invoked with an argument outside
       the domain of the mathematical function.

EXIT STATUS

       The following exit values shall be returned:

       0      All input files were processed successfully.

       unspecified
              An error occurred.

CONSEQUENCES OF ERRORS

       If any file operand is specified and the named file cannot be accessed,
       bc  shall  write  a  diagnostic message to standard error and terminate
       without any further action.

       In an interactive invocation of bc, the utility should print  an  error
       message  and  recover  following  any  error  in  the  input. In a non-
       interactive invocation of bc, invalid input causes undefined  behavior.

       The following sections are informative.

APPLICATION USAGE

       Automatic  variables  in  bc  do not work in exactly the same way as in
       either C or PL/1.

       For historical reasons, the exit status from bc cannot be  relied  upon
       to  indicate  that an error has occurred. Returning zero after an error
       is possible. Therefore, bc should  be  used  primarily  by  interactive
       users (who can react to error messages) or by application programs that
       can somehow validate  the  answers  returned  as  not  including  error
       messages.

       The  bc utility always uses the period ( ’.’ ) character to represent a
       radix point, regardless of any  decimal-point  character  specified  as
       part  of  the  current  locale.  In languages like C or awk, the period
       character is used  in  program  source,  so  it  can  be  portable  and
       unambiguous,  while  the locale-specific character is used in input and
       output. Because there is no distinction between source and input in bc,
       this  arrangement  would  not  be  possible.  Using the locale-specific
       character in bc’s input would introduce ambiguities into the  language;
       consider the following example in a locale with a comma as the decimal-
       point character:

              define f(a,b) {
                  ...
              }
              ...

              f(1,2,3)

       Because of such ambiguities, the period character  is  used  in  input.
       Having   input  follow  different  conventions  from  output  would  be
       confusing in either pipeline usage or interactive usage, so the  period
       is also used in output.

EXAMPLES

       In  the  shell, the following assigns an approximation of the first ten
       digits of ’pi’ to the variable x:

              x=$(printf "%s\n"scale = 10; 104348/33215| bc)

       The following bc program prints the same approximation of ’pi’ , with a
       label, to standard output:

              scale = 10
              "pi equals "
              104348 / 33215

       The following defines a function to compute an approximate value of the
       exponential function (note that such a function is predefined if the -l
       option is specified):

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

       The  following prints approximate values of the exponential function of
       the first ten integers:

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

RATIONALE

       The bc utility is implemented historically as a front-end processor for
       dc;   dc   was   not   selected   to   be   part   of  this  volume  of
       IEEE Std 1003.1-2001 because bc was thought to have  a  more  intuitive
       programmatic  interface.   Current  implementations  that  implement bc
       using dc are expected to be compliant.

       The exit status for error conditions  has  been  left  unspecified  for
       several reasons:

        * The  bc  utility  is  used  in  both interactive and non-interactive
          situations. Different exit codes may  be  appropriate  for  the  two
          uses.

        * It  is unclear when a non-zero exit should be given; divide-by-zero,
          undefined functions, and syntax errors are all possibilities.

        * It is not clear what utility the exit status has.

        * In the 4.3 BSD, System V,  and  Ninth  Edition  implementations,  bc
          works  in  conjunction  with dc. The dc utility is the parent, bc is
          the child. This was done to cleanly terminate bc if dc aborted.

       The decision to have bc exit upon encountering  an  inaccessible  input
       file is based on the belief that bc file1 file2 is used most often when
       at least  file1  contains  data/function  declarations/initializations.
       Having  bc  continue  with  prerequisite  files missing is probably not
       useful. There is no implication in the CONSEQUENCES OF  ERRORS  section
       that  bc  must check all its files for accessibility before opening any
       of them.

       There was considerable debate on the appropriateness  of  the  language
       accepted by bc. Several reviewers preferred to see either a pure subset
       of the C language or some changes to make the language more  compatible
       with  C.  While  the bc language has some obvious similarities to C, it
       has  never  claimed  to  be  compatible  with  any  version  of  C.  An
       interpreter  for  a subset of C might be a very worthwhile utility, and
       it could potentially make bc obsolete.  However,  no  such  utility  is
       known  in  historical practice, and it was not within the scope of this
       volume of IEEE Std 1003.1-2001 to define such a language  and  utility.
       If  and when they are defined, it may be appropriate to include them in
       a  future  version  of  IEEE Std 1003.1.  This   left   the   following
       alternatives:

        1. Exclude    any    calculator   language   from   this   volume   of
           IEEE Std 1003.1-2001.

       The consensus of the standard developers was that a simple programmatic
       calculator   language   is   very  useful  for  both  applications  and
       interactive users. The only arguments for excluding any calculator were
       that  it  would become obsolete if and when a C-compatible one emerged,
       or that the absence would  encourage  the  development  of  such  a  C-
       compatible  one. These arguments did not sufficiently address the needs
       of current application writers.

        2. Standardize the historical dc, possibly with minor modifications.

       The consensus of the standard developers was that dc is a fundamentally
       less  usable  language  and that that would be far too severe a penalty
       for avoiding the issue of being similar to but incompatible with C.

        3. Standardize the historical bc, possibly with minor modifications.

       This was the approach taken. Most of the  proponents  of  changing  the
       language  would  not  have  been  satisfied  until  most  or all of the
       incompatibilities with C were  resolved.  Since  most  of  the  changes
       considered  most  desirable  would  break  historical  applications and
       require significant modification to historical implementations,  almost
       no  modifications  were made. The one significant modification that was
       made was the replacement of the historical bc assignment operators "=+"
       ,  and so on, with the more modern "+=" , and so on. The older versions
       are considered to  be  fundamentally  flawed  because  of  the  lexical
       ambiguity in uses like a=-1.

       In order to permit implementations to deal with backwards-compatibility
       as they see fit, the behavior of this one ambiguous construct was  made
       undefined.  (At  least three implementations have been known to support
       this change already, so the degree of change  involved  should  not  be
       great.)

       The  ’%’  operator is the mathematical remainder operator when scale is
       zero. The behavior of this operator for other values of scale  is  from
       historical  implementations of bc, and has been maintained for the sake
       of historical applications despite its non-intuitive nature.

       Historical implementations permit setting ibase and obase to a  broader
       range  of values. This includes values less than 2, which were not seen
       as sufficiently useful to standardize.  These  implementations  do  not
       interpret  input properly for values of ibase that are greater than 16.
       This is because numeric constants are recognized syntactically,  rather
       than  lexically,  as  described in this volume of IEEE Std 1003.1-2001.
       They are built from lexical tokens of  single  hexadecimal  digits  and
       periods. Since <blank>s between tokens are not visible at the syntactic
       level, it is not possible to recognize the multi-digit "digits" used in
       the  higher  bases  properly.  The  ability to recognize input in these
       bases was not considered  useful  enough  to  require  modifying  these
       implementations.  Note that the recognition of numeric constants at the
       syntactic level is not a problem with conformance  to  this  volume  of
       IEEE Std 1003.1-2001,  as it does not impact the behavior of conforming
       applications (and correct bc programs). Historical implementations also
       accept  input with all of the digits ’0’ - ’9’ and ’A’ - ’F’ regardless
       of the value of ibase; since digits with value greater than or equal to
       ibase  are  not  really  appropriate,  the behavior when they appear is
       undefined, except for the common case of:

              ibase=8;
                  /* Process in octal base. */
              ...
              ibase=A
                  /* Restore decimal base. */

       In some historical implementations, if the expression to be written  is
       an  uninitialized  array  element,  a leading <space> and/or up to four
       leading 0 characters may be output  before  the  character  zero.  This
       behavior  is  considered  a  bug;  it  is  unlikely  that any currently
       conforming application relies on:

              echob[3]| bc

       returning 00000 rather than 0.

       Exact calculation of the number of fractional digits to  output  for  a
       given  value  in a base other than 10 can be computationally expensive.
       Historical implementations use a  faster  approximation,  and  this  is
       permitted.  Note  that  the  requirements apply only to values of obase
       that this volume of IEEE Std 1003.1-2001  requires  implementations  to
       support  (in  particular,  not  to  1,  0,  or  negative  bases,  if an
       implementation supports them as an extension).

       Historical implementations of bc did not allow array parameters  to  be
       passed  as  the  last  parameter to a function. New implementations are
       encouraged to remove this restriction even though it is not required by
       the grammar.

FUTURE DIRECTIONS

       None.

SEE ALSO

       Grammar Conventions , awk

COPYRIGHT

       Portions  of  this text are reprinted and reproduced in electronic form
       from IEEE Std 1003.1, 2003 Edition, Standard for Information Technology
       --  Portable  Operating  System  Interface (POSIX), The Open Group Base
       Specifications Issue 6, Copyright (C) 2001-2003  by  the  Institute  of
       Electrical  and  Electronics  Engineers, Inc and The Open Group. In the
       event of any discrepancy between this version and the original IEEE and
       The  Open Group Standard, the original IEEE and The Open Group Standard
       is the referee document. The original Standard can be  obtained  online
       at http://www.opengroup.org/unix/online.html .