prob2struct

Convert optimization problem to solver form

collapse all in page

Syntax

problem = prob2struct(prob)

Description

example

problem = prob2struct(prob) returns an optimization problem structure suitable for solution by linprog or intlinprog.

Examples

collapse all

Open Live Script

Convert an optimization problem object to a problem structure.

Input the basic MILP problem from Mixed-Integer Linear Programming Basics: Problem-Based.

ingots = optimvar('ingots',4,1,'Type','integer','LowerBound',0,'UpperBound',1);
alloys = optimvar('alloys',4,1,'LowerBound',0);

weightIngots = [5,3,4,6];
costIngots = weightIngots.*[350,330,310,280];
costAlloys = [500,450,400,100];
cost = costIngots*ingots + costAlloys*alloys;

steelprob = optimproblem;
steelprob.Objective = cost;

totalweight = weightIngots*ingots + sum(alloys);

carbonIngots = [5,4,5,3]/100;
molybIngots = [3,3,4,4,]/100;
carbonAlloys = [8,7,6,3]/100;
molybAlloys = [6,7,8,9]/100;

totalCarbon = (weightIngots.*carbonIngots)*ingots + carbonAlloys*alloys;
totalMolyb = (weightIngots.*molybIngots)*ingots + molybAlloys*alloys;

steelprob.Constraints.conswt = totalweight == 25;
steelprob.Constraints.conscarb = totalCarbon == 1.25;
steelprob.Constraints.consmolyb = totalMolyb == 1.25;

Convert the problem to an intlinprog problem structure.

problem = prob2struct(steelprob);

Examine the resulting linear equality constraint matrix and vector.

Aeq = problem.Aeq
Aeq = 
   (1,1)       1.0000
   (2,1)       0.0800
   (3,1)       0.0600
   (1,2)       1.0000
   (2,2)       0.0700
   (3,2)       0.0700
   (1,3)       1.0000
   (2,3)       0.0600
   (3,3)       0.0800
   (1,4)       1.0000
   (2,4)       0.0300
   (3,4)       0.0900
   (1,5)       5.0000
   (2,5)       0.2500
   (3,5)       0.1500
   (1,6)       3.0000
   (2,6)       0.1200
   (3,6)       0.0900
   (1,7)       4.0000
   (2,7)       0.2000
   (3,7)       0.1600
   (1,8)       6.0000
   (2,8)       0.1800
   (3,8)       0.2400


beq = problem.beq
beq = 

   25.0000
    1.2500
    1.2500

Examine the bounds.

problem.lb
ans = 

     0
     0
     0
     0
     0
     0
     0
     0


problem.ub
ans = 

   Inf
   Inf
   Inf
   Inf
     1
     1
     1
     1

Solve the problem by calling intlinprog.

x = intlinprog(problem)
LP:                Optimal objective value is 8125.600000.                                          

Cut Generation:    Applied 3 mir cuts.                                                              
                   Lower bound is 8495.000000.                                                      
                   Relative gap is 0.00%.                                                          


Optimal solution found.

Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal
value, options.AbsoluteGapTolerance = 0 (the default value). The intcon variables are
integer within tolerance, options.IntegerTolerance = 1e-05 (the default value).

x = 

    7.2500
         0
    0.2500
    3.5000
    1.0000
    1.0000
         0
    1.0000

Input Arguments

collapse all

Optimization problem, specified as an OptimizationProblem object.

Output Arguments

collapse all

Problem structure, returned as an intlinprog problem structure or as a linprog problem structure. If any of the problem variables have type 'integer', then the structure is an intlinprog problem structure, and otherwise the structure is a linprog problem structure.

The problem structure includes an additional field, f0, that represents an additive constant for the objective function. If you solve the problem structure using intlinprog or linprog, the returned objective function value does not include the f0 value. If you solve prob using the solve function, the returned objective function value includes the f0 value.

Algorithms

The basis for the problem structure is an implicit ordering of all problem variables into a single vector. The order of the problem variables is the same as the order of the Variables property in prob. See OptimizationProblem.

For example, suppose that the problem variables are in this order:

  • x — a 3-by-2-by-4 array

  • y — a 3-by-2 array

Then the implicit variable order is as if the problem variable is vars = [x(:);y(:)].

The first 24 elements of vars are equivalent to x(:), and the next six elements are equivalent to y(:), for a total of 30 elements. The lower and upper bounds correspond to this variable ordering, and in this example, each linear constraint matrix has 30 columns.

See Also

| |

Topics

Introduced in R2017b

Was this topic helpful?
Optimization Toolbox Documentation
Other Documentation
Support