A review and comparison of solvers for convex MINLP
 2.8k Downloads
 4 Citations
Abstract
In this paper, we present a review of deterministic software for solving convex MINLP problems as well as a comprehensive comparison of a large selection of commonly available solvers. As a test set, we have used all MINLP instances classified as convex in the problem library MINLPLib, resulting in a test set of 335 convex MINLP instances. A summary of the most common methods for solving convex MINLP problems is given to better highlight the differences between the solvers. To show how the solvers perform on problems with different properties, we have divided the test set into subsets based on the continuous relaxation gap, the degree of nonlinearity, and the relative number of discrete variables. The results also provide guidelines on how well suited a specific solver or method is for particular types of MINLP problems.
Keywords
Convex MINLP MINLP solver Solver comparison Numerical benchmark1 Introduction
Mixedinteger nonlinear programming (MINLP) combines the modeling capabilities of mixedinteger linear programming (MILP) and nonlinear programming (NLP) into a versatile modeling framework. By using integer variables, it is possible to incorporate discrete decisions, e.g., to choose between some specific options, into the optimization model. Furthermore, by using both linear and nonlinear functions it is possible to accurately model a variety of different phenomena, such as chemical reactions, separations, and material flow through a production facility. The versatile modeling capabilities of MINLP means there are a wide variety of realworld optimization problems that can be modeled as MINLP problems, e.g., block layout design problems (Castillo et al. 2005), cancer treatment planning (Cao and Lim 2011), design of water distribution networks (Bragalli et al. 2012), portfolio optimization (Bonami and Lejeune 2009), nuclear reactor core fuel reloading (Quist et al. 1999), process synthesis (Grossmann et al. 1999), pooling problems in the petrochemical industry (Misener and Floudas 2009), and production planning (Sahinidis and Grossmann 1991). More of MINLP applications are described by, e.g., Floudas (1995), Biegler and Grossmann (2004), Boukouvala et al. (2016) and Trespalacios and Grossmann (2014). For a recent review on MINLP methods see D’Ambrosio and Lodi (2013) and Bonami et al. (2012).
MINLP is often considered as a “difficult” class of optimization problems. However, there has been significant progress in the field during the last twenty years and there are several good solvers for MINLP problems available today (Bussieck and Vigerske 2010). Here we will focus on convex MINLP, which is a specific subclass with some desirable properties, e.g., it is possible to decompose a convex MINLP problem into a finite sequence of tractable subproblems. An MINLP problem is often considered as convex when its continuous relaxation yields a convex NLP problem. In recent years there has been significant progress within the field of MILP and NLP (Achterberg and Wunderling 2013; Bazaraa et al. 2013) which is also reflected onto the field of MINLP since decomposition techniques for MINLP problems often rely on solving these types of subproblems. It is also possible to solve certain classes of nonconvex MINLP problems, such as problems with signomial or general twicedifferentiable constraints, by reformulating them into convex MINLP problems (Pörn et al. 1999; Lundell et al. 2009; Lundell and Westerlund 2017; Nowak et al. 2018), further motivating the study of efficient methods for convex MINLP.
The intention of this paper is to give an overview of commonly available deterministic solvers for convex MINLP problems and to present a thorough numerical comparison of the most common solvers. Most optimization solvers are connected to one or more of the wellestablished modeling environments for MINLP optimization, such as, AIMMS (Bisschop 2006), AMPL (Fourer et al. 1993), and GAMS (Brook et al. 1988). In recent years, there has also been a growing interest in optimization modeling in Python and Julia (Bezanson et al. 2012); JuMP is a modeling environment for optimization embedded in Julia (Dunning et al. 2017), and Pyomo is a similar environment in Python (Hart et al. 2012). Several MINLP solvers also offer interfaces to MATLAB, and through OPTI Toolbox it is also possible to access several solvers in MATLAB (Currie et al. 2012).
The solvers considered in the numerical comparison are AlphaECP, Antigone, AOA, BARON, BONMIN, Couenne, DICOPT, Juniper, KNITRO, LINDO, Minotaur, Muriqui, Pavito, SBB, SCIP, and SHOT. These were chosen based on criteria like availability, active development, and support for a file format available in MINLPLib (MINLPLib 2018). Some of these are global solvers and therefore not limited to convex problems. However, most of the global solvers have convexity identification techniques or manual strategy settings that can be set by the user to allow them to more efficiently deal with convex problems. The convex solvers can also often be used as heuristic methods without guarantee for finding the optimal solution for nonconvex MINLP problems.
In Sect. 2, the convex MINLP problem is defined and a general overview of the most common algorithms for such problems are given in Sect. 3. Most solvers in the comparison utilize one or more of these solution methods, as described in Sect. 4, which contains a summary of the solvers considered. Section 5 describes the benchmark in detail, and the numerical results are, finally, presented in Sect. 6.
2 Convex MINLP problem formulation
3 Methods
This section describes the most commonly used algorithms for convex MINLP. The methods described are branch and bound, extended cutting plane, extended supporting hyperplane, outer approximation, generalized Benders decomposition, and LP/NLPbased branch and bound. This summary is not intended to give an indepth analysis of the algorithms, but to better exemplify the differences between the solvers. For a more detailed discussion about the algorithms see, e.g., D’Ambrosio and Lodi (2013), Belotti et al. (2013), Grossmann (2002), and Floudas (1995).
3.1 Branch and bound
Branch and bound (BB) was first presented as a technique for solving MILP problems by Land and Doig (1960). A few years later it was noted by Dakin (1965) that MINLP problems can be solved with a similar branch and bound approach, although the paper focused on linear problems. Solving convex MINLP problems with a BB approach was also studied by Gupta and Ravindran (1985).
In the basic form, BB solves the MINLP problem by relaxing the integer restrictions of the original problem and solving continuous (convex) NLP relaxations. Solving a continuous relaxation of problem (PMINLP) results in a solution \(({\mathbf {x}}^{k},{\mathbf {y}}^{k})\), which provides a valid lower bound. If all components of \({\mathbf {y}}^{k}\) take on integer values, then it is also an optimal solution to the MINLP problem. Otherwise, the continuous relaxation is divided (branched) into two new NLP subproblems by adding the constraints \(y_i \le {\lfloor }{ y_i^k}{\rfloor }\) and \(y_i \ge {\lceil }{ y_i^k}{\rceil }\) to the relaxed problem. The branching variable \(y_i\) is a variable that takes on a fractional value and usually chosen based on some criteria, e.g., the variable furthest away from an integer value. A new lower bound can be obtained by solving the new subproblems (child nodes), and in case one of the subproblems returns an integer solution it also provides a valid upper bound. The search procedure is often represented by a tree, where the nodes are connected to their parent node and represent the subproblems. If one of the nodes does not provide an integer solution, then it is branched into two new nodes creating two new subproblems. In case one of the nodes obtains an optimum worse than the upper bound or in case the subproblem is infeasible, then the node can be pruned since an optimal solution cannot exist in that part of the search space. This approach of solving convex NLP problems in each node is often referred to as NLPbased branch and bound (NLPBB).
Obtaining a tight continuous relaxation is of great importance within BB to avoid large search trees. Stubbs and Mehrotra (1999) presented a branch and cut method for convex MINLP problems that uses cutting planes to strengthen the continuous relaxation. Several techniques have been proposed for obtaining cuts to strengthen the continuous relaxation for MINLP problems, e.g., liftandproject cuts (Kılınç et al. 2017; Zhu and Kuno 2006; Balas et al. 1993), Gomory cuts (Çezik and Iyengar 2005; Gomory et al. 1958), and perspective cuts (Frangioni and Gentile 2006).
Compared to BB techniques for MILP problems, NLPBB involves computationally more demanding subproblems; it is often not unusual to explore more than 100,000 nodes for a modestsized problem! Techniques to efficiently integrate the NLP solver and not solving all subproblems to optimality have also been proposed by Borchers and Mitchell (1994) and Leyffer (2001). Another BB approach is to solve LP relaxations in the nodes and construct a polyhedral approximation of the nonlinear constraints. A polyhedral branch and cut technique, solving LP relaxations in the nodes, was presented by Tawarmalani and Sahinidis (2005).
Many important details on BB such as branching strategies have been left out for the sake of brevity. For more details on BB see, e.g., Bonami et al. (2011) and Floudas (2000).
3.2 Extended cutting plane
The extended cutting plane (ECP) algorithm was first presented by Westerlund and Petterson (1995), and can be seen as an extension of Kelley’s cutting plane method for convex NLP problems presented by Kelley (1960). In its original form the ECP method is intended for convex MINLP problems, and by some modifications, given the name generalized alpha ECP (GAECP), it can be applied to pseudoconvex problems as shown by Westerlund and Pörn (2002).
In the first iteration, the set \(\hat{N_0}\) can simply be defined as \({\mathbb {R}}^{n+m}\). New trial solutions are then obtained by solving subproblem (MILPk), and the procedure is repeated until a trial solution satisfies all the constraints within a given tolerance. Once a trial solution satisfies all nonlinear constraints it is also the optimal solution, since the solution was obtained by minimizing the objective within a set containing the entire feasible region. For more details on the ECP algorithm see, e.g., Westerlund and Petterson (1995) or Westerlund and Pörn (2002).
3.3 Extended supporting hyperplane
The extended supporting hyperplane (ESH) algorithm was presented by Kronqvist et al. (2016) as an algorithm for solving convex MINLP problems. The ESH algorithm uses the same technique as the ECP algorithm for obtaining trial solutions, but uses a different technique for generating the polyhedral outer approximation \(\hat{N_k}\). It has been observed that the cutting planes used to construct the polyhedral outer approximation in the ECP algorithm are, in general, not as tight as possible, see Kronqvist et al. (2016). By using a one dimensional root search, the ESH algorithm is able to obtain supporting hyperplanes to the set N at each iteration, and use these to construct a polyhedral outer approximation \(\hat{N_k}\).
Similar to the ECP algorithm, the trial solutions \(\left( {\mathbf {x}}^k_\text {MILP},{\mathbf {y}}^k_\text {MILP}\right)\) are obtained by solving problem (MILPk). These solutions provide a valid lower bound on the optimal solution of problem (PMINLP). However, they will not be directly used to construct the set \(\hat{N_k}\) as in the ECP method.
The ESH algorithm also uses a preprocessing step to obtain supporting hyperplanes of the set N by solving linear programming (LP) relaxations. The procedure of solving MILP subproblems and generating supporting hyperplanes is repeated until a trial solution satisfies all nonlinear constraints. The tighter polyhedral outer approximation usually gives the ESH algorithm an advantage over the ECP algorithm. It has been shown in Eronen et al. (2017), that the ESH algorithm can also be successfully applied to nonsmooth MINLP problems with pseudoconvex constraint functions.
3.4 Outer approximation
The outer approximation (OA) method was first presented by Duran and Grossmann (1986), with additional properties for convex MINLP problems described in Fletcher and Leyffer (1994). Some modifications of the OA method have been presented to handle nonconvex problems more efficiently, see, e.g., Kocis and Grossmann (1988) and Viswanathan and Grossmann (1990). For more details on the basic convex approach discussed in this paper see, e.g., Grossmann (2002).
OA is a decomposition technique, which obtains the optimal solution of the original problem by solving a sequence of MILP and NLP subproblems. Similar to both ECP and ESH, OA also constructs an iteratively improving polyhedral outer approximation \(\hat{N_k}\) of the nonlinear feasible region defined by the set N. However, OA only uses the polyhedral approximation for choosing the integer combination \({\mathbf {y}}^k\), while the corresponding continuous variables \({\mathbf {x}}^k\) are chosen by solving a convex NLP subproblem.
The OA algorithm is usually initiated by solving a continuous relaxation of the MINLP problem, giving an initial lower bound and a solution that can be used to construct the polyhedral approximation \(\hat{N_0}\) (Viswanathan and Grossmann 1990). It is also possible to use integer cuts to exclude specific integer combinations, as suggested by Duran and Grossmann (1986). Solving the MILP master problems (MILPk) provides a lower bound on the optimum, and the procedure is repeated until the upper and lower bound is within a given tolerance.
In general, OA results in tighter polyhedral outer approximations than the ECP algorithm, and may, therefore, require fewer iterations. For a feasible integer combination, OA will in general result in a tighter polyhedral outer approximation than ESH, but for an infeasible integer combination, ESH can give a tighter approximation. OA may thus require fewer iterations than both ESH and ECP to solve certain problems. However, since each iteration is somewhat more computationally demanding, the methods are difficult to compare directly.
3.5 Generalized Benders decomposition
Generalized Benders decomposition (GBD) was first presented by Geoffrion (1972) and is a generalization of Benders decomposition, a partitioning procedure for solving MILP problems (Benders 1962). As noted by Quesada and Grossmann (1992), GBD is closely related to OA and the main difference is the derivation of the master problem. In GBD, the master problem is projected onto the space defined by the integer variables and the master problem is, thus, only expressed in the integer variables. Here we will not present the full derivation of GBD, but use the same approach as Grossmann (2002) to derive the master problem. For more details on GBD see, e.g., Grossmann and Kravanja (1997) or Floudas (1995).
Since the cuts obtained by equations (6) and (7) can be viewed as surrogate cuts of the linear constraints included in the OA master problem, GBD generates weaker cuts than OA at each iteration and usually requires more iterations to solve a given problem. However, the master problems in GBD may be easier to solve since they contain fewer variables compared to OA and only one cut is added in each iteration.
A compromise between OA and GBD has been proposed by Quesada and Grossmann (1992), where the continuous variables are classified into linear or nonlinear based on how they are involved in the original MINLP problem. By projecting out the nonlinear continuous variables, one can derive a Lagrangean cut in a similary way as with GBD while still retaining the linear constraints involving continuous variables in the master problem. The given method has been coined as partial surrogate cuts (PSC), and as proved in Quesada and Grossmann (1992), it results in a tighter linear relaxation compared to GBD while still only adding one cut per iteration.
3.6 LP/NLPbased branch and bound
When solving a convex MINLP problem with either ECP, ESH, GBD or OA, most of the total solution time is usually spent on solving the MILP subproblems. The MILP problems are also quite similar in consecutive iterations since they only differ by a few linear constraints. To avoid constructing many similar MILP branch and bound trees, Quesada and Grossmann (1992) presented a method which integrates OA within BB, called LP/NLPbased branch and bound (LP/NLPBB). The main idea is to only construct one branch and bound tree, where the MILP master problem is dynamically updated.
An initial polyhedral outer approximation is constructed by solving a continuous relaxation and linearizing the constraints at the relaxed solution, as in OA. The polyhedral outer approximation is used to construct the first MILP master problem and the branch and bound procedure, where an LP relaxation is solved in each node, is initiated. Once an integer solution is obtained at a given node, the integer combination is used as in OA. If the NLP problem (NLPfixed) with the given integer combination is feasible, it provides an upper bound and new linearizations are generated. If it is infeasible, new linearizations can be obtained by solving the feasibility problem (NLPfeasibility). The new linearizations are then added to all open nodes, and the LP relaxation is resolved for the node which returned the integer combination. The branch and bound procedure continues normally by solving LP relaxations, which now give a more accurate approximation of the nonlinear constraints. Here, the search must continue down each node until either the LP relaxation returns an integer solution that satisfies all nonlinear constraints, the LP relaxation obtains an objective value worse than the upper bound, or until the LP relaxation becomes infeasible. As in normal BB, a lower bound is provided by the lowest optimal solution of the LP relaxations in all open nodes, and the search continues until the upper and lower bounds are within a given tolerance. The LP/NLPBB procedure, thus, only generates a single branch and bound tree, and is sometimes referred to as a singletree OA.
Numerical results have shown that LP/NLPBB technique can result in significantly fewer nodes than the total number of nodes explored in the multiple MILP master problems in OA (Duran and Grossmann 1986; Leyffer 1993). Implementations of the LP/NLPBB algorithm have shown promising results, cf. Abhishek et al. (2010), Bonami et al. (2008) or Mahajan et al. (2017).
3.7 Solver enhancement techniques
Most solvers are not based on a single algorithm but combines several techniques to improve its performance. In this section, we briefly describe some preprocessing techniques and primal heuristics that can be integrated with all the previously mentioned methods to improve the practical performance. Other important techniques to improve the performance include various cutting planes as well as different branching rules. For more details on cutting planes for convex MINLP see, e.g., Belotti et al. (2013), Bonami (2011) and (Kılınç et al. 2017). Overviews of branching rules are given by Linderoth and Savelsbergh (1999) and Achterberg et al. (2005).
3.7.1 Preprocessing
Preprocessing includes various techniques for modifying the problem into a form more favorable for the actual solver. The preprocessing procedures can result in tighter relaxations or reduce the problem size. Belotti et al. (2013) classified MINLP presolving techniques into two major categories: housekeeping and reformulations. Housekeeping includes techniques such as bound tightening and removal of redundant constraints, while reformulations can include techniques such as improvement of coefficients in the constraints and disaggregation of constraints.
There are two main approaches for tightening the variable bounds, feasibilitybased bound tightening (Shectman and Sahinidis 1998; Belotti et al. 2010), and optimizationbased bound tightening (Liberti and Maculan 2006). Feasibilitybased bound tightening analyzes the constraints sequentially to improve the variable bounds, whereas optimizationbased bound tightening solves a sequence of relaxed problems where each individual variable is maximized and minimized to obtain optimal bounds.
By reformulating the original problem, it is in some cases possible to obtain significantly tighter relaxations. Within MILP it is well known that different problem formulations can result in a tighter or weaker continuous relaxations; the uncapacitated facility location problem is a good example of when disaggregation of some constraints leads to a tighter continuous relaxation (Wolsey 1998). Similar techniques can also be used to obtain tighter relaxations for MINLP problems. Some types of nonlinear constraints can also be disaggregated to obtain a lifted reformulation of the problem, where the nonlinear constraint is split into several constraints by the introduction of new variables. Such lifted reformulations were proposed by Tawarmalani and Sahinidis (2005), where it was shown that a lifted reformulation results in tighter polyhedral outer approximations. In a recent paper by Kronqvist et al. (2018b), it was shown that the performance of several MINLP solvers, based on ECP, ESH, and OA, could be drastically improved by utilizing a reformulation technique based on lifting. Lifted reformulations of MINLP problems have also been studied by Hijazi et al. (2013), and Lubin et al. (2016). Some further reformulation techniques for MINLP problems are also presented in Liberti (2009).
3.7.2 Primal heuristics
Primal heuristics is a common term for algorithms and techniques intended to obtain good feasible solutions with relatively little computational effort compared to solving the original problem. The use of primal heuristics began in the field of MILP, and for instance Fischetti and Lodi (2011) claimed that primal heuristics were one of the most important improvements in MILP solvers within the last decade. In recent years, there has also been an interest in primal heuristics for MINLP problems and several algorithms have been proposed for this task. Such algorithms are, e.g., undercover (Berthold and Gleixner 2014), feasibility pumps (Bonami et al. 2009), rounding heuristics (Berthold 2014b), and the centercut algorithm (Kronqvist et al. 2018a). Another technique for obtaining feasible solutions in solvers based on ECP, ESH or OA, is to check the alternative solutions in the solution pool provided by the MILP solver (Kronqvist et al. 2016). A detailed summary of several primal heuristics for MINLP problems is given by Berthold (2014a) and D’Ambrosio et al. (2012).
Finding a good feasible solution to an MINLP problem can improve the performance of MINLP solvers, as shown by the numerical results in Berthold (2014a) and Bernal et al. (2017). Having a good feasible solution can, e.g., reduce the size of the search tree in BBbased solvers and provide a tight upper bound. Obtaining a tight upper bound is especially important in solvers based on the ECP or ESH algorithm, because neither of the algorithms will in their basic form obtain a feasible solution before the very last iteration.
4 Solvers
This section is intended as an introduction to commonly available MINLP solvers, and to describe their main properties. Most of the solvers are not based on a single “pure” algorithm but they combine several techniques and ideas to improve their performance. On top of this, MINLP solver technology has evolved from the more mature NLP and MILP fields, and most MINLP solvers rely heavily on such subsolvers. Among the MILP solvers, the most recognized commercial solvers are CPLEX (IBM ILOG CPLEX Optimization Studio 2017), Gurobi (Gurobi 2018), and XPRESS (FICO 2017). The solvers GLPK (Makhorin 2008) and Cbc (Forrest 2005), the latter is a part of the COINOR initiative (LougeeHeimer 2003), and are among the most recognized opensource solvers for MILP. All of these solvers implement an arsenal of methods within a branch and cut framework. In the NLP case, solvers like CONOPT (Drud 1994), Knitro (Byrd et al. 2006), Mosek (Andersen and Andersen 2000), and SNOPT (Gill et al. 2005) are wellknown commercial options, and IPOPT (Wächter and Biegler 2006) is a wellknown opensource solver (also part of the COINOR initiative). There exists more variability in the algorithms behind NLP solvers, e.g., CONOPT implements a Generalized Reduced Gradient (GRG) method, while IPOPT, Knitro, and Mosek use an interiorpoint method, and SNOPT uses a sequential quadratic programming (SQP) approach; see Biegler (2010) for a review in NLP.
Besides convexity, some of the solvers mentioned here also require an algebraic formulation of the problem. By analyzing the problem structure and applying different reformulations for instance it is, e.g., possible to obtain tighter relaxations. Furthermore, some of the NLP solvers also require the nonlinear functions to be twice continuously differentiable to guarantee convergence, which in turn imposes additional restrictions on some of the MINLP solvers.
In this section, we only mention the main features of the solvers, and for more details see the references given in the solver sections. A summary of solvers and software for MINLP problems was previously also given by Bussieck and Vigerske (2010). The solvers are implemented in a variety of programming languages, either available as standalone executables or libraries accessible from algebraic modeling software like GAMS, AMPL, and AIMMS. Other solvers have been implemented directly in the same programming languages as their modeling systems, e.g., MATLAB, PythonPyomo, JuliaJuMP. The solvers used in the numerical comparison are listed in alphabetical order below.
4.1 AlphaECP
 License type:

Commercial
 Interfaces:

GAMS, NEOS
 URL:
4.2 ANTIGONE
 License type:

Commercial
 Interfaces:

GAMS, NEOS
 URL:
4.3 AOA
 License type:

Commercial (source code available)
 Interfaces:

AIMMS
 URL:
4.4 BARON
 License type:

Commercial
 Interfaces:

Standalone; AIMMS, AMPL, GAMS, JuMP, MATLAB, NEOS, Pyomo, YALMIP
 URL:
4.5 BONMIN
 License type:

Opensource (EPL 1.0)
 Interfaces:

Standalone; AMPL, C++, GAMS, JuMP, MATLAB, NEOS, OS, Pyomo, YALMIP
 URL:
4.6 Couenne
 License type:

Opensource (EPL 1.0)
 Interfaces:

Standalone; AMPL, C++, GAMS, JuMP, NEOS, OS, Pyomo
 URL:
4.7 DICOPT
 License type:

Commercial
 Interfaces:

GAMS, NEOS
 URL:
4.8 Juniper
 License type:

Opensource (MIT)
 Interfaces:

JuMP
 URL:
4.9 Knitro
 License type:

Commercial
 Interfaces:

AIMMS, AMPL, C++, C#, Fortran, Java, JuMP, GAMS, NEOS, Pyomo, Python, YALMIP
 URL:
