*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Tru64 Unix man pages -> bc (1)              



NAME    [Toc]    [Back]

       bc  -  Provides a processor for arbitrary-precision arithmetic

SYNOPSIS    [Toc]    [Back]

       bc [-cl] [file...]

       The bc command is an  interactive  program  that  provides
       unlimited  precision arithmetic.  It is a preprocessor for
       the dc command.

STANDARDS    [Toc]    [Back]

       Interfaces documented on this reference  page  conform  to
       industry standards as follows:

       bc:  XCU5.0

       Refer to the standards(5) reference page for more information
 about industry standards and associated tags.

OPTIONS    [Toc]    [Back]

       [Tru64 UNIX]  Compiles  file,  but  does  not  invoke  dc.
       Includes  a  library of mathematical functions.  Also sets
       the number of digits retained after the decimal point (the
       scale) to 20; by default the scale is 0.

OPERANDS    [Toc]    [Back]

       Pathname  of  a  text  file containing program statements.
       After file has been exhausted, standard input is read.

DESCRIPTION    [Toc]    [Back]

       [Tru64 UNIX]  The bc  command  invokes  dc  automatically,
       unless  the -c (compile only) option is specified.  If the
       -c option is specified, the output from  bc  goes  to  the
       standard output.

       The  bc  command lets you specify an input and output base
       in decimal, octal, or hexadecimal (the  default  is  decimal).
   The command also has a scaling provision for decimal
 point notation.  The syntax for bc is similar to  that
       of the C language.

       The  bc command takes input first from the specified file.
       When bc reaches the end of the input file, it reads  standard

       In  the  following  description  of  syntax for bc, letter
       means one of the letters a-z.

   Comments    [Toc]    [Back]
       Comments are enclosed in /* and */.

   Names    [Toc]    [Back]
       Simple variables: letter

       Array elements: letter[expression]

       The words ibase, obase, and scale

   Other Operands    [Toc]    [Back]
       Arbitrarily long numbers with optional  sign  and  decimal
       point.   Number  of  significant  decimal digits Number of
       digits to right of decimal point

   Operators    [Toc]    [Back]
       +  -  *  /  %  ^  (% is remainder; ^ is power)

       ++  -- (prefix and suffix; apply to names)

       ==  <=  >=  !=  <>

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

       +=  -=  *=  /=  %=

   Statements    [Toc]    [Back]


       if (expression) statement

       while (expression) statement

       for (expression;expression;expression) statement

       (null statement)



   Function Definitions    [Toc]    [Back]
       define letter ( letter,...,letter ) {

              auto letter,...,letter
              return ( expression ) }

   Functions in -l Math Library    [Toc]    [Back]
       sine cosine exponential log arctangent Bessel function

   General Syntax    [Toc]    [Back]
       All function parameters are passed by value.

       The value of a statement that is  an  expression  is  displayed,
  unless  the  main  operator  is an assignment.  A
       semicolon  or  newline  character  separates   statements.
       Assignments  to scale control the number of decimal places
       printed on output and  maintained  during  multiplication,
       division,  and  exponentiation.   Assignments  to ibase or
       obase set the input and output number radix, respectively.

       The  same  letter may refer to an array, a function, and a
       simple variable simultaneously.  All variables are  global
       to  the program.  Automatic variables are pushed down during
 function calls. When you use arrays as function parameters,
 or define them as automatic variables, empty brackets
 must follow the array name.

       All for statements must have all three expressions.

       The quit statement is interpreted when read, not when executed.

EXIT STATUS    [Toc]    [Back]

       The following exit values are returned: Successful completion.
  An error occurred.

