intlinprog

Mixed-integer linear programming (MILP)

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

Description
Mixed-integer linear programming solver.

Finds the minimum of a problem specified by


x (intcon ) are integers



A ⋅ x ≤ b
T
min f x subject to 

Aeq ⋅ x = beq
x


lb ≤ x ≤ ub.

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

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

 Not e
intlinprog applies only to the solver-based approach. For a discussion of the two optimization approaches, see First Choose
Problem-Based or Solver-Based Approach.

x = intlinprog(f,intcon,A,b) solves min f'*x such that the components of x in intcon are integers, and exam ple
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.
exam ple
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 range lb ≤ x ≤ ub. Set Aeq = [] and beq = [] if no equalities exist.
exam ple
x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,x0)optimizes using an initial feasible point x0. Set lb = [] and
ub = [] if no bounds exist.
exam ple
x = intlinprog(f,intcon,A,b,Aeq,beq,lb,ub,x0,options) minimizes using the optimization options
specified in options. Use optimoptions to set these options. Set x0 = [] if no initial point exists.
exam ple
x = intlinprog(problem) uses a problem structure to encapsulate all solver inputs. You can import a problem
structure from an MPS file using mpsread. You can also create a problem structure from an OptimizationProblem
object by using prob2struct.
exam ple
[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 wit h Linear Inequalit ies

Solve the problem

Try it in MATLAB
 

x is an integer


2

x + 2x 2 ≥ −14
1

min 8x 1 + x 2 subject to

−4x − x 2 ≤ −33
x


1


2x 1 + x 2 ≤ 20.

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 = 2×1

6.5000
7.0000

 Solve an MILP wit h All T ypes of Const raint s

Solve the problem

 Try it in MATLAB

x binary


3

x , x2 ≥ 0
1

(
min −3x 1 − 2x 2 − x 3 ) subject to

x + x2 + x3 ≤ 7
x


1


4x 1 + 2x 2 + x 3 = 12.

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 = 3×1

0
5.5000
1.0000

 Use Init ial Point

Compare the number of steps to solve an integer programming problem both with and
without an initial feasible point. The problem has eight variables, four linear equality
Try it in MATLAB
constraints, and has all variables restricted to be positive.

Define the linear equality constraint matrix and vector.

Aeq = [22 13 26 33 21 3 14 26
39 16 22 28 26 30 23 24
18 14 29 27 30 38 26 26
41 26 28 36 18 38 16 26];
beq = [ 7872
10466
11322
12058];

Set lower bounds that restrict all variables to be nonnegative.

N = 8;
lb = zeros(N,1);

Specify that all variables are integer-valued.

intcon = 1:N;

Set the objective function vector f.

f = [2 10 13 17 7 5 7 3];

Solve the problem without using an initial point, and examine the display to see the number of branch-and-bound nodes.

[x1,fval1,exitflag1,output1] = intlinprog(f,intcon,[],[],Aeq,beq,lb);

LP: Optimal objective value is 1554.047531.

Cut Generation: Applied 8 strong CG cuts.

Lower bound is 1591.000000.
 Branch and Bound:

nodes total num int integer relative

explored time (s) solution fval gap (%)
10000 1.03 0 - -
18027 1.69 1 2.906000e+03 4.509804e+01
21859 2.12 2 2.073000e+03 2.270974e+01
23546 2.30 3 1.854000e+03 1.180593e+01
24121 2.36 3 1.854000e+03 1.563342e+00
24294 2.39 3 1.854000e+03 0.000000e+00

Optimal solution found.

Intlinprog stopped 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).
For comparison, find the solution using an initial feasible point.

x0 = [8 62 23 103 53 84 46 34];
[x2,fval2,exitflag2,output2] = intlinprog(f,intcon,[],[],Aeq,beq,lb,[],x0);

LP: Optimal objective value is 1554.047531.

Cut Generation: Applied 8 strong CG cuts.

Lower bound is 1591.000000.
Relative gap is 59.20%.

Branch and Bound:

nodes total num int integer relative

explored time (s) solution fval gap (%)
3627 0.48 2 2.154000e+03 2.593968e+01
5844 0.70 3 1.854000e+03 1.180593e+01
6204 0.73 3 1.854000e+03 1.455526e+00
6400 0.77 3 1.854000e+03 0.000000e+00

Optimal solution found.

Intlinprog stopped 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).
• Without an initial point, intlinprog took about 30,000 branch-and-bound steps.
• Using an initial point, intlinprog took about 5,000 steps.

Giving an initial point does not always help. For this problem, giving an initial point saves time and computational steps. However, for
some problems, giving an initial point can cause intlinprog to take more steps.

 Solve an MILP wit h Nondef ault Opt ions

