Author

Tapio Westerlund (twesterl@abo.fi) and Toni Lastusilta. Åbo Akademi University, Finland

Ville-Pekka Eronen. University of Turku, Finland

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 [104] . 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 [198] and [144, 173, 197, 199] .

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:

1. If the MIP solver would otherwise return infeasible.
2. When the violation is not reducing, but the cutting planes are repeatedly moved close to their generation point.
3. 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

Algorithmic options for advanced users

MIP Solver related options

NLP Solver related options

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