MS-E2140. Short introduction to CPLEX studio

Transcription

1 Linear Programming MS-E2140 Short introduction to CPLEX studio Disclaimer: This tutorial is not a complete introduction to the full features and potentiality of CPLEX Optimization Studio. More detailed documentation is available at

2 Features CPLEX studio is an optimization package which includes A modeling development tool: IBM ILOG OPL A powerful optimization package: IBM ILOG CPLEX OPL is a modeling language for optimization problems with intutitive syntax that facilitates the implementation of mathematical models CPLEX is one of the state-of-the-art commercial solvers for various types of optimization problems including: Linear programming problems Integer and mixed integer prgramming problems Quadratic programming problems CPLEX studio provides a development environment that facilitates the creation and solution of mathematical programming models and the analysis of the results Models are independent of the data they use meaning, e.g., that the model code needs not be changed for solving different instances of the same problem

3 Resources A full version of CPLEX studio is installed in the lab machines A free trial version (90 days evaluation period and with limitations on the maximum size of solvable problems) is available through the IBM website Full official documentation is available at Examples. Several examples of projects can be opened and explored within CPLEX studio. To load them from the start window main menu click: File -> Import -> Example... (then double click IBM ILOG CPLEX Examples ) OPL keywords. From the start window: Help -> Search (type OPL keywords) OPL functions. From the start window: Help -> Search (type OPL functions)

4 Creating an empty project The main working unit in CPLEX studio is the project which groups one or more models together with data. It is composed of three types of files Model files (.mod): data declarations, model definition (decision variables, objective function, constraints); Data files (.dat): Actual values for the data declared in model files; Settings files (.ops): Specify changes to the default settings in OPL, (parameters for the solution algorithm, display options,...) To create a new project select File -> New -> OPL Project from the main window s menu. Then choose a name and location folder and click Finish. A project contains one or more run configurations each specifying a model instance by linking the model with a particular set of data (and, optionally, settings)

5 Project name Run configuration Model file Data file To create new model or data files in a project right-click on the project name and then select new -> model or new -> data To create an empty run configuration right-click on the Run Configurations icon and then select New -> Run configuration To add a file to a run configuration right-click on the file name, then select Add to Run Configuration and choose the configuration To remove a file from a configuration right-click on its name inside the configuration and select Delete

6 A simple project This section guides you to create a simple project, and to solve the corresponding optimization problem We will implement and solve part (b) of Exercise 1.1 from the first exercise session Create the project Start by creating a project with a model file, a data file, and one run configuration Data declarations The first step is to define the data needed by the model in the model file.

7 First recall the model to be implemented Maximize z = 150 x x 2 80 y y 2 20 y 3 s.t x x y 1 Production time of Department A 0.30 x x y 2 Production time of Department B 0.20 x x y 3 Production time of Department C y 1 10 Max. overtime of Department A y 2 6 Max. overtime of Department B y 3 8 Max. overtime of Department C x 1, x 2 0, y 1, y 2, y 3 0 Non-negativity x 1, x 2 integer Integrality where y i : Total number of overtime hours for department i x j : Total number of units produced of product j

8 A data specification is called data item and consists of a data type Integer (OPL keyword int) Real (OPL keyword float) String (OPL keyword string) and a data structure ( scalar, range, set, array, or tuple) In our model we will need to specify the following data items Model data Data type Data struct. OPL Syntax Set of department names string Set {string} Departments =...; Set of product names string Set {string} Products =...; Departments manufacturing time for each product float 2-d array (matrix) float Manuf_Time[ ][ ] =...; Departments time capacity float 1-d array float Time_Capacity[ ] =...; Products unit revenue float 1-d array float Revenue[ ] =...; Max. Departments overtime float 1-d array float Max_Overtime[ ] =...; Overtime cost for each Dept. float 1-d array float Overtime_Cost[ ] =...;

9 Set data structures The following is the declaration of the Departments set {string} Departments =...; The curly brackets { } indicate that the structure Departments is a set, and the keyword string specifies the type of its elements Array data structures The following is the declaration of the structure specifying the manufacturing time for each product float Manuf_Time[Departments][Products] =...; The double brackets [][] indicate that the structure Manuf_Time is a matrix, and the keyword float specifies the type of its elements The sets Departments and Products are used to index the array. With this declaration each element i, j of Manuf_Time is associated with element i of the set Departments, and element j of set Products To define a one dimensional array just put one single pair of brackets [] Note: All declarations (and other instructions) must end with a ;

10 Note that all data declarations ended with the syntax = ; This indicates that the actual values of the elements in the data item are not specified in the declaration, but somewhere else (e.g., in the data file) -> Double-click on the model file and type the following declarations:

11 Data initializations Data items whose declaration ends with the syntax = ; in the model file can be initialized in the data file Alternatively data items can be intialized directly in the model file by replacing = ; with the initialization when they are declared Set intialization The following is the initialization of the Departments set Departments = { A, B, C }; The initialization just specifies the element values within the brackets. Note that the value types must match those defined in the declaration. In this case, elements are strings, and must be enclosed in, i.e. the syntax for any element s of type string is s. Similarly, we intialize the set Products: Products = {"Prod_1", "Prod_2"};

12 Array initialization For 1-d arrays values of the elements can be simply inserted inside the brackets separated by commas The following is the initialization of the Time_Capacity array Time_Capacity = [100, 36, 50]; Since in the initialization of Departments its elements are listed in the order A, B, C, the value 100 will be associated with A, 36 with B, and 50 with C. For 2-d arrays each row is inserted as it was a 1-d array, and rows are separated by commas. The following is the initialization of the Manuf_Time array Manuf_Time = [[1.00, 0.35], [0.30, 0.20], [0.20, 0.50]];

13 -> Double-click on the data file and type the following definitions:

14 Decision variables Decision variable declarations are similar to those of data items, but do not require initialization. Variables can be of type: Integer (OPL keyword int) Real (OPL keyword float) Boolean (0 1 values, OPL keyword boolean) In our model we need the following variables Model decision variable Var. Type Data struct. Total number of overtime hours for each department i (y i ) Total number of manufactured units for each product j (x j ) OPL Syntax float Array dvar float+ Overtime_h[Departments]; int Array dvar Int+ Production[Products]; Declaration of variables is similar to that of data items and requires: a type, a data structure, a name, optionally a domain (range of values)

15 Declaration of a single variable (a variable z not part of our model) dvar float+ z in ; dvar is the keyword used to identify variable declarations, the variable type is specified by the keyword float; the optional sign + indicates that the variable can take only non-negative values in specifies that the variable can have only values between 0 and 100 (instead of numbers like 0 and 100 data items can also be used) Declaration of an array of variables (variables y i of our model) dvar float+ Overtime_h[Departments]; Overtime_h is the name of the array of variables The variable data structure is defined by the brackets as for data items. In this case, Overtime_h is an array of float variables The argument Departments inside the brackets specifies that each variable in the array is associated with an element of Departments Note: the keyword infinity specifies the largest possible float number, and similarly does maxint for integers

16 -> Add the variable declarations to the model file:

17 Variable expressions and operators Decision variables and data items can be combined to define more complex expressions, constraints, or objective functions For this we need operators and aggregators to combine different variables and data items For example in our model we may want to define the total profit z = 150 x x 2 80 y y 2 20 y 3 To do this we can first define the following variable expressions dexpr float revenue = sum (j in Products) Production[j]*Revenue[j]; dexpr float cost = sum (i in Departments) Overtime_h[i]*Overtime_cost[i]; (150 x x 2 ) (80 y y y 3 ) Note: Variable expressions can then be used to defined constraints or the objective function

18 Consider the first of the two expressions above: dexpr is the OPL keyword used to declare decision expressions float is the type of the new decision expression The aggregator sum( ) expression returns the sum over all the elements indexed in parenthesis of the following expression (j in Products) indexes all items of the set Products, Production[j]*Revenue[j] is the expression summed over all items Note that this works because in the their declaration, the arrays Production and Revenue have both been defined over the set Products (e.g., dvar int+ Production [Products];) Using the two expressions just defined, we can define the profit dexpr float profit = revenue - cost; Note: Don t multiply two variables in a dexpr as that would yield a non-linear model! Also, you can t use the syntax type+ for a dexpr

19 Indexing with filtering When indexing the items of a set it is also possible to restrict the selection according to some criteria. The following are two examples: sum (i in Departments : Overtime_Cost[i] < 60) Overtime_h[i]*Overtime _Cost[i]; Filtering condition sum (j in Products : j > Prod_1 ) Production[j]*Revenue[j]; Note the use of the sintax : to separate the filtering condition from the indexing expession inside the parentheses Common aggregators for integer and float expressions sum (summations) prod (products) minima (min of a collection of related expressions) maxima (max of a collection of related expressions) // selects only elements coming after Prod_1 in the declaration of Products

20 Objective function An obj. function consists of a keyword maximize or minimize followed by an expression to optimize Since in our model we are maximizing the profit, which we already defined as a dexpr, we can just write maximize profit; Note: It is optional to define an objective function. If you don t, you can still solve the model to find just a feasible solution Constraints All constraints must be put inside a block starting with the syntax subject to { and ending with } The quantifier forall( ) can be used to specify multiple constraints compactly, each associated with one element indexed in parenthesis.

