Hexaly

https://www.hexaly.com/docs/last/
Admin
Hexaly provides a comprehensive suite of optimization software, including a global optimization...
Tokens:865,797
Snippets:8,573
Trust Score:8.2
Update:1 week ago
Show doc for...
Tokens:
Raw
### Test Hexaly installation with toy example

Source: https://www.hexaly.com/docs/last/installation/installationonmacosx.html

Run Hexaly Optimizer on the toy example with a time limit of 1 second. If no error occurs, the installation is ready for use.

```bash
$ hexaly examples/toy/toy.hxm hxTimeLimit=1

```

--------------------------------

### Run Hexaly Optimizer from command line

Source: https://www.hexaly.com/docs/last/installation/installationonwindows.html

Use this command to launch Hexaly Optimizer from the command line after installation. The example invokes the optimizer on a model file named 'model.lsp' with a time limit of 10 seconds.

```text
hexaly model.lsp -t 10
```

--------------------------------

### start

Source: https://www.hexaly.com/docs/last/pythonapi/optimizer/hxmodel.html

Creates a start expression.

```APIDOC
## start

### Description
Creates a start expression.

### Method
start

### Parameters
None

### Returns
A start expression.
```

--------------------------------

### start()

Source: https://www.hexaly.com/docs/last/pythonapi/optimizer/hxinterval.html

Returns the start of the interval. Cannot be called on a void interval as it does not have a valid start.

```APIDOC
## HxInterval.start()

### Description
Returns the start of the interval. Cannot be called on a void interval as it does not have a valid start.

### Returns
- **int** - Start of the interval.
```

--------------------------------

### Run Hexaly Optimizer installer

Source: https://www.hexaly.com/docs/last/installation/installationonlinux.html

Executes the Hexaly Optimizer installer archive for Linux. Requires administrator rights and a terminal as root.

```bash
$ bash Hexaly_15_0_20260914_Linux64.run

```

--------------------------------

### HxInterval::getStart()

Source: https://www.hexaly.com/docs/last/cppapi/optimizer/hxinterval.html

Returns the start of the interval.

```APIDOC
## HxInterval::getStart()

### Description
Returns the start of the interval. Cannot be called on a void interval as it does not have a valid start.

### Method
Member function

### Signature
`hxint getStart()`

### Parameters
None

### Returns
Start of the interval.

```

--------------------------------

### Install Hexaly with pip

Source: https://www.hexaly.com/docs/last/installation/pythonsetup.html

Install the Hexaly Optimizer Python integration. This command should be run in a command prompt or Python environment prompt, and must be re-executed each time you install a new version of Hexaly Optimizer. Note that this does not replace a full Hexaly Optimizer installation with a license.

```pip
pip install hexaly
```

--------------------------------

### start(expression)

Source: https://www.hexaly.com/docs/last/modelerreference/standardlibrary/builtinfunctions.html

Returns the start of a non-void interval.

```APIDOC
## start(expression)

### Description
Returns the start of a non-void interval.

### Parameters
- **expression** (interval expression) - Required - The interval to get the start of.

### Returns
A solver expression.
```

--------------------------------

### start(HxExpression) - com.hexaly.optimizer.HxModel

Source: https://www.hexaly.com/docs/last/java/index-all.html

Creates a start expression.

```APIDOC
## start(HxExpression) - Method in class com.hexaly.optimizer.HxModel

### Description
Creates a start expression.

### Method
start

### Signature
`HxExpression start(HxExpression interval)`

### Parameters
- **interval** (HxExpression) - The interval expression.

### Returns
HxExpression - The start expression.
```

--------------------------------

### HxModel::start

Source: https://www.hexaly.com/docs/last/cppapi/optimizer/hxmodel.html

Creates a start expression.

```APIDOC
## HxModel::start

### Description
Creates a start expression.

### Method
start

### Parameters
- **interval** (HxExpression) - Required - The interval expression.

### Returns
- **HxExpression** - The created start expression.
```

--------------------------------

### getParam

Source: https://www.hexaly.com/docs/last/cppapi/optimizer/hexalyoptimizer.html

Gets the parameters of this HexalyOptimizer environment.

```APIDOC
## getParam()

### Description
Gets the parameters of this HexalyOptimizer environment.

### Method
Function

### Parameters
None

### Returns
The parameters (HxParam) of this environment.

```

--------------------------------

### HxOperator.Start

Source: https://www.hexaly.com/docs/last/java/com/hexaly/optimizer/HxOperator.html

Start operator to get the start of a non-void interval.

```APIDOC
## HxOperator.Start

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

### Since
12.0

### Type
public static final HxOperator

### Operands
- **interval** (interval) - Required - The interval whose start is to be retrieved.

### Return Value
Integer representing the start of the interval.
```

--------------------------------

### Hexaly installer help and options

Source: https://www.hexaly.com/docs/last/installation/installationonlinux.html

Displays the installer's help message, listing all available options such as --help, --list, --check, --noroot, --target, and --nointeractive. Includes notes on --noroot and --target.

