# Expressions in Tcl

In this part of the Tcl tutorial, we will talk about expressions.
In Tcl language the expressions are not built into the core language.
Rather, the expressions are evaluated with the `expr`

command.

Expressions are constructed from operands and operators. The operators of
an expression indicate which operations to apply to the operands.
The order of evaluation of operators in an expression is determined by the
*precedence* and *associativity* of the operators.

An *operator* is a special symbol which indicates
a certain process is carried out. Operators in programming languages are
taken from mathematics. Programmers work with data. The operators are used
to process data. An *operand* is one of the inputs
(arguments) of an operator.

The following table shows a set of operators used in the Tcl language:

Category | Symbol |
---|---|

Sign, bit-wise, logical NOT | `- + ~ !` |

Exponentiation | `**` |

Arithmetic | `+ - * / %` |

Shift | `<< >>` |

Relational | `== != < > <= >=` |

String comparison | `eq ne` |

List | `in ni` |

Bitwise | `& | ^` |

Boolean | `&& ||` |

Ternary | `?:` |

An operator usually has one or two operands. Those operators that work
with only one operand are called *unary operators*.
Those which work with two operands are called *binary operators*.
There is also one ternary operator `?:`

, which works with three operands.

## Basic operators

Basic operators are commonly used operators. These are sign operators, arithmetic operators, modulo, and exponentiation operators.

#!/usr/bin/tclsh puts [expr +2] puts [expr -2] puts [expr -(-2)] puts [expr 2+2] puts [expr 2-2] puts [expr 2*2] puts [expr 2/2] puts [expr 2/2.0] puts [expr 2 % 2] puts [expr 2 ** 2]

The above example shows the usage of common operators in Tcl.

puts [expr +2]

In this code line we use the plus sign operator. It has no effect on the number. It merely indicates that the number is positive. It can be omitted and most of the time it is.

puts [expr -2] puts [expr -(-2)]

The minus operator is compulsory. It says that the number is negative. The minus operator changes the sign of the number. In the second line, the minus operator changes -2 to positive 2.

puts [expr 2+2] puts [expr 2-2] puts [expr 2*2] puts [expr 2/2]

The above lines show common arithmetic operators in use.

puts [expr 2 % 2]

The % is the modulo or remainder operator. It finds the remainder of
division of one number by another. The expression `2 % 2`

,
2 modulo 2 is 0 because 2 goes into 2 once with the remainder of 0.
So the code line prints zero to the console.

puts [expr 2 ** 2]

This is the exponentiation operator. The code line prints 4 to the console.

$ ./exp.tcl 2 -2 2 4 0 4 1 1.0 0 4

Output of the example.

## The division operator

Beginning programmers are often confused by division operation. In many programming languages there are two kinds of division operations: integer and non-integer. This applies for the Tcl as well.

% expr 3/2 1 % expr 3/2.0 1.5

Note the difference between the integer and floating point division. When at least one of the operands is a floating point number, the result is a floating point value too. The result is more exact. If both operands are integers, the result is an integer too.

## The assignment and increment operators

There is no assignment operator `=`

and no increment and decrement
(`++`

and `--`

) operators in Tcl. These operators are
common in other computer languages. Instead of that, Tcl has commands.

% set a 5 5 % incr a 6 % incr a 7 % incr a -1 6

The above code shows what commands are used to implement the missing operators.

% set a 5

In Python, we would do `a = 5`

. In Tcl, we set a value to
a variable using the `set`

command.

% incr a 6

In C, Java and many other languages, we would increment a variable by
one this way: `a++;`

. In Tcl, we use the `incr`

command. By default, the value is incremented by 1.

% incr a -1 6

The above code shows how to decrement a variable by one, which is
accomplished by the `--`

decrement operator in C-based languages.

## Boolean operators

In Tcl, we have the following logical operators:

Symbol | Name |
---|---|

&& | logical and |

|| | logical or |

! | negation |

Boolean operators are also called logical.

