BC(1) | General Commands Manual | BC(1) |

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

**-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) process.**-e**`expression`- Evaluate
`expression`. If multiple**-e**options are specified, they are processed in the order given, separated by newlines. **-l**- Include an arbitrary precision math library. The definitions in the library are available to command line expressions and are documented below.

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

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

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 )

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 |

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

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

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

return return () return E

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

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

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

$ bc -l -e 'scale = 500; 4 * a(1)' -e quit

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

`quit`

’ statement is interpreted when
read, not when executed.
Some non-portable extensions, as found in the GNU version of the
October 9, 2017 | OpenBSD-current |