~ubuntu-branches/ubuntu/oneiric/bc/oneiric

 

 

File: bc.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)

* Functions::

* Examples::

* Readline and Libedit Options::

* Limits::

* Environment Variables::

 

 

File: bc.info,  Node: Introduction,  Next: Basic Elements,  Prev: Top,  Up: Top

 

 

* Menu:

 

 

File: bc.info,  Node: Description,  Next: Command Line Options,  Prev: Introduction,  Up: Introduction

 

 

 

   `bc' is a language that supports arbitrary precision numbers with

interactive execution of statements.  There are some similarities in

 

File: bc.info,  Node: Command Line Options,  Next: Numbers,  Prev: Description,  Up: Introduction

 

 

`-h, --help'

     Print the usage and exit.

 

`-v, --version'

     Print the version number and copyright and quit.

 

 

File: bc.info,  Node: Basic Elements,  Next: Expressions,  Prev: Introduction,  Up: Top

 

 

* Menu:

 

 

File: bc.info,  Node: Numbers,  Next: Variables,  Prev: Command Line Options,  Up: Basic Elements

 

 

precision numbers.  This precision is both in the integer part and the

fractional part.  All numbers are represented internally in decimal and

all computation is done in decimal.  (This version truncates results

 

File: bc.info,  Node: Variables,  Next: Comments,  Prev: Numbers,  Up: Basic Elements

 

 

arrays.  Both simple variables and array variables are named.  Names

begin with a letter followed by any number of letters, digits and

underscores.  All letters must be lower case.  (Full alphanumeric names

 

File: bc.info,  Node: Comments,  Prev: Variables,  Up: Basic Elements

 

 

characters `*/'.  Comments may start anywhere and appear as a single

space in the input.  (This causes comments to delimit other input

items.  For example, a comment can not be found in the middle of a

 

File: bc.info,  Node: Expressions,  Next: Statements,  Prev: Basic Elements,  Up: Top

 

 

* Menu:

 

 

File: bc.info,  Node: About Expressions and Special Variables,  Next: Basic Expressions,  Prev: Expressions,  Up: Expressions

 

 

later, are defined when encountered.)

 

   A simple expression is just a constant. `bc' converts constants into

 

File: bc.info,  Node: Basic Expressions,  Next: Relational Expressions,  Prev: About Expressions and Special Variables,  Up: Expressions

 

 

A simple variable is just a

 

   NAME

 

File: bc.info,  Node: Relational Expressions,  Next: Boolean Expressions,  Prev: Basic Expressions,  Up: Expressions

 

 

evaluate to 0 or 1, 0 if the relation is false and 1 if the relation is

true.  These may appear in any legal expression.  (POSIX `bc' requires

that relational expressions are used only in `if', `while', and `for'

 

File: bc.info,  Node: Boolean Expressions,  Next: Precedence,  Prev: Relational Expressions,  Up: Expressions

 

 

 

`!expr'

     The result is 1 if expr is 0.

 

File: bc.info,  Node: Precedence,  Next: Special Expressions,  Prev: Boolean Expressions,  Up: Expressions

 

 

 

     || operator, left associative

     && operator, left associative

 

File: bc.info,  Node: Special Expressions,  Prev: Precedence,  Up: Expressions

 

 

These have to do with user-defined functions and standard functions.

They all appear as "NAME`('PARAMETERS`)'".  *Note Functions::, for

user-defined functions.  The standard functions are:

 

File: bc.info,  Node: Statements,  Next: Functions,  Prev: Expressions,  Up: Top

 

 

* Menu:

 

 

File: bc.info,  Node: Pseudo Statements,  Prev: Statements,  Up: Statements

 

 

 

`limits'

     Print the local limits enforced by the local version of `bc'.  This

 

File: bc.info,  Node: Functions,  Next: Examples,  Prev: Statements,  Up: Top

 

 

* Menu:

 

 

   Parameters are numbers or arrays (an extension).  In the function

definition, zero or more parameters are defined by listing their names

 

   The AUTO_LIST is an optional list of variables that are for "local"

use.  The syntax of the auto list (if present) is "`auto' NAME, ... ;".

function `read', which will always use the current value of IBASE for

conversion of numbers.

 

 

        define d (n) { return (2*n); }

        define d (n)

            { return (2*n); }

 

 

File: bc.info,  Node: Math Library Functions,  Prev: Functions,  Up: Functions

 

 

and the default SCALE is set to 20.  The math functions will calculate

their results to the scale set at the time of their call.  The math

library defines the following functions:

`l (X)'

     The natural logarithm of X.

 

     The exponential function of raising E to the value X.

 

 

 

File: bc.info,  Node: Examples,  Next: Readline and Libedit Options,  Prev: Functions,  Up: Top

 

 

variable PI.

 

     pi=$(echo "scale=10; 4*a(1)" | bc -l)

 

 

     scale = 20

     /* Uses the fact that e^x = (e^(x/2))^2

        When x is small enough, we use the series:

          e^x = 1 + x + x^2/2! + x^3/3! + ...

     */

     define e(x) {

       auto  a, d, e, f, i, m, v, z

       /* Check the sign of x. */

       if (x<0) {

         m = 1

         x = -x

       }

       /* Precondition x. */

       z = scale;

       scale = 4 + z + .44*x;

         f += 1;

         x /= 2;

       }

       /* Initialize the variables. */

       v = 1+x

       a = x

       d = 1

       for (i=2; 1; i++) {

         e = (a *= x) / (d *= i)

         if (e == 0) {

     print "\nCheck book program\n!"

     print "  Remember, deposits are negative transactions.\n"

     print "  Exit by a 0 transaction.\n\n"

     print "Initial balance? "; bal = read()

     bal /= 1

     print "\n"

     }

 

 

`readline' input editor library or the BSD `libedit' library.  This

allows the user to do more editing of lines before sending them to

`bc'.  It also allows for a history of previous lines typed.  When this

same time.

 

 

traditional way using `dc'.  This version is a single process which

parses and runs a byte code translation of the program.  There is an

"undocumented" option (-c) that causes the program to output the byte

     session, the SIGINT signal will terminate the entire run of `bc'.

 

 

processor.  Some of them may have been changed by an installation.  Use

the `limits' statement to see the actual values.

 

 

File: bc.info,  Node: Environment Variables,  Prev: Limits,  Up: Top

 

 

 

`POSIXLY_CORRECT'

     This is the same as the -s option (*note Command Line Options::).

`BC_ENV_ARGS'

     This is another mechanism to get arguments to `bc'.  The format is

     the same as the command line arguments.  These arguments are

     are processed before any command line argument files.  This allows

     the user to set up "standard" options and files to be processed at

     every invocation of `bc'.  The files in the environment variables

     wants defined every time `bc' is run.

 

`BC_LINE_LENGTH'

     output line for numbers. This includes the backslash and newline

 

 

 

Tag Table:

 

End Tag Table