4.10 LINDO
 License type:

Commercial
 Interfaces:

C, C++, Delphi, Excel/What’s Best!, Fortran, Java, JuMP, GAMS, LINGO, MATLAB, NEOS, .NET, Ox, Python, R
 URL:
4.11 Minotaur
 License type:

Opensource
 Interfaces:

Standalone; AMPL, C++
 URL:
4.12 Muriqui
 License type:

Opensource (MIT)
 Interfaces:

Standalone; AMPL, C++
 URL:
4.13 Pavito
 License type:

Opensource (MPL 2.0)
 Interfaces:

JuMP
 URL:
4.14 SBB
 License type:

Commercial
 Interfaces:

GAMS, NEOS
 URL:
4.15 SCIP
 License type:

Free for academic use (ZIB academic license); commercial
 Interfaces:

Standalone; AMPL, C, GAMS, JuMP, MATLAB, NEOS, Java, Pyomo, Python
 URL:
4.16 SHOT
 License type:

Opensource (EPL 2.0)
 Interfaces:

Standalone; C++, GAMS
 URL:
4.17 Other MINLP solvers
Besides the solvers mentioned above, there are a few others solvers capable of solving convex MINLP problems that the authors are aware of. It should be noted that the solvers left out of the numerical comparison are not necessarily inferior compared to the other solvers. These solvers have been left out of the comparison due to one of the following reasons: not publicly available, not maintained within the last years, or not able to read the problem formats available in MINLPlib.
bnb is a MATLAB implementation of NLPBB by K. Kuipers at the University of Groningen. The solver uses the fmincon routine in MATLAB’s Optimization Toolbox for solving the integer relaxed subproblems. The MATLAB code for the solver can be downloaded from www.mathworks.com/matlabcentral/fileexchange/95bnb.
FICO XpressSLP is a solver currently developed by FICO (FICO 2017) and is available as both standalone binaries and a FICO XpressMOSEL module. The solver has an interface to Python and can be used in several other programming environments through the BCL Builder Component Library (FICO 2017). XpressSLP is a local solver designed for large scale nonconvex problems, and global optimality is only guaranteed for convex problems. For general MINLP problems, the solver uses a mixed integer successive linear programming (MISLP) approach. With the MISLP approach, it is, e.g., possible to use an NLPBB technique where the NLP subproblem at each node is solved using a successive linear programming (SLP) technique. For certain types of problems, such as convex MIQP, MIQCQCP and MISOCP, the solver detects convexity and automatically reverts to FICO Xpress’s purpose written solvers. The solver also includes some heuristic approaches for quickly obtaining solutions. More information about FICO and its solvers can be found at www.fico.com/en/products/ficoxpressoptimization.
FilMINT is an MINLP solver developed by K. Abhishek, S. Leyffer and J. Linderoth based on the NLP/LPBB algorithm (Abhishek et al. 2010). The solver is built on top of the MILP solver MINTO (Nemhauser et al. 1994) and uses filterSQP (Fletcher and Leyffer 1998) for solving NLP relaxations. By utilizing functionality in MINTO, FilMINT is able to combine the NLP/LPBB algorithm with features frequently used by MILP solvers, such as cut generation procedures, primal heuristics, and enhanced branching and node selection rules. There is an AMPL interface available for FilMINT and the solver can also be used through the NEOS server. For more details, we refer to Abhishek et al. (2010).
fminconset is an implementation of NLPBB in MATLAB by I. Solberg. The NLP subproblems are solved with MATLAB’s fmincon routine in the Optimization Toolbox. The solver is available to download from www.mathworks.com/matlabcentral/fileexchange/96fminconset.
GAECP (Generalized Alpha Extended Cutting Plane) is a solver based on the GAECP algorithm (Westerlund and Pörn 2002) developed by T. Westerlund. The solver also uses supporting hyperplanes as in the ESH algorithm and is able to guarantee convergence for MINLP problems with nonsmooth pseudoconvex functions. The solver is described in detail in Westerlund (2018).
MILANO (MixedInteger Linear and Nonlinear Optimizer) is a MATLABbased MINLP solver developed by H. Y. Benson at Drexel University. There are two versions of the solver available; one uses an NLPBB technique and the other is based on OA. The NLPBB technique version uses an interior point NLP solver with warmstarting capabilities described in Benson (2011). The solver can be downloaded from www.pages.drexel.edu/~hvb22/milano.
MindtPy (MixedInteger Nonlinear Decomposition Toolbox in Pyomo) is an opensource software framework implemented in Python for Pyomo by the research group of I. Grossmann at Carnegie Mellon University. This toolbox implements the ECP, GBD, and OA algorithms, together with primal heuristics. It relies on Pyomo to handle the resulting MILP and NLP subproblems, allowing any of the solvers compatible with Pyomo to be used with MindtPy (Bernal et al. 2018). The toolbox is available in the following repository www.github.com/bernalde/pyomo/tree/mindtpy.
MINLP_BB was developed by S. Leyffer and R. Fletcher as a general solver for MINLP problems (Leyffer 1999). The solver is based on NLPBB and uses filterSQP for solving the continuous relaxations. There are interfaces to AMPL and Fortran. Furthermore, the solver can also be used in MATLAB through the TOMLAB optimization environment (Holmström 1999). More information about the solver is available at wiki.mcs.anl.gov/leyffer.
MINOPT (Mixed Integer Nonlinearl Optimizer) was developed by C.A. Schweiger and C.A. Floudas as a modelling language for a wide range of optimization problems (Schweiger and Floudas 1998). For MINLP problems MINOPT offered several algorithms, such as variants of OA and GBD.
MISQP (MixedInteger Sequential Quadratic Programming) is a solver based on a modified sequential quadratic programming (SQP) algorithm for MINLP problems presented by Exler and Schittkowski (2007). The solver is developed by K. Schittkowski’s research group and the University of Bayreuth. MISQP is intended for problems where function evaluations may be expensive, e.g., where some function values are obtained by running a simulation. Unlike some of the other solvers, MISQP does not need to evaluate functions at fractional values for integer variables which can be an important property, e.g., for simulationbased optimization tasks. There is an interface in MATLAB through TOMLAB as well as a standalone Fortran interface. A more detailed description of the solver is available at tomwiki.com/MISQP.
Finally, there are a few other deterministic solvers that the authors are aware of, capable of handling convex MINLP problems but mainly focusing on nonconvex MINLP. These solvers are: Decogo (DECOmpositionbased Global Optimizer; Nowak et al. (2018)), NOMAD (Le Digabel 2011), POD (Piecewise convex relaxation, Outerapproximation, and Dynamic discretization; Nagarajan et al. (2017)), LaGO (Lagrangian Global Optimizer; Nowak et al. (2002)). For more details on nonconvex MINLP see, e.g., Tawarmalani and Sahinidis (2002), Liberti and Maculan (2006) and Floudas (2000).
5 Benchmark details
The objective of the forthcoming two sections is to compare some of the convex MINLP solvers mentioned in the previous section by applying them on a comprehensive set of test problems. There are some benchmarks available in literature, e.g., Kronqvist et al. (2016), Bonami et al. (2012), Lastusilta (2011) and Abhishek et al. (2010). However, these are limited to only a few of the solvers considered here or used a smaller set of test problems. The goal here is to give a comprehensive uptodate comparison of both opensource and commercial solvers available in different environments. The main interest has been to study how the solvers perform on a desktop computer, and all the benchmarks were performed on a Linuxbased PC with an Intel Xeon 3.6 GHz processor with four physical cores (able to process eight threads at once) and 32 GB memory. We have allowed the solvers to use a maximum of eight threads to replicate a realworld situation where one tries to solve the problems with all the available resources. However, it is worth mentioning that the solvers and subsolvers utilize parallelism to different extents.
The table shows which subsolvers were used with each solver, and on which platform the solver was run on
MINLP solver  Subsolvers used  Platform  