Solve the problem

 Try it in MATLAB

x binary


3

x , x2 ≥ 0
1

(
min −3x 1 − 2x 2 − x 3 ) subject to

x + x2 + x3 ≤ 7
x


1


4x 1 + 2x 2 + x 3 = 12

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
x0 = [];

Specify no display.

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

Run the solver.

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

x = 3×1

0
5.5000
1.0000

 Solve MILP Using Problem-Based Approach

This example shows how to set up a problem using the problem-based approach and
then solve it using the solver-based approach. The problem is
Try it in MATLAB


x binary


3

x , x2 ≥ 0
1

(
min −3x 1 − 2x 2 − x 3 ) subject to

x + x2 + x3 ≤ 7
x


1


4x 1 + 2x 2 + x 3 = 12

Create an OptimizationProblem object named prob to represent this problem. To specify a binary variable, create an
optimization variable with integer type, a lower bound of 0, and an upper bound of 1.

x = optimvar('x',2,'LowerBound',0);
xb = optimvar('xb','LowerBound',0,'UpperBound',1,'Type','integer');
prob = optimproblem('Objective',-3*x(1)-2*x(2)-xb);
cons1 = sum(x) + xb <= 7;
cons2 = 4*x(1) + 2*x(2) + xb == 12;
prob.Constraints.cons1 = cons1;
prob.Constraints.cons2 = cons2;

Convert the problem object to a problem structure.

problem = prob2struct(prob);

Solve the resulting problem structure.

[sol,fval,exitflag,output] = intlinprog(problem)

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).
sol = 3×1

0
5.5000
1.0000

fval = -12
exitflag = 1
output = struct with fields:
relativegap: 0
absolutegap: 0
numfeaspoints: 1
numnodes: 0
constrviolation: 0
message: 'Optimal solution found....'

Both sol(1) and sol(3) are binary-valued. Which value corresponds to the binary optimization variable xb?

prob.Variables

ans = struct with fields:

x: [2x1 optim.problemdef.OptimizationVariable]
xb: [1x1 optim.problemdef.OptimizationVariable]

The variable xb appears last in the Variables display, so xb corresponds to sol(3) = 1. See Algorithms.

 Examine t he MILP Solut ion and Process

Call intlinprog with more outputs to see solution details and process.
Try it in MATLAB
The goal is to solve the problem


x binary


3

x , x2 ≥ 0
1

(
min −3x 1 − 2x 2 − x 3 ) subject to

x + x2 + x3 ≤ 7
x


1


4x 1 + 2x 2 + x 3 = 12.

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 = 3×1

0
5.5000
1.0000

fval = -12
exitflag = 1
output = struct with fields:
relativegap: 0
absolutegap: 0
numfeaspoints: 1
numnodes: 0
constrviolation: 0
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.

Input Arguments collapse all

f — Coefficient vect or
 real vector | real array

Coefficient vector, specified as a real vector or real array. The coefficient vector represents the objective function f'*x. The notation
assumes that f is a column vector, but you are free to use a row vector or array. Internally, linprog converts f to the column 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];

Dat a T ypes: double

intcon — Vect or of int eger const raint s

 vector 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. intcon has 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.

Dat a T ypes: double

A — Linear inequalit y const raint mat rix

 real 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).

Dat a T ypes: double

 b — Linear inequalit y const raint vect or
 real 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]

Dat a T ypes: double

Aeq — Linear equalit y const raint mat rix

 [] (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).

Dat a T ypes: double

beq — Linear equalit y const raint vect or

 [] (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]

Dat a T ypes: 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.

Dat a T ypes: 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.

Dat a T ypes: double

x0 — Init ial point

 [] (default) | real array
Initial point, specified as a real array. The number of elements in x0 is the same as the number of elements of f, when f exists.
Otherwise, the number is the same as the number of columns of A or Aeq. Internally, the solver converts an array x0 into a vector
x0(:).

Providing x0 can change the amount of time intlinprog takes to converge. It is difficult to predict how x0 affects the solver. For
suggestions on using appropriate Heuristics with x0, see Tips.

x0 must be feasible with respect to all constraints. If x0 is not feasible, the solver errors. If you do not have a feasible x0, set x0 =
[].

Example: x0 = 100*rand(size(f))

Dat a T ypes: double

options — Opt ions f or intlinprog

 options created using optimoptions

Options for intlinprog, specified as the output of optimoptions.

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

Opt io n Descript io n Def ault

AbsoluteGapTolerance Nonnegative real. intlinprog stops if the difference between the 0

internally calculated upper (U) and lower (L) bounds on the objective
function is less than or equal to AbsoluteGapTolerance:

U – L <= AbsoluteGapTolerance.

