EVAL

Syntax

An EVAL command uses the following general syntax:

result := eval expression

or

result := evalcheck expression

result: This is the target to be assigned with the result of the evaluation of the numerical expression. The result can be a shell variable or a numerical object
expression: The numerical expression to be evaluated. The expression consists of numerical objects, functions and operators.

Examples:

result := eval (5 * 10) % 3
result := eval init(10,1,1)
result := eval 5+max(fill(6,1,1))

The following list shows the syntax of EVAL expression using the EBNF notation. The expressions are listed in the reverse order of priority (lowest first). The operators with lower priority are evaluated after that with higher priority.

assignment	Value = Or [ "?" Or ":" Or ]
logical or	Or = And { "\|\|" And }
logical and	And = Comparison { "&&" Comparison }
comparison:	Comparison = AddSub { "<" \| "<=" \| "==" \| "!=" \| ">=" \| ">" AddSub }
add, substract	AddSub = MulDiv { "+" \| "-" MulDiv }
multiply, divide	MulDiv = Pwr [ "" \| "/" \| "%" Pwr ]
power	Pwr = NegInv [ "^" NegInv ]
negate	NegInv = [ "-" \| "!" ] Atom
brackets, functions, numerical objects	Atom = "(" expression ")" \| "\|" expression "\|" \| functionName "(" [ expression { "," expression } ] ")" \| numericalObject

If the expression is syntactically ill-formed an error (EVAL) or warning (EVALCHECK) is reported and the assignment is not performed (content of result is not changed). See the example script expression_check.sts for details. Note that a good place to try out the EVAL command is the BScript console.

Note: The special bracket |expression| implements a short form to compute the absolute value of expression. The result is always a number (scalar).

|x_S| → the absolute value of number x_S
|x_V| → the length of the vector x_V
|x_M| → the determinant of the square matrix x_M

The functions abs(x) and det(x) can be used as aliases for |expression|.

Numerical objects

The following numerical objects are known to the EVAL command. The fields of the table item table are all numeric (extended table or parameter table). The value item value can contain numbers, vectors or matrices. The wave item wave is any wave item.

Syntax	Description	Data type
constant	a scalar constant. Any number (17, 4.5, 2.5e-6, ...) or one of the following strings: pi (3.14159...), e (2.71828...), true (1) or false (0)	scalar
table	the content of the whole table	vector, matrix
table[i,] or table*[i,]	the i-th row of the table	scalar, vector
table[,j] or table*[,j]	the j-th column of the table	scalar, vector
table[i,j]	the value of the i-th row and j-th column of the table	scalar
value	the content of the value item	scalar, vector, matrix
value[i,] or value*[i,]	the i-th row of the value item	scalar, vector
value[,j] or value*[,j]	the j-th column of the value item	scalar, vector
value[i,j]	the value of the i-th row and j-th column of the value item	scalar
wave[!signal,] or wave*[!signal,]	the signal from all channels	vector, matrix
wave[!signal,ch]	the signal from channel ch (=1,2,...)	vector
wave[!signal,,*b,l]	the signal from all channels from sample b (0 <= b < wave[!length]) to sample b+l-1 (l > 0) If b is lower than 0 or b+l is greater than wave[!length] zero padding is applied to the result	vector, matrix
wave[!signal,ch,b,l]	the signal from channel ch from sample b to sample b+l-1	vector

row- and column-vectors

In STx it is not possible to differentiate between row-vectors and column-vectors. Normally a vector is a row-vector, but it depends on the context (the operator or function used) which type of vector is supposed.

complex numbers

The current version of STx do not implement the datatype complex, but a lot of functions take complex arguments and/or return complex results. Therefore the following convention for numerical objects holding complex numbers is used:

complex number: A vector with two elements. If the number is stored in the cartesian format, the first element is the real part and the second the imaginary part. If it is stored in polar format, the first element is the magnitude (or length) and the second the phase.
complex vector: A vector of N complex numbers consists of 2N elements. The element 2i is the real part (or magnitude) and the element 2i+1 is the imaginary part (or phase) of the i-th complex number (i = 0..N-1).
complex matrix: A matrix of N x M complex numbers consists of 2N rows and M. Each row is formatted like a complex vector described above.

polygons

