HxOperator Enumeration¶

class hexaly.optimizer.HxOperator¶

Mathematical operators available for modeling. These operators are used to type the expressions created in Hexaly mathematical optimization model.

As other enumerations present in the hexaly.optimizer module, HxOperator is enumerable and indexable:

print (HxOperator[0])           # Shows HxOperator.BOOL
print (HxOperator.BOOL.value)   # Shows 0

# Iterates over the members of HxOperator
for e in HxOperator:
    print e

BOOL¶

Boolean decision. Decisional operator with no operand. Decision variable with domain {0,1}.

FLOAT¶

Float decision. Operator with two operands that represent the lower bound and the upper bound of the decision (domain [lb, ub]). The bounds must be constants (integers or doubles).

Since:

4.0

CONST¶

Constant. Unary operator. Can be equal to any integer. Note that constants 0 or 1 are considered as boolean. Constants are implicitly created when passing integer arguments to HxModel.create_expression() or HxExpression.add_operand().

SUM¶

Sum. N-ary arithmetic operator. SUM(e1, e2, ..., eN) is equal to the sum of all operands e1, e2, ..., eN. This operator returns an integer if all the operands are booleans or integers and a double as soon as one operand is a double.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will sum all the values computed and returned by the function.

SUB¶

Substraction. Binary arithmetic operator. SUB(x, y) is equal to the value of x - y. This operator returns an integer or a double according to the type of its operands.

Since:

4.0

PROD¶

Product. N-ary arithmetic operator. PROD(e1, e2, ..., eN) is equal to the product of all operands e1, e2, ..., eN. This operator returns an integer if all the operands are booleans or integers, and a double as soon as one operand is a double.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will compute the product of all the values returned by the function.

MAX¶

Maximum. N-ary arithmetic operator. MAX(e1, e2, ..., eN) is equal to the maximum value among all operands e1, e2, ..., eN. This operator returns an integer if all the operands are booleans or integers, and a double as soon as one operand is a double.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will find the maximum value among all the values returned by the function.

MIN¶

Minimum. N-ary arithmetic operator. MIN(e1, e2, ..., eN) is equal to the minimum value among all operands e1, e2, ..., eN. This operator returns an integer if all the operands are booleans or integers, and a double as soon as one operand is a double.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will find the minimum value among all the values returned by the function.

EQ¶

Equal. Binary relational operator. EQ(a, b) = 1 if a == b, and 0 otherwise. This operator returns a boolean.

NEQ¶

Not equal to. Binary relational operator. NEQ(a,b) = 1 if a != b, and 0 otherwise. This operator returns a boolean.

GEQ¶

Greater than or equal to. Binary relational operator. GEQ(a,b) = 1 if a >= b, and 0 otherwise. This operator returns a boolean.

LEQ¶

Lower than or equal to. Binary relational operator. LEQ(a,b) = 1 if a <= b, and 0 otherwise. This operator returns a boolean.

GT¶

Strictly greater than. Binary relational operator. GT(a,b) = 1 if a > b, and 0 otherwise. Can be used to compare two intervals, in that case GT(a, b) = 1 if start(a) >= end(b), and 0 otherwise. Undefined if a or b is void. This operator returns a boolean.

LT¶

Strictly lower than. Binary relational operator. LT(a, b) = 1 if a < b, and 0 otherwise. Can be used to compare two intervals, in that case LT(a, b) = 1 if end(a) <= start(b), and 0 otherwise. Undefined if a or b is void. This operator returns a boolean.

IF¶

If-Then-Else. Ternary conditional operator. IF(a,b,c) is equal to b if a is true, and c otherwise. Note that the first operand must be a boolean (that is, equal to 0 or 1). This operator returns a boolean, an integer or a double according to the type of the second and third operands.

NOT¶

Not. Unary logical operator. NOT(a) = 1 - a. Note that the operand must be boolean (that is, equal to 0 or 1). This operator returns a boolean.

AND¶

And. N-ary logical operator. AND(e1, e2, ..., eN) is equal to 1 (true) if all the operands e1, e2, ..., eN are 1, and 0 otherwise. All the operands must be boolean (that is, equal to 0 or 1). This operator returns a boolean.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will return 1 if all the values returned by the function are 1 and 0 otherwise.

