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

FreeBSD Manual Pages


home | help
BC(1)			  BSD General Commands Manual			 BC(1)

     bc	-- arbitrary-precision arithmetic language and calculator

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

     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

     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)

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

     -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

	   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 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.1-2008 ("POSIX.1")	standard only allows them in
	       the conditional expression of an	`if', `while' or `for' state-

	   +o   The relational operators	have a lower precedence	than the as-
	       signment	operators.  This has the consequence that the expres-
	       sion 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-

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

	   { 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 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 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	equiv-
     alent 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

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

     prints an approximation of	pi.

     bc	supports interactive command line editing, via the editline(3) li-
     brary.  It	is enabled by default if input is from a tty.  Previous	lines
     can be recalled and edited	with the arrow keys, and other GNU Emacs-style
     editing keys may be used as well.

     The editline(3) library is	configured with	a .editrc file - refer to
     editrc(5) for more	information.

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

     The -q and	--quiet	options	are no-ops for compatibility with some other
     implementations of	bc and their use is discouraged.


     The bc utility is compliant with the IEEE Std 1003.1-2008 ("POSIX.1")

     The flags [-ce], as well as the parts noted above,	are extensions to that

     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.

     The `quit'	statement 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).

BSD			       November	21, 2015			   BSD


Want to link to this manual page? Use this URL:

home | help