Go to the first, previous, next, last section, table of contents.

# Expressions

## About Expressions and Special Variables

The numbers are manipulated by expressions and statements. Since the language was designed to be interactive, statements and expressions are executed as soon as possible. There is no main program. Instead, code is executed as it is encountered. (Functions, discussed in detail later, are defined when encountered.)

A simple expression is just a constant. `bc` converts constants into internal decimal numbers using the current input base, specified by the variable ibase. (There is an exception in functions.) The legal values of ibase are 2 through 16. Assigning a value outside this range to ibase will result in a value of 2 or 16. Input numbers may contain the characters 0-9 and A-F. (Note: They must be capitals. Lower case letters are variable names.) Single digit numbers always have the value of the digit regardless of the value of ibase. (i.e. A = 10.) For multi-digit numbers, `bc` changes all input digits greater or equal to ibase to the value of ibase-1. This makes the number `FFF` always be the largest 3 digit number of the input base.

Full expressions are similar to many other high level languages. Since there is only one kind of number, there are no rules for mixing types. Instead, there are rules on the scale of expressions. Every expression has a scale. This is derived from the scale of original numbers, the operation performed and in many cases, the value of the variable scale. Legal values of the variable scale are 0 to the maximum number representable by a C integer.

## Basic Expressions

In the following descriptions of legal expressions, "expr" refers to a complete expression and "var" refers to a simple or an array variable. A simple variable is just a

name

and an array variable is specified as

name[expr]

Unless specifically mentioned the scale of the result is the maximum scale of the expressions involved.

`- expr`
The result is the negation of the expression.
`++ var`
The variable is incremented by one and the new value is the result of the expression.
`-- var`
The variable is decremented by one and the new value is the result of the expression.
`var ++`
The result of the expression is the value of the variable and then the variable is incremented by one.
`var --`
The result of the expression is the value of the variable and then the variable is decremented by one.
`expr + expr`
The result of the expression is the sum of the two expressions.
`expr - expr`
The result of the expression is the difference of the two expressions.
`expr * expr`
The result of the expression is the product of the two expressions.
`expr / expr`
The result of the expression is the quotient of the two expressions. The scale of the result is the value of the variable `scale`
`expr % expr`
The result of the expression is the "remainder" and it is computed in the following way. To compute a%b, first a/b is computed to scale digits. That result is used to compute a-(a/b)*b to the scale of the maximum of scale+scale(b) and scale(a). If scale is set to zero and both expressions are integers this expression is the integer remainder function.
`expr ^ expr`
The result of the expression is the value of the first raised to the second. The second expression must be an integer. (If the second expression is not an integer, a warning is generated and the expression is truncated to get an integer value.) The scale of the result is scale if the exponent is negative. If the exponent is positive the scale of the result is the minimum of the scale of the first expression times the value of the exponent and the maximum of scale and the scale of the first expression. (e.g. scale(a^b) = min(scale(a)*b, max(scale, scale(a))).) It should be noted that expr^0 will always return the value of 1.
`( expr )`
This alters the standard precedence to force the evaluation of the expression.
`var = expr`
The variable is assigned the value of the expression.
`var <op>= expr`
This is equivalent to "var = var <op> expr" with the exception that the "var" part is evaluated only once. This can make a difference if "var" is an array.

## Relational Expressions

Relational expressions are a special kind of expression that always evaluate to 0 or 1, 0 if the relation is false and 1 if the relation is true. These may appear in any legal expression. (POSIX `bc` requires that relational expressions are used only in `if`, `while`, and `for` statements and that only one relational test may be done in them.) The relational operators are

`expr1 < expr2`
The result is 1 if expr1 is strictly less than expr2.
`expr1 <= expr2`
The result is 1 if expr1 is less than or equal to expr2.
`expr1 > expr2`
The result is 1 if expr1 is strictly greater than expr2.
`expr1 >= expr2`
The result is 1 if expr1 is greater than or equal to expr2.
`expr1 == expr2`
The result is 1 if expr1 is equal to expr2.
`expr1 != expr2`
The result is 1 if expr1 is not equal to expr2.

## Boolean Expressions

Boolean operations are also legal. (POSIX `bc` does NOT have boolean operations). The result of all boolean operations are 0 and 1 (for false and true) as in relational expressions. The boolean operators are:

`!expr`
The result is 1 if expr is 0.
`expr && expr`
The result is 1 if both expressions are non-zero.
`expr || expr`
The result is 1 if either expression is non-zero.

## Precedence

The expression precedence is as follows: (lowest to highest)

```|| operator, left associative
&& operator, left associative
! operator, nonassociative
Relational operators, left associative
Assignment operator, right associative
+ and - operators, left associative
*, / and % operators, left associative
^ operator, right associative
unary - operator, nonassociative
++ and -- operators, nonassociative
```

This precedence was chosen so that POSIX compliant `bc` programs will run correctly. This will cause the use of the relational and logical operators to have some unusual behavior when used with assignment expressions. Consider the expression:

```a = 3 < 5
```

Most C programmers would assume this would assign the result of "3 < 5" (the value 1) to the variable "a". What this does in `bc` is assign the value 3 to the variable "a" and then compare 3 to 5. It is best to use parentheses when using relational and logical operators with the assignment operators.

## Special Expressions

There are a few more special expressions that are provided in `bc`. These have to do with user-defined functions and standard functions. They all appear as "name`(`parameters`)`". See section Functions, for user-defined functions. The standard functions are:

`length ( expression )`
The value of the length function is the number of significant digits in the expression.
`read ( )`
The `read` function (an extension) will read a number from the standard input, regardless of where the function occurs. Beware, this can cause problems with the mixing of data and program in the standard input. The best use for this function is in a previously written program that needs input from the user, but never allows program code to be input from the user. The value of the `read` function is the number read from the standard input using the current value of the variable ibase for the conversion base.
`scale ( expression )`
The value of the `scale` function is the number of digits after the decimal point in the expression.
`sqrt ( expression )`
The value of the `sqrt` function is the square root of the expression. If the expression is negative, a run time error is generated.

Go to the first, previous, next, last section, table of contents.