#!/usr/bin/tclsh set x 3 set y 8 puts [expr $x == $y] puts [expr $y > $x] if {$y > $x} { puts "y is greater than x" }

Many expressions result in a boolean value. Boolean values are used in conditional statements.

puts [expr $x == $y] puts [expr $y > $x]

Relational operators always result in a boolean value. These two lines print 0 and 1. In Tcl, 0 is false and any nonzero value is true.

if {$y > $x} { puts "y is greater than x" }

The body of the `if`

command is executed only if the condition
inside the parentheses is met. The `$y > $x`

returns true, so
the message "y is greater than x" is printed to the terminal.

#!/usr/bin/tclsh puts [expr 0 && 0] puts [expr 0 && 1] puts [expr 1 && 0] puts [expr 1 && 1]

This example shows the logical and `&&`

operator.
It evaluates to true only if both operands are true.

$ ./andoperator.tcl 0 0 0 1

The logical or `||`

operator evaluates to true
if either of the operands is true.

#!/usr/bin/tclsh puts [expr 0 || 0] puts [expr 0 || 1] puts [expr 1 || 0] puts [expr 1 || 1]

If one of the sides of the operator is true, the outcome of the operation is true.

$ ./oroperator.tcl 0 1 1 1

The negation operator `!`

makes true false and false true.

#!/usr/bin/tclsh puts [expr ! 0] puts [expr ! 1] puts [expr ! (4<3)]

The example shows the negation operator in action.

$ ./not.tcl 1 0 1

The `||`

and `&&`

operators
are short circuit evaluated. *Short circuit evaluation* means
that the second argument is only evaluated if the first argument does
not suffice to determine the value of the expression: when the first
argument of the logical and evaluates to false, the overall value must
be false; and when the first argument of logical or evaluates to true,
the overall value must be true.
Short circuit evaluation is used mainly to improve performance.

An example may clarify this a bit more.

#!/usr/bin/tclsh proc One {} { puts "Inside one" return false } proc Two {} { puts "Inside two" return true } puts "Short circuit" if { [One] && [Two] } { puts "Pass" } puts "###################" if { [Two] || [One] } { puts "Pass" }

We have two procedures in the example. (Procedures and conditionals will be described later.) They are used as operands in boolean expressions. We will see if they are called or not.

if { [One] && [Two] } { puts "Pass" }

The `One`

procedure returns false. The short circuit ` &&`

does not evaluate the second procedure. It is not necessary.
Once an operand is false, the result of the logical conclusion is always
false. Only "Inside one" is printed to the console.

puts "###################" if { [Two] || [One] } { puts "Pass" }

In the second case, we use the `||`

operator and use the `Two`

procedure as the first operand. In this case, "Inside two" and "Pass"
strings are printed to the terminal. It is again not necessary to evaluate the second
operand, since once the first operand evaluates to true, the
logical or is always true.

$ ./shortcircuit.tcl Short circuit Inside one ################### Inside two Pass

Result of the `shorcircuit.tcl`

script.

## Relational operators

Relational operators are used to compare values. These operators always result in boolean value. In Tcl 0 stands for false and 1 for true. Relational operators are also called comparison operators.

Symbol | Meaning |
---|---|

`<` | less than |

`<=` | less than or equal to |

`>` | greater than |

`>=` | greater than or equal to |

`==` | equal to |

`!=` | not equal to |

The table presents six Tcl relational expressions.

#!/usr/bin/tclsh puts [expr 3 < 4] puts [expr 3 == 4] puts [expr 4 >= 3] puts [expr 4 != 3]

In Tcl we use the `==`

operator to compare numbers. Some languages
like Ada, Visual Basic, or Pascal use `=`

for comparing numbers.

$ ./rel.tcl 1 0 1 1

The example prints four boolean values.

## Bitwise operators

Decimal numbers are natural to humans. Binary numbers are native to computers. Binary, octal, decimal, and hexadecimal symbols are only notations of the same number. Bitwise operators work with bits of a binary number. Bitwise operators are seldom used in higher level languages like Tcl.

