bc man page on OpenBSD

Man page or keyword search:  
man Server   11362 pages
apropos Keyword Search (all sections)
Output format
OpenBSD logo
[printable version]

BC(1)			   OpenBSD Reference Manual			 BC(1)

     bc - arbitrary-precision arithmetic language and calculator

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

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

     Options available:

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

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

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

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

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

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

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

     Other operands
	   arbitrarily long numbers with optional sign and decimal point
	   ( E )
	   sqrt ( E )
	   length ( E )	  number of significant decimal digits
	   scale ( E )	  number of digits right of decimal point
	   L ( E , ... , E )

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


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

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

     Note the following:

	   o   The relational operators may appear in any expression.  The
	       IEEE Std 1003.2 (``POSIX.2'') standard only allows them in the
	       conditional expression of an `if', `while' or `for' statement.

	   o   The relational operators have a lower precedence than the
	       assignment operators.  This has the consequence that the
	       expression a = b < c is interpreted as (a = b) < c, which is
	       probably not what the programmer intended.

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

	   o   The boolean operators (!, && and ||) are non-portable

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

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

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

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

     Function definitions

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

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

	   return ()
	   return E

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

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

	   s(x)	   sine
	   c(x)	   cosine
	   e(x)	   exponential
	   l(x)	   log
	   a(x)	   arctangent
	   j(n,x)  Bessel function

     All function arguments are passed by value.

     The value of a statement that is an expression is printed unless the main
     operator is an assignment.	 The value printed is assigned to the special
     variable `last'.  This is a non-portable extension.  A single dot may be
     used as a synonym for `last'.  Either semicolons or newlines may separate
     statements.  Assignment to scale influences the number of digits to be
     retained on arithmetic operations in the manner of dc(1).	Assignments to
     ibase or obase set the input and output number radix respectively.

     The same letter may be used as an array, a function, and a simple
     variable simultaneously.  All variables are global to the program.
     `Auto' variables are pushed down during function calls.  When using
     arrays as function arguments or defining them as automatic variables,
     empty square brackets must follow the array name.

     For example

	   scale = 20
	   define e(x){
		   auto a, b, c, i, s
		   a = 1
		   b = 1
		   s = 1
		   for(i=1; 1==1; i++){
			   a = a*x
			   b = b*i
			   c = a/b
			   if(c == 0) return(s)
			   s = s+c

     defines a function to compute an approximate value of the exponential
     function and

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

     prints approximate values of the exponential function of the first ten

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

     prints an approximation of pi.

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


     The bc utility is compliant with the IEEE Std 1003.1-2008 (``POSIX'')

     The flags [-ce] are extensions to that specification.

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

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

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

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

OpenBSD 4.9		       October 18, 2010			   OpenBSD 4.9

List of man pages available for OpenBSD

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
Vote for polarhome
Free Shell Accounts :: the biggest list on the net