Expressions¶

Applied on numbers (integers or floats)¶

The operators +, -, * convert their operands to floats and return a float as soon as one of the two operands is a float. On the contrary they return an integer when both operands are integers.

The operator / converts its operands to floats and returns a float, even if the two operands are integers.

The operator modulo % can be applied on integers only.

Applied on strings¶

Only the + operator is defined for strings. It corresponds to the concatenation operator. When one of the two operands is a string, then the other is converted to a string and a new string concatenating the two operands is returned. For instance "abc"+12 returns abc12.

Applied on LSExpressions¶

When one of the two operands is an LSExpression, then the operators return an LSExpression representing the arithmetic operation of these two terms in the mathematical model. If the mathematical model cannot handle one of the operand (e.g if one of them is a string), an exception is thrown.

Other cases, other types¶

By default, throws an exception. See the different modules for additionnal information on the available arithmetic operators for each type.

Examples:

a = 10;
b = a + 5.0;      // a is equals to 15
c <- a * 3.0;     // a is converted to an LSExpression
                  // and a new LSExpression of type PRODUCT is added to the model.
d = "foo" + 42    // 42 is converted to a string, then the concatenation is performed.

// This arithmetic operation will throw an exception:
// the modulo operation is not overloaded for strings.
e = "foo" % 2;

Applied on numbers (integers or floats)¶

The operators return a boolean value equal to 1 when the comparison is true, 0 otherwise. If one of the operand is a float, the operators convert both operands to floats and then, compare them.

Applied on strings¶

When one of the two operands is a string then the other is converted to a string. Then, the comparison is done lexicographically.

Applied on LSExpressions¶

When one of the two operands is an LSExpression then the operators return an LSExpression representing the comparison of these two terms in the mathematical model. If the mathematical model cannot handle one of the operand (e.g if one of them is a string), an exception is thrown.

Applied on nil¶

The operators ==, != can be used to compare a value with nil. In that case, the operators return 1 (respectively 0) if the compared operand is equals (respectively not equals) to nil. The other relational operators (<, >, <=, >=) cannot be used with nil.

Other cases, other types¶

By default, throws an exception. See the different modules for additionnal information on the available relational operators for each type.

Examples:

a = {1,8};
b = {1,8};

println(8 < 9.2);           // print 1
println(a == b);            // throw an exception since "==" is not defined on maps
println("abc" <= "abcde");  // print 1
println("abc" == "aBc");    // print 0 since comparison is case-sensitive

Applied on booleans¶

When applied on booleans (0 or 1), the logical operators use short-circuit evaluation: the second argument is interpreted only if the value of the first argument is not sufficient to determine the whole value of the expression.

• The unary operator ! returns 1 if its argument is 0, 0 otherwise.

• The operation x && y first evaluates x; if x is 0 (false), its value is returned; otherwise, y is evaluated and the resulting value is returned.

• The operation x || y first evaluates x; if x is 1 (true), its value is returned; otherwise, y is evaluated and the resulting value is returned.

Applied on LSExpressions¶

As soon as one of the operands is an LSExpression, the logical operation returns an LSExpression representing the operation in the mathematical model. In that case, both operands are evaluated. If the mathematical model cannot handle one of the operand (e.g if one of them is a string), an exception is thrown.

Other cases, other types¶

By default, throws an exception. See the different modules for additionnal information on the available logical operators for each type.

Applied on integers¶

If both operands are integers, a range object representing all integers between these two integers is returned. If the operator .. is used, the end number is included in the range. It is excluded with the operator .... The returned object is iterable. It can be used in for loops or iterated assignments.

If the bounds are crossed (i.e if the lower bound is greater than the upper bound for the inclusive operator, or if the lower bound is greater than or equals to the upper bound for the exclusive operator), the returned range object will be considered as empty. No iteration will be performed on such an object when used with a for loop.

Note that the modeler actually contains only one range object operator which is exclusive. The inclusive notation a..b is syntactic sugar which is replaced by a...b+1.

Applied on LSExpressions¶

As soon as one of the operands (left or right) is an LSExpression, the range operators returns an LSExpression representing an interval in the mathematical model (operator RANGE). If the mathematical model cannot handle one of the operand (e.g if one of them is a string), an exception is thrown.

Note that the solver contains only one RANGE operator which is exclusive. When using the inclusive operator .. in the modeler, an underlying addition is automatically created. In other words, writing a..b will be transformed into RANGE(a, b + 1) in the solver.

Other cases, other types¶

By default, throws an exception. See the different modules for additionnal information on the available range operators for each type.

First argument is boolean¶

The ternary operation cond ? trueExpr : falseExpr first evaluates cond expression. If cond is 1, then trueExpr is evaluated and returned, otherwise falseExpr is evaluated and returned. Note that only two of the three operands are evaluated. trueExpr and falseExpr can be of any type.

First argument is an LSExpression¶

The operation returns an LSExpression representing this conditional operation in the mathematical model (operator IF). In that case, the three operands are evaluated. If the mathematical model cannot handle one of the operand (e.g if one of them is a string), an exception is thrown.

Other cases, other types¶

By default, throws an exception. See the different modules for additionnal information on the availability of the ternary operator for each type.

Applied on maps¶

The main usage of the index selector is for maps. a[b] returns the value in a for the key b. The key can be of any type except nil that has a special meaning. If the key does not exist in the map, no error is thrown but nil is returned.

Applied on LSExpressions¶

As soon as one of the operands (value or index) is an LSExpression, the index selector returns an LSExpression representing the index operation in the mathematical model (operator AT). If the mathematical model cannot handle one of the operand (e.g if one of them is a string), an exception is thrown.

Applied on modules¶

The key must be a string. In that case, the expression a[b] returns the global variable with the name represented in b for the module a. If the global variable was not declared in the module, no error is thrown but nil is returned.

Other cases, other types¶

By default, throws an exception. See the different modules for additionnal information on the availability of the index operator for each type.

Applied on maps¶

The expression a.b returns the value in a for the key b, where b is a string literal. Contrary to the index operator, if the key does not exist in the map, an exception is thrown.

Applied on modules¶

The expression a.b returns the global variable with the name b for the module a. Contrary to the index operator, if the global variable was not declared in the module, an exception is thrown.

Other cases, other types¶

As the member selector is the base of Object-oriented-programming, it is extensively used in all modules and types. Please refer to the documentation of each module for additionnal information.

Typeof operator¶

This unary operator returns the type of the expression. All values have a type. The returned type itself is a value and also has a type.

Examples:

t = typeof "foo";
m = {};
println(t);             // print the type that describes strings.
println(typeof t);      // print the type that describes types.
println(t == typeof m); // print 0 since the type of maps is different from the type of strings

Is operator¶

The is operator takes two arguments: the first can be a value of any type, the second one must be a type. The operator returns true (1) if the first argument is an instance of the given type and false (0) otherwise.

There are 3 shortcuts for the common types int, double and nil.

Examples:

a = 10;
b = -42.45e+8;
c = "foo";
println(a is int);      // print 1
println(a is double);   // print 0
println(b is typeof c); // print 0 since b is a double and c is a string
println(a is typeof 4); // print 1, equivalent to "a is int"