BranchRule Rule for choosing the component for branching: 'reliability'

• 'maxpscost' — T he fractional component with maximum
pseudocost. See Branch and Bound.
• 'strongpscost' — T he fractional component with maximum
pseudocost and a more accurate estimate of pseudocost than
in 'maxpscost'. See Branch and Bound.
• 'reliability' — T he fractional component with maximum
pseudocost and an even more accurate estimate of pseudocost
than in 'strongpscost'. See Branch and Bound.
• 'mostfractional' — T he component whose fractional part is
closest to 1/2.
• 'maxfun' — T he fractional component with a maximal
corresponding component in the absolute value of the objective
vector f.

ConstraintTolerance Real from 1e-9 through 1e-3 that is the maximum discrepancy 1e-4
that linear constraints can have and still be considered satisfied.
ConstraintTolerance is not a stopping criterion.

CutGeneration Level of cut generation (see Cut Generation): 'basic'

• 'none' — No cuts. Makes CutMaxIterations 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 10

entering the branch-and-bound phase, an integer from 1 through 50.
Disable cut generation by setting the CutGeneration option to
'none'.

Display Level of display (see Iterative Display): 'iter'

• 'off' or 'none' — No iterative display
• 'final' — Show final values only
• 'iter' — Show iterative display
Opt io n Descript io n Def ault

Heuristics Algorithm for searching for feasible points (see Heuristics for 'basic'
Finding Feasible Solutions):
• 'basic'
• 'intermediate'
• 'advanced'
• 'rss'
• 'rins'
• 'round'
• 'diving'
• 'rss-diving'
• 'rins-diving'
• 'round-diving'
• 'none'

HeuristicsMaxNodes Strictly positive integer that bounds the number of nodes 50

intlinprog can explore in its branch-and-bound search for feasible
points. Applies only to 'rss' and 'rins'. See Heuristics for
Finding Feasible Solutions.

