Lambda expressions

Hexaly Optimizer offers the possibility to apply n-ary operators (like sum, min, max and so on) to a range of dynamic size. For instance it allows defining a sum whose number of terms will depend on other expressions. In such an expression, the iterated term is introduced as a lambda function. A typical usage is for defining a sum over items of a collection:

// with x a list or a set
total <- sum(x, i => quantity[i]);

In the above example, sum has two operands:

  • The first operand is the collection.

  • The second operand is a lambda expression defining the lambda function that should be applied to each element in the range.

In addition to lists and sets, it is possible to use a range of integers defined by its extremities. For example, if x is a list, the above construct is equivalent to:

total <- sum(0...count(x), i => quantity[x[i]]);

We will describe the properties of a range and how a lambda function can be introduced. Then we will detail which operators can benefit from this feature, including the special case of the array operator.

Several examples of our our example tour illustrate this feature (including the classical CVRP).


A range is a collection of consecutive integers.

Both extremities of the range can be non-constant expressions. Note that some n-ary operators (like min and max) will be considered as undefined when the range is empty, that is to say that the solution will remain infeasible while the range is empty. For instance, the following expression implicitly constrains b to be larger than a:

minimize max(a...b, i => v[i+1] * z);

Lambda functions

A lambda function is a particular Hexaly expression composed of two parts, arguments => body:

  • The arguments of the function, which are also LS expressions, are automatically and implicitely created when you use the arguments => body construct.

  • The body of the function. The body is an LS expression that will be used to evaluate the result of the function. The body can be any LS expression composed of any operands and operators supported by Hexaly Optimizer.

Note that these functions are explicitly defined with a combination of Hexaly operators and should not be confused with External functions.

Applying a lambda function to an iterable

Applying a lambda function to a range, a collection or an interval is achieved with the syntax op(iterable, function) where:

  • op is some n-ary operator among: sum, prod, min, max, and, or, xor, array.

  • iterable is an iterable with integer values such as a range, a collection or an interval.

  • function is a lambda function with exactly one argument, except for the array operator which accepts one or two operands (see below).

The value of such a op(iterable, function) expression can be computed as follows. For each integer i within iterable, function(i) is evaluated; and all these numbers are agregated with the operator op. If we define v <- sum(a...b, i => f(i)), then v will be equal to the sum of all f(i) for i in [a,b).

A typical usage of this feature can be found in our TSP example, where the sum of distances along the circuit is computed as follows:

obj <- sum(0...nbCities-1, i => distanceWeight[cities[i]][cities[i+1]])
       + distanceWeight[cities[nbCities-1]][cities[0]];

In the bin packing example, a similar syntax allows to sum the weights of items in a bin, which is defined as a set:

bin <- set(nbItems);
binWeight <- sum(bin, i => itemWeights[i]);

Finally, one can also iterate over an interval, resulting in the enumeration of the successive integers between its start (inclusive) and its end (exclusive). The job shop problem with intensity uses this feature to compute the number of active time steps over the duration of a task:

task <- interval(0, timeHorizon);
constraint sum(task, t => intensity[t]) >= processingTime;

Special case

When the array operator is used in this context, it creates an array whose size will vary with the size of the associated range. We allow a recursive definition of elements of this array by using a second argument in the function, containing the evaluation of the function on the previous element of the range.

Formally, if we define v <- array(a...b, (i,prev) => f(i,prev), c), we will have v[i] = f(i,v[i-1]) for all i in interval [a,b), with v[a-1] equal to c.

The use of this feature can be illustrated on a routing problem with time-windows. Having opening hours on each location visited by a truck, we have to take into account the possible waiting time of the truck in case of early arrival. In fact the resulting time will be the maximum between the earliest arrival time (based on the driving time from the previous location) and the opening hour. Taking into account a service time on each location, we have:

function departureTime(route, i, prev) {
   arrivalTime <- (i==0) ?
       openingHour[route[i]] :
       max(openingHour[route[i]], prev + distance(route[i-1],route[i]));
   return arrivalTime + serviceTime[route[i]];

And the array of all departure times can be defined recursively as:

times <- array(0...count(route), (i, prev) => departureTime(route, i, prev), 0);

Although we have used a lambda function of the modeling language to obtain a more readable model, it is important to note that departureTime merely returns an expression made of Hexaly operators.

Now what if we also have closing hours at each location that is to say that the truck must have left location L before closingHour[L]? Such a constraint can be added applying operator and to the same range:

constraint and(0...count(route), i => times[i] <= closingHour[route[i]]);