```bash
$ ./Hexaly_15_0_20260914_Linux64.run --help
Usage: ./Hexaly_15_0_20260914_Linux64.run [options]
with following options
  --help                Print this message
  --list                Print the list of files in the archive
  --check               Checks integrity of the archive
  --noroot              Disable installation features that require root access
  --target directory    Install Hexaly Optimizer in the given directory
  --nointeractive       Install without any user intervention (no prompt)

Note on --noroot: Hexaly Optimizer by itself does not require root privileges
but the installer needs them to put symbolic links in /usr/bin and /usr/lib
directories. If you use the --noroot option, you may encounter difficulties to
run or compile programs based on Hexaly Optimizer except if you can deal with
LD_LIBRARY_PATH environment variable or if you add the symoblic links manually.

Note on --target: The content of this archive will be copied in the given
directory. Thus, if you want to install Hexaly Optimizer in /usr/local/hexaly,
you have to specify --target /usr/local/hexaly on the command line.

```

--------------------------------

### Main mode knapsack example (knapsackMain.hxm)

Source: https://www.hexaly.com/docs/last/modelerreference/mainmode.html

Complete main-mode implementation of the knapsack problem. Uses a single main function that parses command-line arguments, reads the instance file, builds the model, solves, and optionally saves the solution. The time limit defaults to 20 seconds if not provided.

```hexaly
use hexaly;
use io;

function main(args) {
    if(args.count() == 0 || args.count() > 3) {
        local usage = "Usage: hexaly knapsackMain.hxm inputFile [outputFile [timeLimit]]";
        throw usage;
    }

    local inputFile = args[0];
    local outputFile = args[1];
    local timeLimit = args[2] != nil ? args[2].toInt() : 20;

    with(optimizer = hexaly.create()) {
        parseInput(inputFile);

        x[i in 0...nbItems] <- bool();
        knapsackWeight <- sum[i in 0...nbItems](weights[i] * x[i]);
        constraint knapsackWeight <= knapsackBound;
        knapsackValue <- sum[i in 0...nbItems](prices[i] * x[i]);
        maximize knapsackValue;

        optimizer.model.close();
        optimizer.param.timeLimit = timeLimit;
        optimizer.solve();

        if(outputFile != nil)
            saveSolution(outputFile);
    }
}

function parseInput(fileName) {
    local inFile = io.openRead(fileName);
    nbItems = inFile.readInt();
    weights[i in 0...nbItems] = inFile.readInt();
    prices[i in 0...nbItems] = inFile.readInt();
    knapsackBound = inFile.readInt();
}

function saveSolution(fileName) {
    local solFile = io.openWrite(fileName);
    solFile.println(knapsackValue.value);
    for [i in 0...nbItems : x[i].value == 1]
        solFile.print(i + " ");
    solFile.println();
}

```

--------------------------------

### Compute earliest start time using start operator

Source: https://www.hexaly.com/docs/last/mathematicaloperators/intervalvariables.html

Creates interval decisions for tasks and computes the minimum start time using the start operator. The start operator returns NaN for void intervals. Examples are provided for Hexaly Modeler, Python, C++, C#, and Java.

```hexaly_modeler
tasks[i in 0...nbTasks] <- interval(0, horizon);
earliestStart <- min[i in 0...nbTasks](start(tasks[i]));

```

```python
tasks = [model.interval(0, horizon) for i in range(nb_tasks)]
earliest_start = model.min(model.start(tasks[i]) for i in range(nb_tasks))

```

```cpp
std::vector<HxExpression> tasks(nbTasks);
for (int i = 0; i < nbTasks; ++i) {
    tasks[i] = model.intervalVar(0, horizon);
}
HxExpression earliestStart = model.min();
for (int i = 0; i < nbTasks; ++i) {
    earliestStart.addOperand(model.start(tasks[i]));
}

```

```csharp
HxExpression[] tasks = new HxExpression[nbTasks];
for (int i = 0; i < nbTasks; ++i) {
    tasks[i] = model.Interval(0, horizon);
}
HxExpression earliestStart = model.Min();
for (int i = 0; i < nbTasks; ++i) {
    earliestStart.AddOperand(model.Start(tasks[i]));
}

```

```java
HxExpression[] tasks = new HxExpression[nbTasks];
for (int i = 0; i < nbTasks; ++i) {
    tasks[i] = model.intervalVar(0, horizon);
}
HxExpression earliestStart = model.min();
for (int i = 0; i < nbTasks; ++i) {
    earliestStart.addOperand(model.start(tasks[i]));
}

```

--------------------------------

### Examples of the typeof operator

Source: https://www.hexaly.com/docs/last/modelerreference/expressions.html

Shows how to use `typeof` to get the type of a value. The returned type is itself a value and has a type. The example prints the type of a string, the type of a type, and compares types.

```hexaly
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

```

--------------------------------

### Module file layout for $main.hxm and foobar.hxm

Source: https://www.hexaly.com/docs/last/modelerreference/modules.html

Example filesystem layout showing the main program $main.hxm and module foobar.hxm in the same folder. The module name is derived from the filename without extension or path.

```text
/
|- $main.hxm
|- foobar.hxm

```

--------------------------------

### Get interval value

Source: https://www.hexaly.com/docs/last/mathematicaloperators/intervalvariables.html

Retrieves the current value of an interval decision variable as an HxInterval object, which can be queried for its start, end, count, and void status.

