Statements¶

Simple statements¶

The simple statement is the classical variable = value; that assigns the given value to the specified variable, overriding the previous value. The variable can be local or global. If the variable was not previously declared as local, the variable is considered as global by default and is implicitly declared if necessary.

This statement cannot be used to add an LSExpression to the mathematical model. See Link statements for that.

Examples:

a = true;     // a = 1
b = 9;        // b = 9
c = a + b;    // c = 10
c = a * b;    // c = 9
c = (a == b); // c = 0
c = a < b;    // c = 1

Coumpound assignment statements¶

A coumpound assignment (also called “augmented assignment”) is the combination of an arithmetic operation and an assignment. The arithmetic operations allowed with coumpound assignment statements are:

• + addition
• - substraction
• * multiplication
• / division
• % modulo

Thus, an assignment like a = a + b can be rewritten as a += b; with the coumpound assignment syntax.

Exemples:

a += 2;     // a = a + 2
a /= 2;     // a = a/2
a *= b + c; // a = a*(b + c)

Link statements¶

The link statement is a particular assignment that only applies to LSExpression or values that can be casted to LSExpression. This statement is used to add expressions to the mathematical model. If the assigned value is not an LSExpression or cannot be cast to an LSExpression, an exception is thrown. Only integers, floating point numbers and in certain circonstances maps, can be casted to LS expressions.

Examples:

a = true;   // a = 1
b = 9;      // b = 9
c = a + b;  // c = 10
c = a * b;  // c = 9
c = a == b; // c = 0
c = a < b;  // c = 1

x <- 1;      // 1 is transformed to a constant LS expression and is added to the mathematical model
y <- bool(); // y is a new decision variable and is added to the mathematical model
z <- x+y;    // z is an LS expression and is added to the mathematical model

// This assignment will throw an exception: strings cannot be casted to LSExpression.
z <- "a string";

Local assignment and local statements¶

Local statements local variable, local variable = value or local variable <- value introduce a new local variable with the given name and set its value to nil or to the specified value.

If a global variable with the same name was already defined, then the global variable will be masked while this local variable is visible. If a local variable with the same name was already defined an error is thrown. See Variables for the differences between local and global variables and for details on the visibility scopes of variables.

Examples:

local i;        // Declare i as local and set its value to nil.
local j = 2;    // Declare j as local and set its value to 2.

for[z in 1..10] {
    // This assignment will throw an exception since z was already implicitly
    // declared as local in the for loop.
    local z = "foo";
}

Iterated assignment statements¶

a[v in V] = f(v); is an iterated assignment which is strictly equivalent to for [v in V] a[v] = f(v); Similarly a[v in V] <- f(v); is an iterated assignment which is strictly equivalent to for [v in V] a[v] <- f(v); These iterated assignment features will help you will help you to make your models shorter and clearer. Similarly to the for statement introduced in the previous section, iterations can be nested and filtered:

for[i in 0..9][j in i+1..9][k in j+2..9]
    a[i][j][k] = i + j + k;
a[i in 0..9][j in i+1..9][k in j+2..9] = i + j + k; // compact

Simple for-loops¶

for [v in A] S; is a simple for-loop where the statement S is iteratively executed with v taking all values in A, where A can be a range or an iterable value like a map. Variable v is implicitly declared as a local variable visible within this for statement and in nested blocks only.

When a range is given, it is declared with the from..to syntax where both from and to are included.

When an iterable object is given, the iteration is performed on the sub-values of the object. The iteration order is specific to the type of the value. For the maps, the order is defined as follows:

1. Iterates on number keys (integer or floats) in ascending order.
2. Iterates on strings in ascending order.
3. Iterates on other types in an implementation specific way.

It is also possible to iterate on the pairs (key, value) using the syntax for [k,v in M]. In that case, k and v are both declared implicitly as local variables and contain respectively the current key and the current value of the loop.

Example:

s = { -44, 12, 14 };
for [i in 0..2] a[i] = i + 1; // a[0] = 1, a[1] = 2, a[2] = 3
for [v in s] println(v/2); // prints -22, 6 and 7.
for [k, v in s] println(k, ":", v); // prints 0:-44, 1:12 and 2:14

Filtered for-loops¶

for [v in V : C] is a filtered iteration loop: v takes only the values in V satisfying the condition C.

Compact for-loops¶

Filtered and non filtered for-loops can be nested in a compact way, as follows:

// Non compact
for[i in 0..9]
    for [j in i+1..9 : j % 2 == 0]
        for [k in j+2..9]
            a[i][j][k] = i + j + k;

// Compact
for[i in 0..9][j in i+1..9 : j % 2 == 0][k in j+2..9]
    a[i][j][k] = i + j + k;

The behavior of these 2 examples is similar except that the language considers the non-compact case as the association of 3 enclosing loops, while the compact example is solely a loop with 3 iterated indexes. This semantic difference is particularly important for break statement: a break statement stops the most inner loop, regardless of the number of iterated indexes.

For all kinds of loops, a block of statements can be declared instead of a sole statement by using the braces {}:

for[i in 0..9][j in i+1..9][k in j+2..9] {
    a[i][j][k] = i + j + k;
    b[i][j][k] = i * j * k;
}

for-loops can contain ‘break’ and ‘continue’ statement to respectively terminate the loop unconditionnaly or to go back to testing the condition of the loop whitout executing the rest of the statement suite.