Mixed-integer linear programming (MILP)

collapse all in page

Mixed-integer linear programming solver.

Finds the minimum of a problem specified by

T
f x subject to x(intcon) are integersAxbAeqx=beqlbxub.
minx

f, x, intcon, b, beq, lb, and ub are vectors, and A and Aeq are matrices.

You can specify f, intcon, lb, and ub as vectors or arrays. See Matrix Arguments.

Syntax
x = intlinprog(f,intcon,A,b)
example
x = intlinprog(f,intcon,A,b,Aeq,beq)
x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub)
example
x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,options)
example
x = intlinprog(problem)
example
[x,fval,exitflag,output] = intlinprog(___)
example

Description
example
x = intlinprog(f,intcon,A,b) solves min f'*x such that the components of x in intcon are integers,
and A*x b.
x = intlinprog(f,intcon,A,b,Aeq,beq) solves the problem above while additionally satisfying the equality
constraints Aeq*x = beq. Set A = [] and b = []if no inequalities exist.
example
x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub) defines a set of lower and upper bounds on the design
variables, x, so that the solution is always in the rangelb x ub. Set Aeq = [] and beq = [] if no equalities
exist.
example
x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,options) minimizes using the optimization options
specified in options. Use optimoptions to set these options. Set lb = [] and ub = [] if no bounds exist.
example
x = intlinprog(problem) uses a problem structure to encapsulate all solver inputs. You can import
a problem structure from an MPS file using mpsread.
example
[x,fval,exitflag,output] = intlinprog(___), for any input arguments described above,
returns fval = f'*x, a value exitflag describing the exit condition, and a structure output containing
information about the optimization process.

Examples
collapse all
Solve an MILP with Linear Inequalities
Open This Example

Solve the problem

Write the objective function vector and vector of integer variables.

f = [8;1];
intcon = 2;

Convert all inequalities into the form A*x <= b by multiplying "greater than" inequalities by -1.

A = [-1,-2;
-4,-1;
2,1];
b = [14;-33;20];

Call intlinprog.

x = intlinprog(f,intcon,A,b)

LP: Optimal objective value is 59.000000.

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 =

6.5000
7.0000

Solve an MILP with All Types of Constraints

Open This Example

Solve the problem

Write the objective function vector and vector of integer variables.

f = [-3;-2;-1];
intcon = 3;

Write the linear inequality constraints.

A = [1,1,1];
b = 7;

Write the linear equality constraints.

Aeq = [4,2,1];
beq = 12;

Write the bound constraints.

lb = zeros(3,1);
ub = [Inf;Inf;1]; % Enforces x(3) is binary

Call intlinprog.

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub)

LP: Optimal objective value is -12.000000.

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 =

0
5.5000
1.0000

Solve an MILP with Nondefault Options

Open This Example

Solve the problem

without showing iterative display.

Specify the solver inputs.

f = [-3;-2;-1];
intcon = 3;
A = [1,1,1];
b = 7;
Aeq = [4,2,1];
beq = 12;
lb = zeros(3,1);
ub = [Inf;Inf;1]; % enforces x(3) is binary

Specify no display.

options = optimoptions('intlinprog','Display','off');

Run the solver.

x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,options)

x =

0
5.5000
1.0000

Use a Problem Structure

Open This Example

Solve the problem

using iterative display. Use a problem structure as the intlinprog input.

Specify the solver inputs.

f = [-3;-2;-1];
intcon = 3;
A = [1,1,1];
b = 7;
Aeq = [4,2,1];
beq = 12;
lb = zeros(3,1);
ub = [Inf;Inf;1]; % enforces x(3) is binary
options = optimoptions('intlinprog','Display','off');

Insert the inputs into a problem structure. Include the solver name.

problem = struct('f',f,'intcon',intcon,...
'Aineq',A,'bineq',b,'Aeq',Aeq,'beq',beq,...
 'lb',lb,'ub',ub,'options',options,...
'solver','intlinprog');

Run the solver.

x = intlinprog(problem)

x =

0
5.5000
1.0000

Examine the MILP Solution and Process

Open This Example

Call intlinprog with more outputs to see solution details and process.

The goal is to solve the problem

Specify the solver inputs.

f = [-3;-2;-1];
intcon = 3;
A = [1,1,1];
b = 7;
Aeq = [4,2,1];
beq = 12;
lb = zeros(3,1);
ub = [Inf;Inf;1]; % enforces x(3) is binary

Call intlinprog with all outputs.

[x,fval,exitflag,output] = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub)

LP: Optimal objective value is -12.000000.

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 =

0
 5.5000
1.0000

fval =

-12.0000

exitflag =

output =