```APIDOC
## Get Interval Value

### Description
Retrieves the current value of an interval decision variable as an HxInterval object, which can be read through its methods.

### Method
Value accessor

### Endpoint
`x.value` (Hexaly Modeler), `x.value` or `x.get_interval_value()` (Python), `getIntervalValue()` (C++/Java), `GetIntervalValue()` (C#)

### Parameters
None

### Returns
- **HxInterval** - The current interval value of the decision variable.

### HxInterval Methods
- **start()** - Returns the start of the interval (integer).
- **end()** - Returns the end of the interval (integer).
- **count()** - Returns the size of the interval (integer).
- **isVoid()** - Returns 1 (or true) if the interval is absent (void), 0 (or false) if it is present.
- **toString()** - Returns a string representation of the interval (C++ only).

### Example (Python)
```python
interval = x.value
print(interval.start())     # Current start of the interval
print(interval.end())       # Current end of the interval
print(interval.count())     # Current size of the interval
print(interval.is_void())   # True if the interval is absent (void), or False if it is present
print(interval)             # Print the content of the interval
```

### Example (C++)
```cpp
HxInterval interval = x.getIntervalValue();
std::cout << interval.getStart() << std::endl;  // Current start of the interval
std::cout << interval.getEnd() << std::endl;    // Current end of the interval
std::cout << interval.count() << std::endl;     // Current size of the interval
std::cout << interval.isVoid() << std::endl;    // 1 if the interval is absent (void), or 0 if it is present
std::cout << interval.toString() << std::endl;  // Print the content of the interval
```

```
HxInterval interval = x.GetIntervalValue();
Console.WriteLine(interval.Start());  // Current start of the interval
Console.WriteLine(interval.End());    // Current end of the interval
Console.WriteLine(interval.Count());  // Current size of the interval
Console.WriteLine(interval.IsVoid()); // True if the interval is absent (void), or False if it is present
Console.WriteLine(interval);          // Print the content of the interval
```

```
HxInterval interval = x.getIntervalValue();
System.out.println(interval.getStart()); // Current start of the interval
System.out.println(interval.getEnd());   // Current end of the interval
System.out.println(interval.count());    // Current size of the interval
System.out.println(interval.isVoid());   // true if the interval is absent (void), or false if it is present
System.out.println(interval);            // Print the content of the interval
```

Setting the value of an interval variable can be done by creating a new `HxInterval` object. When using Hexaly Modeler, this is done by defining an integer range using the `a...b` syntax. When `a <= b`, this creates a regular interval `[a, b)`, and when `a > b`, this creates a void interval:
  * Hexaly Modeler
  * Python
  * C++
  * C#
  * Java


```
x.value = 0...4;    // Interval [0, 4)
x.value = 1...1;    // Interval [1, 1)
x.value = 0...-1;   // Void interval

```

```
x.set_interval_value(HxInterval(0, 4))  # Interval [0, 4)
x.set_interval_value(HxInterval(1))     # Interval [1, 1)
x.set_interval_value(HxInterval())      # Void interval

```

```
x.setIntervalValue(HxInterval(0, 4));   // Interval [0, 4)
x.setIntervalValue(HxInterval(1));      // Interval [1, 1)
x.setIntervalValue(HxInterval());       // Void interval

```

```
x.SetIntervalValue(new HxInterval(0, 4)); // Interval [0, 4)
x.SetIntervalValue(new HxInterval(1));    // Interval [1, 1)
x.SetIntervalValue(new HxInterval());     // Void interval

```

```
x.setIntervalValue(new HxInterval(0, 4)); // Interval [0, 4)
x.setIntervalValue(new HxInterval(1));    // Interval [1, 1)
x.setIntervalValue(new HxInterval());     // Void interval

```

With Hexaly Optimizer APIs, this is done by using `HxInterval`’s constructor. It can be used with zero operand to create a void interval, with a single operand `a` to create a degenerate interval `[a, a)`, or with two operands `a <= b` to create an interval `[a, b)`.
```

--------------------------------

### Classic mode knapsack example (knapsack.hxm)

Source: https://www.hexaly.com/docs/last/modelerreference/mainmode.html

Classic-mode implementation of the same knapsack problem, provided in the next tab for comparison. Uses separate input, model, param, and output functions. The time limit defaults to 20 seconds if hxTimeLimit is not set.

```hexaly
// Copyright (c) Hexaly. Permission is hereby granted to use, copy,
// and modify this code for applications developed with Hexaly.
use io;

/* Read instance data */
function input() {
    local usage = "Usage: hexaly knapsack.hxm "
            + "inFileName=inputFile [solFileName=outputFile] [hxTimeLimit=timeLimit]";

    if (inFileName == nil) throw usage;

    local inFile = io.openRead(inFileName);
    nbItems = inFile.readInt();
    weights[i in 0...nbItems] = inFile.readInt();
    prices[i in 0...nbItems] = inFile.readInt();
    knapsackBound = inFile.readInt();
}

/* Declare the optimization model */
function model() {
    // Decision variables x[i]
    x[i in 0...nbItems] <- bool();

    // Weight constraint
    knapsackWeight <- sum[i in 0...nbItems](weights[i] * x[i]);
    constraint knapsackWeight <= knapsackBound;

    // Maximize value
    knapsackValue <- sum[i in 0...nbItems](prices[i] * x[i]);
    maximize knapsackValue;
}

/* Parametrize the solver */
function param() {
    if (hxTimeLimit == nil) hxTimeLimit = 20; 
}

/* Write the solution in a file */
function output() {
    if (solFileName == nil) return;
    local solFile = io.openWrite(solFileName);
    solFile.println(knapsackValue.value);
    for [i in 0...nbItems : x[i].value == 1]
        solFile.print(i + " ");
    solFile.println();
}

```