OR¶

Or. N-ary logical operator. OR(e1, e2, ..., eN) is equal to 0 (false) if all operands e1, e2, ..., eN are 0, and 1 otherwise. All the operands must be boolean (that is, equal to 0 or 1). This operator returns a boolean.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will return 0 if all the values returned by the function are 0 and otherwise.

XOR¶

Exclusive or (also called “xor”). N-ary logical operator. XOR(e1, e2, ..., eN) is equal to 0 if the number of operands with value 1 among e1, e2, ..., eN is even, and 1 otherwise. Remarkable case: XOR(a,b) = 0 if a == b, and 1 otherwise. All the operands must be boolean (that is, equal to 0 or 1). This operator returns a boolean.

With collections (lists, sets), 1D arrays or intervals

This operator can also be used with intervals, LIST, SET or 1D ARRAY to create expressions with a dynamic number of operands. In that case, this operator becomes a binary operator that takes an interval, a list, a set or a 1D array as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval, list, set or 1D array and will return 0 if the number of value 1 returned by the function is even, and 1 otherwise.

ABS¶

Absolute value. Unary arithmetic operator. ABS(e) = e >= 0 ? e : -e. This operator returns an integer or a double according to the type of its operand.

DIST¶

Distance between two numbers. Binary arithmetic operator. DIST(a,b) = ABS(a-b). This operator returns an integer or a double according to the type of its operands.

DIV¶

Division. Binary arithmetic operator. This operator always returns a double. Note that until version 4.0, the division was an integer division if both operands were integers.

MOD¶

Modulo (remainder of the integer division). Binary arithmetic operator. MOD(a, b) = r such that a = q * b + r with q, r integers, where r, a have the same sign and |r| < |b|. Note that the operands must be integers. This operator returns an integer. Be careful: when a > 0 and b < 0, the value computed by MOD(a, b) differs from the evaluation of a%b in python.

ARRAY¶

Array. An array is a collection of elements. Indexes begin at 0. It could be used with operators like AT or SCALAR. An array doesn’t have a value by itself, but can contain operands of type boolean, integer, double, array (for multi-dimensional arrays) or collection (list or set). In the latter case, the collections must share the same domain and same type (either list or set). All the elements of an array must be of the same type.

With intervals or lists

This operator can also be used with intervals or lists to create an array with a dynamic number of elements. In that case, this operator becomes a binary operator that takes an interval or a list as first operand and a LAMBDA_FUNCTION as second operand. The operator will call the function on each value of the interval or the list and the returned values will be used to populate the array.

Since:

2.1

AT¶

Returns the element at specific coordinates of an array or a list.

For arrays

The first operand must be the array and the other operands must be the coordinates of the element to get. The number of coordinates depends on the dimension of the array. Thus AT(myArray, i) returns the i element of the one-dimensional array myArray. This operator returns a boolean, an integer or a double according to the type of the operands in the array. If one of the specified coordinate is out of range, the evaluation of the expression will fail.

For lists

The first operand must be the list and the second operand must be the index of the element to get. If the index is out of range (index < 0 or index > count(list)), the evaluation of the expression will fail.

Since:

2.1

SCALAR¶

Scalar product. SCALAR(a, x) = sum(a[i]*x[i]) with a and x two arrays. This operator returns an integer or a double according to the type of the operands in the arrays.

Since:

2.1

CEIL¶

Ceil. Unary arithmetic operator. Returns a value rounded to the next highest integer. This operator returns an integer.

Since:

3.0

FLOOR¶

Floor. Unary arithmetic operator. Returns a value rounded to the next lowest integer. This operator returns an integer.

Since:

3.0

ROUND¶

Round. Unary arithmetic operator. Returns a value rounded to the nearest integer. This operator returns an integer.

Since:

3.0

SQRT¶

Square root. Unary arithmetic operator. This operator returns a double.

Since:

3.0

LOG¶

Natural logarithm (base-e). Unary arithmetic operator. This operator returns a double.