21 In our model, we have two types of constraints Constraints on the maximum production time for each Department In mathematical notation these could be written compactly as j P t ij x j T i + y i, i D where D denotes the set of Departments, P the set of products, t ij is the manufacturing time of Dept. i for product j, and T i denotes the time capacity of Dept. i In OPL we can translate the above using quantifiers and aggregators: forall(i in Departments) sum(j in Products) Manuf_Time[i][j]*Production[j] <= Time_Capacity[i] + Overtime_h[i]; Constraints on the maximum overtime for each Department Similarly as above we can write: forall(i in Departments) Overtime_h[i] <= Max_Overtime[i];

22 Note: The last constraints on the max. overtime for each Department actually only express a maximum value each variable y i can assume As mentioned when describing decision variable, the same can be imposed by specifying a domain when declaring the variables y For variables y this can be done by changing their declaration to dvar float+ Overtime_h[i in Departments] in 0.. Max_Overtime[i]; If variables y are declared in this way, then the constraints on the max. overtime for each Department of the previous slide are not needed -> This is generally a preferable way of specifying maximum (or minimum) values for a set of variables

23 Recall that each constraint definition ends with ;, and that all constraints have to be included inside a block like this subject to{... } -> Add the objective function and constraints to the model file

24 The model can now be solved -> Right-click on the run configuration icon and select Run this Righ-click here and select Run this to solve the model After the problem is solved the obj. function value will be displayed here The values of the decision variables and expressions are displayed here, or alternatively you can click here The optimal solution is x 1 = 82, x 2 = 80, y 1 = 10, y 2 = 4.6, y 3 = 6.4 with profit 16,797

25 Other useful commands Here we briefly examine some other useful features and structures of OPL that were not used in the previous example Range data structures Integer ranges are often used in arrays and decision variable declarations, in aggregate operators, queries, and quantifiers An integer range is specified by using the keyword range, and by giving its lower and upper bounds, as in the example below range Rows = 1..10; The above declares a range named Rows with bounds 1 and 10 (i.e., the interval [1,, 10]). The lower and upper bounds can also be expressions int n = 8; range Rows = n+1..2*n+1;

26 Typical uses of ranges are as an array index in an array declaration For example, in our model we could define Departments as a range rather than a set, and still use it in the declaration of the arrays equivalently range Departments = 1..3; float Time_Capacity[Departments]; float Time_Capacity[1..3]; One advantage over using sets, is that CPLEX does not store explicitly all the elements of the range, but it does store all elements of a set to define the domain of a variable We already discussed how to define the domain of a variable or an array of variables

27 as an iteration range For example, for defining constraints range Departments = 1..3; range Products = 1..2; forall(i in Departments) sum(j in Products) Manuf_Time[i][j]*Production[j] Overtime_h[i] <= Time_Capacity[i]; The syntax is the same as if Departments and Products were sets One advantage is that now Departments and Products are numbers, and we can use arithmetic operators in the filtering condition. Example For a description of operators see the summary at forall(i in Departments : i mod 2 == 0) the end or official CPLEX studio documentation sum(j in Products : j < 2 ) Manuf_Time[i][j]*Production[j] Overtime_h[i] <= Time_Capacity[i];

28 More ways of initializing sets Ranges can be converted into sets by using the keyword asset For example, the following declarations (in the model file) range Departments = 1..3 {int} Departments_Sets = asset(departments) define Departments as the interval [1,...,3] and then a corresponding set Departments_Sets = {1, 2, 3} Sets can be initialized as subsets of other sets (in the model file). The following are two examples: {string} Departments = { Dep1, Dep2, Dep3 }; {string} Sub_Departments = {i i in Departments : i!= Dep1 }; {int} Departments = asset(1..3); {int} Sub_Departments = {i i in Departments : i > 1};

29 Some operators (Arithmetic) Type Operator Description +, -, *, / Usual math operators infinity Represents the infinite abs(f) The absolute value of f float ceil(f) The smallest integer greater than or equal to f floor(f) The largest integer less than or equal to f trunc(f) The integer part of f frac(f) The fractional part of f round(f) The nearest integer to f Type Operator Description +, -, *, / Usual math operators int x mod y or x % y The integer remainder of x divided by y abs(f) The absolute value of f maxint The greatest integer

30 Some operators (Symbolic) Type Operator Description first, last First (last) element in the set list item The n-th element in the set card Number of elements in the set set next, prev Next (previous) element in the set list a inter b Intersection a union b Union a diff b Difference Type Operator Description == Equivalent to string!= Different from

31 Some operators (Symbolic) Type Operator Description && Conjunction (logical "and") Disjunction (logical "or") boolean == Equivalence Important!= Difference (exclusive "or")! Negation (logical "not") Get used to the help system included in CPLEX studio: -> Click Help from the main menu and then select Search or Help Contents