--------------------------------

### Valid values for an interval variable with minStart=0 and maxEnd=5

Source: https://www.hexaly.com/docs/last/mathematicaloperators/intervalvariables.html

Shows examples of valid interval values for an interval decision variable with minimum start 0 and maximum end 5. Intervals are half-open `[a, b)` with start included and end excluded, and must satisfy `a >= minStart`, `b <= maxEnd`, and `a <= b`.

```text
[0, 1)  // Singleton (0 is included, but 1 is excluded)
[1, 4)
[2, 2)  // Degenerate interval (zero length)
[0, 5)  // Full interval (maximum length)
```

--------------------------------

### HexalyOptimizer::getSolution()

Source: https://www.hexaly.com/docs/last/cppapi/optimizer/hexalyoptimizer.html

Gets the best solution found by the optimizer. If the optimizer has not been started at least once, all decision variables are set to 0 or their closest bound. Only allowed in states S_Paused or S_Stopped.

```APIDOC
## HexalyOptimizer::getSolution()

### Description
Gets the best solution found by the optimizer. If the optimizer has not been started at least once, all the decision variables of the solution are set to 0, or to their closest bound if 0 is not part of their domain (such a solution may be infeasible). Only allowed in states `S_Paused` or `S_Stopped`.

### Method
Getter

### Signature
`HxSolution HexalyOptimizer::getSolution() const`

### Parameters
None

### Returns
- **HxSolution** - Best solution.
```

--------------------------------

### Complete Car Sequencing model and main method in Java

Source: https://www.hexaly.com/docs/last/tutorials/solvingyourfirstbusinessproblem.html

Complete Java code for the car sequencing example. It builds decision expressions for the number of cars per option per window, derives violations against capacity, minimizes the total violations, and initializes the sequence with all positions. The main method handles command-line arguments, creates the optimizer, reads the instance, solves within a time limit (default 60 seconds), and writes the solution if a file is provided.

```java
// Number of cars with option o in each window
HxExpression[][] nbCarsWindows = new HxExpression[nbOptions][];
for (int o = 0; o < nbOptions; ++o) {
    HxExpression oExpr = model.createConstant(o);
    nbCarsWindows[o] = new HxExpression[nbPositions - windowSize[o] + 1];
    for (int j = 0; j < nbPositions - windowSize[o] + 1; ++j) {
        nbCarsWindows[o][j] = model.sum();
        for (int k = 0; k < windowSize[o]; ++k) {
            HxExpression classAtPosition = model.at(initialArray, model.at(sequence, j + k));
            nbCarsWindows[o][j].addOperand(model.at(optionArray, classAtPosition, oExpr));
        }
    }
}

// Number of violations of option o capacity in each window
HxExpression[][] nbViolationsWindows = new HxExpression[nbOptions][];
for (int o = 0; o < nbOptions; ++o) {
    nbViolationsWindows[o] = new HxExpression[nbPositions - windowSize[o] + 1];
    for (int j = 0; j < nbPositions - windowSize[o] + 1; ++j) {
        HxExpression delta = model.sub(nbCarsWindows[o][j], maxCarsPerWindow[o]);
        nbViolationsWindows[o][j] = model.max(0, delta);
    }
}

// Minimize the sum of violations for all options and all windows
totalViolations = model.sum();
for (int o = 0; o < nbOptions; ++o) {
    totalViolations.addOperands(nbViolationsWindows[o]);
}

model.minimize(totalViolations);
model.close();

// Set the initial solution
sequence.getCollectionValue().clear();
for (int p = 0; p < nbPositions; ++p)
    sequence.getCollectionValue().add(p);

// Parametrize the optimizer
optimizer.getParam().setTimeLimit(limit);

optimizer.solve();
}

/*
* Write the solution in a file with the following format:
* - 1st line: value of the objective;
* - 2nd line: for each position p, index of class at positions p.
*/
private void writeSolution(String fileName) throws IOException {
    try (PrintWriter output = new PrintWriter(fileName)) {
        output.println(totalViolations.getValue());
        for (int p = 0; p < nbPositions; ++p) {
            output.print(initialSequence[(int) sequence.getCollectionValue().get(p)] + " ");
        }
        output.println();
    }
}

public static void main(String[] args) {
    if (args.length < 1) {
        System.err.println("Usage: java CarSequencing inputFile [outputFile] [timeLimit]");
        System.exit(1);
    }

    String instanceFile = args[0];
    String outputFile = args.length > 1 ? args[1] : null;
    String strTimeLimit = args.length > 2 ? args[2] : "60";

    try (HexalyOptimizer optimizer = new HexalyOptimizer()) {
        CarSequencing model = new CarSequencing(optimizer);
        model.readInstance(instanceFile);
        model.solve(Integer.parseInt(strTimeLimit));
        if (outputFile != null) {
            model.writeSolution(outputFile);
        }
    } catch (Exception ex) {
        System.err.println(ex);
        ex.printStackTrace();
        System.exit(1);
    }
}
}
```

--------------------------------

### run

