1. Introduction

1.1 Solver Highlights

2. Solving your First Problem

2.1 Using the Command Line Interface

2.2 Using Python

2.3 Using C++

3. Solver Flags

3.1 Input Flags

3.2 Exit Flags

4. Solver Options

5. Running in Parallel Mode Using MPI

5.1 Running on a Single Machine

5.2 Running on a Computer Cluster

\begin{align} P : \min_{\substack{ x\in X \\y\in Y }} &f(x,y)\\ \textrm{s.t. } &g(x,y)\leq \ 0 \nonumber\\ &h(x,y)=\ 0 \nonumber \\ &X=[\ x^L,\ x^U]\subset\mathbb{R}^n \nonumber \\ &Y=\{0,1\}\nonumber \end{align}

The solver can solve any nonlinear function to global optimality, as long as that function has an analytical form that does not include differential expressions or integrals. For instance,

\begin{equation} \underset{x\in[-1,1]}\min\sqrt{x}\nonumber,\;\;\; \underset{x\in[-1,1]}\min\Big|-\log(\frac{1}{\tan(x)^{0.85}})\Big|,\;\;\; \underset{x\in[-1,1]}\min\sqrt{\max(x^{-1/2},1)}\nonumber,\;\;\; \nonumber \end{equation} are valid inputs, whereas:

\begin{equation} \underset{x\in[-1,1]}\min \Gamma{(x)}\nonumber \nonumber \end{equation} is not valid input because the expression for the Gamma function is an integral.

Users do not need to define starting points when using Octeract Engine. The solver will locate feasible solutions automatically as part of its branch-and-bound search.

Octeract Engine uses a combination of Interval Arithmetic and Arbitrary Precision Arithmetic to guarantee the correctness of all internal calculations. The combination of these two paradigms enables the solver to handle extremely challenging numerics. This is very important in Deterministic Global Optimisation, as our algorithms are always at risk of incorrectly eliminating the global solution due to bad floating-point calculations. However, Octeract Engine relies on third-party solvers in order to solve NLP and LP subproblems, meaning that it is possible for the solver to return an incorrect result due to numerical error from third-party software. In the majority of cases, the solver compensates for such errors using conservative tolerances for external calculations, but it is important for users to be aware that the end result is still subject to third-party floating-point errors.

Octeract Engine comes equipped with a full-fledged symbolic engine designed for optimisation mathematics, which allows it to perform symbolic manipulation of user input to an unprecedented degree.

Octeract Engine can be run in parallel using MPI out of the box, for single machines and computing clusters alike.

` ````
octeract-engine [problem_file]
```

Invoke the solver using the following command:

` ````
octeract-engine ex2_1_1.nl
```

` ````
-----------------------------------------------------------------------------------------------
Iteration GAP LLB BUB Pool Time Mem
-----------------------------------------------------------------------------------------------
11 5.000e-11 ( 0.00%) -1.700e+01 -1.700e+01 3 0.0s 91.0MB
Objective value at global solution: -1.700e+01
```

- Number of iterations (in this case 11).
- Absolute and relative optimality gap (here \(5x10^{−11}\) and 0.00% respectively).
- Least Lower Bound (LLB). This is the smallest lower bound throughout the branch-and-bound tree.
- Best Upper Bound (BUB). This is the best local optimum that has been located so far.
- Pool. This is the number of nodes in the branching pool.
- Time. This is the real time (not CPU time) spent in branch-and-bound (in seconds).
- Memory. The amount of RAM that the solver is currently taking up.

By default, the solver will automatically write an

` ````
octeract-engine ex2_1_1.nl -s MY_SOLUTION_PATH
```

` ````
=========================================
*************** Solution ***************
========================================
- Local Engine : ipopt
- Local Eng. Status : 0
- Feasible : Yes
- Problem type : UB
- Found in node : 20
- Objective value : -16.9999999999499778
- Model name : ex2_1_1
- Problem structure : QP
- DGO exit status : Solved_To_Global_Optimality
- Solving time (s) : 0.078000
- Nu cores : 1
- nu vars : 5
* nu nlvars : 5
* nu linear vars : 0
* nu binary vars : 0
- nu cons : 1
* nu linear cons : 1
* nu fixed cons : 0
* nu quadratic cons : 0
* nu general nl cons : 0
- Solution vector :
x1 : 0.9999999999998276
x2 : 0.9999999999998215
x3 : 0.0000000000002222
x4 : 0.9999999999998114
x5 : 0.0000000000002105
- Lagrange multipliers :
con1 : 0.0000000000099999
x1 : -57.9999999999529479
x2 : -56.0000000000025153
x3 : 45.0000000009757386
x4 : -53.0000000000258993
x5 : 47.5000000009467271
========================================
```

**–help**: Show help.**-o, –option**: Location of a custom options file.**-s, –solution**: Directory where solution files should be saved.**-t, –timeout**: Solver timeout in seconds.**-n, –core**: Number of MPI processes to be created (equivalent to number of CPU cores to use if n<=total_cores).**–hostfile**: Location of the MPI hostfile (if running on a computer cluster).

- Global_Solution_Status_Undefined
- Solved_To_Global_Optimality
- Proved_Global_Infeasibility
- Found_Solution_For_CS_Problem (CS stands for constraint satisfaction)
- Timeout_With_Feasible_Solution
- Timeout_Without_Feasible_Solution
- Interrupt_With_Feasible_Solution
- Interrupt_Without_Feasible_Solution
- Catastrophic_Error
- Parsing_Error

` ````
OPTION_NAME = option_value
```

` ````
octeract-engine -n [number_of_processes] [problem_file]
```

` ````
octeract-engine -n [nu_processes] --hostfile [hostfile]
```

` ````
10.200.300.01 : 32
10.200.300.02 : 8
10.200.300.45 : 2
10.200.300.32 : 12
```

man/man1002