### Table of Contents

# Introduction

AlphaECP is a Mixed-Integer Non-Linear Programming (MINLP) solver based on the extended cutting plane (ECP) method. The solver can be applied to general MINLP problems and it can ensure global optimal solutions for pseudo-convex MINLP problems. The documentation is written as if the considered problem is a minimization problem, if not otherwise denoted.

The ECP method is an extension of Kelley's cutting plane method, which was originally given for convex NLP problems [139] . The method only requires the solution of a MIP sub-problem in each iteration. The MIP sub-problems can be solved to optimality, to feasibility, or only to an integer relaxed solution in intermediate iterations. This makes the ECP algorithm efficient and easy to implement. Further information about the underlying algorithm can be found in [257] and [196, 230, 256, 258] .

Further developments of the GAMS/AlphaECP algorithm have introduced additional functionality. A NLP solver can now be called at MIP solutions. This improves AlphaECP's ability to find feasible and accurate solutions, especially for MINLP problems which mainly contain continuous variables. Furthermore, a heuristic that reselects cutting planes during the iteration procedure can be used to improve the capability of solving non-convex problems. In addition to the termination based on constraint tolerance the algorithm can terminate also if relative objective gap termination criterion is satisfied. This is only supported for convex problems.

## Licensing and software requirements

Users need to have a GAMS/AlphaECP license in order to use GAMS/AlphaECP. In addition, a licensed MIP solver is required for solving the mixed integer sub-problem, and a licensed NLP solver is required if the NLP option is used.

## Running AlphaECP

AlphaECP solves MINLP models. If AlphaECP is not specified as the default solver for these models it can be invoked by issuing the following command before the solve statement:

option minlp=alphaecp, miqcp=alphaecp;

In principle AlphaECP can also handle NLP models, but it is more suitable for MINLP problems. However, when combined with an NLP solver it can find solutions the NLP solver cannot find by itself. In this case it acts as a good starting point generator. If you want to solve NLPs with AlphaECP you need to *trick* the GAMS system by solving your NLP as an MINLP:

solve mynlpmodel minimizing obj using minlp;

Constraint violations are reported throughout the progress of AlphaECP and at the end of the algorithm. The violation is reported for the non-linear constraints only. The violation of the linear constraints is subject to the feasibility tolerance of the MIP/NLP solver.

# GAMS/AlphaECP Output

The log output below is obtained for the MINLP model fuel.gms from the GAMS model library:

------------------------------------------------------------------------------ Welcome to AlphaECP v2.11.01 MINLP Problem Solver using the Extended Cutting Plane Approach. Method development - T.Westerlund, Abo Akademi University, FIN Algorithm development - T.Lastusilta, Abo Akademi University, FIN Algorithm development - V.-P. Eronen, Turku University, FIN Westerlund Tapio and Poern Ray (2002). Optimization & Engineering, 3, 253-280 ------------------------------------------------------------------------------ Minimization problem: "fuel.gms" The GAMS-model has in total 39 elements of which 15% are non-linear(NL) included in 16 constraints of which 25% are NL The NL constraint signs: =E=(3), =G=(1), =L=(0) The number of variables in NL elements are 6 from a total of 16 variables: Continuous(13), Binary(3), Integer(0) ------------------------------------------------------------------------------- Using following settings AlphaECP option file optfile=0 Time limit for AlphaECP (in seconds) reslim=10000000000 Solvelink for NLP and MIP sub-solver solvelink=5 Solver trace file solvetrace=(Inactive) Cutting plane strategy (0-3) CUTdelcrit=3 Cut generation pace CUTnrcuts=0 Updating multiplier if MIP is infeasible ECPbeta=1.3 Write encountered solutions to gdx files ECPdumpsol=0 Updating multiplier when verifying solution ECPgamma=2 Maximum number of AlphaECP iterations ECPiterlim=-1 Level of AlphaECP output to statusfile (0-4) ECPloglevel=0 Master strategy (0=User 1=Convex) ECPmaster=0 Return solution (1.MIP/2.NLP/...) ECPretsol=2 User specified start-point (0-3) ECPstart=3 AlphaECP strategy (1-5) ECPstrategy=2 AlphaECP termination criterion (1-2) ECPtoltype=1 Upper limit of considered MIP solutions per MIP call MIPnrsols=50 Relative MIP gap in intermediate sub-problems (0->1.0) MIPoptcr=1.00 Initial iteration limit when MIPoptcr is reduced MIPoptcrlim=200 Strategy to increase MIPoptcrlim MIPoptcrlimtype=0 MIP is solved to optimality with this frequency MIPoptimaliter=0 Strategy for multiple MIP solutions MIPsolstrat=1 MIP solver for sub-problems and . option file number MIPsolver=cplex.0 NLP strategy. Inactive:0 Active strategy:1-5 NLPcall=5 NLP solver call at next (incremental) iteration NLPcalliter=0 NLP time limit per call (in seconds or auto=0) NLPreslim=30 NLP solver for sub-problems and . option file number NLPsolver=conopt.0 Constraint tolerance TOLepsg=0.001 Distance tolerance for a new linearization TOLepsz=0.1 Gradient tolerance TOLgrad=1e-06 Infinity bound (MIP variable bound) TOLinfbnd=1e+10 Relative termination tolerance for MINLP TOLoptcr=(Inactive) ------------------------------------------------------------------------------- Itera Stepcode, Number Point Alpha OPT Movement Viol Maximum MIPobjval tion Problems of Cuts usage Upd. CR Norm Cons Violation Start-point: NL constraint (1) infeasibile 0 H 0 0 0 1 0 4 1.8E+03 NA 1 SAFGI 1 1 1 1 9.3E+03 0 1.1E-13 8566.12 1 FOUND SOLUTION: 8566.12 (NLP) in 1 sec. 2 SAFH 1 1 0 1 6.6E+03 4 1.8E+03 4844.02 3 SAFH 3 2 0 1 8.4E+03 3 1.8E+03 7031.72 4 SAFH 4 3 0 1 1E+03 2 1.8E+03 10157 5 SAH 5 4 0 1 0 1 7E+02 11925 6 SAH 6 5 0 1 1.1E+03 2 3.5E+02 11925 7 SAH 8 6 0 1 1.9E+03 2 5.3E+02 11925 8 SAH 9 7 0 1 8.8E+02 3 2.6E+02 11925 9 SAH 12 8 0 1 8.8E+02 3 1.3E+02 11925 10 SAH 15 9 0 1 4.4E+02 3 66 11925 ... 79 SAIJL 101 65 0 1 0 0 0.00067 11925 80 SAJ 100 64 0 0.5 0 0 0.00067 11925 81 SAJ 100 64 0 0.3 0 0 0.00067 11925 ... 100 AI 106 39 1 0 0 0 0.00067 11925 101 AI 106 39 1 0 0 0 0.00067 11925 102 AIJ 106 39 0 0 0 0 0.00067 11925 AlphaECP: Iteration procedure terminated normally ------------------------------------------------------------------------------- Problem : fuel.gms Solver Status : Normal Completion Model Status : Locally Optimal Exit comment : No Issues Final solution : NLP Objective value : 8566.1189616876672517 Max constraint (4) : 1.1368683772161602974e-13 Alternative solution : MIP Alt. objective value : 8566.1189616876672517 Max constraint (4) : 1.1368683772161602974e-13 Time used (seconds) : 0.81 Time limit (seconds) : 10000000000 Iterations used : 102 Iteration limit : -1 Function evaluations : 496 Gradient evaluations : 186 Domain violations : 0 Gradients unusable : 0 Alphamax bound violations : 0 ECP time usage : 3.9 % NLP time usage : 3.8 % MIP time usage : 92.3 % Optimal/total MIPs : 19/102 NLP solver calls : 8 -------------------------------------------------------------------------------

In every iteration, information about the MIP problem and modifications to it is given in 10 columns. Here is a description of the different columns:

**Iteration:** Iteration identifier.

**Stepcode, Problems:** Letter for what actions were taken in this iteration, i.e. MIP problem modifications before the next iteration.

A: MIP solver feasible.

B: MIP solver feasible after moving cutting planes, i.e. alpha update.

C: MIP solver feasible after moving cutting planes close to their generation point. The movement is done to make it easier to satisfy nonlinear equality constraints.

D: Line search was successful (in ECPstrategy

`3`

).E: Line search failed (in ECPstrategy

`3`

).F: A NLP solver was called.

G: Found a MINLP solution.

H: Added linearization(s) to the next MIP problem.

I: Updated alpha values and possibly added linearizations.

J: All cutting planes are valid underestimators for the pseudo-convex constraints, except for the nonlinear objective function constraint.

