Main index | Section 1 | 日本語 | 한국인 | Options |

Options available:

| |

bc
is actually a preprocessor for
dc(1),
which it invokes automatically, unless the
| |

expression , expression
| |

Evaluate
expression.
If multiple
| |

| |

Prints usage information. | |

| |

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

| |

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

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

- 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' statement.
- 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. - 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. - The boolean operators (!, && and ||) are non-portable extensions.
- 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.

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

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

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

prints an approximation of pi.

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

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")
specification.

The flags
[

The
**bc**
command first appeared in
*AT&T v6 .*
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**
utility are not implemented (yet).

BC (1) | November 21, 2015 |

Main index | Section 1 | 日本語 | 한국인 | Options |

Please direct any comments about this manual page service to Ben Bullock.

“ | Never write it in C if you can do it in `awk'; Never do it in `awk' if `sed' can handle it; Never use `sed' when `tr' can do the job; Never invoke `tr' when `cat' is sufficient; Avoid using `cat' whenever possible. |
” |

— Taylor's Laws of Programming |