Multi-Parametric Toolbox 3.0
Martin Herceg, Michal Kvasnica, Colin N. Jones, and Manfred Morari
Abstract — The Multi-Parametric Toolbox is a col-
lection of algorithms for modeling, control, analysis,
and deployment of constrained optimal controllers
developed under Matlab. It features a powerful ge-
ometric library that extends the application of the
toolbox beyond optimal control to various problems
arising in computational geo metry. The new version
3.0 is a complete rewrite of the original toolbox with
a more flexible structure that offers faster integration
of new algorithms. The numerical side of the toolbox
has been improved by adding interfaces to state of the
art solvers and by incorporation of a new parametric
solver that relies on solving linear-complementarity
problems. The toolbox provides algorithms for design
and implementation of real-time model predictive
controllers that have been extensively teste d.
I. INTRODUCTION
The Multi-Parametric Toolbox (MPT) is a software
tool for Matlab [19] that aims at solving parametric
optimization problems t hat arise in constrained optimal
control. In particular, as the name of the toolbox sug-
gests, its primal objective is to provide computationally
efficient means for design and application of explicit
model predictive control (MPC). Since the initial release
in 2004 [14] there has been a significant progress in
the development of the toolbox and the s cope of the
toolbox has widened to deal also with problems arising
in comp ut ational geometry.
On the market there exist toolboxes that offer oper-
ations involved purely in computational geometry, i.e.
GEOMETRY toolbox [3], CGLAB [23], and Ellipsoidal
Toolbox [13]. Other toolboxes beside geometrical tools
offer also algorithms for computing and implementation
of control routines e.g. the Hybrid toolbox [1], MOBY-
DIC toolbox [21], RACT toolbox [29], PnPMPC toolbox
[25], and RoMulOC [22]. MPT is also one of the tools
that combines computational geometry with control rou-
tines. Many of these toolboxes including MPT rely on
YALMIP [17] which provides a high level language for
modeling and formulating optimization problems.
The content of MPT can be divided into four modules:
• modeling of dynamical systems,
• MPC-based control synthesis,
Martin Herceg and Manfred Morari are with the
Automatic Control Laboratory, ETH Zurich, Switzerland;
{herceg,morari}@control.ee.ethz.ch.
Michal Kvasnica is with the Institute of Information Engi-
neering, Automation, and Mathematics, STU Bratislava, Slovakia;
michal.kvasnica@stuba.sk.
Colin N. Jones is with the Au tomatic Control Laboratory, EPF
Lausanne, Switzerland; colin.jones@epfl.ch.
• closed-loop analysis,
• deployment of MPC controllers to h ard ware.
Each part represents one stage in design and implemen-
tation of explicit MPC. The modeling module of MPT
allows to describe discrete-time systems with either linear
or hybrid dynamics. The latter can be directly imported
from the HYSDEL environment [28]. The control modul e
allows to formulate and solve constrained optimal control
problems for both linear and hybrid systems. For a de-
tailed overview of employed mathematical formulations
the reader is referred to [2]. The analysis module provides
methods for investigation of closed-loop behavior and
performance. Moreover, it also features methods to r e-
duce complexity of explicit MPC feedbacks. The deploy-
ment p ar t allows to export control r outi ne s to the ANSI-
C language, which can be subseq ue ntly downloaded to a
target hardware implementation platform.
Compared to the previous release, the 3.0 version
of MPT significantly improves capabilities of all four
aforementioned modules. The main advances can be
summarized as follows:
• Completely new installation procedure using a soft-
ware manager.
• New optimization engines based on linear-
complementarity problem solvers.
• Extended support for computational geometry.
• New flexible user interface based on object-oriented
programming.
• Modular structure for easier integration of new al-
gorithms.
• Extended support for real-time control.
• Improved numerical reliability based on extensive
testing.
• Detailed documentation including examples and de-
mos.
This paper describes the new features of MPT in detail
and highlights the key properties that may be of interest
to a broader control community.
II. Notations
To clarify the presentation, this sect ion introduces
the common notations to be referred throughout the
text. Speci fic ally, the notation is required to define the
solutions to multi-parametric problems and is used in
description of the polyhedral sets to underst and the
features of the geometric library.
A. Set Description
Definition 2.1 (Convex set): A set S ⊆ R
n
is convex
if the line segment connecting any pair of points of S lies
entirely in S, i .e . if for any s
1
, s
2
∈ S and any α with
0 ≤ α ≤ 1, we have αs
1
+ (1 − α)s
2
∈ S.
Definition 2.2 (Set collection) : S is called a set collec-
tion (union) in R
n
if it is a collection of a finite number of
n-dimensional sets S
i
, i.e., S :=
S
N
S
i=1
S
i
, where N
S
< ∞.
Definition 2.3 (Piecewise function): The function f :
S 7→ R
n
f
is called a piecewise function if its domain
is defined over a collection of a finite number of n-
dimensional sets S
i
, and each set is associated with a
particular vector field f
i
, i. e., f (x) := f
i
(x) if x ∈ S
i
,
where S :=
S
N
S
i=1
S
i
and N
S
< ∞.
Definition 2.4 (Polyhedron): A polyhedron is a convex
set given as the intersection of a finite number of hyper-
planes and half-spaces or as a convex combination of a
finite number of vertices and rays.
Definition 2.5 (Polytope): A polytop e is a bounded
polyhedron.
Definition 2.6 (H-representation): The polyhedron P
is formed by the intersection of m inequalities and m
e
equalities, i.e.
P = {x ∈ R
n
| Ax ≤ b, A
e
x = b
e
} (1)
where A ∈ R
m×n
, b ∈ R
m
, A
e
∈ R
m
e
×n
, b
e
∈ R
m
e
are the data representing the halfspaces and hyperplanes,
respectively.
Definition 2.7 (V-representation): The polyhedron P
is formed by a convex combination of n
v
vertices and n
r
rays, i.e.
P = {x ∈ R
n
| x = λ
T
V +γ
T
R, λ, γ ≥ 0, 1
T
λ = 1} (2)
where V ∈ R
n×n
v
, R ∈ R
n×n
r
represent vertices and
rays, respectively.
III. Features of MPT 3.0
A. Installation and Updates
The new version of MPT is distributed in a modular
structure that is operated by a Toolbox Manager avail-
able at www.tbxmanager.com. Toolbox Manager provides
means for automatic installation, uninstallation and up-
dates of Matlab toolboxes. The manager can be installed
as per instructions on its web page.
MPT 3.0 is composed of several modules that are re-
quired to achieve the full functionality. The base package
is referred to as mpt and the related documentation as
mptdoc which can be installed by issuing
tbxmanager install mpt mptdoc
at the Matlab prompt. The other modules can be in-
stalled by pointing to the names of the submodules
tbxmanager install lcp hysdel cddmex clpmex
glpkmex fourier sedumi yalmip
After installation of the submodules, the user can start
using the software directly. If any module has been
updated, the new versions can be obtained and installed
with t he help of
tbxmanager update
The Toolbox Manager thus provides a very simple ap-
proach to keep updated with any future releases of MPT,
including its submodules.
B. Modular Structure
The MPT 3.0 comes with an extended stru ct ur e that is
based on submodules and object-oriented programming.
The main motivation for th is change was to achieve eas ier
maintainability of the toolbox and to provide flexible
structure for possible future enhancements. For instance,
in the previous version of MPT there was a single object
encompassing multiple algorithms. In the version 3.0,
several new objects have been introduced that follow
a hierarchy derived from object-oriented programming
approach. Using this hierarchy it is possible to introduce
new objects and methods to the existing framework
with a minimal effort. The new class can be added by
creating a ne w folder and by subclassing an existing
object. The new object inherits properties and methods
of the superclass and can be used to associate specific
methods for tackling a particular problem. In the next
sections some of the new objects will be pr es ented and
the main functionality will be explained.
C. Core Numerical Engines
Majority of the optimization problems involved in the
computational geometr y can be expressed as linear (LP)
or quadratic problems (QP). To solve these problems
effectively, MPT requires additional solvers that can
be installed easily as submodu les using the Toolbox
Manager. Version 3.0 of MPT comes with new solvers
that tackle both of these problems effectively. The new
optimization engines are based on solvers for a linear
complementarity problem (LCP) that represents a su-
perclass for LP and QP. The advantage of representing
and solving the optimization problems as LCPs is that
a single solver covers all three scenarios and there is no
need for multiple solvers that could potentially return
different results. There are two new solvers implemented
in MPT 3.0: LCP solver and parametric LCP solver.
Both of these solvers will b e reviewed next including their
properties and implementation details.
1) LCP Solver: The linear-complementarity problem
represents the class of optimization problems given as
find w, z
s.t.: w − M z = q (3a)
w
T
z = 0 (3b)
w, z ≥ 0 (3c)
where the problem data is given by a sufficient matrix
M ∈ R
n×n
and vector q ∈ R
n
. The unknown variables
are z and w that are coupled by the linear complementar-
ity constraints (3b). LCP problems are well studied in the
literature [20] and several efficient methods for solving
such problems have been proposed. One of the most
successful approaches to solve LCP (3) is by employing
the lexicographic Lemke’s algorithm [20, Chap 2.]. This
active set algorithm fe atur e s a symbolic pertu r b ation
technique that ensures unique pivot step selection at
each iteration, wh ich prevents the method from internal
cycling.
MPT 3.0 provides a C-code implementation of the
lexicographic Lemke’s algorithm, enriched by various
techniques and methods to improve speed and nume-
rical robustness of the method. In particular, the LU
recursive factorization based on r ank- one updates [26]
has been incorporated to reduce computational t ime at
each iteration. The LCP solver automatically performs
scaling of the input data in case the problem is not
well-conditioned. In addition, the LCP solver executes
re-factorization of the basis if the le xi cograph ic per-
turbation did not properly identify the unique pivot.
The package is linked to BLAS and LAPACK numer-
ical routines that provide state-of-the art algorithms
for imp le mentation of linear algebra. With all these
features implemented, the LCP solver should provide
a numerically reliable engine for resolvi ng also difficult
degenerate cases that may easily arise in formulations of
MPC problems. The LCP solver is seamlessly integrated
in MPT, but can also be installed separately via the
Toolbox manager.
2) Parametric LCP Solver: The parametric LCP
(PLCP) solver aims at solving the following class of
problems
find w, z
s.t.: w − M z = q + Qθ, (4a)
w
T
z = 0, (4b)
w, z ≥ 0, (4c)
θ ∈ Θ, (4d)
which differs from (3) by the addition of the parametric
term Qθ in (4a) with Q ∈ R
n×d
. Here, θ ∈ R
d
represents a free parameter, which is assumed to be
bounded by (4d), where Θ ⊂ R
d
is a polytope. The
problem data are furthermore given by a sufficient matrix
M ∈ R
n×n
and the vector q ∈ R
n
.
MPT 3.0 implements the algorithm of [12] to solve
PLCP (4) that e mploys the lexicographic perturbations
to improve robust ne s s. In the initial phase of the algo-
rithm, the PLCP (4) is solved as an LCP for a parti cu lar
value of the parameter θ ∈ Θ. This results in a starting
basis for exploration of the parametric space. In subse-
quent steps the algorithm proceeds by lexicographic pivot
steps that id entify the solution for the remain in g space
of parameters. The solution is given by an optimal pair
of z
∗
, w
∗
that forms a piecewise affine (PWA) function
of the parameters θ:
w
∗
z
∗
= F
i
θ + g
i
if θ ∈ P
i
. (5)
Here, F
i
, g
i
define the i-th local affine function which
determines values of w
∗
and z
∗
for any θ that resides in
the i-th polytope P
i
.
The PLCP formulation (4a) naturally entails paramet-
ric linear programming (PLP) and parametric quadratic
programming (PQP) as special cases. In particular, con-
sider a formulation of the form
min
x
1
2
x
T
Hx + (F θ + f )
T
x (6a)
s.t.: A
e
x = b
e
+ Eθ (6b)
Ax ≤ b + Bθ (6c)
θ ∈ Θ (6d)
which consists of a parametrized objective function (6a)
with problem data H ∈ R
n×n
, H 0, F ∈ R
n×d
,
f ∈ R
n
, and parametrized polyhedron (6b)-(6c) where
E ∈ R
m
e
×d
, B ∈ R
m×d
. The formulation (6) can
be converted into the PLCP setup (4) using suitable
affine transformations between variables x, w, z, and
θ. Since the process can be tedious for a human, MPT
3.0 provides automatic routines that convert PQP/PLP
setups into the PLCP form.
There are few advantages of solving PLP/PQP (6) as
PLCP (4). Firstly, a single method is used to tackle all
three classes of problems that prevents from encoding
inconsistencies that may be eventually caused by dif-
ferent algorithms and different tolerance settings. This
was one of the problems in the previous version where
there were multiple versions for multi-parametric LP/QP
solvers. Secondly, according to [12], the PLCP app r oach
is numerically robust and superior in efficiency to other
methods. Furthermore, the PLCP approach can handle
PLP/PQP problems where the parameters appear lin-
early in the cost function and in the right hand side
of constraints and therefore is applicable to solve wider
classes of practical problems.
3) Interfaces to External Solvers: Besides the new
LCP solvers, MPT 3.0 provides interfaces to ex-
ternal state-of-the-art solvers. Supported solvers in-
clude, but are not limited to, CDD [7], GLPK [18],
CLP [10], QPOASES [6], QPSPLINE [16], SeDuMi [24],
GUROBI [9], and CPLEX [4]. With the exception of
the latter two, all other solvers are provided under an
open-source license and can easily be installed using the
Toolbox manager.
It is worth noting that MPT 3.0 relies heavily on
CDD solver for performing many tasks related to com-
putational geometry. In particular, facet and vertex enu-
meration for convex polyhedra and polytopes, as well
as elimination of redundant cons t r aints, are delegated
to CDD. For more information, the interested reader
is referred to [8]. In addition, MPT 3.0 also requires a
freely-available Fourier solver for computing projections
of polyhedra and polytopes.
4) Interface for General Optimizat ion Problems:
MPT 3.0 provides a unified gateway for formulating
LP/QP/LCP (and parametric versions thereof). The
gateway is represented by the Opt class. Using this class
it is possible to formulate the optimization problem and
to pass the data to any s up ported solver that has been
installed. Th e general syntax is as follows:
problem = Opt(’H’,H,’f’,f,’A’,A,’b’,b)
which accepts the problem data as matrices and vectors
of the form (6) or (4). At the time of creation of the
object, the type of the optimization pr oble m is recog-
nized and the appropriate solver from the list of available
solvers is associated with the problem. If the problem is
formulated as an LP/QP/PLP/PQP, the transformation
to LCP/PLCP can be invoking the qp2lcp method as
follows:
problem.qp2lcp()
In general, the optimization problem can be solved by
calling t he solve method, i.e.,
solution = problem.solve()
and the output is retur n ed in a corresponding form for
non-parametric and parametric solvers.
MPT 3.0 also allows to import parametric opti-
mization problems defined using the YALMIP environ-
ment [17]. This is achieved by creating an instance of the
Opt class as follows
problem = Opt(constraints, objective, theta, x)
Here, constraints and objective define, res pectively,
constraints and the cost function of a particular opti-
mization problem, and theta and x denote YALMIP’s
variables used to define the problem. New versions of
YALMIP also direc tl y interact with MPT 3.0’s PLCP
solvers to directly solve parametric optimization setups
via the solvemp command of YALMIP. For further de-
tails the user is referred to documentation of YALMIP.
D. Enhancements in t he Geometric Library
The geometric library is a vital part of MPT since
it provides basic building blocks for solving parametric
optimization problems that arise in explicit MPC. The
increasing interest in using features of the geometric
library has motivated the development of new supported
sets and related operations. In th is section the enh ance -
ments in the geometric library are reviewed.
1) Polyhedral Library: Polyhedr a and polytopes are
represented in MPT 3.0 as instances of the Polyhedron
class. The half-space representation of a polyhedron as in
Definition 2.6 is created by calling the class constructor
as f ollows:
P = Polyhedron(’A’,A,’b’,b,’Ae’,Ae,’be’,be)
where A, b specify the inequaliti es Ax ≤ b, and Ae with
be define the equalities A
e
x = b
e
. If the polyhedron
has no equality constraints, then a shorter version of the
constructor can be used:
P = Polyhedron(A, b)
V-representation of a polyhedron as in (2) can be created
by calling
P = Polyhedron(’V’,V,’R’,R)
where V are the vertices (stored row-wise), and R specifies
the rays. If no rays are present, the shorter syntax
P = Polyhedron(V)
can be used.
The main improvement in the geometric library com-
paring to pr ev ious version of MPT, is that the polyhedral
sets can be constructed not just as bounded polytopes
but also as general polyhedra according to Def. 2.6
and Def. 2.7. With this feature the geometric library
in MPT 3.0 seamlessly supports unbounded and lower-
dimensional polyhedra, as illustrated in Fig. 1. Another
point worth mentioning is that, unlike the previous
versions, MP T 3.0 does not automatically convert be-
tween H- and V-representations, neither does it eliminate
redundant constraints. The H-to-V and V-to-H conver-
sions, as well as elimination of redundant data, have to
be manually requested by calling
P.minHRep()
to comp ut e the minimal H-representation, or by
P.minVRep()
for obtaining a minimal V-representation of a polyhe-
dron.
Once the polyhedron is constructed using the
Polyhedron constructor, the user can directly access
data of the (irredundant) H- and V-representations by
accessing t he A, b, Ae, be, V, and R fields. For instance:
vertices = P.V
will retur n vertices of the polyhedron, regard le ss of
whether the object P was originally constructed as a
V-polyhedron or from a half- s pace representation. Simi-
larly, to access the H-representation, use
A = P.A, b = P.b, Ae = P.Ae, be = P.be
The new geometric library in MPT 3.0 implements
various methods that operate on instances of the
Polyhedron class. The ne w feature is that these methods
apply also to lower-dimensional and unbounded sets. As
an illustrative example, consider two polyhedra P and
Q. Then their Minkowski sum is given by P + Q =
{x + z | x ∈ P, z ∈ Q}. Such an operation can
be straightforwardly performed in MPT 3.0 using the
overloaded + (plus) op e r ator:
S = P + Q
As an another example, consider the subset test check
P ⊆ Q. This can be achieved by using the overloaded <=
operator as follows
issubset = P <= Q
(a) Bounded polyhedron.
(b) Unbounded polyhedron.
(c) Lower-dimensional polytope.
Fig. 1. Extended polyhedral libra ry supports bounded, un-
bounded and low-dimensional polyhedra.
Additional me th ods ar e summarized in Table I.
Another new feature of the geometric lib r ary is sim-
plified creation of functions defined over poly he dr a by
allowing function handles to be associated to instances
of the Polyhedron class. As an example, consi de r a 1D
polytope P = {x ∈ R | − 1 ≤ x ≤ 1}, over which we
want to define the functi on f(x) = sin(x) + 2. In MPT
3.0 this can be achieved first by creating a Polyhedron
object and a Function object followed by attaching the
function:
P = Polyhedron(’lb’, -1, ’ub’, 1)
F = Function(@(x) sin(x)+2)
P.addFunction(F, ’f1’)
Here, the string ’f1’ denotes the name of the function.
Multiple functions can be associated to each polyhedron
Fig. 2. Depiction of piecewise function consisting of t h ree
affine parts and one quadratic p a r t.
objects. Then one can either plot the function by calling
P.fplot(’f1’)
or evaluate the f un ct ion at a particular point z by
value = P.feval(z, ’f1’)
If the polyhedron only has a single function associated
to it , the second input argument can be omitted.
MPT 3.0 also provides a ne w PolyUnion class that
represents unions of polyhedra of identical dimensions.
Purpose of this class is to capture geometric properties of
such unions, such as boundedness, connectivity, overlaps,
convexity, and full-dimen si onality. Sub se qu ent computa-
tion can then benefit from these stored properties to
reduce computational time. Unions of polyhedra can be
created as follows:
U = PolyUnion([P1 P2 P3 P4])
where P1, P2, P3, P4 are Polyhedron objects that form
the union. Methods that operate on such unions ar e
summarized in Table II. If each el ement of the union has
a function associated to it, the PolyUnion object repre-
sents a piecewise function over polyhedra, cf. Def. 2.3. A
plot of such a function, obtained by calling
U.fplot()
is shown in Fig. 2. The funct ion value at a point z can
be obtained by
value = U.feval(z, ’f1’)
Here, ’f1’ denotes name of the function that should
be evaluated. The syntax for function evaluation is the
same as for the Polyhedron object, i.e. if the union only
has a sin gle function associated to it, the second input
argument can be omitted.
Using this feature of the geomet r ic library it is possible
assign any type functions to a set to form piecewise func-
tions. For instance, Tab. III lists methods that operate
over PWA functions. These metho ds are used in the
analysis module of M PT to postpr ocess explicit solution
that i s obtained in the hybrid MPC design.
2) General Convex Sets: The geometric library in
MPT 3.0 is not restricted to polyhedra. It allows to
