Package com.hexaly.optimizer

Enum Class HxOperator

java.lang.Object

java.lang.Enum<HxOperator>

com.hexaly.optimizer.HxOperator

All Implemented Interfaces:

Serializable, Comparable<HxOperator>, Constable

public enum HxOperator
extends Enum<HxOperator>

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

See Also:

• HxModel
• HxExpression

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Enum

Enum.EnumDesc<E extends Enum<E>>

Enum Constant Summary

Enum Constants

Enum Constant	Description
Abs	Absolute value.
And	And.
Argument	Argument of a function.
Array	Array.
At	Returns the element at specific coordinates of an array or a list.
Bool	Boolean decision.
Call	Call a particular function.
Ceil	Ceil.
Const	Constant.
ConstArray	A constant array.
Contains	Contains.
Cos	Cosine.
Count	The number of elements in an array, a collection or an interval.
Cover	Cover.
Deprecated	Deprecated. This operator is deprecated.
Disjoint	Disjoint.
Dist	Distance between two numbers.
Distinct	Returns the distinct values of the elements of an array, collection or interval.
Div	Division.
End	The end of a non-void interval.
Eq	Equal.
Exp	Base-e exponential.
ExternalFunction	External function.
Find	Find.
Float	Float decision.
Floor	Floor.
Geq	Greater than or equal to.
Gt	Strictly greater than.
Hull	The smallest interval including all intervals given in operands.
If	If-Then-Else.
IndexOf	The index of a value in a list (-1 if the value is not in the list).
Int	Integer decision variable.
Intersection	Returns the intersection between an array/collection and an array/collection.
Interval	Interval decision variable.
LambdaFunction	Lambda function.
Length	The length of a non-void interval.
Leq	Lower than or equal to.
List	A list is an ordered collection of integers within a range [0, n-1] where n is the unique argument of this operator.
Log	Natural logarithm (base-e).
Lt	Strictly lower than.
Max	Maximum.
Min	Minimum.
Mod	Modulo (remainder of the integer division).
Neq	Not equal to.
Not	Not.
OptionalInterval	Optional interval decision variable.
Or	Or.
Partition	Partition.
Piecewise	Piecewise-linear function operator.
Pow	Power operator.
Presence	The presence of an interval.
Prod	Product.
Range	Range expression.
Round	Round.
Scalar	Scalar product.
Set	A set is an unordered collection of integers within a range [0, n-1] where n is the unique argument of this operator.
Sin	Sine.
Sort	Sort.
Sqrt	Square root.
Start	The start of a non-void interval.
StepArray	A constant array with optimised memory.
Sub	Substraction.
Sum	Sum.
Tan	Tangent.
Union	Returns the union of iterables.
Xor	Exclusive or (also called "xor").

Method Summary

Modifier and Type	Method	Description
static HxOperator	valueOf(String name)	Returns the enum constant of this class with the specified name.
static HxOperator[]	values()	Returns an array containing the constants of this enum class, in the order they are declared.

Methods inherited from class java.lang.Enum

compareTo, describeConstable, equals, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Enum Constant Details

Bool

public static final HxOperator Bool

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

Float

public static final HxOperator 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

public static final HxOperator Const

Constant. Operator with no argument. Constants can be booleans, integers or doubles. Note that constants 0 or 1 are considered as boolean. Constants are implicitly created when passing int or double arguments to HxModel.createExpression(com.hexaly.optimizer.HxOperator) or HxExpression.addOperand(com.hexaly.optimizer.HxExpression). They can also be created with the dedicated function HxModel.createConstant(long).

Sum

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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

public static final HxOperator Sub

Substraction. Binary arithmetic operator. SUB(x, y) is equal to the value of x - y. This operator returns an integer if the two operands are booleans or integers, and a double as soon as one operand is a double.

Since:

4.0

Prod

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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 among all the values returned by the function.

Eq

public static final HxOperator Eq

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

Neq

public static final HxOperator Neq

Not equal to. Binary relational operator. NEQ(a,b) = 1 if a != b, and 0 otherwise. Can be used to compare two intervals, in that case NEQ(a, b) = 1 if start(a) != start(b) or length(a) != length(b) or end(a) != end(b), and 0 otherwise. Undefined if a or b is void. This operator returns a boolean.

Geq

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator If

