Changeset View
Changeset View
Standalone View
Standalone View
contrib/bc/manuals/bc.1.ronn
bc(1) -- arbitrary-precision arithmetic language and calculator | |||||
=============================================================== | |||||
SYNOPSIS | |||||
-------- | |||||
`bc` [`-ghilPqsvVw`] [`--global-stacks`] [`--help`] [`--interactive`] | |||||
[`--mathlib`] [`--no-prompt`] [`--quiet`] [`--standard`] [`--warn`] | |||||
[`--version`] [`-e` *expr*] [`--expression=`*expr*...] [`-f` *file*...] | |||||
[`-file=`*file*...] [*file*...] | |||||
DESCRIPTION | |||||
----------- | |||||
bc(1) is an interactive processor for a language first standardized in 1991 by | |||||
POSIX. (The current standard is [here][1].) The language provides unlimited | |||||
precision decimal arithmetic and is somewhat C-like, but there are differences. | |||||
Such differences will be noted in this document. | |||||
After parsing and handling options, this bc(1) reads any files given on the | |||||
command line and executes them before reading from `stdin`. | |||||
With all build options, except for extra math, enabled this bc(1) is a drop-in | |||||
replacement for ***any*** bc(1), including (and especially) the GNU bc(1). It is | |||||
also a drop-in replacement for any bc(1) if extra math is enabled, but it will | |||||
have extra features not found in other bc(1) implementations. | |||||
OPTIONS | |||||
------- | |||||
The following are the options that bc(1) accepts. | |||||
* `-g`, `--global-stacks`: | |||||
Turns the globals `ibase`, `obase`, and `scale` into stacks. | |||||
This has the effect that a copy of the current value of all three are pushed | |||||
onto a stack for every function call, as well as popped when every function | |||||
returns. This means that functions can assign to any and all of those | |||||
globals without worrying that the change will affect other functions. | |||||
Thus, `output(x,b)` (in the [extended library](#extended-library)) could | |||||
have been written like this: | |||||
`define void output(x, b) { obase=b; x }` | |||||
instead of like this: | |||||
`define void output(x, b) { auto c; c=obase; obase=b; x; obase=c }` | |||||
This makes writing functions much easier. | |||||
However, since using this flag means that functions cannot set `ibase`, | |||||
`obase`, or `scale` globally, functions that are made to do so cannot work | |||||
anymore. There are two possible use cases for that, and each has a solution. | |||||
First, if a function is called on startup to turn bc(1) into a number | |||||
converter, it is possible to replace that capability with various shell | |||||
aliases. Examples: | |||||
`alias d2o="bc -e ibase=A -e obase=8"; alias h2b="bc -e ibase=G -e obase=2"` | |||||
Second, if a function's purpose is to set `ibase`, `obase`, or `scale` | |||||
globally for any other purpose, it could be split into one to three | |||||
functions (based on how many globals it sets) and each of those functions | |||||
could return the desired value for a global. | |||||
If this behavior is desired for every run of bc(1), then users could make | |||||
sure to define `BC_ENV_ARGS` and include this option (see the | |||||
ENVIRONMENT VARIABLES section for more details). | |||||
If `-s`, `-w`, or any equivalents are used, this option is ignored. | |||||
This is a **non-portable extension**. | |||||
* `-h`, `--help`: | |||||
Prints a usage message and quits. | |||||
* `-i`, `--interactive`: | |||||
Forces interactive mode. | |||||
Per the [standard][1], bc(1) has an interactive mode and a non-interactive | |||||
mode. The interactive mode is turned on automatically when both `stdin` and | |||||
`stdout` are hooked to a terminal, but this flag can turn it on in other | |||||
cases. In interactive mode, bc(1) attempts to recover from errors (see the | |||||
RESET section), and in normal execution, flushes `stdout` as soon as | |||||
execution is done for the current input. | |||||
This is a **non-portable extension**. | |||||
* `-l`, `--mathlib`: | |||||
Sets `scale` (see the Scale section) to `20` and loads the included math | |||||
library before running any code, including any expressions or files | |||||
specified on the command line. | |||||
To learn what is in the library, see the LIBRARY section. | |||||
* `-P`, `--no-prompt`: | |||||
Disables the prompt in interactive mode. This is mostly for those users that | |||||
do not want a prompt or are not used to having them in `bc`. Most of those | |||||
users would want to put this option in `BC_ENV_ARGS`. | |||||
This is a **non-portable extension**. | |||||
* `-q`, `--quiet`: | |||||
Do not print copyright header. bc(1) will also suppress the header in | |||||
non-interactive mode. | |||||
This is mostly for compatibility with the [GNU bc(1)][2]. | |||||
This is a **non-portable extension**. | |||||
* `-s`, `--standard`: | |||||
Process exactly the language defined by the [standard][1] and error if any | |||||
extensions are used. | |||||
This is a **non-portable extension**. | |||||
* `-v`, `-V`, `--version`: | |||||
Print the version information (copyright header) and exit. | |||||
This is a **non-portable extension**. | |||||
* `-w`, `--warn`: | |||||
Like `-s` and `--standard`, except that warnings (and not errors) are given | |||||
for non-standard extensions. | |||||
This is a **non-portable extension**. | |||||
* `-e` *expr*, `--expression`=*expr*: | |||||
Evaluates `expr`. If multiple expressions are given, they are evaluated in | |||||
order. If files are given as well (see below), the expressions and files are | |||||
evaluated in the order given. This means that if a file is given before an | |||||
expression, the file is read in and evaluated first. | |||||
In other bc(1) implementations, this option causes the program to execute | |||||
the expressions and then exit. This bc(1) does not, unless the | |||||
`BC_EXPR_EXIT` is defined (see the ENVIRONMENT VARIABLES section). | |||||
This is a **non-portable extension**. | |||||
* `-f` *file*, `--file`=*file*: | |||||
Reads in `file` and evaluates it. If expressions are also given (see above), | |||||
the expressions are evaluated in the order given. | |||||
In other bc(1) implementations, this option causes the program to execute | |||||
the files and then exit. This bc(1) does not, unless the | |||||
`BC_EXPR_EXIT` is defined (see the ENVIRONMENT VARIABLES section). | |||||
This is a **non-portable extension**. | |||||
STDOUT | |||||
------ | |||||
Any non-error output is written to `stdout`. | |||||
**Note**: Unlike other bc(1) implementations, this bc(1) will issue a fatal | |||||
error (see the EXIT STATUS section) if it cannot write to `stdout`, so if | |||||
`stdout` is closed, as in `bc <file> >&-`, it will quit with an error. This is | |||||
done so that bc(1) can report problems when `stdout` is redirected to a file. | |||||
If there are scripts that depend on the behavior of other bc(1) implementations, | |||||
it is recommended that those scripts be changed to redirect `stdout` to | |||||
`/dev/null`. | |||||
STDERR | |||||
------ | |||||
Any error output is written to `stderr`. | |||||
**Note**: Unlike other bc(1) implementations, this bc(1) will issue a fatal | |||||
error (see the EXIT STATUS section) if it cannot write to `stderr`, so if | |||||
`stderr` is closed, as in `bc <file> 2>&-`, it will quit with an error. This is | |||||
done so that bc(1) can report problems when `stderr` is redirected to a file. | |||||
If there are scripts that depend on the behavior of other bc(1) implementations, | |||||
it is recommended that those scripts be changed to redirect `stderr` to | |||||
`/dev/null`. | |||||
SYNTAX | |||||
------ | |||||
The syntax for bc(1) programs is mostly C-like, with some differences. This | |||||
bc(1) follows the [POSIX standard][1], which is a much more thorough resource | |||||
for the language this bc(1) accepts. This section is meant to be a summary and a | |||||
listing of all the extensions to the [standard][1]. | |||||
In the sections below, `E` means expression, `S` means statement, and `I` means | |||||
identifier. | |||||
Identifiers (`I`) start with a lowercase letter and can be followed by any | |||||
number (up to `BC_NAME_MAX-1`) of lowercase letters (`a-z`), digits (`0-9`), and | |||||
underscores (`_`). The regex is `[a-z][a-z0-9_]*` Identifiers with more than one | |||||
character (letter) are a **non-portable extension**. | |||||
`ibase` is a global variable determining how to interpret constant numbers. It | |||||
is the "input" base, or the number base used for interpreting input numbers. | |||||
`ibase` is initially `10`. If the `-s` (`--standard`) and `-w` (`--warn`) flags | |||||
were not given on the command line, the max allowable value for `ibase` is `36`. | |||||
Otherwise, it is `16`. The min allowable value for `ibase` is `2`. The max | |||||
allowable value for `ibase` can be queried in bc(1) programs with the | |||||
`maxibase()` built in function. | |||||
`obase` is a global variable determining how to output results. It is the | |||||
"output" base, or the number base used for outputting numbers. `obase` is | |||||
initially `10`. The max allowable value for `obase` is `BC_BASE_MAX`. The min | |||||
allowable value for `obase` is `2`, unless bc(1) was built with the extra math | |||||
option. If it was, then the min allowable value is `0`. In this case, if `obase` | |||||
is `0`, values are output in scientific notation, and if `obase` is `1`, values | |||||
are output in engineering notation. (Outputting in scientific or engineering | |||||
notation are **non-portable extensions**.) The max allowable value for `obase` | |||||
can be queried in bc(1) programs with the `maxobase()` built in function. | |||||
The **scale** of an expression is the number of digits in the result of the | |||||
expression right of the decimal point, and `scale` is a global variable that | |||||
sets the precision of any operations, with exceptions. `scale` is initially `0`. | |||||
`scale` cannot be negative. The max allowable value for `scale` can be queried | |||||
in bc(1) programs with the `maxscale()` built in function. | |||||
bc(1) has both **global** variables and **local** variables. All **local** | |||||
variables are local to the function; they are parameters or are introduced in a | |||||
function's `auto` list (see FUNCTIONS). If a variable is accessed which is not a | |||||
parameter or in the `auto` list, it is assumed to be **global**. If a parent | |||||
function has a **local** variable version of a **global** variable that is | |||||
accessed by a function that it calls, the value of that **global** variable in | |||||
the child function is the value of the variable in the parent function, not the | |||||
value of the actual **global** variable. | |||||
All of the above applies to arrays as well. | |||||
The value of a statement that is an expression (i.e., any of the | |||||
[Named Expressions](#bc-named-expressions) or [Operands](#bc-operands)) is | |||||
printed unless the lowest precedence operator is an | |||||
[`assignment`](#bc-assignment) operator ***and*** the expression is not | |||||
surrounded by parentheses. | |||||
The value that is printed is also assigned to the special variable `last`. A | |||||
single dot (`.`) may also be used as a synonym for `last`. These are | |||||
**non-portable extensions**. | |||||
Either semicolons or newlines may separate statements. | |||||
### Comments | |||||
There are two kinds of comments: | |||||
1. Block comments are enclosed in `/*` and `*/`. | |||||
2. Line comments go from `#` until, and not including, the next newline. This | |||||
is a **non-portable extension**. | |||||
<a name="bc-named-expressions"/> | |||||
### Named Expressions | |||||
1. Variables: `I` | |||||
2. Array Elements: `I[E]` | |||||
3. `ibase` | |||||
4. `obase` | |||||
5. `scale` | |||||
6. `last` or a single dot (`.`) | |||||
Variables and arrays do not interfere; users can have arrays named the same as | |||||
variables. This also applies to functions (see the FUNCTIONS section), so a user | |||||
can have a variable, array, and function that all have the same name. | |||||
Named expressions are required as the operand of | |||||
[`increment`/`decrement` operators](#bc-increment-decrement) and as the left | |||||
side of [`assignment` operators](#bc-assignment). | |||||
<a name="bc-operands"/> | |||||
### Operands | |||||
1. Numbers (see [Numbers](#bc-numbers) below). | |||||
2. Array indices (`I[E]`). | |||||
3. `(E)`: The value of `E` (used to change precedence). | |||||
4. `sqrt(E)`: The square root of `E`. | |||||
5. `length(E)`: The number of significant decimal digits in `E`. | |||||
6. `length(I[])`: The number of elements in the array `I`. This is a | |||||
**non-portable extension**. | |||||
7. `scale(E)`: `E`'s **scale**. | |||||
8. `abs(E)`: The absolute value of `E`. This is a **non-portable extension**. | |||||
9. `I()`, `I(E)`, `I(E, E)`, and so on, where `I` is an identifier for a | |||||
non-[void function](#void-functions). The `E` parameters may also be arrays | |||||
and [array references](#array-references). | |||||
10. `read()`: Reads a line from `stdin` and uses that as an expression. The | |||||
result of that expression is the result of the `read()` operand. This is a | |||||
**non-portable extension**. | |||||
11. `maxibase()`: The max allowable `ibase`. This is a **non-portable | |||||
extension**. | |||||
12. `maxobase()`: The max allowable `obase`. This is a **non-portable | |||||
extension**. | |||||
13. `maxscale()`: The max allowable `scale`. This is a **non-portable | |||||
extension**. | |||||
<a name="bc-numbers"/> | |||||
### Numbers | |||||
Numbers are strings made up of digits, uppercase letters, and at most `1` period | |||||
for a radix. Numbers can have up to `BC_NUM_MAX` digits. Uppercase letters | |||||
equal `9` + their position in the alphabet (i.e., `A` equals `10`, or `9 + 1`). | |||||
If a digit or letter makes no sense with the current value of `ibase`, they are | |||||
set to the value of the highest valid digit in `ibase`. | |||||
Single-character numbers (i.e., `A`) take the value that they would have if they | |||||
were valid digits, regardless of the value of `ibase`. This means that `A` | |||||
always equals decimal `10` and `Z` always equals decimal `35`. | |||||
In addition, if bc(1) was built with the extra math option, it accepts numbers | |||||
in scientific notation. For bc(1), an example is `1.89237e9`, which is equal to | |||||
`1892370000`. Negative exponents are also allowed, so `4.2890e-3` is equal to | |||||
`0.0042890`. | |||||
Using scientific notation is an error or warning if the `-s` or `-w`, | |||||
respectively, command-line options (or equivalents) are given. | |||||
**WARNING**: Both the number and the exponent in scientific notation are | |||||
interpreted according to the current `ibase`, but the number is still multiplied | |||||
by `10^exponent` regardless of the current `ibase`. For example, if `ibase` is | |||||
`16` and bc(1) is given the number string `"FFeA"`, the resulting decimal number | |||||
will be `2550000000000`, and if bc(1) is given the number string `"10e-4"`, the | |||||
resulting decimal number will be `0.0016`. | |||||
Accepting input as scientific notation is a **non-portable extension**. | |||||
### Operators | |||||
The following arithmetic and logical operators can be used. They are listed in | |||||
order of decreasing precedence. Operators in the same group have the same | |||||
precedence. | |||||
* `++` `--`: | |||||
Type: Prefix and Postfix | |||||
Associativity: None | |||||
Description: `increment`, `decrement` | |||||
* `-` `!`: | |||||
Type: Prefix | |||||
Associativity: None | |||||
Description: `negation`, `boolean not` | |||||
* `$`: | |||||
Type: Postfix | |||||
Associativity: None | |||||
Description: `truncation` | |||||
* `@`: | |||||
Type: Binary | |||||
Associativity: Right | |||||
Description: `set precision` | |||||
* `^`: | |||||
Type: Binary | |||||
Associativity: Right | |||||
Description: `power` | |||||
* `*` `/` `%`: | |||||
Type: Binary | |||||
Associativity: Left | |||||
Description: `multiply`, `divide`, `modulus` | |||||
* `+` `-`: | |||||
Type: Binary | |||||
Associativity: Left | |||||
Description: `add`, `subtract` | |||||
* `<<` `>>`: | |||||
Type: Binary | |||||
Associativity: Left | |||||
Description: `shift left`, `shift right` | |||||
* `=` `<<=` `>>=` `+=` `-=` `*=` `/=` `%=` `^=` `@=`: | |||||
Type: Binary | |||||
Associativity: Right | |||||
Description: `assignment` | |||||
* `==` `<=` `>=` `!=` `<` `>`: | |||||
Type: Binary | |||||
Associativity: Left | |||||
Description: `relational` | |||||
* `&&`: | |||||
Type: Binary | |||||
Associativity: Left | |||||
Description: `boolean and` | |||||
* `||`: | |||||
Type: Binary | |||||
Associativity: Left | |||||
Description: `boolean or` | |||||
The operators will be described in more detail below. | |||||
<a name="bc-increment-decrement"/> | |||||
* `++` `--`: | |||||
The prefix and postfix `increment` and `decrement` operators behave exactly | |||||
like they would in C. They require a [named expression](#named-expressions) | |||||
as an operand. | |||||
* `-`: | |||||
The `negation` operator returns `0` if a user attempts to negate any | |||||
expression with the value `0`. Otherwise, a copy of the expression with its | |||||
sign flipped is returned. | |||||
* `!`: | |||||
The `boolean not` operator returns `1` if the expression is `0`, or `0` | |||||
otherwise. | |||||
This is a **non-portable extension**. | |||||
* `$`: | |||||
The `truncation` operator returns a copy of the given expression with all of | |||||
its **scale** removed. | |||||
This is a **non-portable extension**. | |||||
This is only available if bc(1) has been compiled with the extra math option | |||||
enabled. | |||||
* `@`: | |||||
The `set precision` operator takes two expressions and returns a copy of the | |||||
first with its **scale** equal to the value of the second expression. That | |||||
could either mean that the number is returned without change (if the first | |||||
expression's **scale** matches the value of the second expression), extended | |||||
(if it is less), or truncated (if it is more). | |||||
The second expression must be an integer (no **scale**) and non-negative. | |||||
This is a **non-portable extension**. | |||||
This is only available if bc(1) has been compiled with the extra math option | |||||
enabled. | |||||
* `^`: | |||||
The `power` operator (not the `exclusive or` operator, as it would be in C) | |||||
takes two expressions and raises the first to the power of the value of the | |||||
second. | |||||
The second expression must be an integer (no **scale**). | |||||
* `*`: | |||||
The `multiply` operator takes two expressions, multiplies them, and returns | |||||
the product. If `a` is the **scale** of the first expression and `b` is the | |||||
**scale** of the second expression, the scale of the result is equal to | |||||
`min(a+b,max(scale,a,b))` where `min` and `max` return the obvious values. | |||||
* `/`: | |||||
The `divide` operator takes two expressions, divides them, and returns the | |||||
quotient. The scale of the result shall be the value of `scale`. | |||||
* `%`: | |||||
The `modulus` operator takes two expressions, `a` and `b`, and evaluates | |||||
them by 1) Computing `a/b` to current `scale` and 2) Using the result of | |||||
step 1 to calculate `a-(a/b)*b` to scale `max(scale+scale(b),scale(a))`. | |||||
* `+`: | |||||
The `add` operator takes two expressions, `a` and `b`, and returns the sum, | |||||
with a **scale** equal to the max of the **scale**s of `a` and `b`. | |||||
* `-`: | |||||
The `subtract` operator takes two expressions, `a` and `b`, and returns the | |||||
difference, with a **scale** equal to the max of the **scale**s of `a` and | |||||
`b`. | |||||
* `<<`: | |||||
The `left shift` operator takes two expressions, `a` and `b`, and returns a | |||||
copy of the value of `a` with its decimal point moved `b` places to the | |||||
right. | |||||
The second expression must be an integer (no **scale**) and non-negative. | |||||
This is a **non-portable extension**. | |||||
This is only available if bc(1) has been compiled with the extra math option | |||||
enabled. | |||||
* `>>`: | |||||
The `right shift` operator takes two expressions, `a` and `b`, and returns a | |||||
copy of the value of `a` with its decimal point moved `b` places to the | |||||
left. | |||||
The second expression must be an integer (no **scale**) and non-negative. | |||||
This is a **non-portable extension**. | |||||
This is only available if bc(1) has been compiled with the extra math option | |||||
enabled. | |||||
<a name="bc-assignment"/> | |||||
* `=` `<<=` `>>=` `+=` `-=` `*=` `/=` `%=` `^=` `@=`: | |||||
The `assignment` operators take two expressions, `a` and `b` where `a` is a | |||||
[named expression](#bc-named-expressions). | |||||
For `=`, `b` is copied and the result is assigned to `a`. For all others, | |||||
`a` and `b` are applied as operands to the corresponding arithmetic | |||||
operator and the result is assigned to `a`. | |||||
The `assignment` operators that correspond to operators that are extensions | |||||
are themselves extensions. | |||||
Also, those `assignment` operators that are extensions are only available if | |||||
bc(1) has been compiled with the extra math option enabled. | |||||
* `==` `<=` `>=` `!=` `<` `>`: | |||||
The `relational` operators compare two expressions, `a` and `b`, and if the | |||||
relation holds, according to C language semantics, the result is `1`. | |||||
Otherwise, it is `0`. | |||||
Note that unlike in C, these operators have a lower precedence than the | |||||
`assignment` operators, which means that `a=b>c` is interpreted as | |||||
`(a=b)>c`. | |||||
Also, unlike the [standard][1] requires, these operators can appear anywhere | |||||
any other expressions can be used. This allowance is a | |||||
**non-portable extension**. | |||||
* `&&`: | |||||
The `boolean and` operator takes two expressions and returns `1` if both | |||||
expressions are non-zero, `0` otherwise. | |||||
This is ***not*** a short-circuit operator. | |||||
This is a **non-portable extension**. | |||||
* `||`: | |||||
The `boolean or` operator takes two expressions and returns `1` if one of | |||||
the expressions is non-zero, `0` otherwise. | |||||
This is ***not*** a short-circuit operator. | |||||
This is a **non-portable extension**. | |||||
### Statements | |||||
The following items are statements: | |||||
1. `E` | |||||
2. `{` `S` `;` ... `;` `S` `}` | |||||
3. `if` `(` `E` `)` `S` | |||||
4. `if` `(` `E` `)` `S` `else` `S` | |||||
5. `while` `(` `E` `)` `S` | |||||
6. `for` `(` `E` `;` `E` `;` `E` `)` `S` | |||||
7. An empty statement | |||||
8. `break` | |||||
9. `continue` | |||||
10. `quit` | |||||
11. `halt` | |||||
12. `limits` | |||||
13. A string of characters, enclosed in double quotes | |||||
14. `print` `E` `,` ... `,` `E` | |||||
15. `I()`, `I(E)`, `I(E, E)`, and so on, where `I` is an identifier for a | |||||
[void function](#void-functions). The `E` parameters may also be arrays and | |||||
[array references](#array-references). | |||||
Numbers 4, 9, 11, 12, 14, and 15 are **non-portable extensions**. | |||||
Also, as a **non-portable extension**, any or all of the expressions in the | |||||
header of a for loop may be omitted. If the condition (second expression) is | |||||
omitted, it is assumed to be a constant `1`. | |||||
The `break` statement causes a loop to stop iterating and resume execution | |||||
immediately following a loop. This is only allowed in loops. | |||||
The `continue` statement causes a loop iteration to stop early and returns to | |||||
the start of the loop, including testing the loop condition. This is only | |||||
allowed in loops. | |||||
The `if` `else` statement does the same thing as in C. | |||||
The `quit` statement causes bc(1) to quit, even if it is on a branch that will | |||||
not be executed (it is a compile-time command). | |||||
The `halt` statement causes bc(1) to quit, if it is executed. (Unlike `quit` if | |||||
it is on a branch of an `if` statement that is not executed, bc(1) does not | |||||
quit.) | |||||
The `limits` statement prints the limits that this bc(1) is subject to. This is | |||||
like the `quit` statement in that it is a compile-time command. | |||||
An expression by itself is evaluated and printed, followed by a newline. If | |||||
bc(1) has been built with the extra math option enabled, both scientific | |||||
notation and engineering notation are available for printing the results of | |||||
expressions. Scientific notation is activated by assigning `0` to `obase` (in | |||||
any other context, an `obase` of `0` is invalid), and engineering notation is | |||||
activated by assigning `1` to `obase` (which is also invalid in any other | |||||
context). To deactivate them, just assign a different value to `obase`. | |||||
Scientific notation and engineering notation are disabled if bc(1) is run with | |||||
either the `-s` or `-w` command-line options (or equivalents). | |||||
Printing numbers in scientific notation and/or engineering notation is a | |||||
**non-portable extension**. | |||||
### Print Statement | |||||
The "expressions" in a `print` statement may also be strings. If they are, there | |||||
are backslash escape sequences that are interpreted specially. What those | |||||
sequences are, and what they cause to be printed, are shown below: | |||||
* `\a`: | |||||
`\a` | |||||
* `\b`: | |||||
`\b` | |||||
* `\\`: | |||||
`\` | |||||
* `\e`: | |||||
`\` | |||||
* `\f`: | |||||
`\f` | |||||
* `\n`: | |||||
`\n` | |||||
* `\q`: | |||||
`"` | |||||
* `\r`: | |||||
`\r` | |||||
* `\t`: | |||||
`\t` | |||||
Any other character following a backslash causes the backslash and character to | |||||
be printed as-is. | |||||
Any non-string expression in a print statement shall be assigned to `last`, like | |||||
any other expression that is printed. | |||||
### Order of Evaluation | |||||
All expressions in a statment are evaluated left to right, except as necessary | |||||
to maintain order of operations. This means, for example, that in the expression | |||||
`i = 0; a[i++] = i++`, the first (or 0th) element of `a` is set to `1`, and `i` | |||||
is equal to `2` at the end of the expression. | |||||
This includes function arguments. Thus, this means that in the expression | |||||
`i = 0; x(i++, i++)`, the first argument passed to `x()` is `0`, and the second | |||||
argument is `1`, while `i` is equal to `2` before the function starts executing. | |||||
FUNCTIONS | |||||
--------- | |||||
Function definitions are as follows: | |||||
``` | |||||
define I(I,...,I){ | |||||
auto I,...,I | |||||
S;...;S | |||||
return(E) | |||||
} | |||||
``` | |||||
Any `I` in the parameter list or `auto` list may be replaced with `I[]` to make | |||||
a parameter or `auto` var an array. | |||||
As a **non-portable extension**, the opening brace of a `define` statement may | |||||
appear on the next line. | |||||
The return statement may also be in the following forms: | |||||
1. `return` | |||||
2. `return` `(` `)` | |||||
3. `return` `E` | |||||
The first two, or not specifying a `return` statement, is equivalent to | |||||
`return (0)`, unless the function is a [void function](#void-functions). | |||||
<a name="void-functions"/> | |||||
### Void Functions | |||||
Functions can also be void functions, defined as follows: | |||||
``` | |||||
define void I(I,...,I){ | |||||
auto I,...,I | |||||
S;...;S | |||||
return(E) | |||||
} | |||||
``` | |||||
They can only be used as standalone expressions, where such an expression would | |||||
be printed alone, except in a print statement. | |||||
Void functions can only use the first two `return` statements listed above. | |||||
The word `void` is not treated as a keyword; it is still possible to have | |||||
variables, arrays, and functions named `void`. | |||||
This is a **non-portable extension**. | |||||
<a name="array-references"/> | |||||
### Array References | |||||
For any array in the parameter list, if the array is declared in the form | |||||
``` | |||||
*I[] | |||||
``` | |||||
it is a **reference**. Any changes to the array in the function are reflected, | |||||
when the function returns, to the array that was passed in. | |||||
Other than this, all function arguments are passed by value. | |||||
This is a **non-portable extension**. | |||||
LIBRARY | |||||
------- | |||||
All of the functions below, including the functions in the | |||||
[extended library](#extended-library) if bc(1) has been compiled with the extra | |||||
math option enabled, are available when the `-l` or `--mathlib` command-line | |||||
flags are given. | |||||
<a name="standard-library"/> | |||||
### Standard Library | |||||
The [standard][1] defines the following functions for the math library: | |||||
* `s(x)`: | |||||
Returns the sine of `x`, which is assumed to be in radians. | |||||
This is a [transcendental function][5]. | |||||
* `c(x)`: | |||||
Returns the cosine of `x`, which is assumed to be in radians. | |||||
This is a [transcendental function][5]. | |||||
* `a(x)`: | |||||
Returns the arctangent of `x`, in radians. | |||||
This is a [transcendental function][5]. | |||||
* `l(x)`: | |||||
Returns the natural logarithm of `x`. | |||||
This is a [transcendental function][5]. | |||||
* `e(x)`: | |||||
Returns the mathematical constant `e` raised to the power of `x`. | |||||
This is a [transcendental function][5]. | |||||
* `j(x, n)`: | |||||
Returns the bessel integer order `n` (truncated) of `x`. | |||||
This is a [transcendental function][5]. | |||||
<a name="extended-library"/> | |||||
### Extended Library | |||||
In addition to the [standard library](#standard-library), if bc(1) has been | |||||
built with the extra math option, the following functions are available when | |||||
either the `-l` or `--mathlib` options are given. | |||||
However, the extended library is ***not*** loaded when the `-s`/`--standard` or | |||||
`-w`/`--warn` options are given since they are not part of the library defined | |||||
by the [standard][1]. | |||||
The extended library is a **non-portable extension**. | |||||
* `r(x, p)`: | |||||
Returns `x` rounded to `p` decimal places according to the rounding mode | |||||
[round half away from `0`][3]. | |||||
* `ceil(x, p)`: | |||||
Returns `x` rounded to `p` decimal places according to the rounding mode | |||||
[round away from `0`][7]. | |||||
* `f(x)`: | |||||
Returns the factorial of the truncated absolute value of `x`. | |||||
* `perm(n, k)`: | |||||
Returns the permutation of the truncated absolute value of `n` of the | |||||
truncated absolute value of `k`, if `k <= n`. If not, it returns `0`. | |||||
* `comb(n, k)`: | |||||
Returns the combination of the truncated absolute value of `n` of the | |||||
truncated absolute value of `k`, if `k <= n`. If not, it returns `0`. | |||||
* `l2(x)`: | |||||
Returns the logarithm base `2` of `x`. | |||||
This is a [transcendental function][5]. | |||||
* `l10(x)`: | |||||
Returns the logarithm base `10` of `x`. | |||||
This is a [transcendental function][5]. | |||||
* `log(x, b)`: | |||||
Returns the logarithm base `b` of `x`. | |||||
This is a [transcendental function][5]. | |||||
* `pi(p)`: | |||||
Returns `pi` to `p` decimal places. | |||||
This is a [transcendental function][5]. | |||||
* `t(x)`: | |||||
Returns the tangent of `x`, which is assumed to be in radians. | |||||
This is a [transcendental function][5]. | |||||
* `a2(y, x)`: | |||||
Returns the arctangent of `y/x`, in radians. If both `y` and `x` are equal | |||||
to `0`, it raises an error and causes bc(1) to reset (see the RESET | |||||
section). Otherwise, if `x` is greater than `0`, it returns `a(y/x)`. If `x` | |||||
is less than `0`, and `y` is greater than or equal to `0`, it returns | |||||
`a(y/x) + pi`. If `x` is less than `0`, and `y` is less than `0`, it returns | |||||
`a(y/x) - pi`. If `x` is equal to `0`, and `y` is greater than `0`, it | |||||
returns `pi/2`. If `x` is equal to `0`, and `y` is less than `0`, it returns | |||||
`-pi/2`. | |||||
This function is the same as the `atan2()` function in many programming | |||||
languages. | |||||
This is a [transcendental function][5]. | |||||
* `sin(x)`: | |||||
Returns the sine of `x`, which is assumed to be in radians. | |||||
This is an alias of `s(x)`. | |||||
This is a [transcendental function][5]. | |||||
* `cos(x)`: | |||||
Returns the cosine of `x`, which is assumed to be in radians. | |||||
This is an alias of `c(x)`. | |||||
This is a [transcendental function][5]. | |||||
* `tan(x)`: | |||||
Returns the tangent of `x`, which is assumed to be in radians. | |||||
This is an alias of `t(x)`. | |||||
This is a [transcendental function][5]. | |||||
* `atan(x)`: | |||||
Returns the arctangent of `x`, in radians. | |||||
This is an alias of `a(x)`. | |||||
This is a [transcendental function][5]. | |||||
* `atan2(y, x)`: | |||||
Returns the arctangent of `y/x`, in radians. If both `y` and `x` are equal | |||||
to `0`, it raises an error and causes bc(1) to reset (see the RESET | |||||
section). Otherwise, if `x` is greater than `0`, it returns `a(y/x)`. If `x` | |||||
is less than `0`, and `y` is greater than or equal to `0`, it returns | |||||
`a(y/x) + pi`. If `x` is less than `0`, and `y` is less than `0`, it returns | |||||
`a(y/x) - pi`. If `x` is equal to `0`, and `y` is greater than `0`, it | |||||
returns `pi/2`. If `x` is equal to `0`, and `y` is less than `0`, it returns | |||||
`-pi/2`. | |||||
This function is the same as the `atan2()` function in many programming | |||||
languages. | |||||
This is an alias of `a2(y, x)`. | |||||
This is a [transcendental function][5]. | |||||
* `r2d(x)`: | |||||
Converts `x` from radians to degrees and returns the result. | |||||
This is a [transcendental function][5]. | |||||
* `d2r(x)`: | |||||
Converts `x` from degrees to radians and returns the result. | |||||
This is a [transcendental function][5]. | |||||
* `ubytes(x)`: | |||||
Returns the numbers of unsigned integer bytes required to hold the truncated | |||||
absolute value of `x`. | |||||
* `sbytes(x)`: | |||||
Returns the numbers of signed, two's-complement integer bytes required to | |||||
hold the truncated value of `x`. | |||||
* `hex(x)`: | |||||
Outputs the hexadecimal (base `16`) representation of `x`. | |||||
This is a [void function](#void-functions). | |||||
* `binary(x)`: | |||||
Outputs the binary (base `2`) representation of `x`. | |||||
This is a [void function](#void-functions). | |||||
* `output(x, b)`: | |||||
Outputs the base `b` representation of `x`. | |||||
This is a [void function](#void-functions). | |||||
* `uint(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as an unsigned | |||||
integer in as few power of two bytes as possible. Both outputs are split | |||||
into bytes separated by spaces. | |||||
If `x` is not an integer or is negative, an error message is printed | |||||
instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `int(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as a signed, | |||||
two's-complement integer in as few power of two bytes as possible. Both | |||||
outputs are split into bytes separated by spaces. | |||||
If `x` is not an integer, an error message is printed instead, but bc(1) is | |||||
not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `uintn(x, n)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as an unsigned | |||||
integer in `n` bytes. Both outputs are split into bytes separated by spaces. | |||||
If `x` is not an integer, is negative, or cannot fit into `n` bytes, an | |||||
error message is printed instead, but bc(1) is not reset (see the RESET | |||||
section). | |||||
This is a [void function](#void-functions). | |||||
* `intn(x, n)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as a signed, | |||||
two's-complement integer in `n` bytes. Both outputs are split into bytes | |||||
separated by spaces. | |||||
If `x` is not an integer or cannot fit into `n` bytes, an error message is | |||||
printed instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `uint8(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as an unsigned | |||||
integer in `1` byte. Both outputs are split into bytes separated by spaces. | |||||
If `x` is not an integer, is negative, or cannot fit into `1` byte, an error | |||||
message is printed instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `int8(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as a signed, | |||||
two's-complement integer in `1` byte. Both outputs are split into bytes | |||||
separated by spaces. | |||||
If `x` is not an integer or cannot fit into `1` byte, an error message is | |||||
printed instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `uint16(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as an unsigned | |||||
integer in `2` bytes. Both outputs are split into bytes separated by spaces. | |||||
If `x` is not an integer, is negative, or cannot fit into `2` bytes, an | |||||
error message is printed instead, but bc(1) is not reset (see the RESET | |||||
section). | |||||
This is a [void function](#void-functions). | |||||
* `int16(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as a signed, | |||||
two's-complement integer in `2` bytes. Both outputs are split into bytes | |||||
separated by spaces. | |||||
If `x` is not an integer or cannot fit into `2` bytes, an error message is | |||||
printed instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `uint32(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as an unsigned | |||||
integer in `4` bytes. Both outputs are split into bytes separated by spaces. | |||||
If `x` is not an integer, is negative, or cannot fit into `4` bytes, an | |||||
error message is printed instead, but bc(1) is not reset (see the RESET | |||||
section). | |||||
This is a [void function](#void-functions). | |||||
* `int32(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as a signed, | |||||
two's-complement integer in `4` bytes. Both outputs are split into bytes | |||||
separated by spaces. | |||||
If `x` is not an integer or cannot fit into `4` bytes, an error message is | |||||
printed instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `uint64(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as an unsigned | |||||
integer in `8` bytes. Both outputs are split into bytes separated by spaces. | |||||
If `x` is not an integer, is negative, or cannot fit into `8` bytes, an | |||||
error message is printed instead, but bc(1) is not reset (see the RESET | |||||
section). | |||||
This is a [void function](#void-functions). | |||||
* `int64(x)`: | |||||
Outputs the representation, in binary and hexadecimal, of `x` as a signed, | |||||
two's-complement integer in `8` bytes. Both outputs are split into bytes | |||||
separated by spaces. | |||||
If `x` is not an integer or cannot fit into `8` bytes, an error message is | |||||
printed instead, but bc(1) is not reset (see the RESET section). | |||||
This is a [void function](#void-functions). | |||||
* `hex_uint(x, n)`: | |||||
Outputs the representation of the truncated absolute value of `x` as an | |||||
unsigned integer in hexadecimal using `n` bytes. Not all of the value will | |||||
be output if `n` is too small. | |||||
This is a [void function](#void-functions). | |||||
* `binary_uint(x, n)`: | |||||
Outputs the representation of the truncated absolute value of `x` as an | |||||
unsigned integer in binary using `n` bytes. Not all of the value will be | |||||
output if `n` is too small. | |||||
This is a [void function](#void-functions). | |||||
* `output_uint(x, n)`: | |||||
Outputs the representation of the truncated absolute value of `x` as an | |||||
unsigned integer in the current [`obase`](#obase) using `n` bytes. Not all | |||||
of the value will be output if `n` is too small. | |||||
This is a [void function](#void-functions). | |||||
* `output_byte(x, i)`: | |||||
Outputs byte `i` of the truncated absolute value of `x`, where `0` is the | |||||
least significant byte and `number_of_bytes - 1` is the most significant | |||||
byte. | |||||
This is a [void function](#void-functions). | |||||
<a name="transcendental-functions"/> | |||||
### Transcendental Functions | |||||
All transcendental functions can return slightly inaccurate results (up to 1 | |||||
[ULP][4]). This is unavoidable, and [this article][6] explains why it is | |||||
impossible and unnecessary to calculate exact results for the transcendental | |||||
functions. | |||||
Because of the possible inaccuracy, I recommend that users call those functions | |||||
with the precision (`scale`) set to at least 1 higher than is necessary. If | |||||
exact results are *absolutely* required, users can double the precision | |||||
(`scale`) and then truncate. | |||||
The transcendental functions in the standard math library are: | |||||
* `s(x)` | |||||
* `c(x)` | |||||
* `a(x)` | |||||
* `l(x)` | |||||
* `e(x)` | |||||
* `j(x, n)` | |||||
The transcendental functions in the extended math library are: | |||||
* `l2(x)` | |||||
* `l10(x)` | |||||
* `log(x, b)` | |||||
* `pi(p)` | |||||
* `t(x)` | |||||
* `a2(y, x)` | |||||
* `sin(x)` | |||||
* `cos(x)` | |||||
* `tan(x)` | |||||
* `atan(x)` | |||||
* `atan2(y, x)` | |||||
* `r2d(x)` | |||||
* `d2r(x)` | |||||
RESET | |||||
----- | |||||
When bc(1) encounters an error or a signal that it has a non-default handler | |||||
for, it resets. This means that several things happen. | |||||
First, any functions that are executing are stopped and popped off the stack. | |||||
The behavior is not unlike that of exceptions in programming languages. Then | |||||
the execution point is set so that any code waiting to execute (after all | |||||
functions returned) is skipped. | |||||
Thus, when bc(1) resets, it skips any remaining code waiting to be executed. | |||||
Then, if it is interactive mode, and the error was not a fatal error (see the | |||||
EXIT STATUS section), it asks for more input; otherwise, it exits with the | |||||
appropriate return code. | |||||
Note that this reset behavior is different from the GNU bc(1), which attempts to | |||||
start executing the statement right after the one that caused an error. | |||||
PERFORMANCE | |||||
----------- | |||||
Most bc(1) implementations use `char` types to calculate the value of `1` | |||||
decimal digit at a time, but that can be slow. This bc(1) does something | |||||
different. | |||||
It uses large integers to calculate more than `1` decimal digit at a time. If | |||||
built in a environment where `BC_LONG_BIT` (see the LIMITS section) is `64`, | |||||
then each integer has `9` decimal digits. If built in an environment where | |||||
`BC_LONG_BIT` is `32` then each integer has `4` decimal digits. This value (the | |||||
number of decimal digits per large integer) is called `BC_BASE_DIGS`. | |||||
In addition, this bc(1) uses an even larger integer for overflow checking. This | |||||
integer type depends on the value of `BC_LONG_BIT`, but is always at least twice | |||||
as large as the integer type used to store digits. | |||||
LIMITS | |||||
------ | |||||
The following are the limits on bc(1): | |||||
* `BC_LONG_BIT`: | |||||
The number of bits in the `long` type in the environment where bc(1) was | |||||
built. This determines how many decimal digits can be stored in a single | |||||
large integer (see the PERFORMANCE section). | |||||
* `BC_BASE_DIGS`: | |||||
The number of decimal digits per large integer (see the PERFORMANCE | |||||
section). Depends on `BC_LONG_BIT`. | |||||
* `BC_BASE_POW`: | |||||
The max decimal number that each large integer can store (see | |||||
`BC_BASE_DIGS`) plus `1`. Depends on `BC_BASE_DIGS`. | |||||
* `BC_OVERFLOW_MAX`: | |||||
The max number that the overflow type (see the PERFORMANCE section) can | |||||
hold. Depends on `BC_LONG_BIT`. | |||||
* `BC_BASE_MAX`: | |||||
The maximum output base. Set at `BC_BASE_POW`. | |||||
* `BC_DIM_MAX`: | |||||
The maximum size of arrays. Set at `SIZE_MAX-1`. | |||||
* `BC_SCALE_MAX`: | |||||
The maximum `scale`. Set at `BC_OVERFLOW_MAX-1`. | |||||
* `BC_STRING_MAX`: | |||||
The maximum length of strings. Set at `BC_OVERFLOW_MAX-1`. | |||||
* `BC_NAME_MAX`: | |||||
The maximum length of identifiers. Set at `BC_OVERFLOW_MAX-1`. | |||||
* `BC_NUM_MAX`: | |||||
The maximum length of a number (in decimal digits), which includes digits | |||||
after the decimal point. Set at `BC_OVERFLOW_MAX-1`. | |||||
* Exponent: | |||||
The maximum allowable exponent (positive or negative). Set at | |||||
`BC_OVERFLOW_MAX`. | |||||
* Number of vars: | |||||
The maximum number of vars/arrays. Set at `SIZE_MAX-1`. | |||||
Actual values can be queried with the `limits` statement. | |||||
These limits are meant to be effectively non-existent; the limits are so large | |||||
(at least on 64-bit machines) that there should not be any point at which they | |||||
become a problem. In fact, memory should be exhausted before these limits should | |||||
be hit. | |||||
ENVIRONMENT VARIABLES | |||||
--------------------- | |||||
bc(1) recognizes the following environment variables: | |||||
* `POSIXLY_CORRECT`: | |||||
If this variable exists (no matter the contents), bc(1) behaves as if | |||||
the `-s` option was given. | |||||
* `BC_ENV_ARGS`: | |||||
This is another way to give command-line arguments to bc(1). They should be | |||||
in the same format as all other command-line arguments. These are always | |||||
processed first, so any files given in `BC_ENV_ARGS` will be processed | |||||
before files given on the command-line. This gives the user the ability to | |||||
set up "standard" options and files to be used at every invocation. The most | |||||
useful thing for such files to contain would be useful functions that the | |||||
user might want every time bc(1) runs. | |||||
* `BC_LINE_LENGTH`: | |||||
If this environment variable exists and contains an integer that is greater | |||||
than `1` and is less than `UINT16_MAX` (`2^16-1`), bc(1) will output lines | |||||
to that length, including the backslash (`\`). The default line length is | |||||
`70`. | |||||
* `BC_EXPR_EXIT`: | |||||
If this variable exists (no matter the contents), bc(1) will exit | |||||
immediately after executing expressions and files given by the `-e` and/or | |||||
`-f` command-line options (and any equivalents). | |||||
EXIT STATUS | |||||
----------- | |||||
bc(1) returns the following exit statuses: | |||||
* `0`: | |||||
No error. | |||||
* `1`: | |||||
A math error occurred. This follows standard practice of using `1` for | |||||
expected errors, since math errors will happen in the process of normal | |||||
execution. | |||||
Math errors include divide by `0`, taking the square root of a negative | |||||
number, attempting to convert a negative number to a hardware integer, | |||||
overflow when converting a number to a hardware integer, and attempting to | |||||
use a non-integer where an integer is required. | |||||
Converting to a hardware integer happens for the second operand of the power | |||||
(`^`), places (`@`), left shift (`<<`), and right shift (`>>`) operators and | |||||
their corresponding assignment operators. | |||||
* `2`: | |||||
A parse error occurred. | |||||
Parse errors include unexpected `EOF`, using an invalid character, failing | |||||
to find the end of a string or comment, using a token where it's invalid, | |||||
giving an invalid expression, giving an invalid print statement, giving an | |||||
invalid function definition, attempting to assign to an expression that is | |||||
not a [named expression](#bc-named-expressions), giving an invalid `auto` | |||||
list, having a duplicate `auto`/function parameter, failing to find the end | |||||
of a code block, attempting to return a value from a `void` function, | |||||
attempting to use a variable as a reference, and using any extensions when | |||||
the option `-s` or any equivalents were given. | |||||
* `3`: | |||||
A runtime error occurred. | |||||
Runtime errors include assigning an invalid number to `ibase`, `obase`, or | |||||
`scale`; give a bad expression to a `read()` call, calling `read()` inside | |||||
of a `read()` call, type errors, passing the wrong number of parameters to | |||||
functions, attempting to call an undefined function, and attempting to use a | |||||
`void` function call as a value in an expression. | |||||
* `4`: | |||||
A fatal error occurred. | |||||
Fatal errors include memory allocation errors, I/O errors, failing to open | |||||
files, attempting to use files that do not have only ASCII characters (bc(1) | |||||
only accepts ASCII characters), attempting to open a directory as a file, | |||||
and giving invalid command-line options. | |||||
The exit status `4` is special; when a fatal error occurs, bc(1) always exits | |||||
and returns `4`, no matter what mode bc(1) is in. | |||||
The other statuses will only be returned when bc(1) is not in interactive mode, | |||||
since bc(1) resets its state (see the RESET section) and accepts more input when | |||||
one of those errors occurs in interactive mode. This is also the case when | |||||
interactive mode is forced by the `-i` option. | |||||
These exit statuses allow bc(1) to be used in shell scripting with error | |||||
checking, and its normal behavior can be forced by using `-i`. | |||||
SIGNAL HANDLING | |||||
--------------- | |||||
If bc(1) has been compiled with the signal handling, sending a `SIGINT` will | |||||
cause bc(1) to stop execution of the current input and reset (see the RESET | |||||
section), asking for more input. | |||||
Otherwise, `SIGTERM` and `SIGQUIT` cause bc(1) to clean up and exit, and it uses | |||||
the default handler for all other signals. | |||||
If bc(1) has not been compiled with signal handling, it uses the default signal | |||||
handlers for all signals. | |||||
COMMAND LINE HISTORY | |||||
-------------------- | |||||
bc(1) supports interactive command-line editing, if compiled with the history | |||||
option enabled. If `stdin` is hooked to a terminal, it is enabled. Previous | |||||
lines can be recalled and edited with the arrow keys. | |||||
LOCALES | |||||
------- | |||||
This bc(1) ships with support for adding error messages for different locales. | |||||
SEE ALSO | |||||
-------- | |||||
dc(1) | |||||
STANDARDS | |||||
--------- | |||||
bc(1) is compliant with the [IEEE Std 1003.1-2017 (“POSIX.1-2017”)][1] | |||||
specification. The flags `-efghiqsvVw`, all long options, and the extensions | |||||
noted above are extensions to that specification. | |||||
Note that the specification explicitly says that bc(1) only accepts numbers that | |||||
use a period (`.`) as a radix point, regardless of the value of `LC_NUMERIC`. | |||||
Because this bc(1) ships with support for adding error messages for different | |||||
locales, so it supports `LC_MESSAGES`. | |||||
AUTHOR | |||||
------ | |||||
This bc(1) was made from scratch by Gavin D. Howard. | |||||
BUGS | |||||
---- | |||||
None are known. Report bugs at https://github.com/gavinhoward/bc. | |||||
[1]: https://pubs.opengroup.org/onlinepubs/9699919799/utilities/bc.html | |||||
[2]: https://www.gnu.org/software/bc/ | |||||
[3]: https://en.wikipedia.org/wiki/Rounding#Round_half_away_from_zero | |||||
[4]: https://en.wikipedia.org/wiki/Unit_in_the_last_place | |||||
[5]: #transcendental-functions | |||||
[6]: https://people.eecs.berkeley.edu/~wkahan/LOG10HAF.TXT | |||||
[7]: https://en.wikipedia.org/wiki/Rounding#Rounding_away_from_zero |