Instantiates a Polyhedron in the form {x | x_min <= x[indices] <= x_max}. If indices is None, the inequality is applied to all the el

Checks if two matrices contain the same rows. The order of the rows can be different. The option normalize, normalizes the rows of A and

Adds the equality C x = d to the existing polyhedron. Arguments ---------- C : numpy.ndarray Left-hand s

Calls the desired solver to solve the linear program min_x f^T x s.t. A x <= b, C x = d. Arguments ---------- f : numpy.ndarray

Determines if the given point belongs to the polytope. Arguments ---------- x : numpy.ndarray Point whos

Checks if the polyhedron P is a subset of the polyhedron P2 (returns True or False). For each halfspace H descibed a facet of P2, it

Adds the inequality A x[indices] <= b to the existing polyhedron. Arguments ---------- A : numpy.ndarray

Instantiates a discrete-time linear system starting from its continuous time representation. Arguments ---------- A

Adds the inequality x[indices] <= x_max to the existing polyhedron. If indices is None, the inequality is applied to all the elements

Removes the redundant facets of the polyhedron, it modifies the attributes A and b.

Tests that two lists of array contain the same elements. The order of the elements in the lists can be different. Arguments --------

Adds the inequality x[indices] >= x_min to the existing polyhedron. If indices is None, the inequality is applied to all the elements

Returns the Cartesian product between this instance of Polyhedron (P1) and the polyhedron P2. Arguments ---------- P

Calls the desired solver to solve the strictly convex (H > 0) quadratic program min .5 x' H x + f' x s.t. A x <= b, C x = d. Arguments

Solves the QP at the given point x. Arguments ---------- x : numpy.ndarray Point where we want to get th

Calls the desired solver to solve the strictly convex (H > 0) mixed-integer quadratic program min .5 x' H x + f' x s.t. A x <= b, C x = d. T

Check that the matrices A, B, and c of an affine system have compatible sizes. Arguments ---------- A : numpy.ndarray State

Instantiates a Polyhedron in the form {x | x[indices] >= x_min}. If indices is None, the inequality is applied to all the elements of

Uses SVD to find a basis of the nullsapce of A. Arguments ---------- A : numpy.ndarray Matrix for the nullspace. Return

Plots the 2d projection of the polyhedron in the given dimension. It assumes the polyhedron to be bounded and not empty. Arg

Numeric value of the optimal value function at the point x. Arguments ---------- x : numpy.ndarray Point

Returns the solution of the Discrete Algebraic Riccati Equation (DARE). Consider the linear quadratic control problem V*(x(0)) = min_

For the polyhedron P := {x | A x <= b, C x = d}, returns the change of variables x = [N R] [n' r']' such that P can be expressed only by ineq

Checks that E and f have the same number of rows. Arguments ---------- E : numpy.ndarray Left-hand side

Returns a selection matrix S such that S x = x[indices]. Arguments ---------- indices : list of int Set

Discretizes the continuous-time affine system dx/dt = A x + B u + c approximating x(t+1) with x(t) + h dx/dt(t). Arguments ----------

Returns the explicit solution of the mpQP for a given active set. The solution turns out to be an affine function of x, i.e. u(x) = u

Given the state x of the system, returns the optimal sequence of N inputs and the related cost. Arguments ----------

Given the state x of the system, returns the optimal sequence of N inputs and the related cost. Arguments ----------

Instantiates the polyhedron given from the conve hull of the given set of points. It assumes the polyhedron to be bounded. A

Instantiates a Polyhedron in the form expr(x) <= 0, eq(x) = 0. Arguments ---------- x : sympy matrix filled with sym

Instatiates a LinearSystem starting from the symbolic value of the next state. Arguments ---------- x : sympy matrix

Extracts from the symbolic affine expression the matrices such that expr(x) = A x - b. Arguments ---------- x : sympy matrix fil