K: The nonlinear objective function constraint value and MIP solution value differ more than \(\epsilon_f\). A linearization was done to reduce the difference (in ECPstrategy

`3`

).

L: Removed all temporal linearizations.

M: Domain violation(s), some of the constraint could not be evaluated.

N: Some cutting plane(s) could not be generated because of gradient problems.

O: No cutting planes could be generated.

P: Reselecting cuts because cutting planes are repeatedly moved close to their generation point.

Q: Added temporal linearization(s).

R: Failed to add temporal linearization(s).

S: MIP solver strategy to find encountered solutions selected.

T: MIP solver strategy to require MIPnrsols solutions selected.

U: MIP solver strategy to require MIPnrsols solutions with a MIPoptcr <=

`0.2`

selected.

**Number of Cuts:** The number of cutting planes the solved MIP problem had.

**Point usage:** Number of points used to generate the cuts in the solved MIP problem.

**Alpha Upd.:** The number of times the alpha values has been increased.

**OPTCR:** Relative MIP gap. Note that this is different from TOLoptcr.

**Movement Norm:** The Euclidean norm of the current and previous MIP solution.

**Viol Cons:** Number of unsatisfied (violating) nonlinear constraints.

**Maximum Violation:** The most violating nonlinear constraint value.

**MIPobjval/NLobjval:** MIP or nonlinear objective variable value depending on ECPstrategy setting.

The cut reselection heuristic is called in the following cases:

- If the MIP solver would otherwise return infeasible.
- When the violation is not reducing, but the cutting planes are repeatedly moved close to their generation point.
- When the violation is not reducing and domain violations are repeatedly encountered.

The heuristic reselects cutting planes in different ways, but always ensures that the same point cannot be found twice.

Pointusage 6/90 Cutusage 15/341 ( 0,135 )

`Pointusage`

informs how many points of all usable points have been used to generate the cutting planes. `Cutusage`

tells how many cuts of all usable cuts have been used. The first number in `( 0,135 )`

tells how many cuts is required by the user, see CUTnrcuts and the second number gives the sum of added and removed cuts, i.e. a measure of how much the MIP problem has been modified. AlphaECP may fix some cuts and remove points and cuts during the cut reselection procedure in order to save memory.

At the end of each solve AlphaECP gives a summary which includes Problem, Solver Status, Model Status, etc. Note the following lines:

**Exit comment**may give further information than solverstatus on why the solution procedure stopped.**Domain violations**(function evaluation failed) or**Gradients unusable**(all gradients < TOLgrad) might be caused by poor variable bounds.**Alphamax bound violations**inform the user how many times an alphamax value was calculated to be \(> 10^{154}\) and was reset to \(10^{154}\).

# Notes about Options

To instruct AlphaECP to read an option file you may use **ModelName.OptFile = 1**. The name of the option file is in this case `alphaecp.opt`

. For further information, see The Solver Options File. AlphaECP supports the GAMS parameters reslim and optCR, however, other GAMS parameters are passed on to the sub-solvers. Note that optCR is transferred to option TOLoptcr. Furthermore, you may also pass additional sub-solver specific options to the sub-solvers. For example, if you want to use all available threads and sub-solver CPLEX in opportunistic parallel search mode, then you may specify this in a GAMS model, in a similar way, as follows:

Model m / all /; Option threads=0; m.optfile=1; $echo MIPsolver cplex.1 > alphaecp.opt $echo parallelmode -1 > cplex.opt Solve m using MINLP minimizing objvar;

The following information is worth noting when you are interested in AlphaECP options. A linearization of a nonlinear constraint is called a cutting plane or cut. Here a point refers to the variable levels. Global optimality can be guaranteed for pseudo-convex problems. However, if the objective variable is in a nonlinear constraint and pseudo-convex, then ECPstrategy >= 3 needs to be used to guarantee global optimality (because one non-linear equality constraint makes a problem non-pseudo-convex, and hence also non-convex). The basic options might significantly impact the solution procedure, and the best values are likely to be problem specific. The user is therefore encouraged to try different values for the basic options.

# Summary of AlphaECP Options

## Basic options

Option | Description | Default |
---|---|---|

CUTnrcuts | Cut generation pace | `0` |

ECPmaster | Master strategy (0=User 1=Convex) | `0` |

MIPnrsols | Upper limit of considered MIP solutions per MIP call | `50` |

MIPsolstrat | MIP solution collection strategy | `1` |

