Skip site navigation (1)Skip section navigation (2)

FreeBSD Man Pages

Man Page or Keyword Search:
Man Architecture
Apropos Keyword Search (all sections) Output format
home | help
BC(1)			FreeBSD	General	Commands Manual			 BC(1)

NAME
     bc	-- arbitrary-precision arithmetic language and calculator

SYNOPSIS
     bc	[-chlqv] [-e expression] [file ...]

DESCRIPTION
     bc	is an interactive processor for	a language which resembles C but pro-
     vides unlimited precision arithmetic.  It takes input from	any expres-
     sions 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 auto-
	     matically,	unless the -c (compile only) option is present.	 In
	     this case the generated dc(1) instructions	are sent to the	stan-
	     dard output, instead of being interpreted by a running dc(1)
	     process.

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

     -h, --help
	     Prints usage information.

     -l, --mathlib
	     Allow specification of an arbitrary precision math	library.  The
	     definitions in the	library	are available to command line expres-
	     sions.  Synonym for -l.

     -v, --version
	     Prints version information.

     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 pos-
     sible 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.

     Comments
	   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.

     Names
	   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.

     Operators

     The following arithmetic and logical operators can	be used.  The seman-
     tics 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 expres-
	       sion a <	b < c will produce a syntax error.

	   +o   The boolean operators (!, && and	||) are	non-portable exten-
	       sions.

	   +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 pro-
	       grammers	use parentheses	when writing expressions involving
	       boolean operators.

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

     A string may contain any character, except	double quote.  The if state-
     ment 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 con-
     tinue 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 ()
	   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 vari-
     able 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
     integers.

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

     prints an approximation of	pi.

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

SEE ALSO
     dc(1)

     "BC - An Arbitrary	Precision Desk-Calculator Language",
     /usr/share/doc/usd/06.bc/.

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

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

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

AUTHORS
     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.

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

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

FreeBSD	10.1		       January 22, 2010			  FreeBSD 10.1

NAME | SYNOPSIS | DESCRIPTION | FILES | SEE ALSO | STANDARDS | HISTORY | AUTHORS | BUGS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=bc&sektion=1&manpath=FreeBSD+9.3-RELEASE>

home | help