Since:

3.0

EXP¶

Base-e exponential. Unary arithmetic operator. This operator returns a double.

Since:

3.0

POW¶

Power operator. POW(x, y) is equals to the value of x to the power of y. This operator returns a double.

Since:

3.0

COS¶

Cosine. Unary arithmetic operator. This operator returns a double.

Since:

3.0

SIN¶

Sine. Unary arithmetic operator. This operator returns a double.

Since:

3.0

TAN¶

Tangent. Unary arithmetic operator. This operator returns a double.

Since:

3.0

INT¶

Integer decision variable. Decisional operator with two operands min and max. Decision variable with domain [min,max].

Since:

5.0

PIECEWISE¶

Piecewise-linear function operator. The piecewise linear function is defined by two arrays of numbers giving the breakpoints of the function. This operator has exactly 3 operands: The first two operands must be two arrays of equal lengths (necessarily larger or equal to 2). These arrays must contain constant numbers (int or double). The first array must contain numbers in ascending order. The third operand must be an integer or double expression. An exception will be thrown if its value is strictly smaller that the first element of the first array, or strictly larger than the last element of the first array. This operator returns a double.

PIECEWISE(x,y,z) returns the image of z by the function defined by geometric points (x[0], y[0]), (x[1], y[1]), ..... (x[n-1], y[n-1]), For instance PIECEWISE({0, 50, 100}, {0, 10, 100}, 75) returns 55.

Discontinuities are allowed in the definition of the function, that is to say that two geometric points can share the same x-coordinate. By convention the value taken by the function at such a discontinuous point is the one associated to the last occurrence of this x-coordinate in array x. For instance PIECEWISE({0, 50, 50, 100},{0, 0.1, 0.9, 1}, 50) returns 0.9;

Since:

5.0

LIST¶

A list is an ordered collection of integers within a domain [0, n-1] where n is the unique argument of this operator. Mathematically a list is a permutation of a subset of [0, n-1]. This operator takes exactly one operand: a strictly positive integer constant. All values in the list will be pairwise different, non negative and strictly smaller that this number.

The elements of the list can be accessed individually with the operator AT.

COUNT¶

The number of elements in an array, a collection or an interval. This operator takes exactly one argument of type array, collection or interval.

Since:

5.5

INDEXOF¶

The index of a value in a list (-1 if the value is not in the list). This operator takes exactly two arguments: the first one is a list, the second one is an integer expression.

Since:

5.5

PARTITION¶

Partition. N-ary logical operator. PARTITION(c1, c2, ..., cN) is true if all lists or sets c1, c2, ..., cN form a partition of their common domain. All the operands must be collections of the same type (either list or set) and on the same range. These collections can be stored in a HxArray that will be passed as argument of the partition: PARTITION(array(c1, c2, ..., cN)).

Since:

5.5

DISJOINT¶

Disjoint. N-ary logical operator. DISJOINT(c1, c2, ..., cN) is true if all lists or sets c1, c2, ..., cN are pairwise disjoint. All the operands must be collections of the same type (either list or set) and on the same range. These collections can be stored in a HxArray that will be passed as argument of the disjoint: DISJOINT(array(c1, c2, ..., cN)).

Since:

5.5

COVER¶

Cover. N-ary logical operator. COVER(c1, c2, ..., cN) is true if all values in the domain are at least in one list or set c1, c2, ..., cN. All the operands must be collections of the same type (either list or set) and on the same range. These collections can be stored in a HxArray that will be passed as argument of the cover: COVER(array(c1, c2, ..., cN)).

Since:

10.5

FIND¶

Find. find(a, v) returns the position of the first collection in the array a that contains the value v. If the value is not in any collections of the array, it returns -1. If the element belongs to several collections, it returns the smallest position among the collections containing the element. This operator takes exactly two arguments: the first one is an ARRAY of collections, the second one is the value searched. All the collections of the array must be of the same type and on the same range.

Since:

10.5

EXTERNAL_FUNCTION¶

External function.

External functions are used to retrieve the value of expressions from external functions written with your favorite language. External functions are created with the dedicated methods HxModel.create_int_external_function() or HxModel.create_double_external_function().