MILP/LP  NLP  
AlphaECP 2.10.06  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
Antigone 1.1  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
AOA  CPLEX 12.8  CONOPT 3.14V  AIMMS 4.59.4.1 
BARON 18.5.8  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
BONMIN 1.8  CPLEX 12.8  IPOPT 3.12  GAMS 25.1.2 
Couenne 0.5  CLP 1.16  IPOPT 3.12  GAMS 25.1.2 
DICOPT 2  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
Juniper 0.2.0  CPLEX 12.8  IPOPT 3.12.1  JuMP 0.18.4 
Knitro 10.3.0  –  –  GAMS 25.1.2 
Lindo 11.0  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
Minotaur 05212018  CPLEX 12.6.3  filterSQP 20010817  – 
Muriqui 0.7.01  CPLEX 12.8  IPOPT 3.12.1  – 
Pavito 0.1.0  CPLEX 12.8  IPOPT 3.12.1  JuMP 0.18.4 
SBB  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
SCIP 5.0  CPLEX 12.8  IPOPT 3.12  GAMS 25.1.2 
SHOT 0.9.3  CPLEX 12.8  CONOPT 3.17I  GAMS 25.1.2 
The termination criteria used with the solvers is the relative objective gap between the upper and lower objective bounds, where we used a tolerance of 0.1% with all the solvers. To make sure that the solvers did not terminate prematurely due to other builtin termination criteria and to avoid clear solver failures, some specific solver options were given; these are listed in Appendix B. Except for these, default settings were used for all solvers. Furthermore, a wall clock time limit of 900 s was also used with all solvers. Even with the 15min time limit per problem, the total running time for the experiments was more than two weeks.
5.1 Problem sets
Statistics of the convex MINLP instances used in the benchmark
Objective function type  Problem count 

Linear objective  244 
Quadratic objective  66 
General nonlinear objective  25 
Minimum  Arithmetic mean  Maximum  

Number of discrete variables  2  93  1500 
Number of variables  2  989  107,222 
Number of constraints  0  1213  108,217 
Number of nonlinear constraints  0  16  112 
Number of nonlinear variables  1  132  4521 
The problems selected represent a variety of different types of optimization problems with different properties such as number of variables, number of discrete variables, and number of nonlinear terms. Some of the problems also represent different formulations of the same problems, e.g., both bigM and convex hull formulation of disjunctions. It is therefore of interest to compare the solvers not only on the entire test set but also on smaller subsets with specific properties. We have partitioned the test set into groups, representing both integer and nonlinear properties, to compare both the solvers and algorithms for the different types of problems. The following criteria were used to partition the test problems into subsets:
5.1.1 Continuous relaxation gap
5.1.2 Nonlinearity
5.1.3 Discrete density
A list of the problems in each category is given in “Appendix A”, which also shows the continuous relaxation gap, degree of nonlinearity, and discrete density for each test problem. Scatter plots are also presented in “Appendix A” that show there is little to no correlation between the problem categories.
5.2 Reporting
All the results were analyzed using PAVER (Bussieck et al. 2014), which is a tool for comparing the performance of optimization solvers and analyzing the quality of the obtained solutions. The reports generated by PAVER, as well as all the results obtained by the individual solvers are available at andreaslundell.github.io/minlpbenchmarks. The parameters used for generating the reports are also available within the reports.
A comment must be made regarding the choice of the parameter gaptol in PAVER, which was set to the value \(1.002\times 10^{3}\) instead of the value used as termination criteria (\(1\times 10^{3} = 0.1\%\)). The small perturbation is needed due to differences in how the relative gap is calculated by the solvers. Some of the solvers calculate the relative gap by dividing the gap by the lower bound, whereas others divide by the smallest absolute value of either the upper or lower bound. For example, BARON and ANTIGONE would, without the small perturbation, seem to terminate prematurely on a large number of instances and these would all be marked as failed by PAVER.
PAVER also calculates socalled virtual best and virtual worst solvers. The virtual best solver is the best (in our graphs the fastest) successful solver selected for each individual problem instance, and the virtual worst is then the slowest for each instance. These virtual solvers provide a good comparison for how good or bad an individual solver is compared to all the solvers.
Since MINLPLib also provides a list of known optimal objective values, as well as upper and lower objective bounds, PAVER is able to compare the obtained solutions by the known bounds in MINLPLib. PAVER is, thus, also able to calculate the socalled primal gap, i.e., the difference between the obtained solution and the bestknown integer solution, which can be used to analyze the quality of the obtained solutions. For example, there are cases where the solver returns the optimal solution, but it has not been able to verify optimality within the time limit. PAVER also uses known objective bounds available in MINLPLib to check whether the solvers obtained correct solutions and bounds for the test problems.
6 Results
The table shows the time per problem (in seconds) for a solver to solve a certain number of instances
Number of solved problems  25  39  50  100  150  175  200  225  250  260  270  280  290  300  305  306  310  312  326 