Symbol | Meaning |
---|---|

~ | bitwise negation |

^ | bitwise exclusive or |

& | bitwise and |

| | bitwise or |

The *bitwise negation operator* changes each 1 to 0 and 0 to 1.

% puts [expr ~7] -8 % puts [expr ~-8] 7

The operator reverts all bits of 7. One of the bits also determines whether the number is negative. If we negate all the bits one more time, we get number 7 again.

The *bitwise and operator* performs bit-by-bit comparison between two numbers.
The result for a bit position is 1 only if both corresponding bits in the operands are 1.

00110 & 00011 = 00010

The first number is a binary notation of 6, the second is 3, and the result is 2.

% puts [expr 6 & 3] 2 % puts [expr 3 & 6] 2

The *bitwise or operator* performs bit-by-bit comparison between two numbers.
The result for a bit position is 1 if either of the corresponding bits in the operands is 1.

00110 | 00011 = 00111

The result is `00110`

or decimal 7.

% puts [expr 6 | 3] 7 % puts [expr 3 | 6] 7

The *bitwise exclusive or operator* performs bit-by-bit comparison
between two numbers. The result for a bit position is 1 if one or the other
(but not both) of the corresponding bits in the operands is 1.

00110 ^ 00011 = 00101

The result is `00101`

or decimal 5.

% puts [expr 6 ^ 3] 5 % puts [expr 3 ^ 6] 5

## The expansion operator

The expansion operator, `{*}`

, makes each item in a list an individual
argument of the current command. A list is a basic Tcl data structure; it is
covered in a later chapter.

#!/usr/bin/tclsh set nums {1 2 3 4 5 6} puts $nums puts [tcl::mathfunc::max {*}$nums] puts [tcl::mathfunc::min {*}$nums]

The expansion operator is used with two mathematical functions.

set nums {1 2 3 4 5 6}

A numerical list called `nums`

is created. A list is an ordered
collection of values.

puts $nums

The contents of the list are printed to the terminal.

puts [tcl::mathfunc::max {*}$nums]

The `tcl::mathfunc::max`

is a standard mathematical function.
It does not process lists. The numbers should be passed as individual
arguments. The expansion operator transforms a list of items into
individual items.

$ ./expansion.tcl 1 2 3 4 5 6 6 1

Example output.

## Operator precedence

The *operator precedence* tells us which operators are evaluated first.
The precedence level is necessary to avoid
ambiguity in expressions.

What is the outcome of the following expression, 28 or 40?

3 + 5 * 5

Like in mathematics, the multiplication operator has a higher precedence than addition operator. So the outcome is 28.

(3 + 5) * 5

We use parentheses to change the order of evaluation. Expressions inside parentheses are always evaluated first.

The following table shows common Tcl operators ordered by precedence (highest precedence first):

Category | Symbol | Associativity |
---|---|---|

Sign, bit-wise, logical NOT | `- + ~ !` |
Left |

Exponentiation | `**` |
Left |

Arithmetic | `+ - * / %` |
Left |

Shift | `<< >>` |
Left |

Relational | `== != < > <= >=` |
Left |

String comparison | `eq ne` |
Left |

List | `in ni` |
Left |

Bitwise | `& | ^` |
Left |

Boolean | `&& ||` |
Left |

Ternary | `?:` |
Right |

Operators on the same row of the table have the same precedence.

!/usr/bin/tclsh puts [expr 3 + 5 * 5] puts [expr (3 + 5) * 5] puts [expr ! 1 || 1] puts [expr ! (1 || 1)]

In this code example, we show some common expressions. The outcome of each expression depends on the precedence level.

puts [expr 3 + 5 * 5]

This line prints 28. The multiplication operator has a higher precedence
than addition. First, the product of `5*5`

is calculated, then 3 is added.

puts [expr (3 + 5) * 5]

Round brackets can be used to change the precedence level. In the above expression, 3 is added to 5 and the result is multiplied by 5.