Source: https://www.hexaly.com/docs/last/cppapi/modeler/hxmmodule.html

Starts the execution of the module using the optimizer passed in parameter.

```APIDOC
## run

### Description
Starts the execution of the module using the optimizer passed in parameter.

### Method
run

### Parameters
- optimizer (type: optimizer) - Required - The optimizer to use for execution.

### Returns
- (type: void) - No return value.
```

--------------------------------

### Invalid values for an interval variable with minStart=0 and maxEnd=5

Source: https://www.hexaly.com/docs/last/mathematicaloperators/intervalvariables.html

Shows examples of invalid interval values for an interval decision variable with minimum start 0 and maximum end 5. These violate the bounds or the start/end ordering constraint.

```text
[3, 6)  // Out of bounds for an interval of maximum end 5
[2, 0)  // An interval's start is lower or equal to its end
```

--------------------------------

### Create and launch an optimization model in main mode

Source: https://www.hexaly.com/docs/last/modelerreference/mainmode.html

Use the 'with' syntax with hexaly.create() to manage the optimizer's lifetime. The 'with' block is mandatory for the minimize, maximize, constraint keywords and the '<-' operator to work. Close the model, set time limit, and solve inside the block.

```hexaly
use hexaly;

function main() {
    with(optimizer = hexaly.create()) {
        x <- bool();
        ...
        maximize obj;
        ...
        optimizer.model.close();
        optimizer.param.timeLimit = 2;
        optimizer.solve();
    }
}

```

--------------------------------

### OptimalBucket Java model with Hexaly Optimizer

Source: https://www.hexaly.com/docs/last/tutorials/solvingyourfirstmodel.html

Complete Java example for the OptimalBucket model. It declares float decision variables R, r, h, builds the surface and volume expressions using Hexaly operators (prod, pow, sqrt, sum, sub, div), adds a constraint that surface must not exceed PI, maximizes volume, sets a time limit, and writes the solution to a file. The main method reads an optional output file and time limit from command-line arguments, defaulting the time limit to "2" seconds.

```java
// Copyright (c) Hexaly. Permission is hereby granted to use, copy,
// and modify this code for applications developed with Hexaly.
import java.io.*;
import com.hexaly.optimizer.*;

public class OptimalBucket {
    private static final double PI = 3.14159265359;

    // Hexaly Optimizer
    private final HexalyOptimizer optimizer;

    // Hexaly Program variables
    private HxExpression R;
    private HxExpression r;
    private HxExpression h;

    private HxExpression surface;
    private HxExpression volume;

    private OptimalBucket(HexalyOptimizer optimizer) {
        this.optimizer = optimizer;
    }

    private void solve(int limit) {
        // Declare the optimization model
        HxModel model = optimizer.getModel();
        HxExpression piConst = model.createConstant(PI);

        // Numerical decisions
        R = model.floatVar(0, 1);
        r = model.floatVar(0, 1);
        h = model.floatVar(0, 1);

        // surface = PI*r^2 + PI*(R+r)*sqrt((R - r)^2 + h^2)
        HxExpression s1 = model.prod(piConst, r, r);
        HxExpression s2 = model.pow(model.sub(R, r), 2);
        HxExpression s3 = model.pow(h, 2);
        HxExpression s4 = model.sqrt(model.sum(s2, s3));
        HxExpression s5 = model.sum(R, r);
        HxExpression s6 = model.prod(piConst, s5, s4);
        surface = model.sum(s1, s6);

        // Surface must not exceed the surface of the plain disc
        model.addConstraint(model.leq(surface, PI));

        HxExpression v1 = model.pow(R, 2);
        HxExpression v2 = model.prod(R, r);
        HxExpression v3 = model.pow(r, 2);

        // volume = PI*h/3*(R^2 + R*r + r^2)
        volume = model.prod(piConst, model.div(h, 3), model.sum(v1, v2, v3));

        // Maximize the volume
        model.maximize(volume);

        model.close();

        // Parametrize the optimizer
        optimizer.getParam().setTimeLimit(limit);

        optimizer.solve();
    }

    /* Write the solution in a file with the following format:
     * - surface and volume of the bucket
     * - values of R, r and h */
    private void writeSolution(String fileName) throws IOException {
        try (PrintWriter output = new PrintWriter(fileName)) {
            output.println(surface.getDoubleValue() + " " + volume.getDoubleValue());
            output.println(R.getDoubleValue() + " " + r.getDoubleValue() + " " + h.getDoubleValue());
        }
    }

    public static void main(String[] args) {

        String outputFile = args.length > 0 ? args[0] : null;
        String strTimeLimit = args.length > 1 ? args[1] : "2";

        try (HexalyOptimizer optimizer = new HexalyOptimizer()) {
            OptimalBucket model = new OptimalBucket(optimizer);
            model.solve(Integer.parseInt(strTimeLimit));
            if (outputFile != null) {
                model.writeSolution(outputFile);
            }
        } catch (Exception ex) {
            System.err.println(ex);
            ex.printStackTrace();
            System.exit(1);
        }
    }
}

```

--------------------------------

### HxSolution GetSolution()

Source: https://www.hexaly.com/docs/last/csharpapi/optimizer/hexalyoptimizer.html