ANTIGONE  0.1  0.2  0.3  0.7  11  38  241  598  
AOA  0.1  0.2  0.3  0.4  0.5  0.6  0.7  1.0  2.2  3.7  8.3  15  46  132  210  279  864  
AlphaECP  0.3  0.5  0.6  1.5  4.0  6.9  13  28  81  188  412  
BARON  0.1  0.2  0.3  0.5  1.6  2.6  5.0  9.3  16  22  39  78  147  361  647  824  
BONMINBB  0.1  0.2  0.3  1.1  4.0  12  42  288  
BONMINHYB  0.1  0.2  0.4  2.8  12  26  146  685  
BONMINOA  0.1  0.2  0.3  0.4  0.7  1.4  2.8  5.1  9.5  19  27  71  203  
Couenne  0.1  0.2  0.3  8.4  430  
DICOPT  0.1  0.2  0.3  0.4  1.9  3.5  5.4  11  21  27  49  91  457  
Juniper  0.9  2.1  3.1  9.5  61  195  
KnitroBB  0.1  0.2  0.3  0.4  3.2  18  107  
KnitroQG  0.1  0.2  0.3  1.4  5.7  84  
LINDO  0.1  0.2  0.3  7.2  141  
MinotaurBB  0.1  0.2  0.3  0.4  0.7  3.5  16  90  460  
MinotaurQG  0.1  0.2  0.3  0.4  1.0  2.5  4.3  12  38  119  277  590  
Muriqui  0.1  0.2  0.3  0.6  1.2  2.4  5.5  7.8  16  21  31  47  115  835  
Pavito  0.1  0.2  0.3  0.5  1.3  1.9  3.5  8.4  57  173  539  
SBB  0.2  0.3  0.4  0.5  2.6  25  116  
SCIP  0.1  0.2  0.3  0.4  0.9  1.5  3.2  8.2  27  39  67  141  561  
SHOT  0.1  0.2  0.3  0.4  0.5  0.6  0.8  1.5  3.1  4.3  7.1  12  27  115  267  308  538  746  
Virtual best  0.1  0.2  0.3  0.4  0.5  0.6  0.7  0.8  0.9  1.1  1.8  2.6  4.4  9.5  12  13  19  32  538 
Virtual worst  40  598 
The results are presented using solution profiles showing the number of individual problems that a solver is able to solve as a function of time. Note that the profiles do not represent the cumulative solution time, but shows how many individual problems the solvers can solve within a specific time. We have not used performance profiles where the time is normalized with respect to best solver (Dolan and Moré 2002) since these are not necessarily good for comparing several solvers as noted by Gould and Scott (2016).
In all solution profiles in this section, we have chosen to divide the solvers into two categories to make the solution profiles more easily readable. The solvers are divided into MILP decompositionbased solvers and BBbased solvers. The division is not completely straightforward since some of the solvers could fit into both categories. However, the division is only intended to make it easier to read the results. The solvers classified as MILP decompositionbased solvers are AlphaECP, AOA, BONMINOA, DICOPT, KnitroQG, MinotaurQG, Muriqui, Pavito, and SHOT. Solvers classified as BBbased solvers are ANTIGONE, BARON, BONMINBB, BONMINHYB, Couenne, Juniper, KnitroBB, LINDO, MinotaurBB, SBB, and SCIP. The time scales are also divided into two parts to better highlight differences between the solvers, and it is linear in the first 10 s, and logarithmic between 10 and 900 s. In each plot, the solvers in the nonactive group are indicated with thin gray lines, while the others are as shown in the respective legends. The same line style is used for a specific solver in all figures. If there are several different strategies used with the same solvers, different line types (solid, dashed, dotted) are used while the color remain the same. In the right margin of each profile, the solvers are ranked according to the number of solved problems (as indicated within parenthesis). The virtual best and virtual worst solvers are shown in the figures as the top and bottom thick gray lines, and the region between them is shaded.
Figures 1 and 2 show the solution profiles when applying the solvers on the complete set of test problems. As mentioned, the solution profiles indicate the number of problems that have been solved by the individual solvers as a function of time. A problem is defined as solved in this set of experiments if the relative objective gap, as calculated by PAVER, is \(\le\) 0.1002% (see note above). To better examplify the differences between the solvers, the same data is used for generating Table 3 which shows “snapshots” of the solution profile for different levels of the number of solved problems.
Figure 3 presents statistics regarding the termination of the solvers, e.g., how many errors and timeouts occurred. These values are as reported by the solver, but also include solver crashes where no solution was returned. PAVER also verifies if the solver runs were completed successfully, e.g., by comparing the objective values returned to known values or bounds; if there is a discrepancy, these instances are given the status failed. Statistics on instances marked as failed are shown in Fig. 4.
Figure 5 shows the number of problems where the solver was able to obtain a solution within 0.1% and 1% of the bestknown solution, but not necessarily able to verify optimality. The figure shows that none of the solvers was able to obtain a solution within 1% of the bestknown solution for all of the problems, given the 900 s time limit. For example, BARON was able to obtain a solution within 1% of the optimum for 317 problems, and SHOT obtained such a solution for 320 problems.
The number of instances solved to a relative objective gap, i.e., difference between the upper and lower objective bound, of 0.1%, 1% and 10%, per solver is shown in Fig. 6. By comparing Figs. 5 and 6, it can be observed that some of the solvers are able to obtain a solution within 0.1% of the optimum to significantly more problems than they are able to verify as optimal. For example, AlphaECP and ANTIGONE seems to be struggling with obtaining a tight lower bound for some of the problems, since they are able to obtain solutions within 0.1% for 300 (AlphaECP) and 275 (ANTIGONE) problems, while only verifying optimality for 276 and 236 instances respectively. Since ANTIGONE is a global solver without a userselected convex strategy, it might fail to recognize some of the problems as convex, and therefore, generate weaker relaxations. This would explain the difference between the number of optimal solutions found and number of solutions verified as optimal.
Since it may be difficult to draw more detailed conclusions from the results in Figs. 1 and 2, the next sections consider subsets of test problems with specific properties. A summary of the results for the different subsets is given in Sect. 6.4.
6.1 Impact of the continuous relaxation gap
In this section, we consider problems with a large continuous relaxation gap and problems with a small continuous relaxation gap. Figure 7 shows the solution profiles of the solvers for the problems with a large gap, and Fig. 8 shows the solution profiles for those with a small gap. By comparing the figures, there is a clear difference for the solvers based on a BB approach, as these clearly perform better on the problems with a small gap compared to those with a large continuous relaxation gap. For example, BONMINBB is one of the most efficient solvers for the problems with a small gap, both in terms of speed and number of solved problems, while it is clearly outperformed by several solvers for the problems with a large gap.
The NLPBBbased solvers, BONMINBB, Juniper, KnitroBB, MinotaurBB, and SBB solve significantly fewer problems with a large gap than the solvers based on either an ECP, ESH or OA (AlphaECP, BONMINOA, DICOPT, and SHOT). For problems with a large continuous relaxation gap, the BB trees may become larger and the more expensive subproblems in each node may make the NLPBBbased solvers suffer performancewise. Using a polyhedral approximation within a BB framework, BARON and SCIP are not as strongly affected by the relaxation gap; this could partially be due to having simpler subproblems at each node.
Overall, the MILP decompositionbased solvers seem to be less affected by the continuous relaxation gap then the BBbased ones. Several of the MILP decompositionbased solvers, such as AOA and SHOT, are closely integrated with the MILP subsolver (CPLEX in this case), and rely on it for handling the integer requirements. This close integration enables the usage of several advanced features from the more mature MILP solvers, while NLPBBbased solvers often need to manage branching, handling the BB tree, cut generation, and other techniques on their own. One can expect this advantage to be more important for problems that are challenging due to the integer requirements, which is often a trait of problems with large continuous relaxation gaps. As an example of the impact on the performance of a MILP decompositionbased solver that handle the integer requirements itself, consider MinotaurQG (as it only uses CPLEX as a LP subsolver): The performance difference between MinotaurQG and AOA are significant, even though they utilize the same basic algorithm.
6.2 Impact of nonlinearity
In this section, problem types with a high and low degree of nonlinearity are compared, and the results are shown in Figs. 9 and 10. Several of the solvers use linearizations to approximate the nonlinear functions in some steps of the solution procedure, whereas solvers using an NLPBB approach directly treats the nonlinearity in each node of the BB tree. As expected, most of the solvers utilizing linearizations perform significantly better on the problems with a low degree of nonlinearity, since BONMINOA, DICOPT, and SCIP are among the most efficient solvers in terms of both speed and number of problems solved. However, for problems with a high degree of nonlinearity they are outperformed by the NLPBBbased solvers BONMINBB, KnitroBB, MinotaurBB, and SBB.
SHOT and the LP/NLPBBbased solvers AOA, MinotaurQG and Muriqui have quite similar behavior for both types of problems and perform well in both categories. These solvers rely on linearizations of the nonlinear constraints and one would, thus, expect them to be negatively affected by the degree of nonlinearity. However they all use a quite similar singletree approach where NLP subproblems are solved in some of the nodes, which may help them to cope with problems with a high degree of nonlinearity. The LP/NLPBBbased solver KnitroQG also performs quite well for problems with a high degree of nonlinearity.
6.3 Impact of discrete density
Finally, we compare how the solvers are affected by the relative number of discrete variables, i.e., integer and binary variables. Figures 11 and 12 show how the solvers perform for problems with high and low discrete density.
The MILP decompositionbased solvers perform similarly for both types of problems, and no obvious conclusions can be drawn from the results. However, again there is a clear difference for the NLPBBbased solvers, and surprisingly many of these solvers performed better than the other ones on the high discrete density set of problems. One could expect a correlation between the discrete density and continuous relaxation gap, and that a high discrete density would result in a high continuous relaxation gap. However, as shown in Fig. 13 in “Appendix A”, there is basically no correlation between the two for this set of test problems. Thus, by analyzing the results there is no clear reason for why the NLPBBbased solvers perform better for the problems with a high discrete density, but one should keep in mind that the test set is somewhat limited.
6.4 Summary of the results
The table shows how the solvers are affected by the problem properties described in Sect. 5.1
MINLP solver  Integer relaxation gap  Nonlinearity  Discrete density  