If-Then-Else. Ternary conditional operator. IF(a, b, c) is equal to b if a = 1, and c otherwise. The first operand must be a boolean (that is, equal to 0 or 1). This operator returns a boolean if the three operands are booleans, an integer if the second and third operands are integers, and a double if the second or the third operand is a double.

Not

public static final HxOperator Not

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

And

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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 1 otherwise.

Xor

public static final HxOperator 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), intervals or 1D arrays

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 LambdaFunction 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

public static final HxOperator Abs

Absolute value. Unary arithmetic operator. ABS(e) = e >= 0 ? e : -e. This operator returns an integer if the operand is a boolean or an integer, and a double otherwise.

Dist

public static final HxOperator Dist

Distance between two numbers. Binary arithmetic operator. DIST(a,b) = ABS(a-b). This operator returns an integer if the two operands are booleans or integers, and a double as soon as one of the operand is a double.

Div

public static final HxOperator 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

public static final HxOperator Mod

Modulo (remainder of the integer division). Binary arithmetic operator. MOD(a, b) = r such that a = q * b + r with q, r integers, r, a have the same sign and |r| < |b|. The operands must be integers or booleans. This operator returns an integer.

Array

public static final HxOperator 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 LambdaFunction. 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

public static final HxOperator 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

public static final HxOperator Scalar

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

Since:

2.1

Ceil

public static final HxOperator Ceil

Ceil. Unary arithmetic operator. Returns a value rounded to the next highest integer. The operand can be a boolean, an integer or a double. This operator returns an integer.

Since:

3.0

Floor

public static final HxOperator Floor

Floor. Unary arithmetic operator. Returns a value rounded to the next lowest integer. The operand can be a boolean, an integer or a double. This operator returns an integer.

Since:

3.0

Round

public static final HxOperator Round

Round. Unary arithmetic operator. Returns a value rounded to the nearest integer. The operand can be a boolean, an integer or a double. This operator returns an integer.

Since:

3.0

Sqrt

public static final HxOperator Sqrt

Square root. Unary arithmetic operator. The operand can be a boolean, an integer or a double. This operator returns a double.

Since:

3.0

Log

public static final HxOperator Log

Natural logarithm (base-e). Unary arithmetic operator. The operand can be a boolean, an integer or a double. This operator returns a double.

Since:

3.0

Exp

public static final HxOperator Exp

Base-e exponential. Unary arithmetic operator. The operand can be a boolean, an integer or a double. This operator returns a double.

Since:

3.0

Pow

public static final HxOperator Pow

Power operator. POW(x, y) is equals to the value of x to the power of y. The operands can be booleans, integers or doubles. This operator returns a double.

Since:

3.0

Cos

public static final HxOperator Cos

Cosine. Unary arithmetic operator. The operand can be a boolean, an integer or a double. This operator returns a double.

Since:

3.0

Sin

public static final HxOperator Sin

Sine. Unary arithmetic operator. The operand can be a boolean, an integer or a double. This operator returns a double.

Since:

3.0

Tan

public static final HxOperator Tan

Tangent. Unary arithmetic operator. The operand can be a boolean, an integer or a double. This operator returns a double.

Since:

3.0

Int

public static final HxOperator Int

Integer decision variable. Operator with two operands that represent the lower bound and the upper bound of the decision (domain [lb, ub]). The bounds must be integer constants.

Since:

5.0

Piecewise