The EVAL command implements a set of functions to manipulate 2-dimensional polygons. These functions are using special formatted matrices to store informations about one or more polygon. Some examples for the use of polygon functions and data types can be found in the example script scripts\examples\polygon_examples.sts.

closed point-list (pg_cplist): Is a list of N points P_i in a 2-dimensional plane. Each pair (P_i , P_i+1) builds one edge of a polygon. The list is called closed, because P_N-1 is connected to P₀. A pg_cplist is stored in a matrix PL with N rows and 2 columns. The coordinates of point P_i are stored in PL[i,0] (x_i) and PL[i,1] (y_i).

simple-polygon (pg_simple): Is a closed point-list (pg_cplist) defining a polygon without crossing edges.

polygon-stream (pg_stream): Is a packed format to store the point-list and some additional information for one or more simple-polygons. This format is created by the initialisation function initialisation function and used as argument and/or result by the most other polynom processing functions. A pg_stream is stored in a matrix with 2 columns and 8M+N₀+..+N_M-1 rows, where M means the number of polynoms stored in the stream and N_i the number of points of the i-th polynom. The data for the i-th polygon are stored in the matrix in the following format:

row index	value of column 0	value of column 1	comment
o_i+0	N_i: number of points	reserved (set to 0)
o_i+1	IX_i: the index of the leftmost/lowest point (used for computations y=f(x))	IY_i: the index of the lowest/leftmost point (used for computations x=f(y))
o_i+2	XMIN_i: minimum x of all points	YMIN_i: minimum y of all points	The point (XMIN_i,YMIN_i) is the lower left corner of the bounding rectangle
o_i+3	XMAX_i: maximum x of all points	YMAX_i: maximum y of all points	The point (XMAX_i,YMAX_i) is the upper right corner of the bounding rectangle
o_i+4	XC_i: x value of the center of gravity	YC_i: y value of the center of gravity	The point (XC_i,YC_i) is the center of gravity of the polygon
o_i+5	A_i: area	L_i: circumference
o_i+6	1 if the center of gravity is inside the polygon, 0 otherwise	1 if the polygon is convex, 0 otherwise
o_i+7	reserved (set to 0)	reserved (set to 0)
o_i+8 .. o_i+N_i-1	x values of points	y values of points	the coordinates of the points (corners) of the (simple) polygon

with: o_i is the first row index of the i-th polynum; o₀=0, o_i=o_i-1+8+N_i-1 (i = 1..M-1)

Operators

Numerical operators

Syntax	Description	Data type of Result
-x	Negate all elements of x.	same as x
y+x_S x_S+y	Add the scalar x_S to all elements of y.	same as y
x+y	Add elements of x to the elements of y. Both operands must be of the same type.	same as x and y
y-x_S	Subtract the scalar x_S from each element in y.	same as y
x_S–y	Subtract all elements of y from the scalar x_S.	same as y
x-y	Subtract elements of x from the elements of y. Both operands must be of the same type.	same as x and y
yx_S x_Sy	Multiply all elements of y with the scalar x_S.	same as y
x_V*y_V	The inner (or dot) product of the vectors x_V and y_V. The length of both vectors must be the same.	scalar
x_M*y_V	The product of the matrix x_M and the vector y_V. The length of the vector y_V must be the same as the number of columns in the matrix x_M.	vector with nrow(x_M) elements
x_M*y_M	The product of the matrix x_M and y_M. The number of rows in y_M must be equal to the number of columns in x_M.	matrix with nrow(x_M) rows and ncol(y_M)) columns
y/x_S	Divide all elements of y through the scalar xS. The value of x_M may not be 0.	same as y
x_S/y_M	Multiply all elements of the inverse matrix of y_M with the scalar x_S. The matrix y_Mmust be a square matrix.The special case 1/y_M returns the inverse matrix. Note that the function inv(y) can also be used to invert scalars and matrices.	same as y_M
y%x_S	The rest of the division of every element in y through the scalar x_S (modulo)	same as y
y^x_S	Raise every element of y to the power of the scalar xS. Special cases: `y^-1` is calculated like `1/y` and `y^2` is calculated like this `y*y`	same as y

If one of the numerical operands has the prefix ? then the operation is carried out element per element. Example:

#dotprod := eval $#x * $#y // dot product of vectors #x and #y
#winsig := eval $#x ?* $#y // multiply elements of #x and #y (e.g. to apply signal windowing)

Comparison operators