Extracts from the symbolic expression of the state at the next time step the matrices A, B, and c. Arguments ---------- x : sympy mat

Returns the maximal constraint-admissible invariant set O_inf for the closed-loop system X(t+1) = (A + B K) x(t). It holds that x(0)

Computes the indices of the facets that generate a minimal representation of the polyhedron solving an LP for each facet of the redundant rep

Normalizes the polyhedron dividing each row of A by its norm and each entry of b by the norm of the corresponding row of A. Argument

Numeric value of the primal optimizer at the point x. Arguments ---------- x : numpy.ndarray Point where

Assuming piecewise constant inputs, it returns the exact discretization of the affine system dx/dt = A x + B u + c. Math ----------

Builds a matrix with the form | 0 bigM[1][2] bigM[1][3] ...| |bigM[2][1] 0 bigM[2][3] ...| |bigM[3][

Builds the Gurobi model the LP or the QP. Arguments ---------- H, f, A, b, C, d : numpy.ndarray Matrices of the mathematical

Organizes the solution in a dictionary. Arguments ---------- model : instance of gurobipy.Model Model of the mathematical pr

Adds the inequalities x_min <= x[indices] <= x_max to the existing polyhedron. If indices is None, the inequality is applied to all t

For the PWA system x(t+1) = A_i x(t) + B_i u(t) + c_i if (x(t), u(t)) in D_i, given the mode sequence z = (z(0), ... , z(N-1)), ret

Checks if the point x is inside the critical region. Arguments ---------- x : numpy.ndarray Point we wan

Given a bouned polyhedron in the form P := {x | A x <= b}, returns the orthogonal projection to the given dimensions. Dividing the space in t

Returns the optimal feedback for the given state x. Arguments ---------- x : numpy.ndarray State of the

Returns the critical region that covers the given point. Arguments ---------- x : numpy.ndarray Point wh

Returns the intersection between this instance of Polyhedron (P1) and the polyhedron P2. Arguments ---------- P2 : i

Generates a list of Gurobi linear expressions A_i x + b_i (one element per row of A). Arguments ---------- A : numpy.ndarray

Numeric value of the dual optimizer at the point x. Arguments ---------- x : numpy.ndarray Point where w

Returns the plane a' x = b passing through the points. It first adds a random offset to be sure that the matrix of the points is invertible (

Multiplies from lest to right the matrices in the list matrix_list. Arguments ---------- matrix_list : list of numpy.ndarray

Simulates the system starting from the state x0 and applying the sequence of controls u. Arguments ---------- x0 : n

Returns the Chebyshev radius and center of the polyhedron P := {x | A x <= b, C x = d} solving the LP: min_{z, e} e s.t. F z <= g + F_{row_n

Resets al the attibutes of the class to None.

Constructs the matrices A_bar and B_bar such that x_bar = A_bar x(0) + B_bar u_bar with x_bar = (x(0), ... , x(N)) and u_bar = (u(0), ... , u

For a given mode sequences, condenses the optimal control problem for a PWA affine system min_{x(.), u(.)} 1/2 sum_{t=0}^{N-1} (x'(t) Q x(t)

Returns the explicit solution of the mpQP. It assumes that the facet-to-facet property holds (i.e. each facet of a critical region is

Returns the explicit solution of the mpQP at a given point. In case a guess for the active set is provided, it first tries it.

Returns the optimal feedback for the given state x. Arguments ---------- x : numpy.ndarray State of the s

Finds the critical region where the state x is and returns the optimal feedback for the given state x. Arguments ----------

Finds the critical region where the state x is and returns the optimal feedforward and the cost to go. Arguments ----------

Instantiates a Polyhedron in the form {x | x[indices] <= x_max}. If indices is None, the inequality is applied to all the elements of

Returns the feasible set of the mqQP, i.e. {x | exists u: Au u + Ax x <= b}. Returns ---------- instance of Polyhedr

Given (x,u) returns the i such that (x,u) in D_i. Arguments ---------- x : numpy.ndarray Value for the s

Returns the optimal control problem in condensed form for the given mode sequence. Arguments ---------- mode_sequence

Check if the domains of the pwa system are well posed (i.e. if the intersection of the interior of D_i with the interior of D_j is empty for

uses the QR decomposition to find the indices of a set of linear independent rows of the matrix A. Arguments ---------- A : numpy.nd

Returns the maximal constraint-admissible (positive) invariant set O_inf for the system x(t+1) = A x(t) subject to the constraint x in X. O_i

Returns the orthogonal projection of the polytope. Arguments ---------- residual_dimensions : list of int

Left hand side of the inequalities describing the critical region. Returns ---------- numpy.ndarray Left

Puts equations (1-4) from the documentation of _get_bigM_dynamics(), equation (5) from the documentation of _get_bigM_domains(), and the cond

Puts the equality constraint x(0) = x0, x(t+1) = sum_{i=1}^s z_i(t), t = 0, ..., N-1, in the form x_bar = A_b

Stacks the inequalities Ex x(t) + Eu u(t) + Ez z(t) + Ed delta(t) <= E0, t = 0, ..., N-1, x(N) in X_N, in the form

Generates and stores the optimal control problem in condensed form. Returns ---------- instance of MultiParametricQu

Constructs a multiparametric Mixed Integer Quadratic Program (mpMIQP) in the form |u|' |Huu 0 0 0| |u|

Expands the internal simplex to cover all the projection. Arguments ---------- A : numpy.ndarray Left-hand side of the inequ

Computes all the bigMs for the domains of the PWA system. Each one of the s domains of the PWA system has the form D_i = {(x,

Computes all the bigMs for the dynamics of the PWA system. The PWA system has the dynamics x(t+1) = A_i x(t) + B_i u(t) + c_i

Constructs a simplex contained in the porjection. Arguments ---------- A : numpy.ndarray Left-hand side of the inequalities

Findes two vertices of the projection. Arguments ---------- A : numpy.ndarray Left-hand side of the inequalities describing

Given a list of 1-dimensional points, returns the Voronoi partition of the space as a list of Polyhedron (pympc class). Arguments ------

Given a list of n-dimensional points, returns the Voronoi partition of the space as a list of Polyhedron (pympc class). Uses the scipy wrappe

Adds the inequality eq(x) = 0 to the existing polyhedron. Arguments ---------- x : sympy matrix filled with sympy sy

Adds the inequality ineq(x) <= 0 to the existing polyhedron. Arguments ---------- x : sympy matrix filled with sympy

For the list of Polyhedron P_list in the from Pi = {x | Ai x <= bi} returns a list of lists of numpy arrays, where m[i][j] := max_{x in Pj} Ai x

Constructs the matrices A_bar, B_bar cnd c_bar such that x_bar = A_bar x(0) + B_bar u_bar + c_bar with x_bar = (x(0), ... , x(N)) and u_bar =

See the documentation of condense_pwa_system().

Given a list of n-dimensional points, returns the Voronoi partition of the Polyhedron X as a list of Polyhedron. If X is None, returns the pa

Returns the Cebyshec center of the i-th facet. Implementation note: it is necessary to add the facet as an equality constraint, other

For the PWA system S x+ = Ai x + Bi u + ci if Fi x + Gi u <= hi, returns the graphs of the dynamics (list of Polyhedron) [ Fi Gi 0]

Returns the minimal facets of the critical region. Returns ---------- list of int List of indices of the

Solves the Partial Non-Negative Least Squares problem min_{u, v} ||A v + B u - c||_2^2 s.t. v >= 0. (See "Bemporad - A Multiparametric Quadra

Generates a Gurobi quadratic expressions x' H x. Arguments ---------- H : numpy.ndarray Hessian of the quadratic expression.

Simulates the system starting from the state x0 and applying the sequence of controls u. Arguments ---------- x0 : n