Gets the best solution found by the solver. If the solver has not been started at least once, all the decision variables of the solution are set to 0, or to their closest bound if 0 is not part of their domain (such a solution may be infeasible). Only allowed in states Paused or Stopped.

```APIDOC
## HxSolution GetSolution()

### Description
Gets the best solution found by the solver. If the solver has not been started at least once, all the decision variables of the solution are set to 0, or to their closest bound if 0 is not part of their domain (such a solution may be infeasible). Only allowed in states Paused or Stopped.

### Method
GetSolution

### Parameters
None

### Returns
- **HxSolution** - The best solution.

```

--------------------------------

### Constrain interval length to task duration using length operator

Source: https://www.hexaly.com/docs/last/mathematicaloperators/intervalvariables.html

Creates an interval decision and constrains its length to equal a given duration. The length operator is equivalent to end(x) - start(x) and returns NaN for void intervals. Examples are provided for Hexaly Modeler, Python, C++, C#, and Java.

```hexaly_modeler
task <- interval(0, horizon);
constraint length(task) == duration;

```

```python
task = model.interval(0, horizon)
model.constraint(model.length(task) == duration)

```

```cpp
HxExpression task = model.intervalVar(0, horizon);
model.constraint(model.length(task) == duration);

```

```csharp
HxExpression task = model.Interval(0, horizon);
model.Constraint(model.Length(task) == duration);

```

```java
HxExpression task = model.intervalVar(0, horizon);
model.constraint(model.eq(model.length(task), duration));

```

--------------------------------

### HexalyOptimizer::HexalyOptimizer()

Source: https://www.hexaly.com/docs/last/cppapi/optimizer/hexalyoptimizer.html

Constructs a complete HexalyOptimizer environment and takes a token license. Throws an exception if no token is available or the token server is inaccessible.

```APIDOC
## HexalyOptimizer::HexalyOptimizer()

### Description
Constructs a complete HexalyOptimizer environment and takes a token license. If no token is available or if the token server is not accessible, an exception is thrown. The token license is released when the destructor of this Hexaly Optimizer environment is called.

### Method
Constructor

### Signature
`HexalyOptimizer::HexalyOptimizer()`

### Parameters
None

### Returns
None

### Exceptions
Throws an exception if no token is available or if the token server is not accessible.
```

--------------------------------

### Run Python optimal_bucket.py

Source: https://www.hexaly.com/docs/last/tutorials/solvingyourfirstmodel.html

Launch the Python program for the optimal bucket model. Requires Python >= 3.8 and the recommended pip install procedure.

```shell
python optimal_bucket.py
```

--------------------------------

### long Start()

Source: https://www.hexaly.com/docs/last/csharpapi/optimizer/hxinterval.html

Returns the start of the interval. Cannot be called on a void interval as it does not have a valid start.

```APIDOC
## long Start()

### Description
Returns the start of the interval. Cannot be called on a void interval as it does not have a valid start.

### Method
Instance method

### Signature
`long Start()`

### Parameters
None

### Returns
- **Return type**: `long` - Start of the interval.

### Example
```csharp
HxInterval interval = new HxInterval(0, 10);
long start = interval.Start();
```
```

--------------------------------

### OptimalBucket C++ model with Hexaly Optimizer

Source: https://www.hexaly.com/docs/last/tutorials/solvingyourfirstmodel.html

Complete C++ example for the OptimalBucket model. It declares float decision variables R, r, and h, builds the surface constraint and volume objective using pow, sqrt, leq, and maximize, then solves with a time limit. The writeSolution method outputs surface, volume, and the three variable values to a file.

```cpp
// Copyright (c) Hexaly. Permission is hereby granted to use, copy,
// and modify this code for applications developed with Hexaly.
#include "optimizer/hexalyoptimizer.h"
#include <fstream>
#include <iostream>
#include <vector>

using namespace hexaly;
using namespace std;

class OptimalBucket {
public:
    // Hexaly Optimizer
    HexalyOptimizer optimizer;

    // Hexaly Program variables
    HxExpression R;
    HxExpression r;
    HxExpression h;

    HxExpression surface;
    HxExpression volume;

    void solve(int limit) {
        hxdouble PI = 3.14159265359;

        // Declare the optimization model
        HxModel model = optimizer.getModel();

        // Numerical decisions
        R = model.floatVar(0.0, 1.0);
        r = model.floatVar(0.0, 1.0);
        h = model.floatVar(0.0, 1.0);

        // Surface must not exceed the surface of the plain disc
        surface = PI * model.pow(r, 2) + PI * (R + r) * model.sqrt(model.pow(R - r, 2) + model.pow(h, 2));
        model.constraint(model.leq(surface, PI));

        // Maximize the volume
        volume = PI * h / 3 * (model.pow(R, 2) + R * r + model.pow(r, 2));
        model.maximize(volume);

        model.close();

        // Parametrize the optimizer
        optimizer.getParam().setTimeLimit(limit);

        optimizer.solve();
    }

    /* Write the solution in a file with the following format:
     *  - surface and volume of the bucket
     *  - values of R, r and h */
    void writeSolution(const string& fileName) {
        ofstream outfile;
        outfile.exceptions(ofstream::failbit | ofstream::badbit);
        outfile.open(fileName.c_str());

        outfile << surface.getDoubleValue() << " " << volume.getDoubleValue() << endl;
        outfile << R.getDoubleValue() << " " << r.getDoubleValue() << " " << h.getDoubleValue() << endl;
    }
};

int main(int argc, char** argv) {
    const char* solFile = argc > 1 ? argv[1] : NULL;
    const char* strTimeLimit = argc > 2 ? argv[2] : "2";

    try {
        OptimalBucket model;
        model.solve(atoi(strTimeLimit));
        if (solFile != NULL)
            model.writeSolution(solFile);
        return 0;
    } catch (const exception& e) {
        cerr << "An error occurred:" << e.what() << endl;
        return 1;
    }
}

```