IntegerPreprocess T ypes of integer preprocessing (see Mixed-Integer Program 'basic'

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 1e-5
integer that a 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 max(3e4, 10*
iterations per node during the branch-and-bound process. (numberOfEqualities +
numberOfInequalities +
numberOfVariables))

In this expression,
numberOfEqualities
means the number of rows of
Aeq,
numberOfInequalities
means the number of rows of
A, and numberOfVariables
means the number of
elements of f.

LPOptimalityTolerance Nonnegative real where reduced costs must exceed 1e-7

LPOptimalityTolerance for a variable to be taken into the basis.

LPPreprocess T ype of preprocessing for the solution to the relaxed linear program 'basic'
(see Linear Program Preprocessing):
• 'none' — No preprocessing.
• 'basic' — Use preprocessing.

MaxNodes Strictly positive integer that is the maximum number of nodes 1e7
intlinprog explores in its branch-and-bound process.

MaxFeasiblePoints Strictly positive integer. intlinprog stops if it finds Inf

MaxFeasiblePoints integer feasible points.

MaxTime Positive real that is the maximum time in seconds that intlinprog 7200
runs.
Opt io n Descript io n Def ault

NodeSelection Choose the node to explore next. 'simplebestproj'

• '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 infeasibilities. See Branch and Bound.

ObjectiveCutOff Real greater than -Inf. During the branch-and-bound calculation, Inf
intlinprog discards any node where the linear programming
solution has an objective value exceeding ObjectiveCutOff.

ObjectiveImprovementThreshold Nonnegative real. intlinprog changes the current feasible solution 0

only when it locates another with an objective function value that is
at least ObjectiveImprovementThreshold lower: (fold – fnew)/(1
+ |fold|) > ObjectiveImprovementThreshold.

OutputFcn Specify one or more functions that an optimization function calls at []

events as 'savemilpsolutions', a function handle, or a cell array
of function handles. For custom output functions, pass function
handles.
• 'savemilpsolutions' collects the integer-feasible points in
the xIntSol matrix in your workspace, where each column is
one integer feasible point.

For information on writing a custom output function, see intlinprog

Output Function and Plot Function Syntax.

PlotFcn Plots various measures of progress while the algorithm executes; []

select from predefined plots or write your own. Pass
'optimplotmilp', a function handle, or a cell array of function
handles. For custom plot functions, pass function handles. T he
default is none ([]):
• 'optimplotmilp' plots the internally-calculated upper and
lower bounds on the objective value of the solution.

For information on writing a custom plot function, see intlinprog

Output Function and Plot Function Syntax.

RelativeGapTolerance Real from 0 through 1. intlinprog stops if the relative difference 1e-4
between the internally calculated upper (U) and lower (L) bounds on
the objective function is less than or equal to
RelativeGapTolerance:

(U – L) / (abs(U) + 1) <= RelativeGapTolerance.

intlinprog automatically modifies the tolerance for large L

magnitudes:

tolerance = min(1/(1+|L|), RelativeGapTolerance)

 Not e
Although you specify RelativeGapTolerance as a
decimal number, the iterative display and
output.relativegap report the gap as a
percentage, meaning 100 times the measured relative
gap. If the exit message refers to the relative gap, this
value is the measured relative gap, not a percentage.

RootLPAlgorithm Algorithm for solving linear programs: 'dual-simplex'

• 'dual-simplex' — Dual simplex algorithm
• 'primal-simplex' — Primal simplex algorithm
 Opt io n Descript io n Def ault

RootLPMaxIterations Nonnegative integer that is the maximum number of simplex max(3e4, 10*
algorithm iterations to solve the initial linear programming problem. (numberOfEqualities +
numberOfInequalities +
numberOfVariables))

In this expression,
numberOfEqualities
means the number of rows of
Aeq,
numberOfInequalities
means the number of rows of
A, and numberOfVariables
means the number of
elements of f.
Example: options = optimoptions('intlinprog','MaxTime',120)

problem — St ruct ure encapsulat ing input s and opt ions

 structure

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

x0 Initial feasible point

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';

Dat a T ypes: struct

Output Arguments collapse all

x — Solut ion
 real 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 — Object ive value

 real scalar

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

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

exitflag — Algorit hm st opping condit ion

 integer

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

3 T he solution is feasible with respect to the relative ConstraintTolerance tolerance, but is not
feasible with respect to the absolute tolerance.

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.

-9 Solver lost feasibility.

The exit message can give more detailed information on the reason intlinprog stopped, such as exceeding a tolerance.

Exitflags 3 and -9 relate to solutions that have large infeasibilities. These usually arise from linear constraint matrices that have large
condition number, or problems that have large solution components. To correct these issues, try to scale the coefficient matrices,
eliminate redundant linear constraints, or give tighter bounds on the variables.

output — Solut ion process summar y

 structure

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

relativegap Relative percentage difference between upper (U) and lower (L) bounds of the
objective function that intlinprog calculates in its branch-and-bound algorithm.

relativegap = 100*(U - L) / (abs(U) + 1)

If intcon = [], relativegap = [].

 Not e
Although you specify RelativeGapTolerance as a decimal
number, the iterative display and output.relativegap report the
gap as a percentage, meaning 100 times the measured relative gap.
If the exit message refers to the relative gap, this value is the
measured relative gap, not a percentage.

absolutegap Difference between upper and lower bounds of the objective function that
intlinprog calculates in its branch-and-bound algorithm.

If intcon = [], absolutegap = [].

 numfeaspoints Number of integer feasible points found.

If intcon = [], numfeaspoints = []. Also, if the initial relaxed problem is

infeasible, numfeaspoints = [].

numnodes Number of nodes in branch-and-bound algorithm. If the solution was found during
preprocessing or during the initial 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 within IntegerTolerance of an integer.
To round all supposed integers to be exactly integers, use the round function.

x(intcon) = round(x(intcon));

 Caut ion
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, intlinprog warns 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.

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.
• If you include an x0 argument, intlinprog uses that value in the 'rins' and guided diving heuristics until it finds a better integer-
feasible point. So when you provide x0, you can obtain good results by setting the 'Heuristics' option to 'rins-diving' or
another setting that uses 'rins'.
• 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:
˗ Set intcon to 1:numVars, where numVars is the number of variables in your problem.
˗ Set lb to zeros(numVars,1).
˗ Set ub to ones(numVars,1).
 ˗ Update any relevant options. Use optimoptions to create options for intlinprog.
˗ Change your call to bintprog as follows:

[x,fval,exitflag,output] = bintprog(f,A,b,Aeq,Beq,x0,options)
% Change your call to:
[x,fval,exitflag,output] = intlinprog(f,intcon,A,b,Aeq,Beq,lb,ub,x0,options)

Compatibility Considerations expand all

 Default BranchRule is ' reliabilit y'

Behavior changed in R2019a

See Also
linprog | mpsread | optimoptions | prob2struct

Topics
Mixed-Integer Linear Programming Basics: Solver-Based
Factory, Warehouse, Sales Allocation Model: Solver-Based
Traveling Salesman Problem: Solver-Based
Solve Sudoku Puzzles Via Integer Programming: Solver-Based
Mixed-Integer Quadratic Programming Portfolio Optimization: Solver-Based
Optimal Dispatch of Power Generators: Solver-Based
Mixed-Integer Linear Programming Algorithms
Tuning Integer Linear Programming
Solver-Based Optimization Problem Setup

Int roduced in R2014a