EXAMPLES    [Toc]    [Back]

       When you enter bc expressions directly from the  keyboard,
       press  the  End-of-File key sequence to end the bc session
       and return to the shell command line.  To use bc as a calculator,
 proceed as follows:

              Enter: $ bc 1/4

              The system responds as follows: 0

              Enter: scale = 1  /* Keep 1 decimal place  */ 1/4

              The system responds as follows: 0.2

              Enter: scale = 3  /* Keep 3 decimal places */ 1/4

              The system responds as follows: 0.250

              Enter: 16+63/5

              The system responds as follows: 28.600

              Enter: (16+63)/5

              The system responds as follows: 15.800

              Enter: 71/6

              The system responds as follows: 11.833

              Enter: 1/6

              The system responds as follows: 0.166

              You  may type the comments (enclosed in /* */), but
              they are provided only for your information. The bc
              command  displays the value of each expression when
              you press <Return>,  except  for  assignments.   To
              convert  numbers  from one base to another, proceed
              as follows:

              Enter: bc obase = 16     /* Display numbers in Hexadecimal
  */  ibase  =  8      /*  Input numbers in
              Octal     */ 12

              The system responds as follows: A

              Enter: 123

              The system responds as follows: 53

              Enter: 123456

              The system responds as follows: A72E To  write  and
              run C-like programs, proceed as follows:

              Create the following file prog.bc:

              /* compute the factorial of n */

                define f(n) {      auto i, r;

                   r  =  1;       for  (i=2;  i<=n;  i++) r =* i;
                   return (r);

              Enter: bc -l prog.bc

              This interprets the bc program  saved  in  prog.bc,
              then reads more bc command statements from standard
              input (the keyboard). Starting the bc command  with
              the  -l  option  makes  the math library available.
              This example uses the e (exponential) function from
              the  math  library, and f is defined in the program

              Enter: e(2) /*  e squared  */

              The      system      responds      as      follows:

              Enter: f(5) /*  5 factorial */

              The system responds as follows: 120

              Enter: f(10)     /* 10 factorial */

              The system responds as follows: 3628800

              The  statement  following  a for or while statement
              must begin on the same line.  To convert  an  infix
              expression to Reverse Polish Notation (RPN), enter:

              Enter: bc -c (a * b) % (3 + 4 * c)

              The system responds as follows: lalb* 3 4lc*+%ps.

              This compiles the bc infix-notation expression into
              one that the dc command can interpret.  The dc command
 evaluates extended RPN  expressions.   In  the
              compiled  output, the lowercase l before each variable
 name is the dc subcommand to load the value of
              the  variable  onto  the stack.  The p displays the
              value on top of the stack, and the s.  discards the
              top  value  by storing it in register . (dot).  You
              can save the RPN expression in a  file  for  dc  to
              evaluate  later  by redirecting the standard output
              of this command.


       The following environment variables affect  the  execution
       of  bc: Provides a default value for the internationalization
 variables that are unset or null. If LANG is unset or
       null,  the  corresponding value from the default locale is
       used.  If any of the internationalization  variables  contain
 an invalid setting, the utility behaves as if none of
       the variables had been defined.  If  set  to  a  non-empty
       string value, overrides the values of all the other internationalization
 variables.  Determines the locale for  the
       interpretation of sequences of bytes of text data as characters
 (for example, single-byte as opposed  to  multibyte
       characters  in  arguments).  Determines the locale for the
       format and contents  of  diagnostic  messages  written  to
       standard  error.  Determines the location of message catalogues
 for the processing of LC_MESSAGES.

FILES    [Toc]    [Back]

       Mathematical library.  Desk calculator proper; uses bc  as

SEE ALSO    [Toc]    [Back]

       Commands:  awk(1), dc(1)

       Standards:  standards(5)

[ Back ]
 Similar pages
Name OS Title
bc HP-UX arbitrary-precision arithmetic language
bc OpenBSD arbitrary-precision arithmetic language and calculator
bc IRIX An arbitrary precision calculator language
bc FreeBSD An arbitrary precision calculator language
dc Tru64 Provides an interactive desk calculator for arbitrary precision integer arithmetic
dc IRIX an arbitrary precision calculator
dc FreeBSD an arbitrary precision calculator
m4 FreeBSD macro language processor
m4 OpenBSD macro language processor
mp Tru64 Perform multiple precision integer arithmetic
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service