relativegap: 0
absolutegap: 0
numfeaspoints: 1
numnodes: 0
constrviolation: 1.7764e-15
message: 'Optimal solution found....'

The output structure shows numnodes is 0. This means intlinprog solved the problem before branching. This is
one indication that the result is reliable. Also, the absolutegap and relativegap fields are 0. This is another
indication that the result is reliable.

Related Examples
Mixed-Integer Linear Programming Basics
Factory, Warehouse, Sales Allocation Model
Travelling Salesman Problem
Solve Sudoku Puzzles Via Integer Programming
Mixed-Integer Quadratic Programming Portfolio Optimization
Optimal Dispatch of Power Generators

Input Arguments
collapse all
f Coefficient vectorreal vector
Coefficient vector, specified as a vector of doubles representing the objective function, f'*x. The notation assumes
that f is a column vector, but you are free to use a row vector.

f can also be an array. Internally, intlinprog converts an array f to the vector f(:).

If you specify f = [], intlinprog tries to find a feasible point without trying to minimize an objective function.

Example: f = [4;2;-1.7];

Data Types: double

intcon Vector of integer constraintsvector of integers

Vector of integer constraints, specified as a vector of positive integers. The values in intcon indicate the
components of the decision variable x that are integer-valued. intconhas values from 1 through numel(f).

intcon can also be an array. Internally, intlinprog converts an array intcon to the vector intcon(:).

Example: intcon = [1,2,7] means x(1), x(2), and x(7) take only integer values.

Data Types: double

A Linear inequality constraint matrixreal matrix

Linear inequality constraint matrix, specified as a matrix of doubles. A represents the linear coefficients in the
constraints A*x b. A has size M-by-N, where M is the number of constraints and N = numel(f). To save
memory, A can be sparse.

Example: A = [4,3;2,0;4,-1]; means three linear inequalities (three rows) for two decision variables (two
columns).

Data Types: double

b Linear inequality constraint vectorreal vector

Linear inequality constraint vector, specified as a vector of doubles. b represents the constant vector in the
constraints A*x b. b has length M, where A is M-by-N.

Example: [4,0]

Data Types: double

Aeq Linear equality constraint matrix[] (default) | real matrix

Linear equality constraint matrix, specified as a matrix of doubles. Aeq represents the linear coefficients in the
constraints Aeq*x = beq. Aeq has size Meq-by-N, where Meq is the number of constraints and N = numel(f). To
save memory, Aeq can be sparse.

Example: A = [4,3;2,0;4,-1]; means three linear inequalities (three rows) for two decision variables (two
columns).

Data Types: double

beq Linear equality constraint vector[] (default) | real vector

Linear equality constraint vector, specified as a vector of doubles. beq represents the constant vector in the
constraints Aeq*x = beq. beq has length Meq, where Aeq is Meq-by-N.

Example: [4,0]

Data Types: double

lb Lower bounds[] (default) | real vector or array

Lower bounds, specified as a vector or array of doubles. lb represents the lower bounds elementwise
in lb x ub.

Internally, intlinprog converts an array lb to the vector lb(:).

Example: lb = [0;-Inf;4] means x(1) 0, x(3) 4.

Data Types: double

ub Upper bounds[] (default) | real vector or array

Upper bounds, specified as a vector or array of doubles. ub represents the upper bounds elementwise
in lb x ub.
Internally, intlinprog converts an array ub to the vector ub(:).

Example: ub = [Inf;4;10] means x(2) 4, x(3) 10.

Data Types: double

options Options for intlinprogoptions created using optimoptions

Options for intlinprog, specified as the output of optimoptions.

Some options are absent from the optimoptions display. These options are listed in italics. For details, see View
Options.

Option Description