--------------------------------

### HxInterval(start, end)

Source: https://www.hexaly.com/docs/last/pythonapi/optimizer/hxinterval.html

Constructor of HxInterval. Returns an interval of value [start, end). End must be greater (or equal) than start.

```APIDOC
## HxInterval(start, end)

### Description
Constructor of HxInterval. Returns an interval of value [start, end). End must be greater (or equal) than start.

### Parameters
- **start** - Start of the interval.
- **end** - End of the interval.

### Returns
- **HxInterval** - An interval.
```

--------------------------------

### Run(HexalyOptimizer)

Source: https://www.hexaly.com/docs/last/csharpapi/modeler/hxmmodule.html

Starts the execution of the module using the optimizer passed in parameter. Runs the input, model, param, solve, display, and output steps.

```APIDOC
## Run(HxOptimizer)

### Description
Starts the execution of the module using the optimizer passed in parameter. Runs the input, model, param, solve, display, and output steps.

### Method
void

### Endpoint
Run(_Hexaly.Optimizer.HexalyOptimizer optimizer_)

### Parameters
#### Method Parameters
- **optimizer** (_Hexaly.Optimizer.HexalyOptimizer_) - Required - Instance on which modeling and optimization is performed.

```

--------------------------------

### get

Source: https://www.hexaly.com/docs/last/pythonapi/optimizer/hxarray.html

Gets the value at the given position.

```APIDOC
## get(position)

### Description
Gets the value at the given position.

### Parameters
- **position** (int) - Required - The index in the array.

### Returns
- object - The value at the given position, which can be a number, HxArray, HxInterval, or HxCollection.

```

--------------------------------

### Complete Java example using HexalyModeler

Source: https://www.hexaly.com/docs/last/features/modeler.html

Loads the knapsack.hxm module, sets integer and map data, and creates an optimizer. Use this as a full reference for the Hexaly Modeler Java API.

```java
import java.util.Arrays;
import java.util.List;
import com.hexaly.optimizer.*;
import com.hexaly.modeler.*;

public class ModelerTest {
    public static void main(String[] args) {
        try (HexalyModeler modeler = new HexalyModeler()) {
            HxmModule knapsackModule = modeler.loadModule("knapsack", "knapsack.hxm");

            // Declares a variable and sets its value.
            knapsackModule.setInt("nbItems", 8);
            knapsackModule.setInt("knapsackBound", 102);

            // Data we want to input
            List<Integer> weights = Arrays.asList(10, 60, 30, 40, 30, 20, 20, 2);
            List<Integer> prices = Arrays.asList(1, 10, 15, 40, 60, 90, 100, 15);
            // HxmMap that will hold the values in the modeling program
            HxmMap weightsMap = modeler.createMap();
            HxmMap pricesMap = modeler.createMap();

            for (int value : weights)
                weightsMap.addInt(value);
            for (int value : prices)
                pricesMap.addInt(value);

            knapsackModule.setMap(
```

--------------------------------

### run(HexalyOptimizer optimizer, Iterable<String> arguments)

Source: https://www.hexaly.com/docs/last/java/com/hexaly/modeler/HxmModule.html

Starts the execution of the module using the optimizer passed in parameter.

```APIDOC
## run(HexalyOptimizer optimizer, Iterable<String> arguments)

### Description
Starts the execution of the module using the optimizer passed in parameter.

### Method
run(HexalyOptimizer optimizer, Iterable<String> arguments)

### Parameters
- **optimizer** (HexalyOptimizer) - Required - The optimizer to use for execution.
- **arguments** (Iterable<String>) - Required - The arguments to pass to the module.

### Return Type
void
```

--------------------------------

### HxInterval(long start, long end)

Source: https://www.hexaly.com/docs/last/csharpapi/optimizer/hxinterval.html

Constructor of HxInterval. Returns an interval of value `[start, end)`. End must be greater (or equal) than start.

```APIDOC
## HxInterval(long start, long end)

### Description
Constructor of HxInterval. Returns an interval of value `[start, end)`. End must be greater (or equal) than start.

### Method
Constructor

### Signature
`HxInterval(long start, long end)`

### Parameters
- **start** (long) - Required - Start of the interval.
- **end** (long) - Required - End of the interval.

### Returns
- **Return type**: `HxInterval` - Degenerate interval.

### Example
```csharp
HxInterval interval = new HxInterval(0, 10);
```
```

--------------------------------

### Retrieve solution status in C++

Source: https://www.hexaly.com/docs/last/features/solution.html

Use optimizer.getSolution().getStatus() to get the status. Compare it to SS_Inconsistent, SS_Infeasible, SS_Feasible, SS_Optimal constants.

