The Tela operators, from lower to higher precedence:
Operator Association Meaning
-------- ----------- -------
: - Range creation, ex: 1:10, -5:2.3:7
|| left Logical OR, similar to C
&& left Logical AND, similar to C
==, != left Equality and nonequality
>, >=, <, <= left Comparisons
+, - left Addition and subtraction
*, /, mod, ** left Multiplication, real division, modulus,
matrix multiplication
-, + - Unary minus and plus
^ right Raising to power
! - Unary logical NOT
The special symbols '++' and '--' are not actually operators but statements. See help ++ .
See also the help for each individual operators: : , || , && , == , comparison , + , - , * , / , mod , ** , power , ! . See also: special (type help special).
The Tela special characters
---------------------------
Char(s) Meanings, usages
------- ----------------
( ) Parentheses, expression grouping (a+b)*(a-c)
[ ] Brackets, array indexing A[i,2:N-1]
Function call [a,b] = f(x,y,z);
Function definition function [a,b] = f(x,y,z) {};
<[ ]> Mapped array indexing A<[ivec,jvec]>
#( ) Array constructor #(1,2; 3,4)
{ } Statement grouping {i++; j++};
++ Incrementation i++;
-- Decrementation i--;
; Statement separator {i++; j++};
Separator in for statement for (i=1; i<=imax; i++) {};
Separator of obligatory/optional args function y=f(x; y) {};
Separator in array constructor #(1,2; 3,4)
, Separator of parameters x = f(x,y) + 3;
Separator in array constructor #(1,2; 3,4)
More information available: [ , <[ , ++ .
See also: operators .
Reserved word: mod
a mod b gives the modulus, a modulo b. a and b may be also complex; in that case the modulus is taken separately for the real and imaginary parts. The modulus operator has the same precedence as the pointwise multiplication '*' and real division '/'.
Special symbol: +
a + b is the normal addition operator. If both a and b are scalars, the result is a scalar. If one of them is array, the result is an array of the same size. If both are arrays, their dimensions must agree and the result is an array.
Unary plus (+a) returns 'a' as is.
Special symbol: *
a * b is the normal (pointwise) multiplication operator. If both a and b are scalars, the result is a scalar. If one of them is array, the result is an array of the same size. If both are arrays, their dimensions must agree and the result is an array.
Special symbol: /
a / b is the normal (pointwise) division operator. If both a and b are scalars, the result is a scalar. If one of them is array, the result is an array of the same size. If both are arrays, their dimensions must agree and the result is an array.
Special symbol: -
a - b is the subtraction operator. If both a and b are scalars, the result is a scalar. If one of them is array, the result is an array of the same size. If both are arrays, their dimensions must agree and the result is an array.
Unary minus (-a) is the negative of a.
Special symbol: **
T**U is the generalized matrix product of T and U.
If T has components T
Special symbol: ':'
a:step:b creates a vector of values #(a,a+step,a+2*step,...) such that
all elements are less or equal than b. a:b creates a range using unit
step. A lone ':' stands for the Void value. When used as an array
subscript, it stands for the entire range, for example A
See also: operators
Special symbols: ++, --
The statement a++ increments a by one. The statement a-- decrements a by one. Notice that these are not operators but statements in Tela.
See also: +
Special symbol: ||
a || b is the logical OR of a and b. The operands must be integer valued. For array operand(s), the OR operation is applied componentwise.
Special symbol: &&
a && b is the logical AND of a and b. The operands must be integer valued. For array operand(s), the AND operation is applied componentwise.
Special symbol: !, operators (type help operators)
!a is the logical NOT of a. The operand must be integer valued. If the operand is an integer array, the result is integer array also, otherwise the result is integer scalar.
On command prompt, '!' executes an operating system command, if it is the first character on line. In t-files this extra meaning of '!' does not exist, but you must use the 'system' function explicitly.
Special symbols: ==, !=
a == b is the equality test operator. If both operands are scalars, the result is either 1 or 0. If one operand is numeric array and the other one is scalar, the result is an integer array of 0's and 1's of the same size as the array operand. If both operands are arrays of the same size, the result is again an integer array of 0's and 1's. But if the operands are arrays of different size, the result is 0 (integer scalar). Strings are handled as integer arrays of their ASCII codes, according to their internal representation. For other types of objects, for example functions, the result is 1 only if the objects are exactly equal.
a != b is the 'not-equal' operator. It is analogous to '=='.
Unlike order-related comparison operators (<, >, <=, >=), the '==' and '!=' operators never generate an error message for any operands.
See also: comparison , operators
Special symbols: <, >, <=, >=
These operators obviously test whether the first operand is less than, greater than, less or equal than, or greater or equal than the second operand. If both operands are scalars, the result is scalar (1 or 0). If one operand is array and the other one is scalar, the result is an integer array of 0's and 1's. If both operands are arrays, their dimensions must agree. The result is then again an integer array of 0's and 1's.
The operands may not be nonnumeric, nor they may include complex numbers.
Special symbol: ˆ
a ˆ b is a-raised-to-the-power-b. If both a and b are scalars, the result is a scalar. If one of them is array, the result is an array of the same size. If both are arrays, their dimensions must agree and the result is an array.
Special symbols: [, ]
If A is an array, it can be indexed using A[i,j,...,k]. The number of
indices must be equal to rank(A), except that all arrays can be
indexed using just single index, in which case the array is indexed in
flattened form. The flattened indexing is useful e.g. in connection
with find(), because find() returns a flattened index vector. Flat
indexing is also generally faster than ordinary indexing for
multidimensional arrays.
The indices may be of three types. 1) integer scalars, 2) integer vectors,
3) Void value (notation ':'), which means 'whole range'. The rank of the
result is equal to rank(A) - n, where n is the number of integer scalar
indices.
See also: <[
Special symbols: <[, ]>
Besides ordinary array indexing, accomplished with [ ], you can use
mapped indexing using <[ ]>. Assume A is an array with N = rank(A).
Assume that I1...IN are integer arrays, and that their dimensions
mutually agree. Then A<[I1,I2,...,IN]> is a collection of A's
components, and its size is equal to the size of each Ik.
Unlike ordinary array indexing, in mapped indexing the size of the
result is not determined by A, but the size of the index
arrays. Mapped indexing can not easily be returned to ordinary
indexing, hence it is included as a separate operation in Tela.
See also: [ .
Next Chapter, Previous Chapter
Table of contents of this chapter, General table of contents
Top of the document, Beginning of this Chapter