Since:

9.5

CALL¶

Call a particular function.

The first operand must be a function (like EXTERNAL_FUNCTION or : attr:LAMBDA_FUNCTION). The other operands are passed to the function as arguments.

Since:

6.0

LAMBDA_FUNCTION¶

Lambda function. Lambda functions are created with the dedicated method HxModel.create_lambda_function().

Since:

9.5

ARGUMENT¶

Argument of a function. Arguments are automatically and implicitely created when you create a function with method HxModel.create_function().

Since:

7.0

RANGE¶

Range expression. This operator takes exactly two integer operands. The first one is the lower bound (inclusive), the second one is the upper bound (exclusive).

A range has an interval value and can be used with N-ary operators like SUM, PROD, MIN, MAX, OR, AND, XOR or ARRAY to create expressions that have a dynamic number of operands.

Since:

7.0

CONTAINS¶

Contains. contains(expr, v) is true if and only if the expression expr contains the value v. This operator takes exactly two arguments: the first one is a collection (LIST or SET), an interval or an ARRAY of collections, the second one is the integer expression searched. If expr is an array, all its collections must be of the same type and on the same range.

Since:

7.5

SET¶

A set is an unordered collection of integers within a range [0, n-1] where n is the unique argument of this operator. This operator takes exactly one operand: a strictly positive integer constant. All values in the set will be pairwise different, non negative and strictly smaller that this number. Contrary to the LIST operator, elements in a set are not ordered and cannot be indexed with AT. Sets can only be manipulated with lambdas and n-ary operators like SUM, MIN, AND, …

Since:

8.0

SORT¶

Sort. sort(a) return the input ARRAY a sorted in ascending order. This operator returns an array of integers if the input array is solely composed of booleans or integers, and an array of doubles as soon as the input array contains a double.

This operator can also be used with an optional LAMBDA_FUNCTION as second argument sort(a, key). In that case the operator will sort the array in ascending order based on the values returned by the lambda function. The sort operator guarantees that the order of elements having the same key is preserved.

Since:

11.0

INTERVAL¶

Interval decision variable. Operator with two integer constant operands that represent the min start and the max end of the decision. The interval is included in [minStart, maxEnd). Its start is inclusive and its end is exclusive.

Since:

12.0

START¶

The start of a non-void interval. This operator takes exactly one argument of type interval and returns an integer.

Since:

12.0

END¶

The end of a non-void interval. This operator takes exactly one argument of type interval and returns an integer.

Since:

12.0

LENGTH¶

The length of a non-void interval. This operator takes exactly one argument of type interval and returns an integer. The length of an interval is equivalent to end(interval) - start(interval). It differs from the count on void intervals since the length of a void interval is undefined whereas the count of a void interval is 0.

Since:

12.0

DISTINCT¶

Returns the distinct values of the elements of an array, collection or interval. This operator accepts one or two operands. With one operand, the operator takes an array and returns the unordered set of distinct values in the array. With two operands, the operator takes a collection (set or list), range or interval as first operand and a lambda function as second operand. The operator calls the function on each element of the iterable and returns the unordered set of distinct values among all the values returned by the function.

Since:

12.5

INTERSECTION¶

Returns the intersection between an array/collection and an array/collection. This operator accepts two operands. The operator takes a collection (set or list), or an array (constant or not) as its first and second operand. The operator returns the unordered set of the values present in both operands.

Since:

12.5

HULL¶

The smallest interval including all intervals given in operands. This operator accepts n operands of type interval, or an unique operator of type array of intervals. The operator returns an interval with a start equal to the smallest start of its operands, and an end equal to the largest end of its operands. Void intervals given in operands will be ignored.

Since:

13.0

STEP_ARRAY¶

A constant array with optimised memory. StepArray takes as parameters two constant arrays X and Y of equal size N. X contains the indexes of the constant array where the value changes. X must have strictly positive increasing values. Y is an array of constants. These constants are the value in each interval between the indices given by X : all values between X[i - 1] and X[i] are equal to Y[i].

Since:

13.0