MIPsolver | MIP solver for sub-problems and . option file number | `GAMS MIP solver` |

NLPsolver | NLP solver for sub-problems and . option file number | `GAMS NLP solver` |

reslim | Time limit for AlphaECP (in seconds) | `GAMS reslim` |

## Algorithmic options for advanced users

Option | Description | Default |
---|---|---|

CUTdelcrit | Cutting plane strategy | `3` |

ECPbeta | Updating multiplier if MIP is infeasible | `1.3` |

ECPdumpsol | Write encountered solutions to gdx files | `0` |

ECPgamma | Updating multiplier when verifying solution | `2.0` |

ECPiterlim | Maximum number of AlphaECP iterations | `-1` |

ECPloglevel | Level of AlphaECP output to statusfile | `0` |

ECPpcostrategy | Pseudo-convex objective function strategy | `3` |

ECPretsol | Return solution (1.MIP/2.NLP/3.QUALITY/4.PERFORMANCE) | `2` |

ECPstart | User specified start-point | `3` |

ECPstrategy | AlphaECP strategy | `2` |

ECPtoltype | AlphaECP termination criterion | `1` |

solvelink | Solvelink for NLP and MIP sub-solver | `5` |

solvetrace | Filename of solvetrace file | |

solvetracetime | Time interval when a trace record is written | `1` |

TOLepsf | Pseudo-convex objective function termination tolerance | `1e-3` |

TOLepsg | Constraint tolerance | `1e-3` |

TOLepsz | Distance tolerance for a new linearization | `1e-1` |

TOLgrad | Gradient tolerance | `1e-6` |

TOLinfbnd | Infinity bound (MIP variable bound) | `1e10` |

TOLoptcr | Relative termination tolerance for MINLP | `GAMS optCR` |

## MIP Solver related options

Option | Description | Default |
---|---|---|

MIPloglevel | Level of MIP solver output | `0` |

MIPoptcr | Relative MIP gap in intermediate sub-problems | `1.0` |

MIPoptcrlim | Initial iteration limit when MIPoptcr is reduced | `200` |

MIPoptcrlimtype | Strategy to increase MIPoptcrlim | `0` |

MIPoptimaliter | MIP is solved to optimality with this frequency | `0` |

## NLP Solver related options

Option | Description | Default |
---|---|---|

NLPcall | NLP strategy | `5` |

NLPcalliter | NLP solver call at next (incremental) iteration | `0` |

NLPlimsameint | NLP call after a number of recurring integer solutions | `5` |

NLPloglevel | Level of NLP solver output | `0` |

NLPreslim | NLP time limit per call | `0` |

# Detailed Descriptions of AlphaECP Options

**CUTdelcrit** *(integer)*: Cutting plane strategy ↵

Default:

`3`

value meaning `0`

Do not remove any valid cuts. `1`

As 0 and allow temporary cuts at semirandom points if normal cuts can not be made. `2`

Allow temporary cuts and cut reselection, and use memory to save points and cuts. `3`

As 2 and call the reselection heuristic before termination to improve the solution.

**CUTnrcuts** *(real)*: Cut generation pace ↵

The number of linearizations that are generated during an iteration can be chosen by AlphaECP, proportional to the number of violating constraints, or can be determined by a fixed amount. Furthermore, the cut reselection CUTdelcrit >=2 adds cuts to the problem so that the requested cut generation pace is taken into consideration.

Default:

`0`

value meaning `0`

Let AlphaECP decide. `0<n<1`

Number of linearizations = n* the number of linearizations that is possible to generate. `>1`

Specifies the number of linearizations to generate.

**ECPbeta** *(real)*: Updating multiplier if MIP is infeasible ↵

In case of an infeasible MIP solution, the invalid cuts are updated with the ECPbeta multiplier.

Range: [

`1.001`

, ∞]Default:

`1.3`

**ECPdumpsol** *(integer)*: Write encountered solutions to gdx files ↵

Default:

`0`

value meaning `0`

No. `1`

Solutions that the NLP solver found. `2`

Solutions that the NLP or MIP solver found.

**ECPgamma** *(real)*: Updating multiplier when verifying solution ↵

If a MINLP solution is obtained but some cuts are not valid underestimators they are updated with the ECPgamma multiplier in order to make them into valid underestimators.

Range: [

`1.001`

, ∞]Default:

`2.0`

**ECPiterlim** *(integer)*: Maximum number of AlphaECP iterations ↵

