A short OPL tutorial

Advertisement
Similar documents
Discuss the size of the instance for the minimum spanning tree problem.

Jeffrey Kantor. August 28, 2006

EXCEL SOLVER TUTORIAL

2.3 Scheduling jobs on identical parallel machines

1 Solving LPs: The Simplex Algorithm of George Dantzig

Lecture 3: Linear Programming Relaxations and Rounding

Proximal mapping via network optimization

Approximation Algorithms

4.6 Linear Programming duality

C&O 370 Deterministic OR Models Winter 2011

Linear Programming for Optimization. Mark A. Schulze, Ph.D. Perceptive Scientific Instruments, Inc.

Linear Programming. Widget Factory Example. Linear Programming: Standard Form. Widget Factory Example: Continued.

Introduction to AMPL A Tutorial

Lecture 3. Linear Programming. 3B1B Optimization Michaelmas 2015 A. Zisserman. Extreme solutions. Simplex method. Interior point method

5 INTEGER LINEAR PROGRAMMING (ILP) E. Amaldi Fondamenti di R.O. Politecnico di Milano 1

What is Linear Programming?

Definition of a Linear Program

Mathematical finance and linear programming (optimization)

Practical Guide to the Simplex Method of Linear Programming

Linear Programming. March 14, 2014

Linear Programming I

An Expressive Auction Design for Online Display Advertising. AUTHORS: S├ębastien Lahaie, David C. Parkes, David M. Pennock

Special Situations in the Simplex Algorithm

! Solve problem to optimality. ! Solve problem in poly-time. ! Solve arbitrary instances of the problem. #-approximation algorithm.

Online Adwords Allocation

princeton univ. F 13 cos 521: Advanced Algorithm Design Lecture 6: Provable Approximation via Linear Programming Lecturer: Sanjeev Arora

Discrete Optimization

CHAPTER 9. Integer Programming

Linear Programming: Chapter 11 Game Theory

5.1 Bipartite Matching

Basic Components of an LP:

Permutation Betting Markets: Singleton Betting with Extra Information

Solutions to Homework 6

INTEGER PROGRAMMING. Integer Programming. Prototype example. BIP model. BIP models

Chapter Load Balancing. Approximation Algorithms. Load Balancing. Load Balancing on 2 Machines. Load Balancing: Greedy Scheduling

Solving NP Hard problems in practice lessons from Computer Vision and Computational Biology

Recovery of primal solutions from dual subgradient methods for mixed binary linear programming; a branch-and-bound approach

Why? A central concept in Computer Science. Algorithms are ubiquitous.

CSE 326, Data Structures. Sample Final Exam. Problem Max Points Score 1 14 (2x7) 2 18 (3x6) Total 92.

24. The Branch and Bound Method

Introduction to Algorithms Review information for Prelim 1 CS 4820, Spring 2010 Distributed Wednesday, February 24

! Solve problem to optimality. ! Solve problem in poly-time. ! Solve arbitrary instances of the problem. !-approximation algorithm.

3 Does the Simplex Algorithm Work?

Sensitivity Analysis 3.1 AN EXAMPLE FOR ANALYSIS

Modeling and Solving the Capacitated Vehicle Routing Problem on Trees

DATA ANALYSIS II. Matrix Algorithms

Nonlinear Programming Methods.S2 Quadratic Programming

Linear Programming. April 12, 2005

1 Introduction. Linear Programming. Questions. A general optimization problem is of the form: choose x to. max f(x) subject to x S. where.

Linear Programming Notes VII Sensitivity Analysis

56:171 Operations Research Midterm Exam Solutions Fall 2001

Facility Location: Discrete Models and Local Search Methods

7.1 Modelling the transportation problem

Linear Programming Notes V Problem Transformations

A linear combination is a sum of scalars times quantities. Such expressions arise quite frequently and have the form

Algorithm Design and Analysis

Linear Programming. Solving LP Models Using MS Excel, 18

Instituto Superior T├ęcnico Masters in Civil Engineering. Lecture 2: Transport networks design and evaluation Xpress presentation - Laboratory work