```cpp
// with optimizer an object of type HexalyOptimizer

std::cout << "Status is " << optimizer.getSolution().getStatus() << std::endl;

// you can also compare the status to its possible values
if (optimizer.getSolution().getStatus() == SS_Inconsistent) ...
else if (optimizer.getSolution().getStatus() == SS_Infeasible) ...
else if (optimizer.getSolution().getStatus() == SS_Feasible) ...
else if (optimizer.getSolution().getStatus() == SS_Optimal) ...

```

--------------------------------

### start operator

Source: https://www.hexaly.com/docs/last/mathematicaloperators/intervalvariables.html

Returns the start of a non-void interval (included), or NaN if applied to a void interval. Used to compute the earliest start time of a set of tasks.

```APIDOC
## start Operator

### Description
Returns the start of a non-void interval (included), or NaN if applied to a void interval.

### Usage
`start(interval)`

### Parameters
- **interval** (interval) - Required - The interval expression to get the start of.

### Returns
- The start time of the interval (included), or NaN if the interval is void.

### Example
```
tasks[i in 0...nbTasks] <- interval(0, horizon);
earliestStart <- min[i in 0...nbTasks](start(tasks[i]));
```
```

--------------------------------

### HxmModule.run(optimizer, *args)

Source: https://www.hexaly.com/docs/last/pythonapi/modeler/hxmmodule.html

Starts the execution of the module using the specified optimizer. It executes the input, model, param, solve, and output functions in sequence.

```APIDOC
## HxmModule.run(optimizer, *args)

### Description
Starts the execution of the module using the optimizer passed in parameter. The execution follows a defined sequence: input, model, close, param, solve, and output functions.

### Method
run

### Parameters
- **optimizer** (HexalyOptimizer) - Required - Instance on which modeling and optimization is performed.
- **args** (str or list of str) - Optional - List of arguments to parse and expose as global variables. Each argument must be of the form argName=argValue.

### Notes
- The optimizer must have been created by the HexalyModeler.create_optimizer() method.
- The model function must be declared in the module.
- The display function, if defined, will be called during the resolution process.

```

--------------------------------

### Start - Enum constant in com.hexaly.optimizer.HxOperator

Source: https://www.hexaly.com/docs/last/java/index-all.html

The start of a non-void interval.

```APIDOC
## Start - Enum constant in enum class com.hexaly.optimizer.HxOperator

### Description
The start of a non-void interval.

### Enum Constant
Start
```

--------------------------------

### loadEnvironment(String filename)

Source: https://www.hexaly.com/docs/last/java/com/hexaly/optimizer/HexalyOptimizer.html

Import a complete environment or a model from a file. Only allowed in state `HxState.Modeling`. The current model must be empty. The only format supported is LSB. The chosen file format is determined by the file suffix. An exception is thrown if the provided file suffix is not supported. The suffix may optionally be followed by .gz.

```APIDOC
## loadEnvironment(String filename)

### Description
Import a complete environment or a model from a file. Only allowed in state `HxState.Modeling`. The current model must be empty. The only format supported is LSB. The chosen file format is determined by the file suffix. An exception is thrown if the provided file suffix is not supported. The suffix may optionally be followed by .gz.

### Method
loadEnvironment

### Signature
`public void loadEnvironment(String filename)`

### Parameters
- **filename** (String) - Required - Name of the file.

### Returns
void

### Allowed States
`HxState.Modeling`

### Since
3.0

### See Also
- `saveEnvironment(java.lang.String)`
```

--------------------------------

### If statement examples

Source: https://www.hexaly.com/docs/last/modelerreference/statements.html

Examples of if statements with valid and invalid conditions. The third example shows that a condition must be an integer equal to 0 or 1; otherwise an error is thrown.

```text
if (0) c = "ok";
if (true) c = "ok";
if (2) c = "error"; // ERROR: invalid condition

```

--------------------------------

### Load and run a module in optimization mode

Source: https://www.hexaly.com/docs/last/csharpapi/modeler/index.html

Creates a HexalyModeler environment, creates an optimizer, loads a module from an HXM file, and runs it with optimization parameters. Uses a using statement to ensure native memory is released.

```csharp
using (HexalyModeler modeler = new HexalyModeler())
{
    HexalyOptimizer optimizer = modeler.CreateOptimizer();
    HxmModule module = modeler.LoadModule("module_name", "my_file.hxm");
    module.Run(optimizer, "hxIterationLimit=100", "hxTimeLimit=10");
}

```

--------------------------------

### start(HxExpression a)

Source: https://www.hexaly.com/docs/last/java/com/hexaly/optimizer/HxModel.html

Creates a start expression using the HxOperator.Start operator.

```APIDOC
## HxExpression start(HxExpression a)

### Description
Creates a start expression. This method is a shortcut for `createExpression(HxOperator.Start, a)`.

### Parameters
- `a` (HxExpression) - The expression.

### Returns
HxExpression - The start expression.

### Since
12.0

### See Also
- `HxOperator.Start`
- `createExpression(HxOperator, HxExpression)`
```

--------------------------------

### get(int) - Method in class com.hexaly.optimizer.HxCollection

Source: https://www.hexaly.com/docs/last/java/index-all.html

Gets the value at the given position.

```APIDOC
## get(int)

### Description
Gets the value at the given position.

### Method
get

### Parameters
- **int** - The position.

### Returns
The value at the given position.
```
Tokens:
Raw