AbsoluteGapTolerance Nonnegative real. intlinprog stops if the difference between the internally ca
upper (U) and lower (L) bounds on the objective function is less than or equal
toAbsoluteGapTolerance:
U L <= AbsoluteGapTolerance .
BranchRule Rule for choosing the component for branching:
'maxpscost' The fractional component with maximum pseudocost. See B
Bound.
'mostfractional' The component whose fractional part is closest to 1/2.
'maxfun' The fractional component with maximal corresponding compone
absolute value of objective vector f.
ConstraintTolerance Real from 1e-9 through 1e-3 that is the maximum discrepancy that linear con
have and still be considered satisfied. ConstraintTolerance is not a stopping
CutGeneration Level of cut generation (see Cut Generation):
'none' No cuts. Makes CutGenMaxIter irrelevant.
'basic' Normal cut generation.
'intermediate' Use more cut types.
'advanced' Use most cut types.
CutMaxIterations Number of passes through all cut generation methods before entering the bran
bound phase, an integer from 1 through 50. Disable cut generation by setting
the CutGenerationoption to 'none'.
Display Level of display (see Iterative Display):
'off' or 'none' No iterative display
'final' Show final values only
'iter' Show iterative display
Heuristics Algorithm for searching for feasible points (see Heuristics for Finding Feasib
'none'
'rss'
'round'
'rins'
HeuristicsMaxNodes Strictly positive integer that bounds the number of nodes intlinprog can exp
branch-and-bound search for feasible points. See Heuristics for Finding Feasi
Solutions.
Option Description

IntegerPreprocess Types of integer preprocessing (see Mixed-Integer Program Preprocessing):

'none' Use very few integer preprocessing steps.
'basic' Use a moderate number of integer preprocessing steps.
'advanced' Use all available integer preprocessing steps.
IntegerTolerance Real from 1e-6 through 1e-3, where the maximum deviation from integer tha
component of the solution x can have and still be considered an
integer. IntegerTolerance is not a stopping criterion.
LPMaxIterations Strictly positive integer, the maximum number of simplex algorithm iteration
during the branch-and-bound process.
LPOptimalityTolerance Nonnegative real where reduced costs must exceed LPOptimalityTolerance f
to be taken into the basis.
LPPreprocess Type of preprocessing for the solution to the relaxed linear program (see Line
Preprocessing):
'none' No preprocessing.
'basic' Use preprocessing.
MaxNodes Strictly positive integer that is the maximum number of nodes intlinprog ex
branch-and-bound process.
MaxFeasiblePoints Strictly positive integer. intlinprog stops if it finds MaxFeasiblePoints integ
points.
MaxTime Positive real that is the maximum time in seconds that intlinprog runs.
NodeSelection Choose the node to explore next.
'simplebestproj' Best projection. See Branch and Bound.
'minobj' Explore the node with the minimum objective function.
'mininfeas' Explore the node with the minimal sum of integer infeasibilit
SeeBranch and Bound.
ObjectiveCutOff Real greater than -Inf. During the branch-and-bound calculation, intlinprog
node where the linear programming solution has an objective value
exceedingObjectiveCutOff.
ObjectiveImprovementThreshold Nonnegative real. intlinprog changes the current feasible solution only when
another with an objective function value that is at
least ObjectiveImprovementThresholdlower: (fold fnew)/(1 + fold) >
ObjectiveImprovementThreshold.
OutputFcn Specify one or more functions that an optimization function calls at events, ei
function handle or as a cell array of function handles.
@savemilpsolutions collects the integer-feasible points in the xIntSol matrix
workspace, where each column is one integer feasible point.
For information on writing a custom output function, see intlinprog Output
and Plot Functions.
PlotFcn Plots various measures of progress while the algorithm executes, select from
plots or write your own. Pass a function handle or a cell array of function han
 Option Description

@optimplotmilp plots the internally-calculated upper and lower bounds on the

value of the solution.
For information on writing a custom plot function, see intlinprog Output Fu
Plot Functions.
RelativeGapTolerance Real from 0 through 1. intlinprog stops if the relative difference between the
calculated upper (U) and lower (L) bounds on the objective function is less tha
toRelativeGapTolerance:
(U L) / (abs(U) + 1) <= RelativeGapTolerance .

intlinprog automatically modifies the tolerance for large L magnitudes:

tolerance = min(1/(1+|L|), RelativeGapTolerance)
RootLPAlgorithm Algorithm for solving linear programs:
'dual-simplex' Dual simplex algorithm
'primal-simplex' Primal simplex algorithm
RootLPMaxIterations Nonnegative integer that is the maximum number of simplex algorithm iterat
the initial linear programming problem.
Example: options = optimoptions('intlinprog','MaxTime',120)

problem Structure encapsulating inputs and optionsstructure

Structure encapsulating the inputs and options, specified with the following fields.

f Vector representing objective f'*x (required)

intcon Vector indicating variables that take integer values (required)

Aineq Matrix in linear inequality constraints Aineq*x bineq

bineq Vector in linear inequality constraints Aineq*x bineq

Aeq Matrix in linear equality constraints Aeq*x = beq
beq Vector in linear equality constraints Aeq*x = beq
lb Vector of lower bounds
ub Vector of upper bounds
solver 'intlinprog' (required)
options Options created using optimoptions (required)
You must specify at least these fields in the problem structure. Other fields are optional:

f
intcon
solver
options
Example: problem.f = [1,2,3];
problem.intcon = [2,3];
problem.options = optimoptions('intlinprog');
problem.Aineq = [-3,-2,-1];
problem.bineq = -20;
problem.lb = [-6.1,-1.2,7.3];
problem.solver = 'intlinprog';

Data Types: struct

Output Arguments
collapse all
x Solutionreal vector
Solution, returned as a vector that minimizes f'*x subject to all bounds, integer constraints, and linear constraints.

When a problem is infeasible or unbounded, x is [].

fval Objective valuereal scalar

Objective value, returned as the scalar value f'*x at the solution x.

When a problem is infeasible or unbounded, fval is [].

exitflag Algorithm stopping conditioninteger

Algorithm stopping condition, returned as an integer identifying the reason the algorithm stopped. The following lists
the values of exitflag and the corresponding reasonsintlinprog stopped.

2 intlinprog stopped prematurely. Integer feasible point found.

1 intlinprog converged to the solution x.
0 intlinprog stopped prematurely. No integer feasible point found.
-1 intlinprog stopped by an output function or plot function.
-2 No feasible point found.
-3 Root LP problem is unbounded.
The exit message can give more detailed information on the reason intlinprog stopped, such as exceeding a
tolerance.

output Solution process summarystructure

Solution process summary, returned as a structure containing information about the optimization process.

relativegap Relative difference between upper (U) and lower (L) bounds of the objective function that int
and-bound algorithm.
relativegap = (U - L) / (abs(U) + 1)

If intcon = [], relativegap = [].

absolutegap Difference between upper and lower bounds of the objective function that intlinprog calcula
algorithm.
If intcon = [], absolutegap = [].
numfeaspoints Number of integer feasible points found.
 If intcon = [], numfeaspoints = []. Also, if the initial relaxed problem is infeasible,numfeas
numnodes Number of nodes in branch-and-bound algorithm. If the solution was found during preprocess
cuts, numnodes = 0.
If intcon = [], numnodes = [].
constrviolation Constraint violation that is positive for violated constraints.
constrviolation = max([0; norm(Aeq*x-beq, inf); (lb-x); (x-ub); (Ai*x-bi)])
message Exit message.
Limitations
Often, some supposedly integer-valued components of the solution x(intCon) are not precisely
integers. intlinprog deems as integers all solution values withinIntegerTolerance of an integer.
To round all supposed integers to be exactly integers, use the round function.
x(intcon) = round(x(intcon));

Caution Rounding solutions can cause the solution to become infeasible. Check feasibility after rounding:
max(A*x - b) % See if entries are not too positive, so have small infeasibility
max(abs(Aeq*x - beq)) % See if entries are near enough to zero
max(x - ub) % Positive entries are violated bounds
max(lb - x) % Positive entries are violated bounds

intlinprog does not enforce that solution components be integer-valued when their absolute values
exceed 2.1e9. When your solution has such components, intlinprogwarns you. If you receive this warning,
check the solution to see whether supposedly integer-valued components of the solution are close to integers.
intlinprog does not allow components of the problem, such as coefficients in f, A, or ub, to exceed 1e25 in
absolute value. If you try to run intlinprog with such a problem,intlinprog issues an error.
Currently, you cannot run intlinprog in the Optimization app.

More About
collapse all
MILP
Mixed-integer linear programming definition.

MILP means find the minimum of a problem specified by

T
f x subject to x(intcon) are integersAxbAeqx=beqlbxub.
minx

f, x, intcon, b, beq, lb, and ub are vectors, and A and Aeq are matrices.

You can specify f, intcon, lb, and ub as vectors or arrays. See Matrix Arguments.

Tips
To specify binary variables, set the variables to be integers in intcon, and give them lower bounds of 0 and upper
bounds of 1.
 Save memory by specifying sparse linear constraint matrices A and Aeq. However, you cannot use sparse matrices
for b and beq.
To provide logical indices for integer components, meaning a binary vector with 1 indicating an integer, convert
to intcon form using find. For example,
logicalindices = [1,0,0,1,1,0,0];
intcon = find(logicalindices)

intcon =

1 4 5

intlinprog replaces bintprog. To update old bintprog code to use intlinprog, make the following
changes:
o Set intcon to 1:numVars, where numVars is the number of variables in your problem.
o Set lb to zeros(numVars,1).
o Set ub to ones(numVars,1).
o Update any relevant options. Use optimoptions to create options for intlinprog.
o Change your call to bintprog as follows:
o [x,fval,exitflag,output] = bintprog(f,A,b,Aeq,Beq,x0,options)
o % Change your call to:
[x,fval,exitflag,output] = intlinprog(f,intcon,A,b,Aeq,Beq,lb,ub,options)

Mixed-Integer Linear Programming Algorithms

Tuning Integer Linear Programming
Optimization Problem Setup

See Also
linprog | mpsread | optimoptions

Introduced in R2014a