bc(1) - phpMan

Command: man perldoc info search(apropos)  


BC(1P)                              POSIX Programmer's Manual                              BC(1P)



PROLOG
       This  manual  page  is part of the POSIX Programmer's Manual.  The Linux implementation of
       this interface may differ (consult the corresponding Linux  manual  page  for  details  of
       Linux behavior), or the interface may not be implemented on Linux.

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  stan-
       dard  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,  Sec-
       tion 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 func-
       tion 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, Inter-
              nationalization 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 interna-
              tionalization 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 argu-
              ments and input files).

       LC_MESSAGES
              Determine the locale that should be used to affect the format and contents of diag-
              nostic 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 "*/" . Com-
           ments 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  charac-
           ters 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  charac-
           ters  shall have the value from 0 to 15 in the order listed here, and the period char-
           acter 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  func-
       tion  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 opera-
       tors. 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 Con-
       ventions 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 dig-
           its 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 contin-
       ued 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 brack-
       ets.  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 expres-
              sion. 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 func-
       tion  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, ref-
       erence 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  immedi-
       ately  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  rela-
       tion 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  iden-
       tifiers.  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  argu-
       ments  in  the invocation does not match the number of parameters in the definition. Func-
       tions 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 func-
       tion, 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 regis-
       ter at the time the function is invoked. The value of the scale register after these func-
       tions 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 lan-
       guages like C or awk, the period character is used in program source, so it can be  porta-
       ble  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  interac-
       tive 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 func-
       tion (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 inte-
       gers:


              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 func-
          tions, 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 termi-
          nate 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 proba-
       bly 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.  Sev-
       eral  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 similari-
       ties 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  obso-
       lete.  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  lan-
       guage  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  lan-
       guage and that that would be far too severe a penalty for avoiding the issue of being sim-
       ilar 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  his-
       torical 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 implemen-
       tations  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  standard-
       ize.   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 "dig-
       its" 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 cur-
       rently conforming application relies on:


              echo 'b[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 orig-
       inal Standard can be obtained online at http://www.opengroup.org/unix/online.html .



IEEE/The Open Group                            2003                                        BC(1P)

Generated by $Id: phpMan.php,v 4.55 2007/09/05 04:42:51 chedong Exp $ Author: Che Dong
On Apache
Under GNU General Public License
2018-02-23 18:11 @127.0.0.1 CrawledBy CCBot/2.0 (http://commoncrawl.org/faq/)
Valid XHTML 1.0!Valid CSS!