public static final HxOperator 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 sizes (necessarily larger or equal to 2). These arrays must contain constant numbers (integers or doubles). The first array must contain numbers in ascending order. The third operand must be an integer or a double expression. The evaluation of the piecewise will fail if the value of the third operand 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(ARRAY(0, 50, 100), ARRAY(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(ARRAY(0, 50, 50, 100), ARRAY(0, 0.1, 0.9, 1), 50) returns 0.9.

Since:

5.0

List

public static final HxOperator List

A list is an ordered collection of integers within a range [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.

Since:

5.5

Count

public static final HxOperator 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 and returns an integer.

Since:

5.5

IndexOf

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator 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

ExternalFunction

public static final HxOperator ExternalFunction

External function. External functions are used to compute the value of expressions from external functions written with your favorite programming language. External functions are created with the dedicated methods HxModel.createIntExternalFunction(com.hexaly.optimizer.HxIntExternalFunction) or HxModel.createDoubleExternalFunction(com.hexaly.optimizer.HxDoubleExternalFunction).

Since:

9.5

See Also:

• HxIntExternalFunction
• HxDoubleExternalFunction

Call

public static final HxOperator Call

Call a particular function. The first operand must be a function (like ExternalFunction or LambdaFunction). The other operands are passed to the function as arguments. If the function is not a external function, the number of operands must match the number of arguments of the function.

Since:

6.0

LambdaFunction

public static final HxOperator LambdaFunction

Lambda function. Lambda functions are created with the dedicated method HxModel.createLambdaFunction(com.hexaly.optimizer.HxLambdaFunction0).

Since:

9.5

Argument

public static final HxOperator Argument

Argument of a function. Arguments are automatically and implicitly created when you create a function with method HxModel.createLambdaFunction(com.hexaly.optimizer.HxLambdaFunction0).

Since:

7.0

Range

public static final HxOperator 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

public static final HxOperator Contains

Contains. contains(expr1, expr2) is true if and only if the expression expr1 contains expr2. This operator takes exactly two arguments: the first one is a collection (List or Set), an interval, a constant array or an Array of collections, the second one either an integer expression or an interval to search for. If ``expr1`` is an array, all its collections must be of the same type and on the same range. If ``expr2`` is an interval, ``expr1`` must also be an interval. In this case ``contains(expr1, expr2)`` is true if and only if the interval ``expr2`` is fully contained in the first interval ``expr1``. An interval I2 is considered fully contained in I1 if it starts at or after I1's start and ends at or before I1's end.It will then return False if the interval ``expr1`` is void. If the interval ``expr2`` is void this operator will return undefined.

Since:

7.5

Set

public static final HxOperator 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, etc..

Since:

8.0

Deprecated

public static final HxOperator Deprecated

Deprecated.

This operator is deprecated. Using it will raise an error.

Cover

public static final HxOperator 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

public static final HxOperator 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

Sort

public static final HxOperator Sort

Sort. sort(a) return the input sorted in ascending order. This operator takes one argument that is either an array Array or a collection (List, Set, Union, Distinct or Intersection). If the input is a collection or an array consisting only of booleans or integers, it returns an array of integers. However, it returns an array of doubles as soon as the input contains at least one double. This operator can also be used with an optional LambdaFunction as second argument sort(a, key). In that case the operator will sort the array or collection 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, except when the object is a set. In that case, the order of elements having the same key will be determined by their ascending values.

Since:

11.0

Interval

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator 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

public static final HxOperator 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 LambdaFunction 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

public static final HxOperator 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. With intervals This operator can also be used with intervals. The number of accepted operands is then n 1. In that case, this operator becomes an interval operator, it returns the biggest interval fully present in all operands.

Since:

12.5

Hull

public static final HxOperator 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

StepArray

public static final HxOperator StepArray

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

ConstArray

public static final HxOperator ConstArray

A constant array. An array is a collection of elements. Indexes begin at 0. It could be used with operators like At or Scalar. A constant array doesn't have a value by itself. Unlike classical arrays, its elements are not contained in operands. Using constant array instead of classical arrays will reduce the number of operators in the model and improve memory usage when setting up the model.

Since:

13.5

Union

public static final HxOperator Union

Returns the union of iterables. This operator accepts n operands. The operator takes collections (set or list) or arrays of integer domain (constant or not) as its operands. The operator returns the unordered set of the values present in at least one operands

Since:

13.5

OptionalInterval

public static final HxOperator OptionalInterval

Optional interval decision variable. Operator with two integer constant operands that represent the min start and the max end of the decision. The optional interval is either absent (void) or present and included in [minStart, maxEnd). When present, its start is inclusive and its end is exclusive. When absent, its start and its end are undefined.

Since:

14.0

Presence

public static final HxOperator Presence

The presence of an interval. This operator takes exactly one argument of type interval and returns a Boolean: true if the interval is present and false if the interval is absent (void).

Since:

14.0

Method Details

values

public static HxOperator[] values()

Returns an array containing the constants of this enum class, in the order they are declared.

Returns:

an array containing the constants of this enum class, in the order they are declared

valueOf

public static HxOperator valueOf(String name)

Returns the enum constant of this class with the specified name. The string must match exactly an identifier used to declare an enum constant in this class. (Extraneous whitespace characters are not permitted.)

Parameters:

name - the name of the enum constant to be returned.

Returns:

the enum constant with the specified name

Throws:

IllegalArgumentException - if this enum class has no constant with the specified name

NullPointerException - if the argument is null