IEOR 4404 Homework #2 Intro OR: Deterministic Models February 14, 2011 Prof. Jay Sethuraman Page 1 of 5. Homework #2

Dynamic Programming. Applies when the following Principle of Optimality

Applied Algorithm Design Lecture 5

Factoring Algorithms

How to speed-up hard problem resolution using GLPK?

Permutation Betting Markets: Singleton Betting with Extra Information

Linear Programming in Matrix Form

Can linear programs solve NP-hard problems?

1. Sorting (assuming sorting into ascending order) a) BUBBLE SORT

Parameters and Expressions

Branch-and-Price Approach to the Vehicle Routing Problem with Time Windows

UNIT 1 LINEAR PROGRAMMING

EdExcel Decision Mathematics 1

Using Excel to Find Numerical Solutions to LP's

1.1 Logical Form and Logical Equivalence 1

3. Linear Programming and Polyhedral Combinatorics

Optimal Scheduling for Dependent Details Processing Using MS Excel Solver

Solutions to Linear Algebra Practice Problems 1. form (because the leading 1 in the third row is not to the right of the

a 11 x 1 + a 12 x a 1n x n = b 1 a 21 x 1 + a 22 x a 2n x n = b 2.

LABEL PROPAGATION ON GRAPHS. SEMI-SUPERVISED LEARNING. ----Changsheng Liu

Lecture 11: 0-1 Quadratic Program and Lower Bounds

MATHEMATICS Unit Decision 1

Programming Fundamental. Instructor Name: Lecture-2

Chapter 5. Linear Inequalities and Linear Programming. Linear Programming in Two Dimensions: A Geometric Approach

Linear Programs: Variables, Objectives and Constraints

A Constraint Programming based Column Generation Approach to Nurse Rostering Problems

A Note on the Bertsimas & Sim Algorithm for Robust Combinatorial Optimization Problems

Chapter 6. Linear Programming: The Simplex Method. Introduction to the Big M Method. Section 4 Maximization and Minimization with Problem Constraints

Noncommercial Software for Mixed-Integer Linear Programming

56:171. Operations Research -- Sample Homework Assignments Fall 1992 Dennis Bricker Dept. of Industrial Engineering University of Iowa.

Duality in General Programs. Ryan Tibshirani Convex Optimization /36-725

One last point: we started off this book by introducing another famously hard search problem:

Scheduling Algorithm with Optimization of Employee Satisfaction

Kerby Shedden October, Overview of R

Transportation Polytopes: a Twenty year Update

The number of marks is given in brackets [ ] at the end of each question or part question. The total number of marks for this paper is 72.

Solving Linear Programs

Quantitative Methods in Regulation

Recursive Algorithms. Recursion. Motivating Example Factorial Recall the factorial function. { 1 if n = 1 n! = n (n 1)! if n > 1

Lecture 2: August 29. Linear Programming (part I)

Nan Kong, Andrew J. Schaefer. Department of Industrial Engineering, Univeristy of Pittsburgh, PA 15261, USA

Chapter 13: Binary and Mixed-Integer Programming

Advertisement
Transcription:

A short OPL tutorial Truls Flatberg January 17, 2009 1 Introduction This note is a short tutorial to the modeling language OPL. The tutorial is by no means complete with regard to all features of OPL. More detailed information can be found in the Language User s Manual and the Language Reference Manual provided with the OPL installation. The motivation of this note is to show a few examples to get people quickly started using OPL. OPL is a modeling language for describing (and solving) optimization problems. The motivation for using modeling languages to model optimization problems is primarily due to two reasons: It provides a syntax that is close to the mathematical formulation, thus making it easier to make the transition from the mathematical formulation to something that can be solved by the computer. It enables a clean separation between the model and the accompanying data. The same model can then be solved with different input data with little extra effort. OPL is just one example of a modeling language. Other examples include AMPL, Mosel and GAMS. Modeling languages are typically used for linear and integer optimization problems, but it is also possible to formulate quadratic problems in OPL. Before starting on the examples, we give a short overview of the structure of an OPL model. A model typically includes these four parts: 1. Data declarations. This part declares the data parameters used in the model, typically coefficients and index sets for the decision variables. Individual data parameters can be declared by giving their type and name, e.g. int a = 4; Sets of a specific type are declared by enclosing the type within curly braces 1

{int} I = {1, 2,, 4}; The sets can then be used to create arrays with an entry for each element in the set float A[I] = [0, 1, 5, 2]; 2. Decision variables. These are declared with the keyword dvar, e.g. dvar float+ x; declares x to be a non-negative real variable. Similarly to data, it is possible to create arrays of decision variables for a specific set.. Objective function. The objective function is declared with the keyword minimize or maximize depending on what you want to do. A simple example is maximize 4*x; 4. Constraints. The constraints are declared using the keyword subject to. The following declares two linear inequalities involving the decision variables x and y: subject to { 4*x + 2*y <= 1; -2*x + y >= 5; } Note that all statements in the model file are terminated by a semicolon. In addition to keywords used for describing optimization models, OPL provides a scripting language for non-modelling purposes. This scripting language can be used to display information about the solution, to interact with the model and alter it, or do multiple runs on the same model. The scripting language has a slightly different syntax from the modeling part and is encapsulated in an execute block. For example, execute { writeln("x=", x); } will print the value of the variable x. All model and data files discussed in this note can be downloaded from the author s website http://home.ifi.uio.no/trulsf. The easiest way to run the examples is to open the accompanying project file in OPL Studio. 2

2 A first model We will start out with a minimal OPL model to solve the following linear optimization problem: minimize 4x 2y subject to x y 1 x 0 The OPL model is as follows: 1 dvar float x ; 2 dvar float y ; 4 minimize 5 4 x 2 y ; 6 7 subject to { 8 x y >= 1 ; 9 x >= 0 ; 10 } Listing 1: simple.mod Note how similar the two formulations are. The constraint in line 9 can be removed and replaced with an explicit declaration of the variable x as type float+. Production planning We will continue with a production planning problem. A company produces two products: doors and windows. It has three production facilities with limited production time available: Factory 1 produces the metal frame Factory 2 produces the wooden frame Factory produces glass and mounts the parts The products are produced in series of 200 items and each series generates a revenue depending on the product. Each series require a given amount of time of each factory s capacity. The problem is to find the number of series of each product to maximize the revenue. This can be modelled as the following linear

program: maximize r d x d + r w x w subject to t d,1 x d + t w,1 x w c 1 t d,2 x d + t w,2 x w c 2 t d, x d + t w, x w c x 0, y 0 where r p is the revenue for product p, t p,i is the time needed at factory i to produce a series of product p and c i is the time available at factory i. The series produced is given by x p for each product p. The following is a formulation of the problem in OPL: 1 { string } Products =... ; 2 { string } Factories =... ; Listing 2: prod.mod 4 float r [ Products ] =... ; 5 float t [ Products ] [ Factories ] =... ; 6 float c [ Factories ] =... ; 7 8 dvar float+ x [ Products ] ; 9 10 maximize 11 sum ( p in Products ) r [ p ] x [ p ] ; 12 1 subject to { 14 forall ( i in Factories ) 15 sum ( p in Products ) t [ p ] [ i ] x [ p ] <= c [ i ] ; 16 } Lines 1 and 2 declare two arrays of strings defining the set of products and the set of factories. Note the use of... to indicate that the value will be provided in a separate data file. Lines 4-6 define the input data as real numbers: revenues, time required for each product and the capacity of each factory. Line 8 declares a non-negative decision variable for each product, lines 10-11 declare the objective and lines 1-16 declare the constraints, one for each factory by using the forall keyword. Suppose now that we want to solve the problem with the following data: Hours/series Hours at disposal Door Window Factory 1 1 0 4 Factory 2 0 12 Factory 2 18 Revenue/series 000 5000 4

This can be translated to the following OPL data file: Listing : prod.dat 1 Products = { Door, Window } ; 2 Factories = { Factory 1, Factory 2, Factory } ; 4 r = [000 5 0 0 0 ] ; 5 t = [ [ 1 0 ] [ 0 2 ] ] ; 6 c = [ 4 12 1 8 ] ; Note that the separation between model and data facilitates easy updating if part of the problem is changed. For instance, adding a new product to the problem, will only affect the data file and the model can be left unchanged. 4 Linear programming This example shows how to solve a general linear programming problem, and illustrates how scripting can be combined with the model to display results and obtain details on the solution. The problem we want to solve can be written in matrix form as max c T x s.t. Ax b, x 0 The OPL model is as follows 1 int m =... ; 2 int n =... ; 4 range Rows = 1.. m ; 5 range Cols = 1.. n ; 6 7 float A [ Rows ] [ Cols ] =... ; 8 float b [ Rows ] =... ; 9 float c [ Cols ] =... ; 10 11 dvar float+ x [ Cols ] ; 12 1 maximize 14 sum ( j in Cols ) c [ j ] x [ j ] ; 15 16 subject to 17 { 18 forall ( i in Rows ) 19 ct : Listing 4: lp.mod 5

20 sum ( j in Cols ) A [ i ] [ j ] x [ j ] <= b [ i ] ; 21 } In lines 4-5 we use a special kind of set, range, that can be used to represent a sequence of integer values. Note also that we give a name to the constraint in line 19. This name will be used as an identifier when we later want to obtain information about the constraint. The problem instance can be specified in a separate data file. The following is the input for an example with four constraints and four variables. 1 m = 4 ; 2 n = 4 ; 4 A = [ [ 2 2 1 ] 5 [ 2 2 1 ] 6 [ 0 1 4 ] 7 [ 1 2 4 ] 8 ] ; 9 10 b = [ 4 5 7 ] ; 11 12 c = [ 2 2 2 1 ] ; Listing 5: lp.dat In addition to the modeling features, OPL has a scripting language that can be used for several purposes. In the following example we show how to print both primal and dual solution information for the LP problem. 22 execute { Listing 6: lp.mod 2 writeln ( Optimal value :, cplex. getobjvalue ( ) ) ; 24 writeln ( Primal solution : ) ; 25 write ( x = [ ) ; 26 for ( var j in Cols ) 27 { 28 write ( x [ j ], ) ; 29 } 0 writeln ( ] ) ; 1 2 writeln ( Dual solution : ) ; write ( y = [ ) ; 4 for ( var i in Rows ) 5 { 6 write ( ct [ i ]. dual, ) ; 7 } 8 writeln ( ] ) ; 9 } 6

Note the slightly different syntax used in the scripting language, e.g. variables are declared using the var keyword while iteration over a set is done using the for keyword. If an execute block is placed after the objective and the constraints, it will be performed as a postprocessing step. If placed beforehand, it can also be used as a preprocessing step. 5 Integer programming In this section we show how to model and solve a problem with integer variables, in this case 0-1 variables. Consider the following problem: We want to construct a sequence of n numbers. The i th position should give the number of times the number i occurs in the sequence, where the indexing starts at zero. The following is an example of a legal sequence for n = 4: pos 0 1 2 value 1 2 1 0 The problem of constructing a feasible sequence for a given n can be solved as an integer problem. Let x ij be a 0-1 variable that is one if position i has the value j and zero otherwise, and consider the following integer program min 0 subject to (i) n 1 j=0 x ij = 1, for i = 0,..., n 1 n 1 (ii) k=0 x ki j n(1 x ij ), for i, j = 0,..., n 1 n 1 (iii) k=0 x ki j n(x ij 1), for i, j = 0,..., n 1 (iv) x ij {0, 1} for i, j = 0,..., n 1 Note that we do not need an objective function as we are only interested in a feasible solution. Constraint (i) ensures that each position has a value. While constraints (ii) and (iii) ensure that x ij = 1 implies that n 1 k=0 x ki = j. The following is the corresponding OPL model: 1 int n = 1 0 ; 2 range N = 0.. n 1; 4 dvar boolean x [ N ] [ N ] ; 5 6 minimize 0 ; 7 8 subject to 9 { 10 forall ( i in N ) 11 sum ( j in N ) x [ i ] [ j ] == 1 ; Listing 7: ip.mod 7

12 1 forall ( i in N, j in N ) 14 sum ( k in N ) x [ k ] [ i] j <= n (1 x [ i ] [ j ] ) ; 15 16 forall ( i in N, j in N ) 17 sum ( k in N ) x [ k ] [ i] j >= n ( x [ i ] [ j ] 1); 18 } 19 20 execute { 21 for ( var i in N ) 22 { 2 for ( var j in N ) 24 { 25 if ( x [ i ] [ j]==1) 26 { 27 write ( j, ) ; 28 } 29 } 0 } 1 writeln ( ) ; 2 } Note that 0-1 variables are declared using the keyword boolean, while general integer variables are declared using the int keyword. 6 Minimum spanning tree We end this tutorial with a slightly more complex model. In the minimum spanning tree problem we want to find a spanning tree of minimum weight in an undirected graph G = (V, E) with weight function w : E R. This problem can be solved efficiently as a combinatorial problem using e.g. Kruskal s algorithm. Here we will show how to formulate and solve the problem as an integer problem. The following is a valid formulation of the problem as an integer problem: min e E w ex e s.t. (i) (ii) e E x e = V 1 e δ(u) x e 1, for all U V (iii) x e {0, 1}, for all e E Constraint (ii) is a cut constraint that ensures that we do not get a solution with subcycles. Note that there is an exponential number of these constraints, clearly limiting the size of the problems solvable in OPL. 8

This can be implemented as an OPL model using some additional features of OPL: 1 int n =... ; 2 range Nodes = 1.. n ; { int} NodeSet = asset ( Nodes ) ; 4 5 tuple Edge 6 { 7 int u ; 8 int v ; 9 } Listing 8: mst.mod 10 { Edge} Edges with u in Nodes, v in Nodes =... ; 11 {int} Nbs [ i in Nodes ] = { j <i, j> in Edges } ; 12 1 range S = 1.. ftoi ( round (2ˆ n ) ) ; 14 {int} Sub [ s in S ] = {i i in Nodes : 15 ( s div ftoi ( round ( 2 ˆ ( i 1)))) mod 2 == 1 } ; 16 {int} Compl [ s in S ] = NodeSet diff Sub [ s ] ; 17 18 float Cost [ Edges ] =... ; 19 20 dvar boolean x [ Edges ] ; 21 22 constraint ctcut [ S ] ; 2 24 minimize 25 sum ( e in Edges ) Cost [ e ] x [ e ] ; 26 27 subject to { 28 forall ( s in S : 0 < card ( Subset [ s ] ) < n ) 29 ctcut [ s ] : 0 sum ( i in Sub [ s ], j in Nbs [ i ] inter Compl [ s ] ) x[<i, j>] 1 + sum ( i in Compl [ s ], j in Nbs [ i ] inter Sub [ s ] ) x[<i, j>] 2 >= 1 ; 4 ctall : 5 sum ( e in Edges ) x [ e ] == n 1; 6 } 7 8 {Edge} Used = {e e in Edges : x [ e ] == 1 } ; 9 40 execute 41 { 42 writeln ( Used edges =, Used ) ; 4 } The graph is represented as a list of edges where each edge is an ordered tuple 9

of two nodes. These are declared in line 1-10. For each node we record the set of neighbouring nodes in line 11. Lines 1-16 declares all possible subsets of nodes and the complement of these subsets. Since we have an ordered tuple for each edge we need to check for cutting edges in both directions when implmenting the cut constraints in lines 0-1. The following is data for an example with 12 nodes: 1 n = 1 2 ; 2 Listing 9: mst.mod Edges = { <1,>, <2,>, <,4>, <1,5>, <2,6>, <1,8>, <7,8>, 4 <,5>, <9,10>, <,9>, <10,12>, <11,12>, <,12>, 5 <4,5>, <5,11>, <1,2>, <5,8>, <,11>}; 6 7 Cost = [ 5 1 1 2 4 2 2 5 1 6 2 2 1 1 2 1 ] ; 10