Syntax	Description
x<y	x less than y
x>y	x greater than y
x<=y	x less than or equal to y
x>=y	x greater than or equal to y
x==y	x equal to y.
x!=y	x not equal to y.

The result of a comparison of two numerical expressions is (logical) true (numerical 1), if the condition is fulfilled, otherwise it is (logical) false (numerical 0). Normally it make only sense to compare scalars or, more generally, numerical objects with equal dimensions. The following rules applies to a comparison:

The numerical objects x and y are equal (x==y is true), if (and only if) the dimensions of x and y are the same and all pairs of elements (x_i,j , y_i,j) are numerically equal.
The numerical objects x and y are not equal (x!=y is true), if the dimensions of x and y are different or at least one element pair (x_i,j , y_i,j) is numerically not equal.
For all other comparisons the dimensions of x and y must be the same, otherwise the comparison failes. The result is true, if the condition is fulfilled for all pairs of elements (x_i,j , y_i,j).

Logical operators

Syntax	Description
x\|\|y	logical or
x&&y	logical and
!x	unary not

The result of a logical operation is true (numerical 1) or false (numerical 0). The arguments x and y can be any numerical type. It is also possible to use different arguments with different types. The following rules are used to convert logical (boolean) to numerical values and vice versa:

The numerical result of a logical operation is the value ...

1 if the logical expression is true
0 if the logical expression is false

The logical value of a numerical object (or expression) is ...

true if one of its elements is not equal to 0.
false if all of its elements are equal to 0.

Selection operator

The selectopn operator used in EVAL expressions works similar to the COND command.

log_expr ? true_expr : false_expr

log_expr: A logical expression which is used to select the expression to be evaluated.
true_expr: This expression is evaluated and returned as result of the selection operator, if log_expr is true.
true_expr: This expression is evaluated and returned as result of the selection operator, if log_expr is false.

In contrast to the COND command, the selection operator of the EVAL command can be nested, but must be surrounded by brackets, e.g.:

result := eval 1 > 2 ? (5 == 5 ? 5 : 0) : (4 == 5 ? 3 : 4) // result is 4

Functions

abs · absmax · absmin · absv · acos · aseg1 · asin · asp2osp · atan · avr · cepstrum · complex arithmetic · corr · corrfun · cos · cvphase · dct · density · dev · dft · dist · em · exp · f0ac · f0sp · fft · fill · fir1 · floor · formants · grand · haclust · hcomb · hist · hth · hz2bark · hz2cent · hz2erb · hz2mel · ifft · iir1 · imax · imin · init · int · interp · inv · ipeak · limit · log · log2lin · lpc · map2map · mapmind · max · median · min · modclust · mul · ncol · npow2 · nrow · optmm · otrack1 · pgget · pghull · pgiline · pginit · pgitest · pgsplit · pgtrans · pgxgrid · pztf · qdet · qinterp · rand · rleqs · round · rpoly · rpolyreg · sample · select · shuffle · sig2osp · sign · sin · sinc · smooth · sort · sqrt · sum · svd · tan · ticks2f1 · trn · var · vmcol · vmrow · vsubc · vsubn · vv · vvcat · vvget · vvset · wconvert · window · wsum · ydiff · yint · zcross

Result of EVAL

The result of the evaluation returned to the script is a number, vector or matrix. Numbers are returned in a string format (as usual in STx) and vectors or matrices are stored and returned in a temporary (or local) parameter table. The return value can be assigned to a variable, a shell item or a addressed part of a shell item.

If the result is assigned to a variable, only the returned string (the value of the number or name of the temporary table) is stored.

#x := eval rand(0,100)     // generate a vector with 100 pseudo random numbers in the range -1 to 1
                           // the name of the returned temporary table is assigned to the variable #x
#y := eval $#x * (1 - $#x) // compute the dot-product of 2 vectors
                           // the returned number is assigned to variable #y

Examples

The following script shows some examples for the use of the EVAL command. In the directory scripts\examples you can find a lot of script files using EVAL for differnt purposes (dsp_examples.sts, eval_example.sts, expression_checks.sts, matrix_algebra_examples.sts, parameter_table_example.sts, plot_sample.sts, polygon_examples.sts, ...)

[Macro eval_example]
// force this macro to be run in the debugger
message debug on
message debug init /Step

#a := 0
#b := 1
#c := 2
#d := 3

