4. Elements of UniScript

4.1. Comments in UniScript

A comment is text that is included in a program to explain what the program does and how it works. You should add comments to your programs in order that you or another person understands the program at a later time.

As in C, UniScript language comments start with the characters, /*, and end with */. UniScript also supports the C++ comment format. This comment starts with a double-slash (//) sequence. Wherever this sequence appears (unless it is inside a string), everything to the end of the current line is a comment.


    This is a comment
    in C format.

Comments in C format can appear wherever a blank is allowed, e.g.:

rvSignal = [1.4, 1.45, 133254.4 /* Error ? */, 1.53];

Comments in C format cannot be nested. This means that the character sequence, */, is not allowed inside a /* */ comment.

If you add comments to your program, keep in mind the following hints: It is better to choose a descriptive function name than to add a comment to a bad function name:

ssFilename = GetOpenFileName();

is easier to understand than

f = getname();

Comments are frequently used ignore source code lines as shown in the following example:

def hilb(n)
    h = zeros(n, n);
    for (i in 1:n) {
        for (j in 1:n) {
            h[i;j] = 1/(i+j-1);
    return h;
    // this is much faster than two for loops
    x = 1:n;
    x = x[ones(1,n); /* all columns */ ];
    return 1./(x+x.'-1);

4.2. Continuation Line

If you do not have enough room on the line to type a statement, you can use .. to continue a statement on the next line. UniScript will ignore all characters that appear after the two dots:

return (ones(1,m) .* 10) .^  ..
       [s1+(0:m-2) * (S2-s1) ./ (m-1), S2];

Continuation characters can be used wherever a blank character is allowed. You cannot use them inside a name or a constant.

To write a string in several lines use the .. continuation characters as shown here:

"This is a long constant string" + ..
" written in two lines"

Beginning with UniPlot R2013.11 the continuation characters can be omitted after a comma, a Semicolon or a binary operator. That means the two colons .. in the example above are redundant.

4.3. Constant Expressions

Constants are static values UniScript uses during the execution of your program. There are two types of constants: String constants and numeric constants. A constant may be a scalar, a vector or a matrix. A numeric constant may contain complex values.

4.4. Numeric Constants

A simple numeric constant is a single number that can be an integer, a decimal fraction, a number in exponential notation or a complex number. Note that all numeric values are represented within UniScript in double-precision floating point format. Complex numbers are stored as pairs of double-precision floating point values.

Here are some examples:


The following numbers are not valid:

Incorrect   Correct
.03         0.03        Number cannot start with a period
12.         12.0        Number cannot end with a period
13.9D8      13.9E8      Character D as the exponent
                        character is incorrect
3,82        3.82        Decimal sign is a period and not a comma

UniScript uses the same rules as the programming language C.

If you want to use a name for a constant expression, you can use the #define statement. The #define statement has the following syntax:

#define constant-name replace-text

Every time the UniScript interpreter finds the expression constant-name (except inside a string or a comment) it will be replaced by the replace text. The constant name must be a valid UniScript name, the replace text can be any length.

Example for the constant pi

#define PI  3.1415926535897931

The constant PI can be used in a statement like u = 2 * PI * r. Constant names appear normally in capital letters to distinguish them from variable names.

After the definition of the name PI, the constant can be used in every file, not only in the file where the definition is located.

In the UniScript Editor numeric constants are colored dark red.

4.5. Hexadecimal and Octal Constants

As in C, integer constants can be written as hexadecimal or octal numbers. A hexadecimal number (Base 16) has the prefix 0x or 0X. For hexadecimal numbers, the digits 0...9 and the characters a...f (or A...F) are allowed. Examples:

Hexadecimal Decimal
0x10         16
0xFF         255
0x0d         13
0x5          5

An octal number (Base 8) has the prefix 0. For octal numbers, only the digits 0...7 are allowed.


Octal       Decimal
034         28
0377        255

In the UniScript Editor hexadecimal constants are colored dark red.

4.6. Complex Constants

To specify complex constants, expressions can be written in the following forms: 3i, or 1.23e-8i, or 0xFFi. The letter i stands for the pure imaginary constant, defined as sqrt(-1). A space is not allowed between the number and the i.

4.7. String Constants

A string constant consists of a sequence of characters in double quotes. Example:

"This is a string constant"

Some characters cannot be included literally in a string constant. Instead, they can be represented with escape sequences, which are character sequences beginning with a backslash ("\"). For instance, the escape sequence \n represents a newline. In the following example, the words "string constant" will be printed into a new line:

"This is a\nstring constant"

Here is a table of all the escape sequences used in UniScript. They are the same as those used in the C programming language.

Code Meaning
\\ Represents a literal backslash, \
\n a newline
\r a carriage return
\b a backspace
\f a formfeed
\t a horizontal tab
\a the “alert” character
\" a literal double-quote character "
\zzz an integer

The number zzz represents a decimal, hexadecimal or octal number in the range 0...255 (decimal). It defines the ASCII-Code for the appropriate character. For example, the following strings are identical: "Hello\n", "Hello\10" and "Hello\0x0a".

The length of a constant string is limited to 255 characters. A variable can hold a string of unlimited length.

In the UniScript Editor string constants are colored red.

In hexadecimal form the character \x or \0x must be followed by exactly two hexadecimal characters (0 .. f).

In decimal an octal form all decimal (0 .. 9) or octal (0 .. 7) numbers will be read. If the number is greater than 255 (decimal) the number will be reduced to one byte. Example: "\300a" is not identical to "\30" + "0a".

If a string has a prefix r, e.g. r"Hello\10" all backslashes will be left in the string. r"Hello\10" is identical to "Hallo\\10". Inside a simple string with the r prefix the "-character cannot be used.

4.8. “Long” strings

As of UniScript 4.0 so called “long strings” are available. These strings start with "[[ and end with ]]". Example:

a = "[[
This is a long
string constant

is identical to:

a = "\nThis is a long\nstring constant\n"

In long string constants the "-character can be used with or without the leading backslash. With the r prefix the backslash no longer quotes characters and loses it special meaning. This can be useful for example for file names.

b = r"[[

// b == "\nc:\\foo\n\\t\\n"

4.9. Null-characters in Strings

Beginning with UniScript 4.2.0 character strings can contain Null characters (eight-bit clean Strings). The advantage is that UniScript-Strings can contain binary data. The + operation can be used for strings containing Null characters. The comparison operators only compare the strings to the first Null character:

"Hello\x00Hello" == "Hello"

returns TRUE (1). To compare the complete character string the mem_compare function can be used.

Many string functions will only use the string to the first Null character, for example:


returns 5. The function mem_len("Hello\x00Hello") will return 11.

4.10. Variables

Variables are the names that you have chosen to represent values used in an UniScript program. Variables may represent either numeric values or strings. Variables may not be used before they have been given a value. Doing so results in an error.

The following statement will assign the value 1 to the variable a:

a = 1

If a already exists, the old variable will be destroyed and a new variable will be created. The statement will allocate memory for the constant value and then copy the value 1 into the memory. The old value of a could be a string matrix or anything else. A variable in UniScript can change its type.

The name of a variable must be a sequence of letters, digits and underscores, but it may not begin with a digit. The length of variable names is not limited in UniScript, however, only the first 80 characters are significant. Case is also significant in variable names. For example var is not the same as Var.

The following identifiers are keywords and may not be used as variable or function names:


Variable names should also be distinct from function names: sin = sin(1) is incorrect, but Sin = sin(1) is correct.

Valid names for variables are:


The following names are invalid:

This is not a name

In larger programs it is recommended to choose names that indicate the data type they hold. Therefore, most of the names used in UniScript functions have one of the following prefixes:


Name Meaning
ssFilename ss stands for scalar string. ssFilename might therefore hold only one file name.
svFilename sv stands for string vector. svFilename holds probably more than one file name.
smSorted sm stands for string matrix.
rsXValue rs stands for real scalar.
rvMin rv stands for real vector.
rmSize rm stands for real matrix.
bVisible b stands for boolean. A variable with this prefix should only be assigned the values TRUE (1) or FALSE (0).
hLayer h stands for handle.
hvLayer hv stands for handle vector.
nLayer n stands for numbers. The variable should only hold integers, e.g. 123.

4.11. Vectors and Matrices

The following statement will generate a row vector with the three elements 6, 4 and 13 and assign the vector to the variable a:

a = [6, 4, 13]

If the variable was already used, the old value of a will be replaced by the new vector. a is a real vector with three elements.

Once a variable has been given a value, it can be used in statements. The statement

b = a + 5

adds the value 5 to each element of the vector a and assigns the result to the variable b. b will then have the value [11, 9, 18].

A range is a convenient way to create a row vector with evenly spaced elements. Example: [1, 2, 3, 4, 5, ..., n] or [1, 1.5, 2, ...]. Use the : operator in one of the following manners:




A range constant is defined by the value of the first element in the range, a maximum value which the elements of the range will not exceed, and an optional value for the increment between elements. start, step and end are separated by colons (:).


1:5         defines the set of values [1, 2, 3, 4, 5]
1.3:4       defines the set of values [1.3, 2.3, 3.3]
1:0.5:2     defines the set of values [1, 1.5, 2.0]
1:0.5:2.4   defines the set of values [1, 1.5, 2.0]

start can be greater than end

5:1         defines the set of values [5, 4, 3, 2, 1]

A vector in UniScript is a special form of a matrix. [6, 4, 13] is a 1 * 3 matrix. That means the matrix has one row and three columns.

To create a column vector, the elements must be separated by a semicolon:

a = [1;2;3]

To change a column vector to a row vector (and vice versa), use the transpose operator ('):

b = a'

The following matrix, for example, can be seen as a combination of the row vectors [1,2,3], [4,5,6] and [7,8,9].

   1 & 2 & 3\\
   4 & 5 & 6 \\
       7 & 8 & 9

A matrix in UniScript can be defined as the following:

m = [1,2,3; 4,5,6; 7,8,9]

A matrix can also be created from a combination of vectors and matrices, e.g.

1 & 2 & 3 & 10 & 11 & 16 \\
4 & 5 & 6 & 12 & 13 & 17 \\
    7 & 8 & 9 & 14 & 15 & 18
\end{array} \right]

m1 = [1,2,3; 4,5,6; 7,8,9]
m2 = [10,11; 12,13]
v1 = [14,15]
v2 = [16;17;18]

m = [m1, [m2;v1], v2]

4.12. Index Expressions

An index expression allows you to reference or extract elements of a matrix or vector.

If a = [1.5, 3.8, 6.3], then a[1] is the value 1.5, a[2] the value 3.8 and a[3] the value 6.3. Indices are integers beginning with 1. Instead of a scalar index, you can also use an index vector. The expression a[1, 3] will extract the values [1.5, 6.3] and a[1, 3, 1] will extract [1.5, 6.3, 1.5]. Single indices can be used more than once.

A vector variable with a index vector can stand on both sides of the assignment operator:

a = [1, 2, 3, 4, 5]
a[1, 4] = [-1, 66]

In this statement, the element a[1] will be assigned the value -1 and a[4] the value 66. In any case, the index vector on both sides of the assignment operator must have the same number of elements.

After the statement is executed, the variable a is [-1, 2, 3, 66, 5].

The statement

a[1, 4] = a[4, 1]

will exchange the first and the fourth element of the vector without changing any other element.

The second line of the following statements

a = [1, 2, 3, 4, 5]
a[6] = 100

will result in an runtime error. The vector a contains 5 elements. The following statement will add a sixth element to the vector a.

a = [a, 100]

A matrix can be accessed by two index vectors separated by one semicolon. The first vector is a row index vector and the second is a column index vector. If the matrix a is [5,6;7,8] then a[1;1] is 5 and a[1;2] is 6. The result of the expression a[1,2;1] is [5, 6], the first column of the matrix a.

If a row or column index vector is complete, it can be omitted. Instead of a[1,2;1], you can write a[;1] to access the first row of the matrix a.

A matrix in UniScript is stored columnwise as a vector with one dimension. The elements of the following matrix

are saved in the order [1, 4, 7, 2, 5, 8, 3, 6, 9]. The internal representation can be accessed when the matrix is accessed with a one dimensional vector. Instead of a[2;3] (second row, third column), this element can be accessed with the expression a[8]. To access all elements of the matrix a, you can write a[1:9], this is equivalent to a[:].


var = start:step:end creates a row vector.

var = start:end creates a row vector with the increment 1.0.

var = [e1, e2, e3] creates a row vector.

var = [e1; e2; e3] creates a column vector.

var = [e1, e2; e3, e4] creates a matrix.

var[index-vector] references elements of a vector.

var[row-index-vector; column-index-vector] references elements of a matrix.

var[row-index-vector ; ] references the row elements of a matrix.

var[ ; column-index-vector] references the column elements of a matrix.

var[:] changes a matrix to a row vector.