High  Low  High  Low  High  Low  
AlphaECP  \(\sim\) 120  \(\sim\) 156  − 71  + 205  \(\sim\) 94  \(\sim\) 182 
ANTIGONE  + 114  − 122  \(\sim\) 76  \(\sim\) 160  + 97  − 139 
AOA  \(\sim\) 133  \(\sim\) 177  \(\sim\) 94  \(\sim\) 216  \(\sim\) 110  \(\sim\) 200 
BARON  \(\sim\) 133  \(\sim\) 173  \(\sim\) 94  \(\sim\) 212  \(\sim\) 107  \(\sim\) 199 
BONMINBB  − 60  + 173  + 90  − 143  + 96  − 137 
BONMINOA  \(\sim\) 125  \(\sim\) 167  − 80  + 212  \(\sim\) 99  \(\sim\) 193 
BONMINHYB  − 82  + 146  − 62  + 166  − 71  + 157 
Couenne  \(\sim\) 50  \(\sim\) 105  \(\sim\) 70  \(\sim\) 85  \(\sim\) 74  \(\sim\) 81 
DICOPT  \(\sim\) 122  \(\sim\) 170  − 78  + 214  \(\sim\) 99  \(\sim\) 193 
Juniper  − 52  + 137  + 75  − 114  \(\sim\) 75  \(\sim\) 114 
KnitroBB  − 56  + 167  + 87  − 136  + 94  − 129 
KnitroQG  − 43  + 155  + 78  − 120  + 84  − 114 
LINDO  − 36  + 127  + 76  − 87  + 87  − 76 
MinotaurQG  \(\sim\) 120  \(\sim\) 164  \(\sim\) 82  \(\sim\) 202  \(\sim\) 100  \(\sim\) 184 
MinotaurBB  − 99  + 159  + 89  − 169  + 102  − 156 
Muriqui  \(\sim\) 131  \(\sim\) 170  \(\sim\) 87  \(\sim\) 214  \(\sim\) 105  \(\sim\) 196 
Pavito  − 112  + 161  − 86  + 187  \(\sim\) 91  \(\sim\) 182 
SBB  − 54  + 169  + 91  − 132  + 90  − 133 
SCIP  \(\sim\) 124  \(\sim\) 171  − 82  + 213  + 108  − 187 
SHOT  \(\sim\) 138  \(\sim\) 174  \(\sim\) 92  \(\sim\) 220  − 104  + 208 
Number of problems  151  183  103  232  120  215 
How the solvers are affected by the continuous relaxation gap, degree of nonlinearity and discrete density is summarized in Table 4. The table shows the number of problems solved within each category as well as an indicator of how the solvers’ performances were affected by the specific properties. The performance indicator tries to show how the performance of a solver is affected by the problem properties with respect to the other solvers. If a solver clearly performed better in a category, with respect to speed and number of solved problems, it is indicated by ‘+’, and similarly ‘−’ indicates that solver performed worse for that category of problems. If the performance is similar within both categories it is indicated by ‘\(\sim\)’. Each performance indicator has been chosen by comparing how a specific solver performed in both the high and low category with respect to the other solvers. Note that a ‘–’ sign does not necessarily indicate that the solver performed poorly, it simply states that the solver did not perform as well as in the other category. For example, for the problems with a low degree of nonlinearity DICOPT is overall one of the fastest solvers. For the problems with a high degree of nonlinearity DICOPT also performs well, but not as well as in the other category, and this is indicated by a ‘+’ and ‘−’ sign in Table 4. That there are no significant changes for the performance of AOA with respect to both categories is indicated by ‘\(\sim\)’ sign.
These indicators were obtained by carefully analyzing the performance profiles, and are not intended as a grade of the solver but to show how it is affected by different problem properties. The results presented in Table 4 indicates that BBbased solvers seem to be more affected by the problem properties considered here compared to the MILP decompositionbased solvers. One possible explanation for the differences between the two types of solvers is that several of the MILP decompositionbased solvers rely heavily on the MILP subsolver, and benefits from several advanced features from the MILP solver.
Comparing the global solvers (ANTIGONE, BARON, Couenne, LINDO, and SCIP) with the convex solvers is not completely fair since the global solvers are able to solve a wider class of problems. In the numerical comparison, one should keep in mind that these global solvers are intended for a different (more general) type of problems. Some of these solvers do not have a convex option, and thus, they have access to less information about the problem and might treat it as nonconvex. For example, the performance difference of ANTIGONE and Couenne compared to BARON and SCIP, may be explained with the solvers treating some of the convex functions as nonconvex, and therefore, generate unnecessarily weak relaxations. BARON seems to be very efficient at identifying convex problems since it is able to deal with the problems in the benchmark set in such an efficient manner. Even if it is a global solver, capable of handling a variety of nonconvex problems, it is also one of the most efficient solvers for convex problems.
Furthermore, one should not draw any conclusions on how the solvers perform on nonconvex problems based solely on the results presented in this paper. For example, the convex strategies in AOA and SHOT, the two most efficient solvers for this set of problems, do not necessarily work well for nonconvex problems, and in fact there is another strategy in AOA intended as an heuristic for nonconvex problems. Some of the nonglobal solvers may actually work quite well as heuristics for nonconvex problems, of course without any guarantee of finding the global or even a feasible solution.
7 Conclusions
The comparisons presented in this paper are mainly intended to help the readers make informed decisions about which tools to use when dealing with different types of convex MINLP problems. In the previous sections, we have shown how 16 different solvers performed on a test set containing 335 MINLP instances. By comparing the solvers on MINLP instances with different properties we noticed significant differences in the solvers’ performance. For example, the solvers based on NLPBB were strongly affected by both the continuous relaxation gap and the degree of nonlinearity. Several of the solvers are based on the same main algorithms, although they differ significantly in terms of speed and number of problems solved. The differences are mainly due to different degrees of preprocessing, primal heuristics, cut generation procedures, and different strategies used by the solvers. The performance differences highlight the importance of such techniques for an efficient solver implementation.
For the test set considered here, SHOT and AOA were the overall fastest solvers. Both of the solvers are based on a singletree approach closely integrated with the MILP solver by utilizing callbacks to add the linearizations as lazy constraints. The results show the benefits of such a solution technique and support the strong belief in the singletree approach by Abhishek et al. (2010) and Belotti et al. (2013). The close integration with the MILP solver allows AOA and SHOT to benefit from different techniques integrated within the MILP solver, such as branching heuristics, cut generation procedures, and bound tightening.
Overall, several of the solvers performed well on the test set and were able to solve a large portion of the problems. The most instances any solver could solve within the time limit was 312 instances, and by combining all the solvers we where able solve 326 of the 335 MINLP problems to a 0.1% guaranteed optimality gap. However, it should be noted that many of the test instances are quite small and simple compared to industryrelevant problems. Still today, realworld problems must often be simplified and reduced in size to obtain tractable formulations, in the process limiting the practical benefits of MINLP. Thus, in order to fully benefit from convex MINLP as a tool for design and decisionmaking, both further algorithmic research and solver software development are required. We also hope that this paper encourages MINLP users to submit their problems to the instances libraries, e.g., MINLPLib and www.minlp.org, to benefit both MINLP solver developers and end users.
Notes
Acknowledgements
Open access funding provided by Abo Akademi University (ABO). First, we want to thank the developers of the solvers for their support to the comparison, and we also want to thank both AIMMS (especially M. Hunting) and GAMS (especially S. Vigerske and M. Bussieck) for their support. D. E. Bernal and I. E. Grossmann would like to thank the Center for Advanced Process Decisionmaking (CAPD) for its financial support. A. Lundell wants to express his gratitude for the financial support from the Magnus Ehrnrooth Foundation, as well as the Ruth and NilsErik Stenbäck Foundation. The authors want to acknowledge the Dagstuhl Seminar 18081 on Designing and Implementing Algorithms for MixedInteger Nonlinear Optimization, which provided valuable insight into the current status of MINLP software. Finally, we want to thank the anonymous reviewers for their valuable comments which helped to improve the paper significantly.
References
 Abhishek K, Leyffer S, Linderoth J (2010) FilMINT: an outer approximationbased solver for convex mixedinteger nonlinear programs. INFORMS J Comput 22(4):555–567MathSciNetzbMATHGoogle Scholar
 Achterberg T (2009) SCIP: solving constraint integer programs. Math Program Comput 1(1):1–41MathSciNetzbMATHGoogle Scholar
 Achterberg T, Koch T, Martin A (2005) Branching rules revisited. Oper Res Lett 33(1):42–54MathSciNetzbMATHGoogle Scholar
 Achterberg T, Wunderling R (2013) Mixed integer programming: analyzing 12 years of progress. In: Jünger M, Reinelt G (eds) Facets of combinatorial optimization. Springer, pp 449–481Google Scholar
 Andersen ED, Andersen KD (2000) The MOSEK optimization software. EKA Consulting ApS, CopenhagenzbMATHGoogle Scholar
 Artelys (2018) Artelys Knitro User’s Manual. https://www.artelys.com/tools/knitro_doc/2_userGuide.html
 Balas E, Ceria S, Cornuéjols G (1993) A liftandproject cutting plane algorithm for mixed 0–1 programs. Math Program 58(1–3):295–324MathSciNetzbMATHGoogle Scholar
 Bazaraa MS, Sherali HD, Shetty CM (2013) Nonlinear programming: theory and algorithms. Wiley, New YorkzbMATHGoogle Scholar
 Belotti P (2010) Couenne: a user’s manual. https://www.coinor.org/Couenne/couenneusermanual.pdf
 Belotti P, Lee J, Liberti L, Margot F, Wächter A (2009) Branching and bounds tightening techniques for nonconvex MINLP. Optim Methods Softw 24:597–634MathSciNetzbMATHGoogle Scholar
 Belotti P, Cafieri S, Lee J, Liberti L (2010) Feasibilitybased bounds tightening via fixed points. In: Wu W, Daescu O (eds) International conference on combinatorial optimization and applications. Springer, New York, pp 65–76Google Scholar
 Belotti P, Kirches C, Leyffer S, Linderoth J, Luedtke J, Mahajan A (2013) Mixedinteger nonlinear optimization. Acta Numer 22:1–131MathSciNetzbMATHGoogle Scholar
 Benders JF (1962) Partitioning procedures for solving mixedvariables programming problems. Numer Math 4(1):238–252MathSciNetzbMATHGoogle Scholar
 Benson HY (2011) Mixed integer nonlinear programming using interiorpoint methods. Optim Methods Softw 26(6):911–931MathSciNetzbMATHGoogle Scholar
 Bernal DE, Chen Q, Gong F, Grossmann IE (2018) Mixedinteger nonlinear decomposition toolbox for Pyomo (MindtPy). http://egon.cheme.cmu.edu/Papers/Bernal_Chen_MindtPy_PSE2018Paper.pdf
 Bernal DE, Vigerske S, Trespalacios F, Grossmann IE (2017) Improving the performance of DICOPT in convex MINLP problems using a feasibility pump. http://www.optimizationonline.org/DB_HTML/2017/08/6171.html
 Berthold T (2014a) Heuristic algorithms in global MINLP solvers. Ph.D. thesis, Technische Universität BerlinGoogle Scholar
 Berthold T (2014b) RENS: the optimal rounding. Math Program Comput 6(1):33–54MathSciNetzbMATHGoogle Scholar
 Berthold T, Gleixner AM (2014) Undercover: a primal MINLP heuristic exploring a largest subMIP. Math Program 144(1–2):315–346MathSciNetzbMATHGoogle Scholar
 Bezanson J, Karpinski S, Shah VB, Edelman A (2012) Julia: a fast dynamic language for technical computing. arXiv preprint: 1209.5145Google Scholar
 Biegler LT (2010) Nonlinear programming: concepts, algorithms, and applications to chemical processes. SIAM, PhiladelphiazbMATHGoogle Scholar
 Biegler LT, Grossmann IE (2004) Retrospective on optimization. Comput Chem Eng 28(8):1169–1192Google Scholar
 Bisschop J (2006) AIMMS optimization modeling. www.Lulu.com
 Bonami P (2011) Liftandproject cuts for mixed integer convex programs. In: International conference on integer programming and combinatorial optimization. Springer, pp 52–64Google Scholar
 Bonami P, Lee J (2007) BONMIN user’s manual. Numer Math 4:1–32Google Scholar
 Bonami P, Lejeune MA (2009) An exact solution approach for portfolio optimization problems under stochastic and integer constraints. Oper Res 57(3):650–670MathSciNetzbMATHGoogle Scholar
 Bonami P, Biegler LT, Conn AR, Cornuéjols G, Grossmann IE, Laird CD, Lee J, Lodi A, Margot F, Sawaya N, Wächter A (2008) An algorithmic framework for convex mixed integer nonlinear programs. Discrete Optim 5(2):186–204MathSciNetzbMATHGoogle Scholar
 Bonami P, Cornuéjols G, Lodi A, Margot F (2009) A feasibility pump for mixed integer nonlinear programs. Math Program 119(2):331–352MathSciNetzbMATHGoogle Scholar
 Bonami P, Kilinç M, Linderoth J (2012) Algorithms and software for convex mixed integer nonlinear programs. In: Lee J, Leyffer S (eds) Mixed integer nonlinear programming. Springer, pp 1–39Google Scholar
 Bonami P, Lee J, Leyffer S, Wächter A (2011) More branchandbound experiments in convex nonlinear integer programming. Optimization. http://www.optimizationonline.org/DB_FILE/2011/09/3191.pdf
 Borchers B, Mitchell JE (1994) An improved branch and bound algorithm for mixed integer nonlinear programs. Comput Oper Res 21(4):359–367MathSciNetzbMATHGoogle Scholar
 Boukouvala F, Misener R, Floudas CA (2016) Global optimization advances in mixedinteger nonlinear programming, MINLP, and constrained derivativefree optimization, CDFO. Eur J Oper Res 252(3):701–727MathSciNetzbMATHGoogle Scholar
 Bragalli C, DAmbrosio C, Lee J, Lodi A, Toth P (2012) On the optimal design of water distribution networks: a practical MINLP approach. Optim Eng 13(2):219–246MathSciNetzbMATHGoogle Scholar
 Brook A, Kendrick D, Meeraus A (1988) GAMS, a user’s guide. ACM Signum Newslett 23(3–4):10–11Google Scholar
 Bussieck MR, Vigerske S (2010) MINLP solver software. In: Wiley encyclopedia of operations research and management science. Wiley Online LibraryGoogle Scholar
 Bussieck MR, Dirkse SP, Vigerske S (2014) PAVER 2.0: an open source environment for automated performance analysis of benchmarking data. J Global Optim 59(2):259–275zbMATHGoogle Scholar
 Byrd RH, Nocedal J, Waltz RA (2006) Knitro: an integrated package for nonlinear optimization. Largescale nonlinear optimization. Springer, New York, pp 35–59Google Scholar
 Cao W, Lim GJ (2011) Optimization models for cancer treatment planning. In: Wiley encyclopedia of operations research and management science. Wiley Online LibraryGoogle Scholar
 Castillo I, Westerlund J, Emet S, Westerlund T (2005) Optimization of block layout design problems with unequal areas: a comparison of MILP and MINLP optimization methods. Comput Chem Eng 30(1):54–69Google Scholar
 Çezik MT, Iyengar G (2005) Cuts for mixed 0–1 conic programming. Math Program 104(1):179–202MathSciNetzbMATHGoogle Scholar
 Coey C, Lubin M, Vielma JP (2018) Outer approximation with conic certificates for mixedinteger convex problems. arXiv preprint: 1808.05290Google Scholar
 Currie J, Wilson DI et al (2012) OPTI: lowering the barrier between open source optimizers and the industrial MATLAB user. Found Comput Aided Process Oper 24:32Google Scholar
 Dakin RJ (1965) A treesearch algorithm for mixed integer programming problems. Comput J 8(3):250–255MathSciNetzbMATHGoogle Scholar
 D’Ambrosio C, Lodi A (2013) Mixed integer nonlinear programming tools: an updated practical overview. Ann Oper Res 204(1):301–320. https://doi.org/10.1007/s1047901212725 MathSciNetzbMATHGoogle Scholar
 D’Ambrosio C, Frangioni A, Liberti L, Lodi A (2012) A storm of feasibility pumps for nonconvex MINLP. Math Program 136(2):375–402MathSciNetzbMATHGoogle Scholar
 Dolan ED, Moré JJ (2002) Benchmarking optimization software with performance profiles. Math Program Ser B 91(2):201–213MathSciNetzbMATHGoogle Scholar
 Drud AS (1994) CONOPT—a largescale GRG code. ORSA J Comput 6(2):207–216zbMATHGoogle Scholar
 Dunning I, Huchette J, Lubin M (2017) JuMP: a modeling language for mathematical optimization. SIAM Rev 59(2):295–320MathSciNetzbMATHGoogle Scholar
 Duran MA, Grossmann IE (1986) An outerapproximation algorithm for a class of mixedinteger nonlinear programs. Math Program 36(3):307–339MathSciNetzbMATHGoogle Scholar
 Eronen VP, Mäkelä MM, Westerlund T (2014) On the generalization of ECP and OA methods to nonsmooth convex MINLP problems. Optimization 63(7):1057–1073MathSciNetzbMATHGoogle Scholar
 Eronen VP, Kronqvist J, Westerlund T, Mäkelä MM, Karmitsa N (2017) Method for solving generalized convex nonsmooth mixedinteger nonlinear programming problems. J Global Optim 69(2):443–459MathSciNetzbMATHGoogle Scholar
 Exler O, Schittkowski K (2007) A trust region SQP algorithm for mixedinteger nonlinear programming. Optim Lett 1(3):269–280MathSciNetzbMATHGoogle Scholar
 FICO (2017) FICO XpressSLP manual. https://www.artelys.com/uploads/pdfs/Xpress/Xpress_SLP_2795MS.pdf
 FICO (2017) Xpressoptimizer reference manual. https://www.artelys.com/uploads/pdfs/Xpress/Xpress_Optimizer_2447PS.pdf
 Fischetti M, Lodi A (2011) Heuristics in mixed integer programming. In: Wiley encyclopedia of operations research and management science. Wiley Online LibraryGoogle Scholar
 Fletcher R, Leyffer S (1994) Solving mixed integer nonlinear programs by outer approximation. Math Program 66(1):327–349MathSciNetzbMATHGoogle Scholar
 Fletcher R, Leyffer S (1998) User manual for filterSQP. Numerical analysis Report NA/181. Department of Mathematics, University of Dundee, DundeeGoogle Scholar
 Floudas CA (2000) Deterministic global optimization: Theory, methods and applications. Nonconvex optimization and its applications, vol 37. Springer, US. https://doi.org/10.1007/9781475749496
 Floudas CA (1995) Nonlinear and mixedinteger optimization: fundamentals and applications. Oxford University Press, OxfordzbMATHGoogle Scholar
 Forrest J (2005) Cbc user’s guide. https://projects.coinor.org/Cbc
 Fourer R, Gay D, Kernighan B (1993) AMPL. Boyd & Fraser, DanversGoogle Scholar
 Frangioni A, Gentile C (2006) Perspective cuts for a class of convex 0–1 mixed integer programs. Math Program 106(2):225–236MathSciNetzbMATHGoogle Scholar
 GAMS (2018) Branchandcutandheuristic facility. https://www.gams.com/latest/docs/UG_SolverUsage.html. Accessed 18 May 2018
 Geoffrion AM (1972) Generalized Benders decomposition. J Optim Theory Appl 10(4):237–260MathSciNetzbMATHGoogle Scholar
 Gill PE, Murray W, Saunders MA (2005) SNOPT: an SQP algorithm for largescale constrained optimization. SIAM Rev 47(1):99–131MathSciNetzbMATHGoogle Scholar
 Gleixner A, Bastubbe M, Eifler L, Gally T, Gamrath G, Gottwald RL, Hendel G, Hojny C, Koch T, Lübbecke ME, Maher SJ, Miltenberger M, Müller B, Pfetsch ME, Puchert C, Rehfeldt D, Schlösser F, Schubert C, Serrano F, Shinano Y, Viernickel JM, Walter M, Wegscheider F, Witt JT, Witzig J (2018) The SCIP optimization suite 6.0. Technical report, Optimization. http://www.optimizationonline.org/DB_HTML/2018/07/6692.html
 Gomory RE et al (1958) Outline of an algorithm for integer solutions to linear programs. Bull Am Math Soc 64(5):275–278MathSciNetzbMATHGoogle Scholar
 Gould N, Scott J (2016) A note on performance profiles for benchmarking software. ACM Trans Math Softw (TOMS) 43(2):15MathSciNetzbMATHGoogle Scholar
 Grossmann IE (2002) Review of nonlinear mixedinteger and disjunctive programming techniques. Optim Eng 3(3):227–252MathSciNetzbMATHGoogle Scholar
 Grossmann IE, Kravanja Z (1997) Mixedinteger nonlinear programming: a survey of algorithms and applications. In: Biegler LT, Coleman TE, Conn AR, Santosa FN (eds) Largescale optimization with applications. Springer, New YorkGoogle Scholar
 Grossmann IE, Caballero JA, Yeomans H (1999) Mathematical programming approaches to the synthesis of chemical process systems. Korean J Chem Eng 16(4):407–426Google Scholar
 Gupta OK, Ravindran A (1985) Branch and bound experiments in convex nonlinear integer programming. Manag Sci 31(12):1533–1546MathSciNetzbMATHGoogle Scholar
 Gurobi (2018) Gurobi optimizer reference manual. Gurobi Optimization, LLC. http://www.gurobi.com/documentation/8.0/refman.pdf
 Hart WE, Laird CD, Watson JP, Woodruff DL, Hackebeil GA, Nicholson BL, Siirola JD (2012) Pyomooptimization modeling in Python, vol 67. Springer, New YorkzbMATHGoogle Scholar
 Hijazi H, Bonami P, Ouorou A (2013) An outerinner approximation for separable mixedinteger nonlinear programs. INFORMS J Comput 26(1):31–44MathSciNetzbMATHGoogle Scholar
 Holmström K (1999) The TOMLAB optimization environment in Matlab. Citeseer. http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.134.5714
 HSL (2018) A collection of Fortran codes for largescale scientific computation. http://www.hsl.rl.ac.uk
 Hunting M (2011) The AIMMS outer approximation algorithm for MINLP. Tech. rep. AIMMS B.VGoogle Scholar
 IBM ILOG CPLEX Optimization Studio (2017) CPLEX Users Manual, version 12.7. IBMGoogle Scholar
 Kelley JE Jr (1960) The cuttingplane method for solving convex programs. J Soc Ind Appl Math 8(4):703–712MathSciNetzbMATHGoogle Scholar
 Khajavirad A, Sahinidis NV (2018) A hybrid LP/NLP paradigm for global optimization relaxations. Math Program Comput 10(3):383–421MathSciNetzbMATHGoogle Scholar
 Kılınç MR, Sahinidis NV (2018) Exploiting integrality in the global optimization of mixedinteger nonlinear programming problems with BARON. Optim Methods Softw 33(3):540–562MathSciNetzbMATHGoogle Scholar
 Kılınç MR, Linderoth J, Luedtke J (2017) Liftandproject cuts for convex mixed integer nonlinear programs. Math Program Comput 9(4):499–526MathSciNetzbMATHGoogle Scholar
 Kocis GR, Grossmann IE (1988) Global optimization of nonconvex mixedinteger nonlinear programming (MINLP) problems in process synthesis. Ind Eng Chem Res 27(8):1407–1421Google Scholar
 Kröger O, Coffrin C, Hijazi H, Nagarajan H (2018) Juniper: an opensource nonlinear branchandbound solver in Julia. arXiv preprint: 1804.07332Google Scholar
 Kronqvist J, Lundell A, Westerlund T (2016) The extended supporting hyperplane algorithm for convex mixedinteger nonlinear programming. J Global Optim 64(2):249–272MathSciNetzbMATHGoogle Scholar
 Kronqvist J, Bernal D, Lundell A, Westerlund T (2018a) A centercut algorithm for quickly obtaining feasible solutions and solving convex MINLP problems. Comput Chem Eng. https://doi.org/10.1016/j.compchemeng.2018.06.019
 Kronqvist J, Lundell A, Westerlund T (2018b) Reformulations for utilizing separability when solving convex MINLP problems. J Global Optim 71(3):571–592. https://doi.org/10.1007/s1089801806163 MathSciNetzbMATHGoogle Scholar
 Land AH, Doig AG (1960) An automatic method of solving discrete programming problems. Econom J Econom Soc 28:497–520MathSciNetzbMATHGoogle Scholar
 Lastusilta T (2011) GAMS MINLP solver comparisons and some improvements to the AlphaECP algorithm. PhD thesis, Åbo Akademi UniversityGoogle Scholar
 Le Digabel S (2011) Algorithm 909: Nomad: nonlinear optimization with the mads algorithm. ACM Trans Math Softw (TOMS) 37(4):44MathSciNetzbMATHGoogle Scholar
 Leyffer S (1993) Deterministic methods for mixed integer nonlinear programming. Ph.D. University of DundeeGoogle Scholar
 Leyffer S (1999) User manual for MINLP BB. Technical Report, University of Dundee numerical analysis reportGoogle Scholar
 Leyffer S (2001) Integrating SQP and branchandbound for mixed integer nonlinear programming. Comput Optim Appl 18(3):295–309MathSciNetzbMATHGoogle Scholar
 Liberti L (2009) Reformulation techniques in mathematical programming. HDR thesisGoogle Scholar
 Liberti L, Maculan N (2006) Global optimization: from theory to implementation, vol 84. Springer Science & Business Media, New YorkzbMATHGoogle Scholar
 Lin Y, Schrage L (2009) The global solver in the LINDO API. Optim Methods Softw 24(4–5):657–668MathSciNetzbMATHGoogle Scholar
 Linderoth JT, Savelsbergh MW (1999) A computational study of search strategies for mixed integer programming. INFORMS J Comput 11(2):173–187MathSciNetzbMATHGoogle Scholar
 LINDO Systems Inc (2017) LINDO User’s Manual. https://www.lindo.com/downloads/PDF/LindoUsersManual.pdf
 LougeeHeimer R (2003) The common optimization interface for operations research: Promoting opensource software in the operations research community. IBM J Res Dev 47(1):57–66Google Scholar
 Lubin M, Yamangil E, Bent R, Vielma JP (2016) Extended formulations in mixedinteger convex programming. In: Louveaux Q, Skutella M (eds) 18th International conference integer programming and combinatorial optimization: IPCO 2016. Springer International Publishing, pp 102–113Google Scholar
 Lundell A, Westerlund T (2017) Solving global optimization problems using reformulations and signomial transformations. Comput Chem Eng 116:122–134Google Scholar
 Lundell A, Westerlund J, Westerlund T (2009) Some transformation techniques with applications in global optimization. J Global Optim 43(2–3):391–405MathSciNetzbMATHGoogle Scholar
 Lundell A, Kronqvist J, Westerlund T (2017) SHOT—a global solver for convex MINLP in Wolfram Mathematica. Comput Aided Chem Eng 40:2137–2142Google Scholar
 Lundell A, Kronqvist J, Westerlund T (2018) The supporting hyperplane optimization toolkit—a polyhedral outer approximation based convex MINLP solver utilizing a single branching tree approach. Optimization. http://www.optimizationonline.org/DB_HTML/2018/06/6680.html
 Mahajan A, Leyffer S, Linderoth J, Luedtke J, Munson T (2017) Minotaur: a mixedinteger nonlinear optimization toolkit. Optimization. http://www.optimizationonline.org/DB_FILE/2017/10/6275.pdf
 Makhorin A (2008) GLPK (GNU linear programming kit). http://www.gnu.org/software/glpk/
 Melo W, Fampa M, Raupp F (2018a) First steps to solve MINLP problems with Muriqui Optimizer. http://www.wendelmelo.net/muriqui/manual_muriquiing3.pdf. Accessed 18 May 2018
 Melo W, Fampa M, Raupp F (2018b) An overview of MINLP algorithms and their implementation in Muriqui Optimizer. Ann Oper Res. https://doi.org/10.1007/s1047901828725 Google Scholar
 MINLPLib (2018) Mixedinteger nonlinear programming library. http://www.minlplib.org/. Accessed 27 May 2018
 Misener R, Floudas CA (2009) Advances for the pooling problem: modeling, global optimization, and computational studies. Appl Comput Math 8(1):3–22MathSciNetzbMATHGoogle Scholar
 Misener R, Floudas CA (2013) GloMIQO: global mixedinteger quadratic optimizer. J Global Optim 57(1):3–50MathSciNetzbMATHGoogle Scholar
 Misener R, Floudas CA (2014) ANTIGONE: algorithms for continuous/integer global optimization of nonlinear equations. J Global Optim 59(2–3):503–526MathSciNetzbMATHGoogle Scholar
 Nagarajan H, Lu M, Wang S, Bent R, Sundar K (2017) An adaptive, multivariate partitioning algorithm for global optimization of nonconvex programs. arXiv preprint: 1707.02514Google Scholar
 Nemhauser GL, Savelsbergh MW, Sigismondi GC (1994) MINTO, a MIxed INTeger optimizer. Oper Res Lett 15(1):47–58MathSciNetzbMATHGoogle Scholar
 Nowak I, Alperin H, Vigerske S (2002) LaGO–an object oriented library for solving MINLPs. In: Bliek C, Jermann C, Neumaier A (eds) International workshop on global optimization and constraint satisfaction. Springer, Berlin, pp 32–42Google Scholar
 Nowak I, Breitfeld N, Hendrix EM, NjacheunNjanzoua G (2018) Decompositionbased innerand outerrefinement algorithms for global optimization. J Global Optim 72(2):305–321. https://doi.org/10.1007/s1089801806332 MathSciNetzbMATHGoogle Scholar
 Pörn R, Harjunkoski I, Westerlund T (1999) Convexification of different classes of nonconvex MINLP problems. Comput Chem Eng 23(3):439–448Google Scholar
 Quesada I, Grossmann IE (1992) An LP/NLP based branch and bound algorithm for convex MINLP optimization problems. Comput Chem Eng 16(10–11):937–947Google Scholar
 Quist A, Van Geemert R, Hoogenboom J, Ílles T, Roos C, Terlaky T (1999) Application of nonlinear optimization to reactor core fuel reloading. Ann Nuclear Energy 26(5):423–448Google Scholar
 Roelofs M, Bisschop J (2018) AIMMS—the language reference. https://download.aimms.com/aimms/download/manuals/AIMMS3_LR.pdf
 Ryoo HS, Sahinidis NV (1996) A branchandreduce approach to global optimization. J Global Optim 8(2):107–138MathSciNetzbMATHGoogle Scholar
 Sahinidis N, Grossmann IE (1991) MINLP model for cyclic multiproduct scheduling on continuous parallel lines. Comput Chem Eng 15(2):85–103Google Scholar
 Schweiger C, Floudas C (1998) Minopt: a modeling language and algorithmic framework for linear, mixedinteger, nonlinear, dynamic, and mixedinteger nonlinear optimization. Princeton University. http://titan.princeton.edu/MINOPT
 Shectman JP, Sahinidis NV (1998) A finite algorithm for global minimization of separable concave programs. J Global Optim 12(1):1–36MathSciNetzbMATHGoogle Scholar
 Stubbs RA, Mehrotra S (1999) A branchandcut method for 0–1 mixed convex programming. Math Program 86(3):515–532MathSciNetzbMATHGoogle Scholar
 Tawarmalani M, Sahinidis NV (2002) Convexification and global optimization in continuous and mixedinteger nonlinear programming: Theory, algorithms, software, and applications, vol 65. Springer Science & Business Media, New YorkzbMATHGoogle Scholar
 Tawarmalani M, Sahinidis NV (2005) A polyhedral branchandcut approach to global optimization. Math Program 103:225–249MathSciNetzbMATHGoogle Scholar
 Trespalacios F, Grossmann IE (2014) Review of mixedinteger nonlinear and generalized disjunctive programming methods. Chem Ing Tech 86(7):991–1012Google Scholar
 Vigerske S, Gleixner A (2018) SCIP: global optimization of mixedinteger nonlinear programs in a branchandcut framework. Optim Methods Softw 33(3):563–593MathSciNetzbMATHGoogle Scholar
 Viswanathan J, Grossmann IE (1990) A combined penalty function and outerapproximation method for MINLP optimization. Comput Chem Eng 14(7):769–782Google Scholar
 Wächter A, Biegler LT (2006) On the implementation of an interiorpoint filter linesearch algorithm for largescale nonlinear programming. Math Program 106(1):25–57MathSciNetzbMATHGoogle Scholar
 Westerlund T (2018) Users guide for GAECP, an interactive solver for generalized convex MINLPproblems using cutting plane and supporting hyperplane techniques. http://users.abo.fi/twesterl/GAECPDocumentation.pdf
 Westerlund T, Petterson F (1995) An extended cutting plane method for solving convex MINLP problems. Comput Chem Eng 19:131–136Google Scholar
 Westerlund T, Pörn R (2002) Solving pseudoconvex mixed integer optimization problems by cutting plane techniques. Optim Eng 3(3):253–280MathSciNetzbMATHGoogle Scholar
 Wolsey LA (1998) Integer programming. Series in discrete mathematics and optimization. WileyInterscience, New JerseyGoogle Scholar
 Zhou K, Kılınç MR, Chen X, Sahinidis NV (2018) An efficient strategy for the activation of MIP relaxations in a multicore global MINLP solver. J Global Optim 70(3):497–516MathSciNetzbMATHGoogle Scholar
 Zhu Y, Kuno T (2006) A disjunctive cuttingplanebased branchandcut algorithm for 0–1 mixedinteger convex nonlinear programs. Ind Eng Chem Res 45(1):187–196Google Scholar
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.