#e1 := eval $#d*$#c+$#b
#e2 := eval $#b+$#d*$#c
#e3 := eval $#d*($#c+$#b)

#c1 := eval $#a || $#b || $#c
#c2 := eval $#a && $#b && $#c
#c3 := eval $#a && $#b || $#c
#c4 := eval $#c || $#a && $#b
#c5 := eval ($#c || $#a) && $#b
#c6 := eval ! $#a || ! $#b
#c7 := eval ! $#a && ! $#b

readstr '' #e1 #e2 #e3 #c1 #c2 #c3 #c4 #c5 #c6 #c7 /Delete  // clear variables

#c1 := eval $#a > $#b
#c2 := eval $#a >= $#b
#c3 := eval $#a < $#b
#c4 := eval $#a <= $#b
#c5 := eval $#a == $#b
#c6 := eval $#a != $#b

readstr '' #c1 #c2 #c3 #c4 #c5 #c6 /Delete  // clear variables

#c1 := eval $#b > $#a
#c2 := eval $#b >= $#a
#c3 := eval $#b < $#a
#c4 := eval $#b <= $#a
#c5 := eval $#b == $#a
#c6 := eval $#b != $#a

readstr '' #c1 #c2 #c3 #c4 #c5 #c6 /Delete   // clear variables

#c1 := eval $#a < $#b ? $#a+$#b : $#a-$#b
#c2 := eval $#a > $#b ? $#a+$#b : $#a-$#b
#c3 := eval $#a == $#b ? $#a+$#b : $#a-$#b
#c4 := eval $#a != $#b ? $#a+$#b : $#a-$#b

readstr '' #c1 #c2 #c3 #c4 /Delete           // clear variables

// nested "? :" statements may be hard to read
#c := eval $#a > $#b ? ($#a == $#b ? 1 : 2) : ($#a == $#b ? 3 : 4)

// ...especially if you leave out readability blanks...
#c := eval $#a>$#b?($#a==$#b?1:2):($#a==$#b?3:4)

#c1 := eval sin( $#a > $#b ? $#a : $#b )
#c2 := eval sin( $#a < $#b ? $#a : $#b )

readstr '' #c1 #c2 /Delete                   // clear variables

#vec1 := eval fill( 10, 0.1, 0.2 )           // ten elements
#vec2 := eval fill( 10, 0.2, 0.1 )           // also ten elements
#vec3 := eval fill( 5, 0.2, 0.1 )            // only five elements

// ten elements each of which is larger than the corresponding element in vec1
#vec4 := eval fill( 10, 10, 0.1 )

#c1 := eval $#vec1 == $#vec2
#c2 := eval $#vec1 != $#vec2
#c3 := eval $#vec1 > $#vec2
#c4 := eval $#vec1 < $#vec2
#c5 := eval $#vec1 > $#vec4
#c6 := eval $#vec1 < $#vec4

#sum1 := eval $#vec4 ^ 2                     // normal operation
#sum2 := eval $#vec4 ?^ 2                    // element-wise operation

readstr '' #c1 #c2 #c3 #c4 #c5 #c6           // clear variables

// vectors of different size are trivially unequal
#c1 := eval $#vec1 == $#vec3
#c2 := eval $#vec1 != $#vec3

// illegal comparisons due to different size
#c3 := eval $#vec1 < $#vec3                  // illegal!
#c4 := eval $#vec1 > $#vec3                  // illegal!

readstr '' #c1 #c2 #c3 #c4
delete $#vec1 $#vec2 $#vec3 $#vec4

#vec1 := eval fill( 11, -5, 1 )

// limit all values to be >= -1 and <= 2
#vec2 := eval limit( $#vec1, -2, 2 )

// set lowest bound only
#vec3 := eval limitLow( $#vec1, -2 )

// set highest bound only
#vec4 := eval limitHigh( $#vec1, 2 )

// this works with a number (as opposed to vectors and matrices), too
#c1 := 123.5
#c2 := eval limit($#c1,0,100)
#c3 := eval limitlow( $#c1, 100 )
#c4 := eval limithigh( $#c1, 100 )

// pick out the smallest value from vec1, vec2 and a number of numbers
#min := eval min($#vec1,$#vec2,100,20)

// pick out the largest value from vec1, vec2 and a number of numbers
#max := eval max($#vec1,$#vec2,100,20)

EVAL

Contents