This is the maximum number of iterations given to AlphaECP to perform the optimization. Value -1 deactivates the AlphaECP iteration limit.

Default:

`-1`

value meaning `-1`

No limit. `>=0`

Specifies an iteration limit.

**ECPloglevel** *(integer)*: Level of AlphaECP output to statusfile ↵

Default:

`0`

value meaning `0`

No additional output to statusfile. `1`

Report solutions.

Report all encountered solutions with their corresponding variable levels.`2`

Report main actions at iteration level

(available for minimization problems).`3`

Report main actions at linearization level

(available for minimization problems).`4`

Full reporting.

Report the main actions taken, the linearizations, function values, and solution points for every iteration and line search details (available for minimization problems).

**ECPmaster** *(integer)*: Master strategy (0=User 1=Convex) ↵

The master strategy sets some options in order to solve a model with specific characteristics more efficiently. The affected options are noted in the log output. The set options takes precedence over the value set by the user for the affected options.

Default:

`0`

value meaning `0`

Use only user defined options. `1`

The model is convex. Set option ECPstrategy, CUTdelcrit and ECPtoltype.

**ECPpcostrategy** *(integer)*: Pseudo-convex objective function strategy ↵

Default:

`3`

value meaning `1`

Remove support.

Remove old support planes when a new pseudo-convex problem is formed.`2`

Replace support.

Replace old support planes with linearizations of the reduction constraint when a new pseudo-convex problem is formed.`3`

Remove support and line search.

Remove old support planes when a new pseudo-convex problem is formed and perform a line search when it is possible.`4`

Replace support and line search.

Replace old support planes with linearizations of the reduction constraint when a new pseudo-convex problem is formed and perform a line search when it is possible.

**ECPretsol** *(integer)*: Return solution (1.MIP/2.NLP/3.QUALITY/4.PERFORMANCE) ↵

The reported solution can be extracted from either the MIP or NLP solver result. If the MIP solution is returned only the primal values are available.

Default:

`2`

value meaning `1`

Choose MIP solution if it is available. `2`

Choose NLP solution if it is available. `3`

Choose the solution with the best tolerance. `4`

Choose the solution with the best objective value.

**ECPstart** *(integer)*: User specified start-point ↵

Define which variable levels are used when the optimization is started.

Default:

`3`

value meaning `0`

Do not use a start-point; start the algorithm by solving the linear part (MIP) of the problem. `1`

Use the user specified startpoint, but adjust the variable levels with a small value. `2`

Use the exact start-point set by the user. `3`

Use the exact start-point if linearly feasible; else adjust variable levels with a small value.

**ECPstrategy** *(integer)*: AlphaECP strategy ↵

Default:

`2`

value meaning `1`

Convex strategy.

Ensures global optimality for problems with convex objective function and convex constraints.`2`

Pseudo-convex constraints.

Ensures global optimality for problems with convex objective function and pseudo-convex constraints.`3`

Pseudo-convex objective.

Ensures global optimality for problems with pseudo-convex objective function and pseudo-convex constraints. The reformulation of a non-linear objective function into a constraint must be done in a specific way. The requirement is that the objective variable must be in a linear part of the non-linear function. Assuming that the minimized or maximized variable is called objvar, the reformulation can be done as follows: (objective function expression) - objvar =E= 0. Furthermore, this strategy can effectively use a feasible start-point.`4`

Pseudo-convex objective, but first complete with ECPstrategy 2.

(Only the necessary linearizations are removed when the ECPstrategy is changed.)`5`

Pseudo-convex objective, but find the first solution with ECPstrategy 2.

(Only the necessary linearizations are removed when the ECPstrategy is changed.)

**ECPtoltype** *(integer)*: AlphaECP termination criterion ↵

Default:

`1`

value meaning `1`

Use termination based on tolerances TOLepsg and TOLepsf. `2`

Terminate also if relative objective gap is satisfied according to TOLoptcr.

The relative objective gap termination criterion also called relative termination criterion is only supported for convex problems when using ECPstrategy=1. The relative termination criterion can be used for non-convex problems, as well as, with ECPstrategy=2, however, in this case it may not work properly because the lower bound may be invalid.

**MIPloglevel** *(boolean)*: Level of MIP solver output ↵

By default the detailed log of the MIP solver is suppressed in the AlphaECP log stream. If this option is turned on and the GAMS

`LogOption`

is set to 1 or 3, the MIP log will be merged into the AlphaECP log.Default:

`0`

value meaning `0`

No output. `1`

MIP solver log goes to GAMS log.

**MIPnrsols** *(integer)*: Upper limit of considered MIP solutions per MIP call ↵

When the MIP solver returns several solutions the most suitable solution is chosen. Many times the solutions from the MIP solver are similar and a larger number might help to find a feasible MINLP solution if the constraints are almost satisfied. See MIPsolstrat to change the solution collection strategy.

Range: {

`1`

, ..., ∞}Default:

`50`

**MIPoptcr** *(real)*: Relative MIP gap in intermediate sub-problems ↵

The relative stopping tolerance sent to the MIP solver for intermediate MIP problems. Note that the MIPoptcr value is decreased automatically to zero during the optimization.

Range: [

`0`

,`1`

]Default:

`1.0`

**MIPoptcrlim** *(integer)*: Initial iteration limit when MIPoptcr is reduced ↵

The MIPoptcr parameter is reduced in steps: From 1 to 0.5 to 0.3 to 0.2 to 0.1 to 0.0. The first reduction is at iteration

`MIPoptcrlim`

. The following reductions occur also at iteration`MIPoptcrlim`

but it is updated with a strategy defined by parameter MIPoptcrlimtype. Note that a step reduction may happen for other reasons.Range: {

`1`

, ..., ∞}Default:

`200`

**MIPoptcrlimtype** *(integer)*: Strategy to increase MIPoptcrlim ↵

Default:

`0`

value meaning `0`

Exponential increase of MIPoptcrlim.

The parameter MIPoptcrlim is increased by multiplying it by 2. The increase occurs at iteration "MIPoptcrlim". If MIPoptcrlim=200 it will have values 200,400,800 etc.`1`

Linear increase of MIPoptcrlim.

The parameter MIPoptcrlim is increased by adding the original value of MIPoptcrlim to it. If MIPoptcrlim=200 it will have values 200,400,600 etc.

**MIPoptimaliter** *(integer)*: MIP is solved to optimality with this frequency ↵

Defines the frequency to solve the MIP problem to optimum before the algorithm sets MIPoptcr=0 and, hence, solves MIP problems to optimum. For example if

`MIPoptimaliter`

=n, then at least every nth iteration the MIP problem is solved to the optimum. Solving MIP problem to optimum yields a lower bound for a convex MINLP problem which can help to terminate the algorithm faster if ECPtoltype=2 is used. Non-default value is not recommended for non-convex problems nor if ECPstrategy >1.Default:

`0`

value meaning `0`

Never. `n>0`

Every nth iteration, where n is the given value.

**MIPsolstrat** *(integer)*: MIP solution collection strategy ↵

Default:

`1`

value meaning `0`

Instruct MIP solver to return only one solution. `1`

Instruct MIP solver to return any solutions encountered during MIP procedure. `2`

Instruct MIP solver to search for solutions to obtain requested number MIPnrsols solutions. `3`

As 2, but also require the solutions to fulfill MIPoptcr >= 0.2. `4`

Let AlphaECP decide.

**MIPsolver** *(string)*: MIP solver for sub-problems and . option file number ↵

`solver[.n]`

Solver is the name of the GAMS MIP solver and`n`

is the integer corresponding to optfile. The option file is appended to the option file, that is written by AlphaECP. Hence, the specified options take precedence over the options set by AlphaECP. If`.n`

is missing, the optfile is treated as zero i.e. the MIP solver will not look for a options file specified by the user. This option can be used to overwrite the default that uses the MIP solver specified with an`Option NLP = solver;`

statement or the default GAMS solver for NLP.Default:

`GAMS MIP solver`

**NLPcall** *(integer)*: NLP strategy ↵

Determine when the NLP solver is called.

Default:

`5`

value meaning `0`

No output. `1`

Call the NLP solver at end of AlphaECP algorithm. `2`

As 1 and when a better solution is found. `3`

As 2 and when the same integer solution is encountered NLPlimsameint times. `4`

Let AlphaECP decide. `5`

Let AlphaECP decide and add noise to the variable levels before call.

**NLPcalliter** *(integer)*: NLP solver call at next (incremental) iteration ↵

Specify an iteration interval for the NLP solver calls.

Default:

`0`

**NLPlimsameint** *(integer)*: NLP call after a number of recurring integer solutions ↵

If the same integer solution is encountered

`NLPlimsameint`