puts [expr ! 1 || 1]

In this case, the negation operator has a higher precedence. First,
the first true (1) value is negated to false (0), than the
`||`

operator combines false and true, which gives true in the end.

$ ./precedence.tcl 28 40 1 0

Output.

## Associativity

Sometimes the precedence is not satisfactory to determine the outcome
of an expression. There is another rule called
*associativity*. The associativity of operators determines
the order of evaluation of operators with the *same*
precedence level.

9 / 3 * 3

What is the outcome of this expression, 9 or 1? The multiplication,
deletion, and the modulo operators are left to right associated.
So the expression is evaluated this way: `(9 / 3) * 3`

and the result is 9.

Arithmetic, boolean, relational, and bitwise operators are all left to right associated.

The ternary operator is right associated.

## The ternary operator

The ternary operator `?:`

is a conditional operator. It is a
convenient operator for cases where we want to pick up one of two values,
depending on the conditional expression.

cond-exp ? exp1 : exp2

If cond-exp is true, exp1 is evaluated and the result is returned. If the cond-exp is false, exp2 is evaluated and its result is returned.

#!/usr/bin/tclsh set age 32 set adult [expr $age >= 18 ? true : false] puts "Adult: $adult"

In most countries the adulthood is based on your age. You are adult if you are older than a certain age. This is a situation for a ternary operator.

set adult [expr $age >= 18 ? true : false]

First, the expression on the right side of the assignment
operator is evaluated. The first phase of the ternary operator
is the condition expression evaluation. So if the age is greater
or equal to 18, the value following the `?`

character is returned.
If not, the value following the `:`

character is returned.
The returned value is then assigned to the adult variable.

$ ./ternary.tcl Adult: true

A 32 years old person is adult.

## Calculating prime numbers

We are going to calculate prime numbers. Some of the features (lists, loops) will be covered later in the tutorial.

#!/usr/bin/tclsh # primes.tcl set nums { 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 } puts "Prime numbers:" foreach num $nums { if { $num==1 } { continue } if { $num==2 || $num==3 } { puts -nonewline "$num " continue } set i [expr int(sqrt($num))] set isPrime true while { $i > 1 } { if { $num % $i == 0 } { set isPrime false } incr i -1 } if { $isPrime } { puts -nonewline "$num " } } puts ""

In the above example, we deal with many various operators. A prime number (or a prime) is a natural number greater than 1 that has exactly two distinct natural number divisors: 1 and itself. We pick up a number and divide it by numbers, from 1 up to the picked up number. Actually, we don't have to try all smaller numbers, we can divide by numbers up to the square root of the chosen number. The formula will work. We use the remainder division operator.

set nums { 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 }

We calculate primes from this list of integers.

if { $num==1 } { continue }

By definition, 1 is not a prime. The `continue`

command skips
to the next iteration of the loop.

if { $num==2 || $num==3 } { puts -nonewline "$num " continue }

We skip the calculations for the 2 and 3. They are primes and do not require further
computations. Note the usage of the equality and conditional or
operators. The `==`

has a higher precedence than the
`||`

operator. So we don not need to use parentheses.

set i [expr int(sqrt($num))]

We are OK if we only try numbers smaller than the square root of a number in question.

while { $i > 1 } { if { $num % $i == 0 } { set isPrime false } incr i -1 }

In this while loop, the `i`

is the calculated square root
of the number. We use the `incr`

command to
to decrease `i`

by one each loop cycle. When the `i`

is smaller than
1, the loop is ended. For example, we have number 9.
The square root of 9 is 3. We will divide the 9 number by
3 and 2. This is sufficient for our calculation.

if { $isPrime } { puts -nonewline "$num " }

If the remainder division operator returns 0 for any of the i values, then the number in question is not a prime.

$ ./primes.tcl Prime numbers: 2 3 5 7 11 13 17 19 23 29 31

This is the output of the `primes.tcl`

script.

In this part of the Tcl tutorial, we covered Tcl expressions.