DOCSLIB.ORG

COIN-OR Project Leader for Bonmin Is Pierre Bonami

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
COIN-OR Project Leader for Bonmin Is Pierre Bonami COIN-OR Stefan Vigerske, Humboldt University Berlin, Germany Contents 1 Introduction .......................................... 1 2 CoinBonmin .......................................... 2 2.1 Model requirements ...................................... 3 2.2 Usage of CoinBonmin ..................................... 3 2.3 Specification of CoinBonmin Options ............................. 3 2.4 Description of CoinBonmin Options ............................. 3 3 CoinCbc ............................................. 14 3.1 Model requirements ...................................... 14 3.2 Usage of CoinCbc ....................................... 14 3.3 Summary of CoinCBC Options ................................ 15 3.4 Detailed Descriptions of CoinCBC Options ......................... 16 4 CoinGlpk ............................................ 25 4.1 Model requirements ...................................... 25 4.2 Usage of CoinGlpk ....................................... 25 4.3 Summary of CoinGlpk Options ................................ 26 4.4 Detailed Descriptions of CoinGlpk Options ......................... 26 5 CoinIpopt ............................................ 28 5.1 Model requirements ...................................... 28 5.2 Usage of CoinIpopt ....................................... 28 5.3 Output ............................................. 29 5.4 Specification of CoinIpopt Options .............................. 30 5.5 Detailed Description of CoinIpopt Options ......................... 31 1 Introduction COIN-OR (COmputational INfrastructure for Operations Research, http://www.coin-or.org) is an initiative to spur the development of open-source software for the operations research community. One of the projects hosted at COIN-OR is the GAMSlinks project (https://projects.coin-or.org/GAMSlinks). It is dedicated to the development of interfaces between GAMS and open source solvers. Some of these links and solvers have also found their way into the regular GAMS distribution. They are currently available for Linux (32 and 64 bit), Windows (32 bit), Sun Solaris (Intel 64 bit), and Darwin (Intel 32 bit) systems. As of GAMS Distribution 22.6, available solvers include: • CoinBonmin 0.9: Basic Open-source Nonlinear Mixed Integer programming (model types: LP, RMIP, MIP, DNLP, NLP, RMINLP, MINLP, QCP, RMIQCP, MIQCP) COIN-OR 2 • CoinCbc 2.0: COIN-OR Branch and Cut (model types: LP, MIP, RMIP) • CoinGlpk 4.22: Gnu Linear Programming Kit (model types: LP, MIP, RMIP) • CoinIpopt 3.3: Interior Point Optimizer (model types: LP, RMIP, DNLP, NLP, RMINLP, QCP, RMIQCP) With the availability of source code for the GAMS/COIN-OR links the user is not limited to the out of the box GAMS/COIN-OR solvers that come with a regular GAMS distribution. For more information see the COIN-OR/GAMSlinks web site at https://projects.coin-or.org/GAMSlinks. 2 CoinBonmin GAMS/CoinBonmin brings the open source MINLP solver Bonmin from the COIN-OR foundation to the broad audience of GAMS users. Bonmin (Basic Open-source Nonlinear Mixed Integer programming) 0.9 is an open-source solver for mixed- integer nonlinear programming (MINLPs), whereof some parts are still experimental. The code is developed in a joined project of IBM and the Carnegie Mellon University. The COIN-OR project leader for Bonmin is Pierre Bonami. Bonmin implements five different algorithms: • B-BB: a simple branch-and-bound algorithm based on solving a continuous nonlinear program at each node of the search tree and branching on variables • B-OA: an outer-approximation based decomposition algorithm • B-QG: an outer-approximation based branch-and-cut algorithm (by Queseda and Grossmann) • B-Hyb: a hybrid outer-approximation/nonlinear programming based branch-and-cut algorithm (default) • B-Ecp: an ECP cuts based branch-and-cut algorithm a la FilMINT The algorithms are exact when the problem is convex, otherwise they are heuristics. For convex MINLPs, experiments on a reasonably large test set of problems have shown that B-Hyp is the algorithm of choice (it solved most of the problems in 3 hours of computing time). Therefore, it is the default algorithm in Bonmin. Nevertheless, there are cases where B-OA is much faster than B-Hyb and others where B-BB is interesting. B-QG corresponds mainly to a specific parameter setting of B-Hyb where some features are disabled. B-Ecp has just been added to Bonmin and is still experimental. For nonconvex MINLPs, it is strongly recommend to use B-BB, even though it is only a heuristic for such problems too. For more information we refer to • the Bonmin web site https://projects.coin-or.org/Bonmin and • the paper P. Bonami, L.T. Biegler, A.R. Conn, G. Cornuejols, I.E. Grossmann, C.D. Laird, J. Lee, A. Lodi, F. Margot, N.Sawaya and A. W¨achter, An Algorithmic Framework for Convex Mixed Integer Nonlinear Programs, IBM Research Report RC23771, Oct. 2005. Most of the Bonmin documentation in the section was copied from the Bonmin manual available on the Bonmin web site. COIN-OR 3 2.1 Model requirements Bonmin can handle mixed-integer nonlinear programming models which functions can be nonconvex, but should be twice continuously differentiable. The Bonmin link in GAMS supports continuous, binary, and integer variables, special ordered sets, branching priorities, but no semi-continuous or semi-integer variables (see chapter 17.1 of the GAMS User’s Guide). If GAMS/CoinBonmin is called for a model with only continuous variables, the interface directly calls Ipopt. 2.2 Usage of CoinBonmin The following statement can be used inside your GAMS program to specify using CoinBonmin Option MINLP = CoinBonmin; { or LP, RMIP, MIP, DNLP, NLP, RMINLP, QCP, RMIQCP, MIQCP } The above statement should appear before the Solve statement. If CoinBonmin was specified as the default solver during GAMS installation, the above statement is not necessary. 2.3 Specification of CoinBonmin Options A Bonmin option file contains both Ipopt and Bonmin options, for clarity all Bonmin options should be preceded with the prefix “bonmin.”. The scheme to name option files is the same as for all other GAMS solvers. Specifying optfile=1 let Gams/CoinBonmin read coinbonmin.opt, optfile=2 corresponds to coinbonmin.op2, and so on. The format of the option file is the same as for Ipopt (see Section 5.4). The most important option in Bonmin is the choice of the solution algorithm. This can be set by using the option named bonmin.algorithm which can be set to B-BB, B-OA, B-QG, B-Hyb, or B-Ecp (its default value is B-Hyb). Depending on the value of this option, certain other options may be available or not. In the context of outer approximation decomposition, several options are available for configuring the MIP sub- solver CBC. By setting the option bonmin.milp subsolver to Cbc Par, a version of CBC is chosen that can be parameterized by the user. The options that can be set are the node-selection strategy, the number of strong- branching candidates, the number of branches before pseudo costs are to be trusted, and the frequency of some cut generators. Their name coincide with Bonmins options, except that the “bonmin.” prefix is replaced with “milp sub.”. An example of a bonmin.opt file is the following: bonmin.algorithm B-Hyb bonmin.oa_log_level 4 bonmin.milp_subsolver Cbc_Par milp_sub.cover_cuts 0 print_level 6 This sets the algorithm to be used to the hybrid algorithm, the level of outer approximation related output to 4, the print level for Ipopt to 6, the MIP subsolver for outer approximation to a parameterized version of CBC, and switches off cover cutting planes for the MIP subsolver. GAMS/CoinBonmin understands currently the following GAMS parameters: reslim (time limit), iterlim (iteration limit), nodlim (node limit), cutoff, optca (absolute gap tolerance), and optcr (relative gap tolerance). You can set them either on the command line, e.g. nodlim=1000, or inside your GAMS program, e.g. Option nodlim=1000;. 2.4 Description of CoinBonmin Options The following tables gives the list of options together with their types, default values and availability in each of the four main algorithms. The column labeled ‘type’ indicates the type of the parameter (‘F’ stands for float, ‘I’ for integer, and ‘S’ for string). The column labeled ‘default’ indicates the global default value. Then for each COIN-OR 4 of the four algorithm B-BB, B-OA, B-QG, and B-Hyb, ‘+’ indicates that the option is available for that particular algorithm while ‘−’ indicates that it is not. Options that are marked with ∗ are those that can be used to configure the MIP subsolver. Option type default B-BB B-OA B-QG B-Hyb Algorithm choice algorithm S BHyb + + + + Branch-and-bound allowable fraction gap F optrc (0.1) + + + + allowable gap F optca (0) + + + + cutoff F cutoff or 10100 + + + + cutoff decr F 10−5 + + + + integer tolerance F 10−6 + + + + iteration limit I ∞ + + + + nlp failure behavior S stop + + + + node comparison∗ S dynamic + + + + node limit I nodlim or iterlim (10000) + + + + num cut passes I 1 – + + + num cut passes at root I 20 – + + + number before trust∗ I 8 + + + + number strong branch∗ I 20 + + + + solution limit I ∞ + + + + time limit F reslim (1000) + + + + tree search strategy S topnode + + + + varselect stra S strongbranching + + + + Outer Approximation decomposition milp subsolver S Cbc D – + – + oa dec time limit F 30 + + + + Outer Approximation cuts add only violated oa S no – + + + cut strengthening type S none – + + + disjunctive cut type S none – + + + oa cuts scope S global – + + + tiny element F 10−8 – + + + very tiny element F 10−7
Load more

Recommended publications
  • Nonlinear Optimization Using the Generalized Reduced Gradient Method Revue Française D’Automatique, Informatique, Recherche Opé- Rationnelle
    REVUE FRANÇAISE D’AUTOMATIQUE, INFORMATIQUE, RECHERCHE OPÉRATIONNELLE.RECHERCHE OPÉRATIONNELLE LEON S. LASDON RICHARD L. FOX MARGERY W. RATNER Nonlinear optimization using the generalized reduced gradient method Revue française d’automatique, informatique, recherche opé- rationnelle. Recherche opérationnelle, tome 8, no V3 (1974), p. 73-103 <http://www.numdam.org/item?id=RO_1974__8_3_73_0> © AFCET, 1974, tous droits réservés. L’accès aux archives de la revue « Revue française d’automatique, in- formatique, recherche opérationnelle. Recherche opérationnelle » implique l’accord avec les conditions générales d’utilisation (http://www.numdam.org/ conditions). Toute utilisation commerciale ou impression systématique est constitutive d’une infraction pénale. Toute copie ou impression de ce fi- chier doit contenir la présente mention de copyright. Article numérisé dans le cadre du programme Numérisation de documents anciens mathématiques http://www.numdam.org/ R.A.LR.O. (8* année, novembre 1974, V-3, p. 73 à 104) NONLINEAR OPTIMIZATION USING THE-GENERALIZED REDUCED GRADIENT METHOD (*) by Léon S. LÀSDON, Richard L. Fox and Margery W. RATNER Abstract. — This paper describes the principles and logic o f a System of computer programs for solving nonlinear optimization problems using a Generalized Reduced Gradient Algorithm, The work is based on earlier work of Âbadie (2). Since this paper was written, many changes have been made in the logic, and significant computational expérience has been obtained* We hope to report on this in a later paper. 1. INTRODUCTION Generalized Reduced Gradient methods are algorithms for solving non- linear programs of gênerai structure. This paper discusses the basic principles of GRG, and constructs a spécifie GRG algorithm. The logic of a computer program implementing this algorithm is presented by means of flow charts and discussion.
    [Show full text]
  • Combinatorial Structures in Nonlinear Programming
    Combinatorial Structures in Nonlinear Programming Stefan Scholtes¤ April 2002 Abstract Non-smoothness and non-convexity in optimization problems often arise because a combinatorial structure is imposed on smooth or convex data. The combinatorial aspect can be explicit, e.g. through the use of ”max”, ”min”, or ”if” statements in a model, or implicit as in the case of bilevel optimization where the combinatorial structure arises from the possible choices of active constraints in the lower level problem. In analyzing such problems, it is desirable to decouple the combinatorial from the nonlinear aspect and deal with them separately. This paper suggests a problem formulation which explicitly decouples the two aspects. We show that such combinatorial nonlinear programs, despite their inherent non-convexity, allow for a convex first order local optimality condition which is generic and tight. The stationarity condition can be phrased in terms of Lagrange multipliers which allows an extension of the popular sequential quadratic programming (SQP) approach to solve these problems. We show that the favorable local convergence properties of SQP are retained in this setting. The computational effectiveness of the method depends on our ability to solve the subproblems efficiently which, in turn, depends on the representation of the governing combinatorial structure. We illustrate the potential of the approach by applying it to optimization problems with max-min constraints which arise, for example, in robust optimization. 1 Introduction Nonlinear programming is nowadays regarded as a mature field. A combination of important algorithmic developments and increased computing power over the past decades have advanced the field to a stage where the majority of practical prob- lems can be solved efficiently by commercial software.
    [Show full text]
  • A Lifted Linear Programming Branch-And-Bound Algorithm for Mixed Integer Conic Quadratic Programs Juan Pablo Vielma, Shabbir Ahmed, George L
    A Lifted Linear Programming Branch-and-Bound Algorithm for Mixed Integer Conic Quadratic Programs Juan Pablo Vielma, Shabbir Ahmed, George L. Nemhauser, H. Milton Stewart School of Industrial and Systems Engineering, Georgia Institute of Technology, 765 Ferst Drive NW, Atlanta, GA 30332-0205, USA, {[email protected], [email protected], [email protected]} This paper develops a linear programming based branch-and-bound algorithm for mixed in- teger conic quadratic programs. The algorithm is based on a higher dimensional or lifted polyhedral relaxation of conic quadratic constraints introduced by Ben-Tal and Nemirovski. The algorithm is different from other linear programming based branch-and-bound algo- rithms for mixed integer nonlinear programs in that, it is not based on cuts from gradient inequalities and it sometimes branches on integer feasible solutions. The algorithm is tested on a series of portfolio optimization problems. It is shown that it significantly outperforms commercial and open source solvers based on both linear and nonlinear relaxations. Key words: nonlinear integer programming; branch and bound; portfolio optimization History: February 2007. 1. Introduction This paper deals with the development of an algorithm for the class of mixed integer non- linear programming (MINLP) problems known as mixed integer conic quadratic program- ming problems. This class of problems arises from adding integrality requirements to conic quadratic programming problems (Lobo et al., 1998), and is used to model several applica- tions from engineering and finance. Conic quadratic programming problems are also known as second order cone programming problems, and together with semidefinite and linear pro- gramming (LP) problems are special cases of the more general conic programming problems (Ben-Tal and Nemirovski, 2001a).
    [Show full text]
  • Linear Programming
    Lecture 18 Linear Programming 18.1 Overview In this lecture we describe a very general problem called linear programming that can be used to express a wide variety of different kinds of problems. We can use algorithms for linear program- ming to solve the max-flow problem, solve the min-cost max-flow problem, find minimax-optimal strategies in games, and many other things. We will primarily discuss the setting and how to code up various problems as linear programs At the end, we will briefly describe some of the algorithms for solving linear programming problems. Specific topics include: • The definition of linear programming and simple examples. • Using linear programming to solve max flow and min-cost max flow. • Using linear programming to solve for minimax-optimal strategies in games. • Algorithms for linear programming. 18.2 Introduction In the last two lectures we looked at: — Bipartite matching: given a bipartite graph, find the largest set of edges with no endpoints in common. — Network flow (more general than bipartite matching). — Min-Cost Max-flow (even more general than plain max flow). Today, we’ll look at something even more general that we can solve algorithmically: linear pro- gramming. (Except we won’t necessarily be able to get integer solutions, even when the specifi- cation of the problem is integral). Linear Programming is important because it is so expressive: many, many problems can be coded up as linear programs (LPs). This especially includes problems of allocating resources and business 95 18.3. DEFINITION OF LINEAR PROGRAMMING 96 supply-chain applications. In business schools and Operations Research departments there are entire courses devoted to linear programming.
    [Show full text]
  • Integer Linear Programs
    20 ________________________________________________________________________________________________ Integer Linear Programs Many linear programming problems require certain variables to have whole number, or integer, values. Such a requirement arises naturally when the variables represent enti- ties like packages or people that can not be fractionally divided — at least, not in a mean- ingful way for the situation being modeled. Integer variables also play a role in formulat- ing equation systems that model logical conditions, as we will show later in this chapter. In some situations, the optimization techniques described in previous chapters are suf- ficient to find an integer solution. An integer optimal solution is guaranteed for certain network linear programs, as explained in Section 15.5. Even where there is no guarantee, a linear programming solver may happen to find an integer optimal solution for the par- ticular instances of a model in which you are interested. This happened in the solution of the multicommodity transportation model (Figure 4-1) for the particular data that we specified (Figure 4-2). Even if you do not obtain an integer solution from the solver, chances are good that you’ll get a solution in which most of the variables lie at integer values. Specifically, many solvers are able to return an ‘‘extreme’’ solution in which the number of variables not lying at their bounds is at most the number of constraints. If the bounds are integral, all of the variables at their bounds will have integer values; and if the rest of the data is integral, many of the remaining variables may turn out to be integers, too.
    [Show full text]
  • Nonlinear Integer Programming ∗
    Nonlinear Integer Programming ∗ Raymond Hemmecke, Matthias Koppe,¨ Jon Lee and Robert Weismantel Abstract. Research efforts of the past fifty years have led to a development of linear integer programming as a mature discipline of mathematical optimization. Such a level of maturity has not been reached when one considers nonlinear systems subject to integrality requirements for the variables. This chapter is dedicated to this topic. The primary goal is a study of a simple version of general nonlinear integer problems, where all constraints are still linear. Our focus is on the computational complexity of the problem, which varies significantly with the type of nonlinear objective function in combination with the underlying combinatorial structure. Nu- merous boundary cases of complexity emerge, which sometimes surprisingly lead even to polynomial time algorithms. We also cover recent successful approaches for more general classes of problems. Though no positive theoretical efficiency results are available, nor are they likely to ever be available, these seem to be the currently most successful and interesting approaches for solving practical problems. It is our belief that the study of algorithms motivated by theoretical considera- tions and those motivated by our desire to solve practical instances should and do inform one another. So it is with this viewpoint that we present the subject, and it is in this direction that we hope to spark further research. Raymond Hemmecke Otto-von-Guericke-Universitat¨ Magdeburg, FMA/IMO, Universitatsplatz¨ 2, 39106 Magdeburg, Germany, e-mail: [email protected] Matthias Koppe¨ University of California, Davis, Dept. of Mathematics, One Shields Avenue, Davis, CA, 95616, USA, e-mail: [email protected] Jon Lee IBM T.J.
    [Show full text]
  • Chapter 11: Basic Linear Programming Concepts
    CHAPTER 11: BASIC LINEAR PROGRAMMING CONCEPTS Linear programming is a mathematical technique for finding optimal solutions to problems that can be expressed using linear equations and inequalities. If a real-world problem can be represented accurately by the mathematical equations of a linear program, the method will find the best solution to the problem. Of course, few complex real-world problems can be expressed perfectly in terms of a set of linear functions. Nevertheless, linear programs can provide reasonably realistic representations of many real-world problems — especially if a little creativity is applied in the mathematical formulation of the problem. The subject of modeling was briefly discussed in the context of regulation. The regulation problems you learned to solve were very simple mathematical representations of reality. This chapter continues this trek down the modeling path. As we progress, the models will become more mathematical — and more complex. The real world is always more complex than a model. Thus, as we try to represent the real world more accurately, the models we build will inevitably become more complex. You should remember the maxim discussed earlier that a model should only be as complex as is necessary in order to represent the real world problem reasonably well. Therefore, the added complexity introduced by using linear programming should be accompanied by some significant gains in our ability to represent the problem and, hence, in the quality of the solutions that can be obtained. You should ask yourself, as you learn more about linear programming, what the benefits of the technique are and whether they outweigh the additional costs.
    [Show full text]
  • Chapter 7. Linear Programming and Reductions
    Chapter 7 Linear programming and reductions Many of the problems for which we want algorithms are optimization tasks: the shortest path, the cheapest spanning tree, the longest increasing subsequence, and so on. In such cases, we seek a solution that (1) satisfies certain constraints (for instance, the path must use edges of the graph and lead from s to t, the tree must touch all nodes, the subsequence must be increasing); and (2) is the best possible, with respect to some well-defined criterion, among all solutions that satisfy these constraints. Linear programming describes a broad class of optimization tasks in which both the con- straints and the optimization criterion are linear functions. It turns out an enormous number of problems can be expressed in this way. Given the vastness of its topic, this chapter is divided into several parts, which can be read separately subject to the following dependencies. Flows and matchings Introduction to linear programming Duality Games and reductions Simplex 7.1 An introduction to linear programming In a linear programming problem we are given a set of variables, and we want to assign real values to them so as to (1) satisfy a set of linear equations and/or linear inequalities involving these variables and (2) maximize or minimize a given linear objective function. 201 202 Algorithms Figure 7.1 (a) The feasible region for a linear program. (b) Contour lines of the objective function: x1 + 6x2 = c for different values of the profit c. x x (a) 2 (b) 2 400 400 Optimum point Profit = $1900 ¡ ¡ ¡ ¡ ¡ 300 ¢¡¢¡¢¡¢¡¢ 300 ¡ ¡ ¡ ¡ ¡ ¢¡¢¡¢¡¢¡¢ ¡ ¡ ¡ ¡ ¡ ¢¡¢¡¢¡¢¡¢ 200 200 c = 1500 ¡ ¡ ¡ ¡ ¡ ¢¡¢¡¢¡¢¡¢ ¡ ¡ ¡ ¡ ¡ ¢¡¢¡¢¡¢¡¢ c = 1200 ¡ ¡ ¡ ¡ ¡ 100 ¢¡¢¡¢¡¢¡¢ 100 ¡ ¡ ¡ ¡ ¡ ¢¡¢¡¢¡¢¡¢ c = 600 ¡ ¡ ¡ ¡ ¡ ¢¡¢¡¢¡¢¡¢ x1 x1 0 100 200 300 400 0 100 200 300 400 7.1.1 Example: profit maximization A boutique chocolatier has two products: its flagship assortment of triangular chocolates, called Pyramide, and the more decadent and deluxe Pyramide Nuit.
    [Show full text]
  • Linear Programming
    Stanford University | CS261: Optimization Handout 5 Luca Trevisan January 18, 2011 Lecture 5 In which we introduce linear programming. 1 Linear Programming A linear program is an optimization problem in which we have a collection of variables, which can take real values, and we want to find an assignment of values to the variables that satisfies a given collection of linear inequalities and that maximizes or minimizes a given linear function. (The term programming in linear programming, is not used as in computer program- ming, but as in, e.g., tv programming, to mean planning.) For example, the following is a linear program. maximize x1 + x2 subject to x + 2x ≤ 1 1 2 (1) 2x1 + x2 ≤ 1 x1 ≥ 0 x2 ≥ 0 The linear function that we want to optimize (x1 + x2 in the above example) is called the objective function.A feasible solution is an assignment of values to the variables that satisfies the inequalities. The value that the objective function gives 1 to an assignment is called the cost of the assignment. For example, x1 := 3 and 1 2 x2 := 3 is a feasible solution, of cost 3 . Note that if x1; x2 are values that satisfy the inequalities, then, by summing the first two inequalities, we see that 3x1 + 3x2 ≤ 2 that is, 1 2 x + x ≤ 1 2 3 2 1 1 and so no feasible solution has cost higher than 3 , so the solution x1 := 3 , x2 := 3 is optimal. As we will see in the next lecture, this trick of summing inequalities to verify the optimality of a solution is part of the very general theory of duality of linear programming.
    [Show full text]
  • Implementing Customized Pivot Rules in COIN-OR's CLP with Python
    Cahier du GERAD G-2012-07 Customizing the Solution Process of COIN-OR's Linear Solvers with Python Mehdi Towhidi1;2 and Dominique Orban1;2 ? 1 Department of Mathematics and Industrial Engineering, Ecole´ Polytechnique, Montr´eal,QC, Canada. 2 GERAD, Montr´eal,QC, Canada. [email protected], [email protected] Abstract. Implementations of the Simplex method differ only in very specific aspects such as the pivot rule. Similarly, most relaxation methods for mixed-integer programming differ only in the type of cuts and the exploration of the search tree. Implementing instances of those frame- works would therefore be more efficient if linear and mixed-integer pro- gramming solvers let users customize such aspects easily. We provide a scripting mechanism to easily implement and experiment with pivot rules for the Simplex method by building upon COIN-OR's open-source linear programming package CLP. Our mechanism enables users to implement pivot rules in the Python scripting language without explicitly interact- ing with the underlying C++ layers of CLP. In the same manner, it allows users to customize the solution process while solving mixed-integer linear programs using the CBC and CGL COIN-OR packages. The Cython pro- gramming language ensures communication between Python and COIN- OR libraries and activates user-defined customizations as callbacks. For illustration, we provide an implementation of a well-known pivot rule as well as the positive edge rule|a new rule that is particularly efficient on degenerate problems, and demonstrate how to customize branch-and-cut node selection in the solution of a mixed-integer program.
    [Show full text]
  • An Improved Sequential Quadratic Programming Method Based on Positive Constraint Sets, Chemical Engineering Transactions, 81, 157-162 DOI:10.3303/CET2081027
    157 A publication of CHEMICAL ENGINEERING TRANSACTIONS VOL. 81, 2020 The Italian Association of Chemical Engineering Online at www.cetjournal.it Guest Editors: Petar S. Varbanov, Qiuwang Wang, Min Zeng, Panos Seferlis, Ting Ma, Jiří J. Klemeš Copyright © 2020, AIDIC Servizi S.r.l. DOI: 10.3303/CET2081027 ISBN 978-88-95608-79-2; ISSN 2283-9216 An Improved Sequential Quadratic Programming Method Based on Positive Constraint Sets Li Xiaa,*, Jianyang Linga, Rongshan Bia, Wenying Zhaob, Xiaorong Caob, Shuguang Xianga a State Key Laboratory Base for Eco-Chemical Engineering, College of Chemical Engineering, Qingdao University of Science and Technology, Zhengzhou Road No. 53, Qingdao 266042, China b Chemistry and Chemistry Engineering Faculty,Qilu Normal University, jinan, 250013, Shandong, China [email protected] SQP (sequential quadratic programming) is an effective method to solve nonlinear constraint problems, widely used in chemical process simulation optimization. At present, most optimization methods in general chemical process simulation software have the problems of slow calculation and poor convergence. To solve these problems , an improved SQP optimization method based on positive constraint sets was developed. The new optimization method was used in the general chemical process simulation software named optimization engineers , adopting the traditional Armijo type step rule, L-BFGS (Limited-Memory BFGS) algorithm and rules of positive definite matrix. Compared to the traditional SQP method, the SQP optimization method based on positive constraint sets simplifies the constraint number of corresponding subproblems. L-BFGS algorithm and rules of positive definite matrix simplify the solution of the second derivative matrix, and reduce the amount of storage in the calculation process.
    [Show full text]
  • Appendix a Solving Systems of Nonlinear Equations
    Appendix A Solving Systems of Nonlinear Equations Chapter 4 of this book describes and analyzes the power flow problem. In its ac version, this problem is a system of nonlinear equations. This appendix describes the most common method for solving a system of nonlinear equations, namely, the Newton-Raphson method. This is an iterative method that uses initial values for the unknowns and, then, at each iteration, updates these values until no change occurs in two consecutive iterations. For the sake of clarity, we first describe the working of this method for the case of just one nonlinear equation with one unknown. Then, the general case of n nonlinear equations and n unknowns is considered. We also explain how to directly solve systems of nonlinear equations using appropriate software. A.1 Newton-Raphson Algorithm The Newton-Raphson algorithm is described in this section. A.1.1 One Unknown Consider a nonlinear function f .x/ W R ! R. We aim at finding a value of x so that: f .x/ D 0: (A.1) .0/ To do so, we first consider a given value of x, e.g., x . In general, we have that f x.0/ ¤ 0. Thus, it is necessary to find x.0/ so that f x.0/ C x.0/ D 0. © Springer International Publishing AG 2018 271 A.J. Conejo, L. Baringo, Power System Operations, Power Electronics and Power Systems, https://doi.org/10.1007/978-3-319-69407-8 272 A Solving Systems of Nonlinear Equations Using Taylor series, we can express f x.0/ C x.0/ as: Â Ã.0/ 2 Â Ã.0/ df .x/ x.0/ d2f .x/ f x.0/ C x.0/ D f x.0/ C x.0/ C C ::: dx 2 dx2 (A.2) .0/ Considering only the first two terms in Eq.
    [Show full text]