times in a row then the NLP solver is called. The counter is reset after the NLP solver is called.Range: {

`1`

, ..., ∞}Default:

`5`

**NLPloglevel** *(boolean)*: Level of NLP solver output ↵

By default the detailed log of the NLP solver is suppressed in the AlphaECP log stream. If this option is turned on and the GAMS

`LogOption`

is set to 1 or 3, the NLP log will be merged into the AlphaECP log.Default:

`0`

value meaning `0`

No output. `1`

NLP solver log goes to GAMS log.

**NLPreslim** *(real)*: NLP time limit per call ↵

The time limit (in seconds) given to the chosen NLP solver at each NLP solver call. Setting this option to 0 calculates a time limit which is relative to the problem size.

Default:

`0`

**NLPsolver** *(string)*: NLP solver for sub-problems and . option file number ↵

`solver[.n]`

Solver is the name of the GAMS NLP solver that should be used in the root node, and`n`

is the integer corresponding to optfile. If`.n`

is missing, the optfile is treated as zero, i.e., the NLP solver will not look for an options file. This option can be used to overwrite the default that uses the NLP solver specified with an`Option NLP = solver;`

statement or the default GAMS solver for NLP.Default:

`GAMS NLP solver`

**reslim** *(real)*: Time limit for AlphaECP (in seconds) ↵

Default:

`GAMS reslim`

**solvelink** *(integer)*: Solvelink for NLP and MIP sub-solver ↵

Default:

`5`

value meaning `1`

Call NLP and MIP solver via script. `2`

Call NLP and MIP solver via module. `5`

Call NLP and MIP solver in memory.

**solvetrace** *(string)*: Filename of solvetrace file ↵

**solvetracetime** *(real)*: Time interval when a trace record is written ↵

Default:

`1`

**TOLepsf** *(real)*: Pseudo-convex objective function termination tolerance ↵

Maximum allowed absolute difference between the nonlinear and the MIP objective function value (used only in ECPstrategy 3).

Range: [

`1e-20`

,`1`

]Default:

`1e-3`

**TOLepsg** *(real)*: Constraint tolerance ↵

The nonlinear constraint tolerance defines the maximum value that a nonlinear constraint may violate. For example, a constraint required to be zero may hold a value +/-

`TOLepsg`

at a solution.Range: [

`1e-20`

,`1`

]Default:

`1e-3`

**TOLepsz** *(real)*: Distance tolerance for a new linearization ↵

The maximum perpendicular distance between a valid cutting plane and its generation point (MIP solution).

Range: [

`1e-20`

,`1`

]Default:

`1e-1`

**TOLgrad** *(real)*: Gradient tolerance ↵

The absolute value of a gradient's partial derivative must be above

`TOLgrad`

value in order for it to be considered nonzero.Range: [

`1e-20`

,`1`

]Default:

`1e-6`

**TOLinfbnd** *(real)*: Infinity bound (MIP variable bound) ↵

All variables must have a positive and a negative finite bound in order to ensure a bounded MIP problem. The finite bound value

`TOLinfbnd`

will be applied to single or double unbounded variables.Default:

`1e10`

**TOLoptcr** *(real)*: Relative termination tolerance for MINLP ↵

The relative objective gap termination criterion is satisfied if |UB-LB|/ (10E-12+max(|LB|,|UB|)) <

`TOLoptcr`

, where UB is the current best upper bound and LB is the current best lower bound. Upper bounds are obtained from solving NLP problems and lower bounds are obtained from lower bounds of MIP problems. If the inequality holds true and ECPtoltype=2, the algorithm terminates.Range: [

`1e-20`

, ∞]Default:

`GAMS optCR`

# FAQ

- What are good settings to solve a convex problem?
Use ECPmaster

`1`

. - What are good settings if the solution speed is essential?
Try ECPstrategy

`1`

and CUTdelcrit`1`

to see if using multiple threads for the MIP solver improves the solution speed. However, there is considerable chance that a feasible solution for a non-convex problem with nonlinear equality constraints cannot be found. - What are good settings when the solution quality is essential?
Use NLPcalliter

`1`

and MIPsolstrat`4`

or`3`

, and also try different values, for CUTnrcuts option, for example`0.1`

. - The objective function is non-linear, should the default ECPstrategy be used?
If the objective function constraint can be written in the required form of ECPstrategy

`3`

then this strategy may find a better solution. If the constraints and the objective function are pseudo-convex the global optimal solution will be found.