OPERANDS¶

An expression consists of a combination of operands, operators, parentheses and commas, possibly with whitespace between any of these elements, which is ignored. Each operand is interpreted as a numeric value if at all possible.

Each operand has one of the following forms:

expr 100_000_000		100000000
expr 0xffff_ffff		4294967295
format 0x%x 0b1111_1110_1101_1011		0xfedb
expr 3_141_592_653_589e-1_2		3.141592653589

Because expr parses and performs substitutions on values that have already been parsed and substituted by Tcl, it is usually best to enclose expressions in braces to avoid the first round of substitutions by Tcl.

Below are some examples of simple expressions where the value of a is 3 and the value of b is 6. The command on the left side of each line produces the value on the right side.

expr {3.1 + $a}	6.1
expr {2 + "$a.$b"}	5.6
expr {4*[llength {6 2}]}	8
expr {{word one} < "word $a"}	0

OPERATORS¶

For operators having both a numeric mode and a string mode, the numeric mode is chosen when all operands have a numeric interpretation. The integer interpretation of an operand is preferred over the floating-point interpretation. To ensure string operations on arbitrary values it is generally a good idea to use eq, ne, or the string command instead of more versatile operators such as ==.

Unless otherwise specified, operators accept non-numeric operands. The value of a boolean operation is 1 if true, 0 otherwise. See also string is boolean. The valid operators, most of which are also available as commands in the tcl::mathop namespace (see mathop(3tcl)), are listed below, grouped in decreasing order of precedence:

-  +  ~  !

Unary minus, unary plus, bit-wise NOT, logical NOT. These operators may only be applied to numeric operands, and bit-wise NOT may only be applied to integers.

**

Exponentiation. Valid for numeric operands. The maximum exponent value that Tcl can handle if the first number is an integer > 1 is 268435455.

*  /  %

Multiply and divide, which are valid for numeric operands, and remainder, which is valid for integers. The remainder, an absolute value smaller than the absolute value of the divisor, has the same sign as the divisor.

+  -

Add and subtract. Valid for numeric operands.

<<  >>

Left and right shift. Valid for integers. A right shift always propagates the sign bit.

<  >  <=  >=

Boolean numeric-preferring comparisons: less than, greater than, less than or equal, and greater than or equal. If either argument is not numeric, the comparison is done using UNICODE string comparison, as with the string comparison operators below, which have the same precedence.

lt  gt  le  ge

Boolean string comparisons: less than, greater than, less than or equal, and greater than or equal. These always compare values using their UNICODE strings (also see string compare), unlike with the numeric-preferring comparisons above, which have the same precedence.

==  !=

Boolean equal and not equal.

eq  ne

Boolean string equal and string not equal.

in  ni

List containment and negated list containment. The first argument is interpreted as a string, the second as a list. in tests for membership in the list, and ni is the inverse.

&

Bit-wise AND. Valid for integer operands.

^

Bit-wise exclusive OR. Valid for integer operands.

|

Bit-wise OR. Valid for integer operands.

&&

Logical AND. If both operands are true, the result is 1, or 0 otherwise. This operator evaluates lazily; it only evaluates its second operand if it must in order to determine its result. This operator evaluates lazily; it only evaluates its second operand if it must in order to determine its result.

||

Logical OR. If both operands are false, the result is 0, or 1 otherwise. This operator evaluates lazily; it only evaluates its second operand if it must in order to determine its result.

x ? y : z

If-then-else, as in C. If x is false , the result is the value of y. Otherwise the result is the value of z. This operator evaluates lazily; it evaluates only one of y or z.

The exponentiation operator promotes types in the same way that the multiply and divide operators do, and the result is is the same as the result of pow. Exponentiation groups right-to-left within a precedence level. Other binary operators group left-to-right. For example, the value of

expr {4*2 < 7}

is 0, while the value of

expr {2**3**2}

is 512.

As in C, &&, ||, and ?: feature “lazy evaluation”, which means that operands are not evaluated if they are not needed to determine the outcome. For example, in

expr {$v?[a]:[b]}

only one of [a] or [b] is evaluated, depending on the value of $v. This is not true of the normal Tcl parser, so it is normally recommended to enclose the arguments to expr in braces. Without braces, as in expr $v ? [a] : [b] both [a] and [b] are evaluated before expr is even called.

For more details on the results produced by each operator, see the documentation for C.

MATH FUNCTIONS¶

A mathematical function such as sin($x) is replaced with a call to an ordinary Tcl command in the tcl::mathfunc namespace. The evaluation of an expression such as

expr {sin($x+$y)}

is the same in every way as the evaluation of

expr {[tcl::mathfunc::sin [expr {$x+$y}]]}

which in turn is the same as the evaluation of

tcl::mathfunc::sin [expr {$x+$y}]

tcl::mathfunc::sin is resolved as described in NAMESPACE RESOLUTION in the namespace(3tcl) documentation. Given the default value of namespace path, [namespace current]::tcl::mathfunc::sin or ::tcl::mathfunc::sin are the typical resolutions.

As in C, a mathematical function may accept multiple arguments separated by commas. Thus,

expr {hypot($x,$y)}

becomes

tcl::mathfunc::hypot $x $y

See the mathfunc(3tcl) documentation for the math functions that are available by default.

TYPES, OVERFLOW, AND PRECISION¶

Internal floating-point computations are performed using the double C type. When converting a string to floating-point value, exponent overflow is detected and results in the double value of Inf or -Inf as appropriate. Floating-point overflow and underflow are detected to the degree supported by the hardware, which is generally fairly reliable.

Conversion among internal representations for integer, floating-point, and string operands is done automatically as needed. For arithmetic computations, integers are used until some floating-point number is introduced, after which floating-point values are used. For example,

expr {5 / 4}

returns 1, while

expr {5 / 4.0}
expr {5 / ( [string length "abcd"] + 0.0 )}

both return 1.25. A floating-point result can be distinguished from an integer result by the presence of either “.” or “e”

expr {20.0/5.0}

returns 4.0, not 4.