pydrake.solvers
Bindings for Solving Mathematical Programs.
If you are formulating constraints using symbolic formulas, please review the
top-level documentation for pydrake.math
.
- pydrake.solvers.AddBilinearProductMcCormickEnvelopeSos2(prog: pydrake.solvers.MathematicalProgram, x: pydrake.symbolic.Variable, y: pydrake.symbolic.Variable, w: pydrake.symbolic.Expression, phi_x: numpy.ndarray[numpy.float64[m, 1]], phi_y: numpy.ndarray[numpy.float64[m, 1]], Bx: numpy.ndarray[object[m, 1]], By: numpy.ndarray[object[m, 1]], binning: pydrake.solvers.IntervalBinning) numpy.ndarray[object[m, n]]
Add constraints to the optimization program, such that the bilinear product x * y is approximated by w, using Special Ordered Set of Type 2 (sos2) constraint. To do so, we assume that the range of x is [x_min, x_max], and the range of y is [y_min, y_max]. We first consider two arrays φˣ, φʸ, satisfying
x_min = φˣ₀ < φˣ₁ < ... < φˣₘ = x_max y_min = φʸ₀ < φʸ₁ < ... < φʸₙ = y_max
, and divide the range of x into intervals [φˣ₀, φˣ₁], [φˣ₁, φˣ₂], … , [φˣₘ₋₁, φˣₘ] and the range of y into intervals [φʸ₀, φʸ₁], [φʸ₁, φʸ₂], … , [φʸₙ₋₁, φʸₙ]. The xy plane is thus cut into rectangles, with each rectangle as [φˣᵢ, φˣᵢ₊₁] x [φʸⱼ, φʸⱼ₊₁]. The convex hull of the surface z = x * y for x, y in each rectangle is a tetrahedron. We then approximate the bilinear product x * y with w, such that (x, y, w) is in one of the tetrahedrons.
We use two different encoding schemes on the binary variables, to determine which interval is active. We can choose either linear or logarithmic binning. When using linear binning, for a variable with N intervals, we use N binary variables, and B(i) = 1 indicates the variable is in the i’th interval. When using logarithmic binning, we use ⌈log₂(N)⌉ binary variables. If these binary variables represent integer M in the reflected Gray code, then the continuous variable is in the M’th interval.
- Parameter
prog
: The program to which the bilinear product constraint is added
- Parameter
x
: The decision variable.
- Parameter
y
: The decision variable.
- Parameter
w
: The expression to approximate x * y
- Parameter
phi_x
: The end points of the intervals for
x
.- Parameter
phi_y
: The end points of the intervals for
y
.- Parameter
Bx
: The binary variables for the interval in which x stays encoded as described above.
- Parameter
By
: The binary variables for the interval in which y stays encoded as described above.
- Parameter
binning
: Determine whether to use linear binning or logarithmic binning.
- Returns
lambda The auxiliary continuous variables.
The constraints we impose are
x = (φˣ)ᵀ * ∑ⱼ λᵢⱼ y = (φʸ)ᵀ * ∑ᵢ λᵢⱼ w = ∑ᵢⱼ φˣᵢ * φʸⱼ * λᵢⱼ Both ∑ⱼ λᵢⱼ = λ.rowwise().sum() and ∑ᵢ λᵢⱼ = λ.colwise().sum() satisfy SOS2 constraint.
If x ∈ [φx(M), φx(M+1)] and y ∈ [φy(N), φy(N+1)], then only λ(M, N), λ(M + 1, N), λ(M, N + 1) and λ(M+1, N+1) can be strictly positive, all other λ(i, j) are zero.
Note
We DO NOT add the constraint Bx(i) ∈ {0, 1}, By(j) ∈ {0, 1} in this function. It is the user’s responsibility to ensure that these constraints are enforced.
- Parameter
- pydrake.solvers.AddLogarithmicSos1Constraint(prog: pydrake.solvers.MathematicalProgram, num_lambda: int) Tuple[numpy.ndarray[object[m, 1]], numpy.ndarray[object[m, 1]]]
Adds the special ordered set of type 1 (SOS1) constraint. Namely
λ(0) + ... + λ(n-1) = 1 λ(i) ≥ 0 ∀i ∃ j ∈ {0, 1, ..., n-1}, s.t λ(j) = 1
where one and only one of λ(i) is 1, all other λ(j) are 0. We will need to add ⌈log₂(n)⌉ binary variables, where n is the number of rows in λ. For more information, please refer to Modeling Disjunctive Constraints with a Logarithmic Number of Binary Variables and Constraints by J. Vielma and G. Nemhauser, 2011.
- Parameter
prog
: The program to which the SOS1 constraint is added.
- Parameter
num_lambda
: n in the documentation above.
- Returns
(lambda, y) lambda is λ in the documentation above. Notice that λ are declared as continuous variables, but they only admit binary solutions. y are binary variables of size ⌈log₂(n)⌉. When this sos1 constraint is satisfied, suppose that λ(i)=1 and λ(j)=0 ∀ j≠i, then y is the Reflected Gray code of i. For example, suppose n = 8, i = 5, then y is a vector of size ⌈log₂(n)⌉ = 3, and the value of y is (1, 1, 0) which equals to 5 according to reflected Gray code.
- Parameter
- pydrake.solvers.AddLogarithmicSos2Constraint(prog: pydrake.solvers.MathematicalProgram, lambdas: numpy.ndarray[object[m, 1]], binary_variable_name: str = 'y') numpy.ndarray[object[m, 1]]
Adds the special ordered set 2 (SOS2) constraint,
See also
AddLogarithmicSos2Constraint.
- pydrake.solvers.AddSos2Constraint(prog: pydrake.solvers.MathematicalProgram, lambdas: numpy.ndarray[object[m, 1]], y: numpy.ndarray[object[m, 1]]) None
Adds the special ordered set 2 (SOS2) constraint. y(i) takes binary values (either 0 or 1).
y(i) = 1 => λ(i) + λ(i + 1) = 1.
See also
AddLogarithmicSos2Constraint for a complete explanation on SOS2 constraint.
- Parameter
prog
: The optimization program to which the SOS2 constraint is added.
- Parameter
lambda
: At most two entries in λ can be strictly positive, and these two entries have to be adjacent. All other entries are zero. Moreover, these two entries should sum up to 1.
- Parameter
y
: y(i) takes binary value, and determines which two entries in λ can be strictly positive. Throw a runtime error if y.rows() != lambda.rows() - 1.
- Parameter
- class pydrake.solvers.AugmentedLagrangianNonsmooth
Compute the augmented Lagrangian (AL) of a given mathematical program
min f(x) s.t h(x) = 0 l <= g(x) <= u x_lo <= x <= x_up
We first turn it into an equality constrained program with non-negative slack variable s as follows
min f(x) s.t h(x) = 0 c(x) - s = 0 s >= 0
Depending on the option include_x_bounds, the constraint h(x)=0, c(x)>=0 may or may not include the bounding box constraint x_lo <= x <= x_up.
the (non-smooth) augmented Lagrangian is defined as
L(x, λ, μ) = f(x) − λ₁ᵀh(x) + μ/2 h(x)ᵀh(x) - λ₂ᵀ(c(x)-s) + μ/2 (c(x)-s)ᵀ(c(x)-s)
where s = max(c(x) - λ₂/μ, 0).
For more details, refer to section 17.4 of Numerical Optimization by Jorge Nocedal and Stephen Wright, Edition 1, 1999 (This formulation isn’t presented in Edition 2, but to stay consistent with Edition 2, we use μ/2 as the coefficient of the quadratic penalty term instead of 1/(2μ) in Edition 1). Note that the augmented Lagrangian L(x, λ, μ) is NOT a smooth function of x, since s = max(c(x) - λ₂/μ, 0) is non-smooth at c(x) - λ₂/μ = 0.
- __init__(self: pydrake.solvers.AugmentedLagrangianNonsmooth, prog: pydrake.solvers.MathematicalProgram, include_x_bounds: bool) None
- Parameter
prog
: The mathematical program we will evaluate.
- Parameter
include_x_bounds
: . Whether the Lagrangian and the penalty for the bounds x_lo <= x <= x_up are included in the augmented Lagrangian L(x, λ, μ) or not.
- Parameter
- Eval(*args, **kwargs)
Overloaded function.
Eval(self: pydrake.solvers.AugmentedLagrangianNonsmooth, x: numpy.ndarray[numpy.float64[m, 1]], lambda_val: numpy.ndarray[numpy.float64[m, 1]], mu: float) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]], float]
- Parameter
x
: The value of all the decision variables.
- Parameter
lambda_val
: The estimated Lagrangian multipliers. The order of the Lagrangian multiplier is as this: We first call to evaluate all constraints. Then for each row of the constraint, if it is an equality constraint, we append one single Lagrangian multiplier. Otherwise we append the Lagrangian multiplier for the lower and upper bounds (where the lower comes before the upper), if the corresponding bound is not ±∞. The order of evaluating all the constraints is the same as prog.GetAllConstraints() except for prog.bounding_box_constraints(). If include_x_bounds=true, then we aggregate all the bounding_box_constraints() and evaluate them at the end of all constraints.
- Parameter
mu
: μ in the documentation above. The constant for penalty term weight. This should be a strictly positive number.
- Parameter
constraint_residue
: The value of the all the constraints. For an equality constraint c(x)=0 or the inequality constraint c(x)>= 0, the residue is c(x). Depending on include_x_bounds,
constraint_residue
may or may not contain the residue for bounding box constraints x_lo <= x <= x_up at the end.- Parameter
cost
: The value of the cost function f(x).
- Returns
The evaluated Augmented Lagrangian (AL) L(x, λ, μ).
Eval(self: pydrake.solvers.AugmentedLagrangianNonsmooth, x: numpy.ndarray[object[m, 1]], lambda_val: numpy.ndarray[numpy.float64[m, 1]], mu: float) -> Tuple[pydrake.autodiffutils.AutoDiffXd, numpy.ndarray[object[m, 1]], pydrake.autodiffutils.AutoDiffXd]
- Parameter
x
: The value of all the decision variables.
- Parameter
lambda_val
: The estimated Lagrangian multipliers. The order of the Lagrangian multiplier is as this: We first call to evaluate all constraints. Then for each row of the constraint, if it is an equality constraint, we append one single Lagrangian multiplier. Otherwise we append the Lagrangian multiplier for the lower and upper bounds (where the lower comes before the upper), if the corresponding bound is not ±∞. The order of evaluating all the constraints is the same as prog.GetAllConstraints() except for prog.bounding_box_constraints(). If include_x_bounds=true, then we aggregate all the bounding_box_constraints() and evaluate them at the end of all constraints.
- Parameter
mu
: μ in the documentation above. The constant for penalty term weight. This should be a strictly positive number.
- Parameter
constraint_residue
: The value of the all the constraints. For an equality constraint c(x)=0 or the inequality constraint c(x)>= 0, the residue is c(x). Depending on include_x_bounds,
constraint_residue
may or may not contain the residue for bounding box constraints x_lo <= x <= x_up at the end.- Parameter
cost
: The value of the cost function f(x).
- Returns
The evaluated Augmented Lagrangian (AL) L(x, λ, μ).
- include_x_bounds(self: pydrake.solvers.AugmentedLagrangianNonsmooth) bool
- Returns
Whether the bounding box constraint x_lo <= x <= x_up is included in the augmented Lagrangian L(x, λ, μ).
- is_equality(self: pydrake.solvers.AugmentedLagrangianNonsmooth) List[bool]
- Returns
Whether each constraint is equality or not. The order of the constraint is explained in the class documentation.
- lagrangian_size(self: pydrake.solvers.AugmentedLagrangianNonsmooth) int
- Returns
The size of the Lagrangian multiplier λ.
- prog(self: pydrake.solvers.AugmentedLagrangianNonsmooth) pydrake.solvers.MathematicalProgram
- Returns
The mathematical program for which the augmented Lagrangian is computed.
- x_lo(self: pydrake.solvers.AugmentedLagrangianNonsmooth) numpy.ndarray[numpy.float64[m, 1]]
- Returns
all the lower bounds of x.
- x_up(self: pydrake.solvers.AugmentedLagrangianNonsmooth) numpy.ndarray[numpy.float64[m, 1]]
- Returns
all the upper bounds of x.
- class pydrake.solvers.AugmentedLagrangianSmooth
Compute the augmented Lagrangian (AL) of a given mathematical program
min f(x) s.t h(x) = 0 l <= g(x) <= u x_lo <= x <= x_up
We first turn it into an equality constrained program with non-negative slack variable s as follows
min f(x) s.t h(x) = 0 c(x) - s = 0 s >= 0
We regard this as an optimization problem on variable (x, s), with equality constraints h(x) = 0, c(x)-s = 0, and the bound constraint s >= 0.
Depending on the option include_x_bounds, the constraint h(x)=0, c(x)>=0 may or may not include the bounding box constraint x_lo <= x <= x_up.
The (smooth) augmented Lagrangian is defined as
L(x, s, λ, μ) = f(x) − λ₁ᵀh(x) + μ/2 h(x)ᵀh(x) - λ₂ᵀ(c(x)-s) + μ/2 (c(x)-s)ᵀ(c(x)-s)
For more details, refer to section 17.4 of Numerical Optimization by Jorge Nocedal and Stephen Wright, Edition 2, 2006. Note that the augmented Lagrangian L(x, s, λ, μ) is a smooth function of (x, s),
This is the implementation used in LANCELOT. To solve the nonlinear optimization through this Augmented Lagrangian, the nonlinear solve should be able to handle bounding box constraints on the decision variables.
- __init__(self: pydrake.solvers.AugmentedLagrangianSmooth, prog: pydrake.solvers.MathematicalProgram, include_x_bounds: bool) None
- Parameter
prog
: The mathematical program we will evaluate.
- Parameter
include_x_bounds
: . Whether the Lagrangian and the penalty for the bounds x_lo <= x <= x_up are included in the augmented Lagrangian L(x, s, λ, μ) or not.
- Parameter
- Eval(*args, **kwargs)
Overloaded function.
Eval(self: pydrake.solvers.AugmentedLagrangianSmooth, x: numpy.ndarray[numpy.float64[m, 1]], s: numpy.ndarray[numpy.float64[m, 1]], lambda_val: numpy.ndarray[numpy.float64[m, 1]], mu: float) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]], float]
- Parameter
x
: The value of all the decision variables in prog().
- Parameter
s
: The value of all slack variables s.
- Parameter
lambda_val
: The estimated Lagrangian multipliers. The order of the Lagrangian multiplier is as follows: We first call to evaluate all constraints. Then for each row of the constraint, if it is an equality constraint, we append one single Lagrangian multiplier. Otherwise we append the Lagrangian multiplier for the lower and upper bounds (where the lower comes before the upper), if the corresponding bound is not ±∞. The order of evaluating all the constraints is the same as prog.GetAllConstraints() except for prog.bounding_box_constraints(). If include_x_bounds=true, then we aggregate all the bounding_box_constraints() and evaluate them at the end of all constraints.
- Parameter
mu
: μ in the documentation above. The constant for penalty term weight. This should be a strictly positive number.
- Parameter
constraint_residue
: The value of the all the constraints. For an equality constraint c(x)=0, the residue is c(x); for an inequality constraint c(x)>=0, the residue is c(x)-s where s is the corresponding slack variable. Depending on include_x_bounds,
constraint_residue
may or may not contain the residue for bounding box constraints x_lo <= x <= x_up at the end.- Parameter
cost
: The value of the cost function f(x).
- Returns
The evaluated Augmented Lagrangian (AL) L(x, s, λ, μ).
Note
This Eval function differs from AugmentedLagrangianNonsmooth::Eval() function as
s
is an input argument.Eval(self: pydrake.solvers.AugmentedLagrangianSmooth, x: numpy.ndarray[object[m, 1]], s: numpy.ndarray[object[m, 1]], lambda_val: numpy.ndarray[numpy.float64[m, 1]], mu: float) -> Tuple[pydrake.autodiffutils.AutoDiffXd, numpy.ndarray[object[m, 1]], pydrake.autodiffutils.AutoDiffXd]
- Parameter
x
: The value of all the decision variables in prog().
- Parameter
s
: The value of all slack variables s.
- Parameter
lambda_val
: The estimated Lagrangian multipliers. The order of the Lagrangian multiplier is as follows: We first call to evaluate all constraints. Then for each row of the constraint, if it is an equality constraint, we append one single Lagrangian multiplier. Otherwise we append the Lagrangian multiplier for the lower and upper bounds (where the lower comes before the upper), if the corresponding bound is not ±∞. The order of evaluating all the constraints is the same as prog.GetAllConstraints() except for prog.bounding_box_constraints(). If include_x_bounds=true, then we aggregate all the bounding_box_constraints() and evaluate them at the end of all constraints.
- Parameter
mu
: μ in the documentation above. The constant for penalty term weight. This should be a strictly positive number.
- Parameter
constraint_residue
: The value of the all the constraints. For an equality constraint c(x)=0, the residue is c(x); for an inequality constraint c(x)>=0, the residue is c(x)-s where s is the corresponding slack variable. Depending on include_x_bounds,
constraint_residue
may or may not contain the residue for bounding box constraints x_lo <= x <= x_up at the end.- Parameter
cost
: The value of the cost function f(x).
- Returns
The evaluated Augmented Lagrangian (AL) L(x, s, λ, μ).
Note
This Eval function differs from AugmentedLagrangianNonsmooth::Eval() function as
s
is an input argument.
- include_x_bounds(self: pydrake.solvers.AugmentedLagrangianSmooth) bool
- Returns
Whether the bounding box constraint x_lo <= x <= x_up is included in the augmented Lagrangian L(x, λ, μ).
- is_equality(self: pydrake.solvers.AugmentedLagrangianSmooth) List[bool]
- Returns
Whether each constraint is equality or not. The order of the constraint is explained in the class documentation.
- lagrangian_size(self: pydrake.solvers.AugmentedLagrangianSmooth) int
- Returns
The size of the Lagrangian multiplier λ.
- prog(self: pydrake.solvers.AugmentedLagrangianSmooth) pydrake.solvers.MathematicalProgram
- Returns
The mathematical program for which the augmented Lagrangian is computed.
- s_size(self: pydrake.solvers.AugmentedLagrangianSmooth) int
- Returns
The size of the slack variable s.
- x_lo(self: pydrake.solvers.AugmentedLagrangianSmooth) numpy.ndarray[numpy.float64[m, 1]]
- Returns
All the lower bounds of x.
- x_up(self: pydrake.solvers.AugmentedLagrangianSmooth) numpy.ndarray[numpy.float64[m, 1]]
- Returns
All the upper bounds of x.
- template pydrake.solvers.Binding
Instantiations:
Binding[EvaluatorBase]
,Binding[Constraint]
,Binding[LinearConstraint]
,Binding[LorentzConeConstraint]
,Binding[RotatedLorentzConeConstraint]
,Binding[LinearEqualityConstraint]
,Binding[BoundingBoxConstraint]
,Binding[PositiveSemidefiniteConstraint]
,Binding[LinearMatrixInequalityConstraint]
,Binding[LinearComplementarityConstraint]
,Binding[ExponentialConeConstraint]
,Binding[Cost]
,Binding[LinearCost]
,Binding[QuadraticCost]
,Binding[L1NormCost]
,Binding[L2NormCost]
,Binding[LInfNormCost]
,Binding[PerspectiveQuadraticCost]
,Binding[VisualizationCallback]
- class Binding[EvaluatorBase]
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.solvers.Binding[EvaluatorBase], c: pydrake.solvers.EvaluatorBase, v: numpy.ndarray[object[m, 1]]) -> None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.__init__(self: pydrake.solvers.Binding[EvaluatorBase], arg0: object) -> None
- evaluator(self: pydrake.solvers.Binding[EvaluatorBase]) pydrake.solvers.EvaluatorBase
- variables(self: pydrake.solvers.Binding[EvaluatorBase]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[BoundingBoxConstraint]
- __init__(self: pydrake.solvers.Binding[BoundingBoxConstraint], c: pydrake.solvers.BoundingBoxConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[BoundingBoxConstraint]) pydrake.solvers.BoundingBoxConstraint
- variables(self: pydrake.solvers.Binding[BoundingBoxConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[Constraint]
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.solvers.Binding[Constraint], c: pydrake.solvers.Constraint, v: numpy.ndarray[object[m, 1]]) -> None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.__init__(self: pydrake.solvers.Binding[Constraint], arg0: object) -> None
- evaluator(self: pydrake.solvers.Binding[Constraint]) pydrake.solvers.Constraint
- variables(self: pydrake.solvers.Binding[Constraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[Cost]
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.solvers.Binding[Cost], c: pydrake.solvers.Cost, v: numpy.ndarray[object[m, 1]]) -> None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.__init__(self: pydrake.solvers.Binding[Cost], arg0: object) -> None
- evaluator(self: pydrake.solvers.Binding[Cost]) pydrake.solvers.Cost
- variables(self: pydrake.solvers.Binding[Cost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[EvaluatorBase]
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.solvers.Binding[EvaluatorBase], c: pydrake.solvers.EvaluatorBase, v: numpy.ndarray[object[m, 1]]) -> None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.__init__(self: pydrake.solvers.Binding[EvaluatorBase], arg0: object) -> None
- evaluator(self: pydrake.solvers.Binding[EvaluatorBase]) pydrake.solvers.EvaluatorBase
- variables(self: pydrake.solvers.Binding[EvaluatorBase]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[ExponentialConeConstraint]
- __init__(self: pydrake.solvers.Binding[ExponentialConeConstraint], c: pydrake.solvers.ExponentialConeConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[ExponentialConeConstraint]) pydrake.solvers.ExponentialConeConstraint
- variables(self: pydrake.solvers.Binding[ExponentialConeConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[L1NormCost]
- __init__(self: pydrake.solvers.Binding[L1NormCost], c: pydrake.solvers.L1NormCost, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[L1NormCost]) pydrake.solvers.L1NormCost
- variables(self: pydrake.solvers.Binding[L1NormCost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[L2NormCost]
- __init__(self: pydrake.solvers.Binding[L2NormCost], c: pydrake.solvers.L2NormCost, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[L2NormCost]) pydrake.solvers.L2NormCost
- variables(self: pydrake.solvers.Binding[L2NormCost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LinearComplementarityConstraint]
- __init__(self: pydrake.solvers.Binding[LinearComplementarityConstraint], c: pydrake.solvers.LinearComplementarityConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LinearComplementarityConstraint]) pydrake.solvers.LinearComplementarityConstraint
- variables(self: pydrake.solvers.Binding[LinearComplementarityConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LinearConstraint]
- __init__(self: pydrake.solvers.Binding[LinearConstraint], c: pydrake.solvers.LinearConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LinearConstraint]) pydrake.solvers.LinearConstraint
- variables(self: pydrake.solvers.Binding[LinearConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LinearCost]
- __init__(self: pydrake.solvers.Binding[LinearCost], c: pydrake.solvers.LinearCost, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LinearCost]) pydrake.solvers.LinearCost
- variables(self: pydrake.solvers.Binding[LinearCost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LinearEqualityConstraint]
- __init__(self: pydrake.solvers.Binding[LinearEqualityConstraint], c: pydrake.solvers.LinearEqualityConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LinearEqualityConstraint]) pydrake.solvers.LinearEqualityConstraint
- variables(self: pydrake.solvers.Binding[LinearEqualityConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LinearMatrixInequalityConstraint]
- __init__(self: pydrake.solvers.Binding[LinearMatrixInequalityConstraint], c: pydrake.solvers.LinearMatrixInequalityConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LinearMatrixInequalityConstraint]) pydrake.solvers.LinearMatrixInequalityConstraint
- variables(self: pydrake.solvers.Binding[LinearMatrixInequalityConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LInfNormCost]
- __init__(self: pydrake.solvers.Binding[LInfNormCost], c: pydrake.solvers.LInfNormCost, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LInfNormCost]) pydrake.solvers.LInfNormCost
- variables(self: pydrake.solvers.Binding[LInfNormCost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[LorentzConeConstraint]
- __init__(self: pydrake.solvers.Binding[LorentzConeConstraint], c: pydrake.solvers.LorentzConeConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[LorentzConeConstraint]) pydrake.solvers.LorentzConeConstraint
- variables(self: pydrake.solvers.Binding[LorentzConeConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[PerspectiveQuadraticCost]
- __init__(self: pydrake.solvers.Binding[PerspectiveQuadraticCost], c: pydrake.solvers.PerspectiveQuadraticCost, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[PerspectiveQuadraticCost]) pydrake.solvers.PerspectiveQuadraticCost
- variables(self: pydrake.solvers.Binding[PerspectiveQuadraticCost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[PositiveSemidefiniteConstraint]
- __init__(self: pydrake.solvers.Binding[PositiveSemidefiniteConstraint], c: pydrake.solvers.PositiveSemidefiniteConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[PositiveSemidefiniteConstraint]) pydrake.solvers.PositiveSemidefiniteConstraint
- variables(self: pydrake.solvers.Binding[PositiveSemidefiniteConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[QuadraticCost]
- __init__(self: pydrake.solvers.Binding[QuadraticCost], c: pydrake.solvers.QuadraticCost, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[QuadraticCost]) pydrake.solvers.QuadraticCost
- variables(self: pydrake.solvers.Binding[QuadraticCost]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[RotatedLorentzConeConstraint]
- __init__(self: pydrake.solvers.Binding[RotatedLorentzConeConstraint], c: pydrake.solvers.RotatedLorentzConeConstraint, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[RotatedLorentzConeConstraint]) pydrake.solvers.RotatedLorentzConeConstraint
- variables(self: pydrake.solvers.Binding[RotatedLorentzConeConstraint]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.Binding[VisualizationCallback]
- __init__(self: pydrake.solvers.Binding[VisualizationCallback], c: pydrake.solvers.VisualizationCallback, v: numpy.ndarray[object[m, 1]]) None
Concatenates each VectorDecisionVariable object in
v
into a single column vector, binds this column vector of decision variables with the constraintc
.
- evaluator(self: pydrake.solvers.Binding[VisualizationCallback]) pydrake.solvers.VisualizationCallback
- variables(self: pydrake.solvers.Binding[VisualizationCallback]) numpy.ndarray[object[m, 1]]
- class pydrake.solvers.BoundingBoxConstraint
Bases:
pydrake.solvers.LinearConstraint
Implements a constraint of the form \(lb <= x <= ub\)
Note: the base Constraint class (as implemented at the moment) could play this role. But this class enforces that it is ONLY a bounding box constraint, and not something more general. Some solvers use this information to handle bounding box constraints differently than general constraints, so use of this form is encouraged.
- __init__(self: pydrake.solvers.BoundingBoxConstraint, lb: numpy.ndarray[numpy.float64[m, 1]], ub: numpy.ndarray[numpy.float64[m, 1]]) None
- pydrake.solvers.ChooseBestSolver(prog: pydrake.solvers.MathematicalProgram) pydrake.solvers.SolverId
Choose the best solver given the formulation in the optimization program and the availability of the solvers.
- Raises
RuntimeError if there is no available solver for prog. –
- class pydrake.solvers.ClpSolver
Bases:
pydrake.solvers.SolverInterface
A wrapper to call CLP using Drake’s MathematicalProgram.
Note
Currently our ClpSolver has a memory issue when solving a QP. The user should be aware of this risk.
Note
The authors can adjust the problem scaling option by setting “scaling” as mentioned in https://github.com/coin-or/Clp/blob/43129ba1a7fd66ce70fe0761fcd696951917ed2e/src/ClpModel.hpp#L705-L706 For example prog.SetSolverOption(ClpSolver::id(), “scaling”, 0); will do “no scaling”. The default is 1.
- __init__(self: pydrake.solvers.ClpSolver) None
- static id() pydrake.solvers.SolverId
- class pydrake.solvers.ClpSolverDetails
The CLP solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<ClpSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property status
- class pydrake.solvers.CommonSolverOption
Some options can be applied to not one solver, but many solvers (for example, many solvers support printing out the progress in each iteration). CommonSolverOption contain the names of these supported options. The user can use these options as “key” in SolverOption::SetOption().
Members:
kPrintFileName : Many solvers support printing the progress of each iteration to a
file. The user can call SolverOptions::SetOption(kPrintFileName, file_name) where file_name is a string. If the user doesn’t want to print to a file, then use SolverOptions::SetOption(kPrintFileName, “”), where the empty string “” indicates no print.
kPrintToConsole : Many solvers support printing the progress of each iteration to the
console, the user can call SolverOptions::SetOption(kPrintToConsole, 1) to turn on printing to the console, or SolverOptions::SetOption(kPrintToConsole, 0) to turn off printing to the console.
- __init__(self: pydrake.solvers.CommonSolverOption, value: int) None
- kPrintFileName = <CommonSolverOption.kPrintFileName: 0>
- kPrintToConsole = <CommonSolverOption.kPrintToConsole: 1>
- property name
- property value
- class pydrake.solvers.Constraint
Bases:
pydrake.solvers.EvaluatorBase
A constraint is a function + lower and upper bounds.
Solver interfaces must acknowledge that these constraints are mutable. Parameters can change after the constraint is constructed and before the call to Solve().
It should support evaluating the constraint, and adding it to an optimization problem.
- __init__(*args, **kwargs)
- CheckSatisfied(*args, **kwargs)
Overloaded function.
CheckSatisfied(self: pydrake.solvers.Constraint, x: numpy.ndarray[numpy.float64[m, 1]], tol: float = 1e-06) -> bool
Return whether this constraint is satisfied by the given value,
x
.- Parameter
x
: A
num_vars
x 1 vector.- Parameter
tol
: A tolerance for bound checking.
CheckSatisfied(self: pydrake.solvers.Constraint, x: numpy.ndarray[object[m, 1]], tol: float = 1e-06) -> bool
Return whether this constraint is satisfied by the given value,
x
.- Parameter
x
: A
num_vars
x 1 vector.- Parameter
tol
: A tolerance for bound checking.
CheckSatisfied(self: pydrake.solvers.Constraint, x: numpy.ndarray[object[m, 1]]) -> pydrake.symbolic.Formula
Return whether this constraint is satisfied by the given value,
x
.- Parameter
x
: A
num_vars
x 1 vector.- Parameter
tol
: A tolerance for bound checking.
- CheckSatisfiedVectorized(self: pydrake.solvers.Constraint, x: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], tol: float) List[bool]
A “vectorized” version of CheckSatisfied. It evaluates the constraint for every column of
x
.
- lower_bound(self: pydrake.solvers.Constraint) numpy.ndarray[numpy.float64[m, 1]]
- num_constraints(self: pydrake.solvers.Constraint) int
Number of rows in the output constraint.
- upper_bound(self: pydrake.solvers.Constraint) numpy.ndarray[numpy.float64[m, 1]]
- class pydrake.solvers.Cost
Bases:
pydrake.solvers.EvaluatorBase
Provides an abstract base for all costs.
- __init__(*args, **kwargs)
- class pydrake.solvers.CsdpSolver
Bases:
pydrake.solvers.SolverInterface
Wrap CSDP solver such that it can solve a drake::solvers::MathematicalProgram.
Note
CSDP doesn’t accept free variables, while drake::solvers::MathematicalProgram does. In order to convert MathematicalProgram into CSDP format, we provide several approaches to remove free variables. You can set the approach through
{cc} SolverOptions solver_options; solver_options.SetOption(CsdpSolver::id(), "drake::RemoveFreeVariableMethod", static_cast<int>(RemoveFreeVariableMethod::kNullspace)); CsdpSolver solver; auto result = solver.Solve(prog, std::nullopt, solver_options);
For more details, check out RemoveFreeVariableMethod.
- __init__(self: pydrake.solvers.CsdpSolver) None
Default constructor
- static id() pydrake.solvers.SolverId
- class pydrake.solvers.CsdpSolverDetails
The CSDP solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<CsdpSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property dual_objective
The dual objective value.
- property primal_objective
The primal objective value.
- property return_code
Refer to the Return Codes section of CSDP 6.2.0 User’s Guide for explanation on the return code. Some of the common return codes are
0 Problem is solved to optimality. 1 Problem is primal infeasible. 2 Problem is dual infeasible. 3 Problem solved to near optimality. 4 Maximum iterations reached.
- property y_val
CSDP solves a primal problem of the form
max tr(C*X) s.t tr(Aᵢ*X) = aᵢ X ≽ 0
The dual form is
min aᵀy s.t ∑ᵢ yᵢAᵢ - C = Z Z ≽ 0
y, Z are the variables for the dual problem. y_val, Z_val are the solutions to the dual problem.
- property Z_val
- class pydrake.solvers.EvaluatorBase
- __init__(*args, **kwargs)
- Eval(*args, **kwargs)
Overloaded function.
Eval(self: pydrake.solvers.EvaluatorBase, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]
Evaluates the expression.
- Parameter
x
: A
num_vars
x 1 input vector.- Parameter
y
: A
num_outputs
x 1 output vector.
Eval(self: pydrake.solvers.EvaluatorBase, x: numpy.ndarray[object[m, 1]]) -> numpy.ndarray[object[m, 1]]
Evaluates the expression.
- Parameter
x
: A
num_vars
x 1 input vector.- Parameter
y
: A
num_outputs
x 1 output vector.
Eval(self: pydrake.solvers.EvaluatorBase, x: numpy.ndarray[object[m, 1]]) -> numpy.ndarray[object[m, 1]]
Evaluates the expression.
- Parameter
x
: A
num_vars
x 1 input vector.- Parameter
y
: A
num_outputs
x 1 output vector.
- get_description(self: pydrake.solvers.EvaluatorBase) str
Getter for a human-friendly description for the evaluator.
- gradient_sparsity_pattern(self: pydrake.solvers.EvaluatorBase) Optional[List[Tuple[int, int]]]
Returns the vector of (row_index, col_index) that contains all the entries in the gradient of Eval function (∂y/∂x) whose value could be non-zero, namely if ∂yᵢ/∂xⱼ could be non-zero, then the pair (i, j) is in gradient_sparsity_pattern.
- Returns
gradient_sparsity_pattern
: If nullopt, then we regard all entries of the gradient as potentially non-zero.
- Returns
- num_outputs(self: pydrake.solvers.EvaluatorBase) int
Getter for the number of outputs, namely the number of rows in y, as used in Eval(x, y).
- num_vars(self: pydrake.solvers.EvaluatorBase) int
Getter for the number of variables, namely the number of rows in x, as used in Eval(x, y).
- set_description(self: pydrake.solvers.EvaluatorBase, arg0: str) None
Set a human-friendly description for the evaluator.
- SetGradientSparsityPattern(self: pydrake.solvers.EvaluatorBase, gradient_sparsity_pattern: List[Tuple[int, int]]) None
Set the sparsity pattern of the gradient matrix ∂y/∂x (the gradient of y value in Eval, w.r.t x in Eval) . gradient_sparsity_pattern contains all the pairs of (row_index, col_index) for which the corresponding entries could have non-zero value in the gradient matrix ∂y/∂x.
- class pydrake.solvers.ExponentialConeConstraint
Bases:
pydrake.solvers.Constraint
An exponential cone constraint is a special type of convex cone constraint. We constrain A * x + b to be in the exponential cone, where A has 3 rows, and b is in ℝ³, x is the decision variable. A vector z in ℝ³ is in the exponential cone, if {z₀, z₁, z₂ | z₀ ≥ z₁ * exp(z₂ / z₁), z₁ > 0}. Equivalently, this constraint can be refomulated with logarithm function {z₀, z₁, z₂ | z₂ ≤ z₁ * log(z₀ / z₁), z₀ > 0, z₁ > 0}
The Eval function implemented in this class is z₀ - z₁ * exp(z₂ / z₁) >= 0, z₁ > 0 where z = A * x + b. It is not recommended to solve an exponential cone constraint through generic nonlinear optimization. It is possible that the nonlinear solver can accidentally set z₁ = 0, where the constraint is not well defined. Instead, the user should consider to solve the program through conic solvers that can exploit exponential cone, such as MOSEK™ and SCS.
- __init__(self: pydrake.solvers.ExponentialConeConstraint, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[3, 1]]) None
Constructor for exponential cone. Constrains A * x + b to be in the exponential cone.
- Precondition:
A has 3 rows.
- A(self: pydrake.solvers.ExponentialConeConstraint) numpy.ndarray[numpy.float64[m, n]]
Getter for matrix A.
- b(self: pydrake.solvers.ExponentialConeConstraint) numpy.ndarray[numpy.float64[3, 1]]
Getter for vector b.
- pydrake.solvers.GenerateSDPA(prog: pydrake.solvers.MathematicalProgram, file_name: str, method: pydrake.solvers.RemoveFreeVariableMethod = <RemoveFreeVariableMethod.kNullspace: 2>) bool
SDPA is a format to record an SDP problem
max tr(C*X) s.t tr(Aᵢ*X) = gᵢ X ≽ 0
or the dual of the problem
min gᵀy s.t ∑ᵢ yᵢAᵢ - C ≽ 0
where X is a symmetric block diagonal matrix. The format is described in http://plato.asu.edu/ftp/sdpa_format.txt. Many solvers, such as CSDP, DSDP, SDPA, sedumi and SDPT3, accept an SDPA format file as the input. This function reads a MathematicalProgram that can be formulated as above, and write an SDPA file.
- Parameter
prog
: a program that contains an optimization program.
- Parameter
file_name
: The name of the file, note that the extension will be added automatically.
- Parameter
method
: If
prog
contains free variables (i.e., variables without bounds), then we need to remove these free variables to write the program in the SDPA format. Please refer to RemoveFreeVariableMethod for details on how to remove the free variables. $*Default:* is RemoveFreeVariableMethod::kNullspace.- Returns
is_success
: . Returns true if we can generate the SDPA file. The failure could be 1.
prog
cannot be captured by the formulation above. 2.prog
cannot create a file with the given name, etc.
- Parameter
- pydrake.solvers.GetAvailableSolvers(prog_type: pydrake.solvers.ProgramType) List[pydrake.solvers.SolverId]
Returns the list of available and enabled solvers that definitely accept all programs of the given program type. The order of the returned SolverIds reflects an approximate order of preference, from most preferred (front) to least preferred (back). Because we are analyzing only based on the program type rather than a specific program, it’s possible that solvers later in the list would perform better in certain situations. To obtain the truly best solver, using ChooseBestSolver() instead.
Note
If a solver only accepts a subset of the program type, then that solver is not included in the returned results. For example EqualityConstrainedQPSolver doesn’t accept programs with inequality linear constraints, so it doesn’t show up in the return of GetAvailableSolvers(ProgramType::kQP).
- pydrake.solvers.GetProgramType(arg0: pydrake.solvers.MathematicalProgram) pydrake.solvers.ProgramType
Returns the type of the optimization program (LP, QP, etc), based on the properties of its cost/constraints/variables. Each mathematical program should be characterized by a unique type. If a program can be characterized as either type A or type B (for example, a program with linear constraint and linear costs can be characterized as either an LP or an SDP), then we choose the type corresponding to a smaller set of programs (LP in this case).
- class pydrake.solvers.GurobiSolver
Bases:
pydrake.solvers.SolverInterface
An implementation of SolverInterface for the commercially-licensed Gurobi solver (https://www.gurobi.com/).
The default build of Drake is not configured to use Gurobi, so therefore SolverInterface::available() will return false. You must compile Drake from source in order to link against Gurobi. For details, refer to the documentation at https://drake.mit.edu/bazel.html#proprietary-solvers.
The GRB_LICENSE_FILE environment variable controls whether or not SolverInterface::enabled() returns true. If it is set to any non-empty value, then the solver is enabled; otherwise, the solver is not enabled.
Gurobi solver supports options/parameters listed in https://www.gurobi.com/documentation/9.1/refman/parameters.html. On top of these options, we provide the following additional options 1. “GRBwrite”, set to a file name so that Gurobi solver will write the optimization model to this file, check https://www.gurobi.com/documentation/9.1/refman/py_model_write.html for more details, such as all supported file extensions. Set this option to “” if you don’t want to write to file. Default is not to write to a file. 2. “GRBcomputeIIS”, set to 1 to compute an Irreducible Inconsistent Subsystem (IIS) when the problem is infeasible. Refer to https://www.gurobi.com/documentation/9.1/refman/py_model_computeiis.html for more details. Often this method is called together with setting GRBwrite to “FILENAME.ilp” to write IIS to a file with extension “ilp”. Default is not to compute IIS.
- __init__(self: pydrake.solvers.GurobiSolver) None
- static AcquireLicense() pydrake.solvers.GurobiSolver.License
This acquires a Gurobi license environment shared among all GurobiSolver instances; the environment will stay valid as long as at least one shared_ptr returned by this function is alive. Call this ONLY if you must use different MathematicalProgram instances at different instances in time, and repeatedly acquiring the license is costly (e.g., requires contacting a license server).
- Returns
A shared pointer to a license environment that will stay valid as long as any shared_ptr returned by this function is alive. If Gurobi not available in your build, this will return a null (empty) shared_ptr.
- Raises
RuntimeError if Gurobi is available but a license cannot be –
obtained. –
- AddMipNodeCallback(self: pydrake.solvers.GurobiSolver, callback: Callable[[pydrake.solvers.MathematicalProgram, pydrake.solvers.GurobiSolver.SolveStatusInfo, numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[object[m, 1]]], None]) None
Registers a callback to be called at intermediate solutions during the solve.
- Parameter
callback
: User callback function.
- Parameter
user_data
: Arbitrary data that will be passed to the user callback function.
- Parameter
- AddMipSolCallback(self: pydrake.solvers.GurobiSolver, callback: Callable[[pydrake.solvers.MathematicalProgram, pydrake.solvers.GurobiSolver.SolveStatusInfo], None]) None
Registers a callback to be called at feasible solutions during the solve.
- Parameter
callback
: User callback function.
- Parameter
usrdata
: Arbitrary data that will be passed to the user callback function.
- Parameter
- static id() pydrake.solvers.SolverId
- class License
Context-manageable license from
GurobiSolver.AcquireLicense()
.- __init__(*args, **kwargs)
- is_valid(self: pydrake.solvers.GurobiSolver.License) bool
Indicates that this has a valid license that has not been released.
- class SolveStatusInfo
Contains info returned to a user function that handles a Node or Solution callback.
See also
MipNodeCallbackFunction
See also
MipSolCallbackFunction
- __init__(*args, **kwargs)
- property best_bound
Best known objective lower bound.
- property best_objective
Objective of best solution yet.
- property current_objective
Objective of current solution.
- property explored_node_count
Number of nodes explored so far.
- property feasible_solutions_count
Number of feasible sols found so far.
- property reported_runtime
Runtime as of this callback.
- class pydrake.solvers.GurobiSolverDetails
The Gurobi solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<GurobiSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property error_code
The error message returned from Gurobi call. Please refer to https://www.gurobi.com/documentation/9.5/refman/error_codes.html
- property objective_bound
The best known bound on the optimal objective. This is used in mixed integer optimization. Please refer to https://www.gurobi.com/documentation/9.5/refman/objbound.html
- property optimization_status
The status code when the optimize call has returned. Please refer to https://www.gurobi.com/documentation/9.5/refman/optimization_status_codes.html
- property optimizer_time
The gurobi optimization time. Please refer to https://www.gurobi.com/documentation/9.5/refman/runtime.html
- class pydrake.solvers.IntervalBinning
For a continuous variable whose range is cut into small intervals, we will use binary variables to represent which interval the continuous variable is in. We support two representations, either using logarithmic number of binary variables, or linear number of binary variables. For more details,
See also
AddLogarithmicSos2Constraint and AddSos2Constraint
Members:
kLogarithmic
kLinear
- __init__(self: pydrake.solvers.IntervalBinning, value: int) None
- kLinear = <IntervalBinning.kLinear: 1>
- kLogarithmic = <IntervalBinning.kLogarithmic: 0>
- property name
- property value
- class pydrake.solvers.IpoptSolver
Bases:
pydrake.solvers.SolverInterface
- __init__(self: pydrake.solvers.IpoptSolver) None
- static id() pydrake.solvers.SolverId
- class pydrake.solvers.IpoptSolverDetails
The Ipopt solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<IpoptSolver>() to obtain the details.
- __init__(*args, **kwargs)
- ConvertStatusToString(self: pydrake.solvers.IpoptSolverDetails) str
Convert status field to string. This function is useful if you want to interpret the meaning of status.
- property g
The final value for the constraint function.
- property lambda_val
The final value for the constraint multiplier.
- property status
The final status of the solver. Please refer to section 6 in Introduction to Ipopt: A tutorial for downloading, installing, and using Ipopt. You could also find the meaning of the status as Ipopt::SolverReturn defined in IpAlgTypes.hpp
- property z_L
The final value for the lower bound multiplier.
- property z_U
The final value for the upper bound multiplier.
- class pydrake.solvers.L1NormCost
Bases:
pydrake.solvers.Cost
Implements a cost of the form ‖Ax + b‖₁. Note that this cost is non-differentiable when any element of Ax + b equals zero.
- __init__(self: pydrake.solvers.L1NormCost, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]]) None
Construct a cost of the form ‖Ax + b‖₁.
- Parameter
A
: Linear term.
- Parameter
b
: Constant term.
- Parameter
- A(self: pydrake.solvers.L1NormCost) numpy.ndarray[numpy.float64[m, n]]
- b(self: pydrake.solvers.L1NormCost) numpy.ndarray[numpy.float64[m, 1]]
- UpdateCoefficients(self: pydrake.solvers.L1NormCost, new_A: numpy.ndarray[numpy.float64[m, n]], new_b: numpy.ndarray[numpy.float64[m, 1]] = 0) None
Updates the coefficients of the cost. Note that the number of variables (columns of A) cannot change.
- Parameter
new_A
: New linear term.
- Parameter
new_b
: New constant term.
- Parameter
- class pydrake.solvers.L2NormCost
Bases:
pydrake.solvers.Cost
Implements a cost of the form ‖Ax + b‖₂.
- __init__(self: pydrake.solvers.L2NormCost, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]]) None
Construct a cost of the form ‖Ax + b‖₂.
- Parameter
A
: Linear term.
- Parameter
b
: Constant term.
- Parameter
- A(self: pydrake.solvers.L2NormCost) numpy.ndarray[numpy.float64[m, n]]
- b(self: pydrake.solvers.L2NormCost) numpy.ndarray[numpy.float64[m, 1]]
- UpdateCoefficients(self: pydrake.solvers.L2NormCost, new_A: numpy.ndarray[numpy.float64[m, n]], new_b: numpy.ndarray[numpy.float64[m, 1]] = 0) None
Updates the coefficients of the cost. Note that the number of variables (columns of A) cannot change.
- Parameter
new_A
: New linear term.
- Parameter
new_b
: New constant term.
- Parameter
- class pydrake.solvers.LinearComplementarityConstraint
Bases:
pydrake.solvers.Constraint
Implements a constraint of the form:
Mx + q >= 0 x >= 0 x'(Mx + q) == 0
An implied slack variable complements any 0 component of x. To get the slack values at a given solution x, use Eval(x).
- __init__(*args, **kwargs)
- class pydrake.solvers.LinearConstraint
Bases:
pydrake.solvers.Constraint
Implements a constraint of the form \(lb <= Ax <= ub\)
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.solvers.LinearConstraint, A: numpy.ndarray[numpy.float64[m, n]], lb: numpy.ndarray[numpy.float64[m, 1]], ub: numpy.ndarray[numpy.float64[m, 1]]) -> None
Construct the linear constraint lb <= A*x <= ub
__init__(self: pydrake.solvers.LinearConstraint, A: scipy.sparse.csc_matrix[numpy.float64], lb: numpy.ndarray[numpy.float64[m, 1]], ub: numpy.ndarray[numpy.float64[m, 1]]) -> None
Overloads constructor with a sparse A matrix.
- get_sparse_A(self: pydrake.solvers.LinearConstraint) scipy.sparse.csc_matrix[numpy.float64]
- GetDenseA(self: pydrake.solvers.LinearConstraint) numpy.ndarray[numpy.float64[m, n]]
Get the matrix A as a dense matrix.
Note
this might involve memory allocation to convert a sparse matrix to a dense one, for better performance you should call get_sparse_A() which returns a sparse matrix.
- RemoveTinyCoefficient(self: pydrake.solvers.LinearConstraint, tol: float) None
Sets A(i, j) to zero if abs(A(i, j)) <= tol. Oftentimes the coefficient A is computed numerically with round-off errors. Such small round-off errors can cause numerical issues for certain optimization solvers. Hence it is recommended to remove the tiny coefficients to achieve numerical robustness.
- Parameter
tol
: The entries in A with absolute value <= tol will be set to 0.
Note
tol>= 0.
- Parameter
- set_bounds(self: pydrake.solvers.LinearConstraint, new_lb: numpy.ndarray[numpy.float64[m, 1]], new_ub: numpy.ndarray[numpy.float64[m, 1]]) None
Set the upper and lower bounds of the constraint.
- Parameter
new_lb
: . A
num_constraints
x 1 vector.- Parameter
new_ub
: . A
num_constraints
x 1 vector.
Note
If the users want to expose this method in a sub-class, do using Constraint::set_bounds, as in LinearConstraint.
- Parameter
- UpdateCoefficients(*args, **kwargs)
Overloaded function.
UpdateCoefficients(self: pydrake.solvers.LinearConstraint, new_A: numpy.ndarray[numpy.float64[m, n]], new_lb: numpy.ndarray[numpy.float64[m, 1]], new_ub: numpy.ndarray[numpy.float64[m, 1]]) -> None
Updates the linear term, upper and lower bounds in the linear constraint. The updated constraint is: new_lb <= new_A * x <= new_ub Note that the size of constraints (number of rows) can change, but the number of variables (number of cols) cannot.
- Parameter
new_A
: new linear term
- Parameter
new_lb
: new lower bound
- Parameter
new_up
: new upper bound
UpdateCoefficients(self: pydrake.solvers.LinearConstraint, new_A: scipy.sparse.csc_matrix[numpy.float64], new_lb: numpy.ndarray[numpy.float64[m, 1]], new_ub: numpy.ndarray[numpy.float64[m, 1]]) -> None
Overloads UpdateCoefficients but with a sparse A matrix.
- UpdateLowerBound(self: pydrake.solvers.LinearConstraint, new_lb: numpy.ndarray[numpy.float64[m, 1]]) None
Updates the lower bound.
Note
if the users want to expose this method in a sub-class, do using Constraint::UpdateLowerBound, as in LinearConstraint.
- UpdateUpperBound(self: pydrake.solvers.LinearConstraint, new_ub: numpy.ndarray[numpy.float64[m, 1]]) None
Updates the upper bound.
Note
if the users want to expose this method in a sub-class, do using Constraint::UpdateUpperBound, as in LinearConstraint.
- class pydrake.solvers.LinearCost
Bases:
pydrake.solvers.Cost
Implements a cost of the form
\[a'x + b\].
- __init__(self: pydrake.solvers.LinearCost, a: numpy.ndarray[numpy.float64[m, 1]], b: float) None
Construct a linear cost of the form
\[a'x + b\].
- Parameter
a
: Linear term.
- Parameter
b
: (optional) Constant term.
- Parameter
- a(self: pydrake.solvers.LinearCost) numpy.ndarray[numpy.float64[m, 1]]
- b(self: pydrake.solvers.LinearCost) float
- UpdateCoefficients(self: pydrake.solvers.LinearCost, new_a: numpy.ndarray[numpy.float64[m, 1]], new_b: float = 0) None
Updates the coefficients of the cost. Note that the number of variables (size of a) cannot change.
- Parameter
new_a
: New linear term.
- Parameter
new_b
: (optional) New constant term.
- Parameter
- class pydrake.solvers.LinearEqualityConstraint
Bases:
pydrake.solvers.LinearConstraint
Implements a constraint of the form \(Ax = b\)
- __init__(*args, **kwargs)
Overloaded function.
__init__(self: pydrake.solvers.LinearEqualityConstraint, Aeq: numpy.ndarray[numpy.float64[m, n]], beq: numpy.ndarray[numpy.float64[m, 1]]) -> None
Constructs the linear equality constraint Aeq * x = beq
__init__(self: pydrake.solvers.LinearEqualityConstraint, Aeq: scipy.sparse.csc_matrix[numpy.float64], beq: numpy.ndarray[numpy.float64[m, 1]]) -> None
Overloads the constructor with a sparse matrix Aeq.
__init__(self: pydrake.solvers.LinearEqualityConstraint, a: numpy.ndarray[numpy.float64[1, n]], beq: float) -> None
Constructs the linear equality constraint a.dot(x) = beq
- UpdateCoefficients(self: pydrake.solvers.LinearEqualityConstraint, Aeq: numpy.ndarray[numpy.float64[m, n]], beq: numpy.ndarray[numpy.float64[m, 1]]) None
Overloads UpdateCoefficients but with a sparse A matrix.
- class pydrake.solvers.LinearMatrixInequalityConstraint
Bases:
pydrake.solvers.Constraint
Impose the matrix inequality constraint on variable x
\[F_0 + x_1 F_1 + ... + x_n F_n \text{ is p.s.d}\]where p.s.d stands for positive semidefinite. \(F_0, F_1, ..., F_n\) are all given symmetric matrices of the same size.
- __init__(self: pydrake.solvers.LinearMatrixInequalityConstraint, F: List[numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]], symmetry_tolerance: float = 1e-10) None
- Parameter
F
: Each symmetric matrix F[i] should be of the same size.
- Parameter
symmetry_tolerance
: The precision to determine if the input matrices Fi are all symmetric.
See also
math::IsSymmetric().
- Parameter
- F(self: pydrake.solvers.LinearMatrixInequalityConstraint) List[numpy.ndarray[numpy.float64[m, n]]]
- matrix_rows(self: pydrake.solvers.LinearMatrixInequalityConstraint) int
Gets the number of rows in the matrix inequality constraint. Namely Fi are all matrix_rows() x matrix_rows() matrices.
- class pydrake.solvers.LInfNormCost
Bases:
pydrake.solvers.Cost
Implements a cost of the form ‖Ax + b‖∞. Note that this cost is non-differentiable when any two or more elements of Ax + b are equal.
- __init__(self: pydrake.solvers.LInfNormCost, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]]) None
Construct a cost of the form ‖Ax + b‖∞.
- Parameter
A
: Linear term.
- Parameter
b
: Constant term.
- Parameter
- A(self: pydrake.solvers.LInfNormCost) numpy.ndarray[numpy.float64[m, n]]
- b(self: pydrake.solvers.LInfNormCost) numpy.ndarray[numpy.float64[m, 1]]
- UpdateCoefficients(self: pydrake.solvers.LInfNormCost, new_A: numpy.ndarray[numpy.float64[m, n]], new_b: numpy.ndarray[numpy.float64[m, 1]] = 0) None
Updates the coefficients of the cost. Note that the number of variables (columns of A) cannot change.
- Parameter
new_A
: New linear term.
- Parameter
new_b
: New constant term.
- Parameter
- class pydrake.solvers.LorentzConeConstraint
Bases:
pydrake.solvers.Constraint
Constraining the linear expression \(z=Ax+b\) lies within the Lorentz cone. A vector z ∈ ℝ ⁿ lies within Lorentz cone if
\[z_0 \ge \sqrt{z_1^2+...+z_{n-1}^2}\]where A ∈ ℝ ⁿˣᵐ, b ∈ ℝ ⁿ are given matrices. Ideally this constraint should be handled by a second-order cone solver. In case the user wants to enforce this constraint through general nonlinear optimization, we provide three different formulations on the Lorentz cone constraint 1. [kConvex] g(z) = z₀ - sqrt(z₁² + … + zₙ₋₁²) ≥ 0 This formulation is not differentiable at z₁=…=zₙ₋₁=0 2. [kConvexSmooth] g(z) = z₀ - sqrt(z₁² + … + zₙ₋₁²) ≥ 0 but the gradient of g(z) is approximated as ∂g(z)/∂z = [1, -z₁/sqrt(z₁² + … zₙ₋₁² + ε), …, -zₙ₋₁/sqrt(z₁²+…+zₙ₋₁²+ε)] where ε is a small positive number. 3. [kNonconvex] z₀²-(z₁²+…+zₙ₋₁²) ≥ 0 z₀ ≥ 0 This constraint is differentiable everywhere, but z₀²-(z₁²+…+zₙ₋₁²) ≥ 0 is non-convex. For more information and visualization, please refer to https://www.epfl.ch/labs/disopt/wp-content/uploads/2018/09/7.pdf and https://docs.mosek.com/modeling-cookbook/cqo.html (Fig 3.1)
- __init__(self: pydrake.solvers.LorentzConeConstraint, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]], eval_type: pydrake.solvers.LorentzConeConstraint.EvalType = <EvalType.kConvexSmooth: 1>) None
- A(self: pydrake.solvers.LorentzConeConstraint) scipy.sparse.csc_matrix[numpy.float64]
Getter for A.
- b(self: pydrake.solvers.LorentzConeConstraint) numpy.ndarray[numpy.float64[m, 1]]
Getter for b.
- eval_type(self: pydrake.solvers.LorentzConeConstraint) pydrake.solvers.LorentzConeConstraint.EvalType
Getter for eval type.
- class EvalType
We provide three possible Eval functions to represent the Lorentz cone constraint z₀ ≥ sqrt(z₁² + … + zₙ₋₁²). For more explanation on the three formulations, refer to LorentzConeConstraint documentation.
Members:
kConvex : The constraint is g(z) = z₀ - sqrt(z₁² + … + zₙ₋₁²) ≥ 0. Note this
formulation is non-differentiable at z₁= …= zₙ₋₁=0
kConvexSmooth : Same as kConvex, but with approximated gradient that exists
everywhere..
kNonconvex : Nonconvex constraint z₀²-(z₁²+…+zₙ₋₁²) ≥ 0 and z₀ ≥ 0. Note this
formulation is differentiable, but at z₁= …= zₙ₋₁=0 the gradient is also 0, so a gradient-based nonlinear solver can get stuck.
- __init__(self: pydrake.solvers.LorentzConeConstraint.EvalType, value: int) None
- kConvex = <EvalType.kConvex: 0>
- kConvexSmooth = <EvalType.kConvexSmooth: 1>
- kNonconvex = <EvalType.kNonconvex: 2>
- property name
- property value
- UpdateCoefficients(self: pydrake.solvers.LorentzConeConstraint, new_A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], new_b: numpy.ndarray[numpy.float64[m, 1]]) None
Updates the coefficients, the updated constraint is z=new_A * x + new_b in the Lorentz cone.
- Raises
RuntimeError if the new_A.cols() != A.cols(), namely the variable –
size should not change. –
- Precondition:
new_A
has to have at least 2 rows and new_A.rows() == new_b.rows().
- pydrake.solvers.MakeFirstAvailableSolver(solver_ids: List[pydrake.solvers.SolverId]) pydrake.solvers.SolverInterface
Makes the first available and enabled solver. If no solvers are available, throws a RuntimeError.
- pydrake.solvers.MakeSolver(id: pydrake.solvers.SolverId) pydrake.solvers.SolverInterface
Given the solver ID, create the solver with the matching ID.
- Raises
RuntimeError if there is no matching solver. –
- class pydrake.solvers.MathematicalProgram
MathematicalProgram stores the decision variables, the constraints and costs of an optimization problem. The user can solve the problem by calling solvers::Solve() function, and obtain the results of the optimization.
- __init__(self: pydrake.solvers.MathematicalProgram) None
- Add2NormSquaredCost(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) pydrake.solvers.Binding[QuadraticCost]
Adds a quadratic cost of the form |Ax-b|²=(Ax-b)ᵀ(Ax-b)
- AddBoundingBoxConstraint(*args, **kwargs)
Overloaded function.
AddBoundingBoxConstraint(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], arg1: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], arg2: numpy.ndarray[object[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[BoundingBoxConstraint]
Adds bounding box constraints referencing potentially a subset of the decision variables.
- Parameter
lb
: The lower bound.
- Parameter
ub
: The upper bound.
- Parameter
vars
: Will imposes constraint lb(i, j) <= vars(i, j) <= ub(i, j).
- Returns
The newly constructed BoundingBoxConstraint.
AddBoundingBoxConstraint(self: pydrake.solvers.MathematicalProgram, arg0: float, arg1: float, arg2: pydrake.symbolic.Variable) -> pydrake.solvers.Binding[BoundingBoxConstraint]
Adds bounds for a single variable.
- Parameter
lb
: Lower bound.
- Parameter
ub
: Upper bound.
- Parameter
var
: The decision variable.
AddBoundingBoxConstraint(self: pydrake.solvers.MathematicalProgram, arg0: float, arg1: float, arg2: numpy.ndarray[object[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[BoundingBoxConstraint]
Adds the same scalar lower and upper bound to every variable in
vars
.- Template parameter
Derived
: An Eigen::Matrix with Variable as the scalar type. The matrix has unknown number of columns at compile time, or has more than one column.
- Parameter
lb
: Lower bound.
- Parameter
ub
: Upper bound.
- Parameter
vars
: The decision variables.
- AddConstraint(*args, **kwargs)
Overloaded function.
AddConstraint(self: pydrake.solvers.MathematicalProgram, func: function, lb: numpy.ndarray[numpy.float64[m, 1]], ub: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]], description: str = ‘’) -> pydrake.solvers.Binding[Constraint]
Adds a constraint using a Python function.
AddConstraint(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.symbolic.Expression, arg1: float, arg2: float) -> pydrake.solvers.Binding[Constraint]
Adds one row of constraint lb <= e <= ub where
e
is a symbolic expression.- Raises
RuntimeError if 1. lb <= e <= ub is a trivial constraint such –
as 1 <= 2 <= 3. 2. lb <= e <= ub is unsatisfiable such as 1 <= –
-5 <= 3 –
- Parameter
e
: A symbolic expression of the decision variables.
- Parameter
lb
: A scalar, the lower bound.
- Parameter
ub
: A scalar, the upper bound.
The resulting constraint may be a BoundingBoxConstraint, LinearConstraint, LinearEqualityConstraint, or ExpressionConstraint, depending on the arguments. Constraints of the form x == 1 (which could be created as a BoundingBoxConstraint or LinearEqualityConstraint) will be constructed as a LinearEqualityConstraint.
AddConstraint(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.symbolic.Formula) -> pydrake.solvers.Binding[Constraint]
Add a constraint represented by a symbolic formula to the program. The input formula
f
can be of the following forms:e1 <= e2
e1 >= e2
e1 == e2
A conjunction of relational formulas where each conjunct is a relational formula matched by 1, 2, or 3.
Note that first two cases might return an object of Binding<BoundingBoxConstraint>, Binding<LinearConstraint>, or Binding<ExpressionConstraint>, depending on
f
. Also the third case might return an object of Binding<LinearEqualityConstraint> or Binding<ExpressionConstraint>.It throws an exception if 1.
f
is not matched with one of the above patterns. Especially, strict inequalities (<, >) are not allowed. 2.f
is either a trivial constraint such as “1 <= 2” or an unsatisfiable constraint such as “2 <= 1”. 3. It is not possible to find numerical bounds ofe1
ande2
wheref
= e1 ≃ e2. We allowe1
ande2
to be infinite but only if there are no other terms. For example,x <= ∞
is allowed. However,x - ∞ <= 0
is not allowed becausex ↦ ∞
introducesnan
in the evaluation.AddConstraint(self: pydrake.solvers.MathematicalProgram, constraint: pydrake.solvers.Constraint, vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[Constraint]
Adds a generic constraint to the program. This should only be used if a more specific type of constraint is not available, as it may require the use of a significantly more expensive solver.
AddConstraint(self: pydrake.solvers.MathematicalProgram, formulas: numpy.ndarray[object[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[Constraint]
Adds a constraint represented by an Eigen::Matrix<symbolic::Formula> or Eigen::Array<symbolic::Formula> to the program. A common use-case of this function is to add a constraint with the element-wise comparison between two Eigen matrices, using
A.array() <= B.array()
. See the following example.MathematicalProgram prog; Eigen::Matrix<double, 2, 2> A = ...; Eigen::Vector2d b = ...; auto x = prog.NewContinuousVariables(2, "x"); prog.AddConstraint((A * x).array() <= b.array());
A formula in
formulas
can be of the following forms:e1 <= e2
e1 >= e2
e1 == e2
It throws an exception if AddConstraint(const symbolic::Formula& f) throws an exception for f ∈
formulas
.@overload Binding<Constraint> AddConstraint(const symbolic::Formula& f)
- Template parameter
Derived
: Eigen::Matrix or Eigen::Array with Formula as the Scalar.
- AddCost(*args, **kwargs)
Overloaded function.
AddCost(self: pydrake.solvers.MathematicalProgram, func: function, vars: numpy.ndarray[object[m, 1]], description: str = ‘’) -> pydrake.solvers.Binding[Cost]
Adds a cost function.
AddCost(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.symbolic.Expression) -> pydrake.solvers.Binding[Cost]
Adds a cost expression.
AddCost(self: pydrake.solvers.MathematicalProgram, obj: pydrake.solvers.Cost, vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[Cost]
Adds a cost type to the optimization program.
- Parameter
obj
: The added objective.
- Parameter
vars
: The decision variables on which the cost depend.
- AddDecisionVariables(self: pydrake.solvers.MathematicalProgram, decision_variables: numpy.ndarray[object[m, n], flags.f_contiguous]) None
Appends new variables to the end of the existing variables.
- Parameter
decision_variables
: The newly added decision_variables.
- Precondition:
decision_variables
should not intersect with the existing variables or indeterminates in the optimization program.- Precondition:
Each entry in
decision_variables
should not be a dummy variable.
- Raises
RuntimeError if the preconditions are not satisfied. –
- Parameter
- AddEqualityConstraintBetweenPolynomials(self: pydrake.solvers.MathematicalProgram, p1: pydrake.symbolic.Polynomial, p2: pydrake.symbolic.Polynomial) List[pydrake.solvers.Binding[LinearEqualityConstraint]]
Constraining that two polynomials are the same (i.e., they have the same coefficients for each monomial). This function is often used in sum-of-squares optimization. We will impose the linear equality constraint that the coefficient of a monomial in
p1
is the same as the coefficient of the same monomial inp2
.- Parameter
p1
: Note that p1’s indeterminates should have been registered as indeterminates in this MathematicalProgram object, and p1’s coefficients are affine functions of decision variables in this MathematicalProgram object.
- Parameter
p2
: Note that p2’s indeterminates should have been registered as indeterminates in this MathematicalProgram object, and p2’s coefficients are affine functions of decision variables in this MathematicalProgram object.
Note
It calls
Reparse
to enforcep1
andp2
to have this MathematicalProgram’s indeterminates.- Parameter
- AddExponentialConeConstraint(*args, **kwargs)
Overloaded function.
AddExponentialConeConstraint(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[3, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[3, 1]], vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[ExponentialConeConstraint]
Adds an exponential cone constraint, that z = A * vars + b should be in the exponential cone. Namely {z₀, z₁, z₂ | z₀ ≥ z₁ * exp(z₂ / z₁), z₁ > 0}.
- Parameter
A
: The A matrix in the documentation above. A must have 3 rows.
- Parameter
b
: The b vector in the documentation above.
- Parameter
vars
: The variables bound with this constraint.
AddExponentialConeConstraint(self: pydrake.solvers.MathematicalProgram, z: numpy.ndarray[object[3, 1]]) -> pydrake.solvers.Binding[ExponentialConeConstraint]
Add the constraint that z is in the exponential cone.
- Parameter
z
: The expression in the exponential cone.
- Precondition:
each entry in
z
is a linear expression of the decision variables.
- AddIndeterminates(self: pydrake.solvers.MathematicalProgram, new_indeterminates: numpy.ndarray[object[m, n], flags.f_contiguous]) None
Adds indeterminates. This method appends some indeterminates to the end of the program’s old indeterminates.
- Parameter
new_indeterminates
: The indeterminates to be appended to the program’s old indeterminates.
- Precondition:
new_indeterminates
should not intersect with the program’s old indeterminates or decision variables.- Precondition:
Each entry in new_indeterminates should not be dummy.
- Precondition:
Each entry in new_indeterminates should be of CONTINUOUS type.
- Parameter
- AddL2NormCost(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) pydrake.solvers.Binding[L2NormCost]
Adds an L2 norm cost |Ax+b|₂ (notice this cost is not quadratic since we don’t take the square of the L2 norm).
Note
Currently only the SnoptSolver and IpoptSolver support kL2NormCost.
- AddL2NormCostUsingConicConstraint(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) Tuple[pydrake.symbolic.Variable, pydrake.solvers.Binding[LinearCost], pydrake.solvers.Binding[LorentzConeConstraint]]
Adds an L2 norm cost min |Ax+b|₂ as a linear cost min s on the slack variable s, together with a Lorentz cone constraint s ≥ |Ax+b|₂ Many conic optimization solvers (Gurobi, MOSEK™, SCS, etc) natively prefers this form of linear cost + conic constraints. So if you are going to use one of these conic solvers, then add the L2 norm cost using this function instead of AddL2NormCost().
- Returns
(s, linear_cost, lorentz_cone_constraint).
s
is the slack variable (with variable name string as “slack”),linear_cost
is the cost ons
, andlorentz_cone_constraint
is the constraint s≥|Ax+b|₂
- AddLinearComplementarityConstraint(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], arg1: numpy.ndarray[numpy.float64[m, 1]], arg2: numpy.ndarray[object[m, 1]]) pydrake.solvers.Binding[LinearComplementarityConstraint]
Adds a linear complementarity constraints referencing a subset of the decision variables.
- AddLinearConstraint(*args, **kwargs)
Overloaded function.
AddLinearConstraint(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], lb: numpy.ndarray[numpy.float64[m, 1]], ub: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[LinearConstraint]
Adds linear constraints referencing potentially a subset of the decision variables (defined in the vars parameter).
AddLinearConstraint(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression, lb: float, ub: float) -> pydrake.solvers.Binding[LinearConstraint]
Adds one row of linear constraint lb <= e <= ub where
e
is a symbolic expression.- Raises
RuntimeError if 1. e is a non-linear expression. 2. ``lb <= e –
<= ub`` is a trivial constraint such as 1 <= 2 <= 3. 3. ``lb <= e –
<= ub`` is unsatisfiable such as 1 <= -5 <= 3 –
- Parameter
e
: A linear symbolic expression in the form of
c0 + c1 * v1 + ... + cn * vn
wherec_i
is a constant and @v_i is a variable.- Parameter
lb
: A scalar, the lower bound.
- Parameter
ub
: A scalar, the upper bound.
AddLinearConstraint(self: pydrake.solvers.MathematicalProgram, v: numpy.ndarray[object[m, n], flags.f_contiguous], lb: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], ub: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[LinearConstraint]
Adds linear constraints represented by symbolic expressions to the program. It throws if @v includes a non-linear expression or
lb <= v <= ub
includes trivial/unsatisfiable constraints.AddLinearConstraint(self: pydrake.solvers.MathematicalProgram, f: pydrake.symbolic.Formula) -> pydrake.solvers.Binding[LinearConstraint]
Add a linear constraint represented by a symbolic formula to the program. The input formula
f
can be of the following forms:e1 <= e2
e1 >= e2
e1 == e2
A conjunction of relational formulas where each conjunct is a relational formula matched by 1, 2, or 3.
Note that first two cases might return an object of Binding<BoundingBoxConstraint> depending on
f
. Also the third case returns an object of Binding<LinearEqualityConstraint>.It throws an exception if 1.
f
is not matched with one of the above patterns. Especially, strict inequalities (<, >) are not allowed. 2.f
includes a non-linear expression. 3.f
is either a trivial constraint such as “1 <= 2” or an unsatisfiable constraint such as “2 <= 1”. 4. It is not possible to find numerical bounds ofe1
ande2
wheref
= e1 ≃ e2. We allowe1
ande2
to be infinite but only if there are no other terms. For example,x <= ∞
is allowed. However,x - ∞ <= 0
is not allowed becausex ↦ ∞
introducesnan
in the evaluation.AddLinearConstraint(self: pydrake.solvers.MathematicalProgram, formulas: numpy.ndarray[object[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[LinearConstraint]
Add a linear constraint represented by an Eigen::Array<symbolic::Formula> to the program. A common use-case of this function is to add a linear constraint with the element-wise comparison between two Eigen matrices, using
A.array() <= B.array()
. See the following example.MathematicalProgram prog; Eigen::Matrix<double, 2, 2> A; auto x = prog.NewContinuousVariables(2, "x"); Eigen::Vector2d b; ... // set up A and b prog.AddLinearConstraint((A * x).array() <= b.array());
A formula in
formulas
can be of the following forms:e1 <= e2 2. e1 >= e2 3. e1 == e2
It throws an exception if AddLinearConstraint(const symbolic::Formula& f) throws an exception for f ∈
formulas
.- Template parameter
Derived
: An Eigen Array type of Formula.
- AddLinearCost(*args, **kwargs)
Overloaded function.
AddLinearCost(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression) -> pydrake.solvers.Binding[LinearCost]
Adds a linear cost term of the form a’*x + b.
- Parameter
e
: A linear symbolic expression.
- Precondition:
e is a linear expression a’*x + b, where each entry of x is a decision variable in the mathematical program.
- Returns
The newly added linear constraint, together with the bound variables.
AddLinearCost(self: pydrake.solvers.MathematicalProgram, a: numpy.ndarray[numpy.float64[m, 1]], b: float, vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[LinearCost]
Adds a linear cost term of the form a’*x + b. Applied to a subset of the variables and pushes onto the linear cost data structure.
AddLinearCost(self: pydrake.solvers.MathematicalProgram, a: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[LinearCost]
Adds a linear cost term of the form a’*x. Applied to a subset of the variables and pushes onto the linear cost data structure.
- AddLinearEqualityConstraint(*args, **kwargs)
Overloaded function.
AddLinearEqualityConstraint(self: pydrake.solvers.MathematicalProgram, Aeq: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], beq: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[LinearEqualityConstraint]
AddLinearEqualityConstraint
Adds linear equality constraints referencing potentially a subset of the decision variables.
Example: to add two equality constraints which only depend on two of the elements of x, you could use
auto x = prog.NewContinuousVariables(6,"myvar"); Eigen::Matrix2d Aeq; Aeq << -1, 2, 1, 1; Eigen::Vector2d beq(1, 3); // Imposes constraint // -x(0) + 2x(1) = 1 // x(0) + x(1) = 3 prog.AddLinearEqualityConstraint(Aeq, beq, x.head<2>());
AddLinearEqualityConstraint(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression, b: float) -> pydrake.solvers.Binding[LinearEqualityConstraint]
Adds one row of linear constraint e = b where
e
is a symbolic expression.- Raises
RuntimeError if 1. e is a non-linear expression. 2. e is a –
constant. –
- Parameter
e
: A linear symbolic expression in the form of
c0 + c1 * x1 + ... + cn * xn
wherec_i
is a constant and @x_i is a variable.- Parameter
b
: A scalar.
- Returns
The newly added linear equality constraint, together with the bound variable.
AddLinearEqualityConstraint(self: pydrake.solvers.MathematicalProgram, f: pydrake.symbolic.Formula) -> pydrake.solvers.Binding[LinearEqualityConstraint]
Adds a linear equality constraint represented by a symbolic formula to the program. The input formula
f
is either an equality formula (e1 == e2
) or a conjunction of equality formulas.It throws an exception if
f
is neither an equality formula nor a conjunction of equalities.f
includes a non-linear expression.
AddLinearEqualityConstraint(self: pydrake.solvers.MathematicalProgram, v: numpy.ndarray[object[m, 1]], b: numpy.ndarray[numpy.float64[m, 1]]) -> pydrake.solvers.Binding[LinearEqualityConstraint]
Adds linear equality constraints \(v = b\), where
v(i)
is a symbolic linear expression.- Raises
RuntimeError if 1. v(i) is a non-linear expression. 2. –
v(i)` is a constant –
- Template parameter
DerivedV
: An Eigen Matrix type of Expression. A column vector.
- Template parameter
DerivedB
: An Eigen Matrix type of double. A column vector.
- Parameter
v
: v(i) is a linear symbolic expression in the form of `` c0 + c1 * x1 + … + cn * xn `` where ci is a constant and @xi is a variable.
- Parameter
b
: A vector of doubles.
- Returns
The newly added linear equality constraint, together with the bound variables.
- AddLinearMatrixInequalityConstraint(self: pydrake.solvers.MathematicalProgram, F: List[numpy.ndarray[numpy.float64[m, n], flags.f_contiguous]], vars: numpy.ndarray[object[m, 1]]) pydrake.solvers.Binding[LinearMatrixInequalityConstraint]
Adds a linear matrix inequality constraint to the program.
- AddLorentzConeConstraint(*args, **kwargs)
Overloaded function.
AddLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, v: numpy.ndarray[object[m, 1]], eval_type: pydrake.solvers.LorentzConeConstraint.EvalType = <EvalType.kConvexSmooth: 1>) -> pydrake.solvers.Binding[LorentzConeConstraint]
Adds Lorentz cone constraint referencing potentially a subset of the decision variables.
- Parameter
v
: An Eigen::Vector of symbolic::Expression. Constraining that
\[v_0 \ge \sqrt{v_1^2 + ... + v_{n-1}^2}\]- Returns
The newly constructed Lorentz cone constraint with the bounded variables. For example, to add the Lorentz cone constraint
x+1 >= sqrt(y² + 2y + x² + 5), = sqrt((y+1)²+x²+2²) The user could call
{cc} Vector4<symbolic::Expression> v(x+1, y+1, x, 2.); prog.AddLorentzConeConstraint(v);
- Parameter
eval_type
: The evaluation type when evaluating the lorentz cone constraint in generic optimization. Refer to LorentzConeConstraint::EvalType for more details.
AddLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, linear_expression: pydrake.symbolic.Expression, quadratic_expression: pydrake.symbolic.Expression, tol: float = 0.0, eval_type: pydrake.solvers.LorentzConeConstraint.EvalType = <EvalType.kConvexSmooth: 1>) -> pydrake.solvers.Binding[LorentzConeConstraint]
Adds Lorentz cone constraint on the linear expression v1 and quadratic expression v2, such that v1 >= sqrt(v2)
- Parameter
linear_expression
: The linear expression v1.
- Parameter
quadratic_expression
: The quadratic expression v2.
- Parameter
tol
: The tolerance to determine if the matrix in v2 is positive semidefinite or not.
See also
DecomposePositiveQuadraticForm for more explanation. $*Default:* is 0.
- Parameter
eval_type
: The evaluation type when evaluating the lorentz cone constraint in generic optimization. Refer to LorentzConeConstraint::EvalType for more details.
- Returns
binding
: The newly added Lorentz cone constraint, together with the bound variables.
Precondition: 1.
v1
is a linear expression, in the form of c’*x + d. 2.v2
is a quadratic expression, in the form ofx'*Q*x + b'x + a
Also the quadratic expression has to be convex, namely Q is a positive semidefinite matrix, and the quadratic expression needs to be non-negative for any x.
- Raises
RuntimeError if the preconditions are not satisfied. –
Notice this constraint is equivalent to the vector [z;y] is within a Lorentz cone, where
z = v1 y = R * x + d
while (R, d) satisfies y’*y = x’*Q*x + b’*x + a For example, to add the Lorentz cone constraint
x+1 >= sqrt(y² + 2y + x² + 4), the user could call
{cc} prog.AddLorentzConeConstraint(x+1, pow(y, 2) + 2 * y + pow(x, 2) + 4);
AddLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]], eval_type: pydrake.solvers.LorentzConeConstraint.EvalType = <EvalType.kConvexSmooth: 1>) -> pydrake.solvers.Binding[LorentzConeConstraint]
Adds Lorentz cone constraint referencing potentially a subset of the decision variables (defined in the vars parameter). The linear expression \(z=Ax+b\) is in the Lorentz cone. A vector \(z \in\mathbb{R}^n\) is in the Lorentz cone, if
\[z_0 \ge \sqrt{z_1^2 + ... + z_{n-1}^2}\]- Parameter
A
: A \(\mathbb{R}^{n\times m}\) matrix, whose number of columns equals to the size of the decision variables.
- Parameter
b
: A \(\mathbb{R}^n\) vector, whose number of rows equals to the size of the decision variables.
- Parameter
vars
: The Eigen vector of \(m\) decision variables.
- Parameter
eval_type
: The evaluation type when evaluating the lorentz cone constraint in generic optimization. Refer to LorentzConeConstraint::EvalType for more details.
- Returns
The newly added Lorentz cone constraint.
For example, to add the Lorentz cone constraint
x+1 >= sqrt(y² + 2y + x² + 5) = sqrt((y+1)² + x² + 2²), the user could call
{cc} Eigen::Matrix<double, 4, 2> A; Eigen::Vector4d b; A << 1, 0, 0, 1, 1, 0, 0, 0; b << 1, 1, 0, 2; // A * [x;y] + b = [x+1; y+1; x; 2] prog.AddLorentzConeConstraint(A, b, Vector2<symbolic::Variable>(x, y));
- AddMaximizeGeometricMeanCost(*args, **kwargs)
Overloaded function.
AddMaximizeGeometricMeanCost(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], x: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[LinearCost]
An overloaded version of maximize_geometric_mean.
- Returns
cost The added cost (note that since MathematicalProgram only minimizes the cost, the returned cost evaluates to -c * power(∏ᵢx(i), 1/n).
- Precondition:
A.rows() == b.rows(), A.rows() >= 2.
AddMaximizeGeometricMeanCost(self: pydrake.solvers.MathematicalProgram, x: numpy.ndarray[object[m, 1]], c: float) -> pydrake.solvers.Binding[LinearCost]
An overloaded version of maximize_geometric_mean. We add the cost to maximize the geometric mean of x, i.e., c*power(∏ᵢx(i), 1/n).
- Parameter
c
: The positive coefficient of the geometric mean cost, $*Default:* is 1.
- Returns
cost The added cost (note that since MathematicalProgram only minimizes the cost, the returned cost evaluates to -c * power(∏ᵢx(i), 1/n).
- Precondition:
x.rows() >= 2.
- Precondition:
c > 0.
- AddMaximizeLogDeterminantCost(self: pydrake.solvers.MathematicalProgram, X: numpy.ndarray[object[m, n], flags.f_contiguous]) Tuple[pydrake.solvers.Binding[LinearCost], numpy.ndarray[object[m, 1]], numpy.ndarray[object[m, n]]]
Adds the cost to maximize the log determinant of symmetric matrix X. log(det(X)) is a concave function of X, so we can maximize it through convex optimization. In order to do that, we introduce slack variables t, and a lower triangular matrix Z, with the constraints
⌈X Z⌉ is positive semidifinite. ⌊Zᵀ diag(Z)⌋
log(Z(i, i)) >= t(i)
and we will minimize -∑ᵢt(i).
- Parameter
X
: A symmetric positive semidefinite matrix X, whose log(det(X)) will be maximized.
- Returns
(cost, t, Z) cost is -∑ᵢt(i), we also return the newly created slack variables t and the lower triangular matrix Z. Note that Z is not a matrix of symbolic::Variable but symbolic::Expression, because the upper-diagonal entries of Z are not variable, but expression 0.
- Precondition:
X is a symmetric matrix.
Note
We implicitly require that
X
being positive semidefinite (psd) (as X is the diagonal entry of the big psd matrix above). If yourX
is not necessarily psd, then don’t call this function.Note
The constraint log(Z(i, i)) >= t(i) is imposed as an exponential cone constraint. Please make sure your have a solver that supports exponential cone constraint (currently SCS does). Refer to https://docs.mosek.com/modeling-cookbook/sdo.html#log-determinant for more details.
- Parameter
- AddPositiveDiagonallyDominantMatrixConstraint(self: pydrake.solvers.MathematicalProgram, X: numpy.ndarray[object[m, n], flags.f_contiguous]) numpy.ndarray[object[m, n]]
Adds the constraint that a symmetric matrix is diagonally dominant with non-negative diagonal entries. A symmetric matrix X is diagonally dominant with non-negative diagonal entries if X(i, i) >= ∑ⱼ |X(i, j)| ∀ j ≠ i namely in each row, the diagonal entry is larger than the sum of the absolute values of all other entries in the same row. A matrix being diagonally dominant with non-negative diagonals is a sufficient (but not necessary) condition of a matrix being positive semidefinite. Internally we will create a matrix Y as slack variables, such that Y(i, j) represents the absolute value |X(i, j)| ∀ j ≠ i. The diagonal entries Y(i, i) = X(i, i) The users can refer to “DSOS and SDSOS Optimization: More Tractable Alternatives to Sum of Squares and Semidefinite Optimization” by Amir Ali Ahmadi and Anirudha Majumdar, with arXiv link https://arxiv.org/abs/1706.02586
- Parameter
X
: The matrix X. We will use 0.5(X+Xᵀ) as the “symmetric version” of X.
- Returns
Y The slack variable. Y(i, j) represents |X(i, j)| ∀ j ≠ i, with the constraint Y(i, j) >= X(i, j) and Y(i, j) >= -X(i, j). Y is a symmetric matrix. The diagonal entries Y(i, i) = X(i, i)
- Parameter
- AddPositiveSemidefiniteConstraint(*args, **kwargs)
Overloaded function.
AddPositiveSemidefiniteConstraint(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[object[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[PositiveSemidefiniteConstraint]
Adds a positive semidefinite constraint on a symmetric matrix.
- Raises
RuntimeError in Debug mode if symmetric_matrix_var is not –
symmetric. –
- Parameter
symmetric_matrix_var
: A symmetric MatrixDecisionVariable object.
AddPositiveSemidefiniteConstraint(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[object[m, n], flags.f_contiguous]) -> pydrake.solvers.Binding[PositiveSemidefiniteConstraint]
Adds a positive semidefinite constraint on a symmetric matrix of symbolic expressions
e
. We create a new symmetric matrix of variables M being positive semidefinite, with the linear equality constraint e == M.- Parameter
e
: Imposes constraint “e is positive semidefinite”.
- Precondition:
{1. e is symmetric. 2. e(i, j) is linear for all i, j }
- Returns
The newly added positive semidefinite constraint, with the bound variable M that are also newly added.
For example, to add a constraint that
⌈x + 1 2x + 3 x+y⌉ |2x+ 3 2 0| is positive semidefinite ⌊x + y 0 x⌋ The user could call
{cc} Matrix3<symbolic::Expression> e e << x+1, 2*x+3, x+y, 2*x+3, 2, 0, x+y, 0, x; prog.AddPositiveSemidefiniteConstraint(e);
- AddQuadraticAsRotatedLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, Q: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], c: float, vars: numpy.ndarray[object[m, 1]], psd_tol: float = 0.0) pydrake.solvers.Binding[RotatedLorentzConeConstraint]
Add the convex quadratic constraint 0.5xᵀQx + bᵀx + c <= 0 as a rotated Lorentz cone constraint [rᵀx+s, 1, Px+q] is in the rotated Lorentz cone. When solving the optimization problem using conic solvers (like Mosek, Gurobi, SCS, etc), it is numerically preferable to impose the convex quadratic constraint as rotated Lorentz cone constraint. See https://docs.mosek.com/latest/capi/prob-def-quadratic.html#a-recommendation
- Raises
exception if this quadratic constraint is not convex (Q is not –
positive semidefinite) –
- Parameter
Q
: The Hessian of the quadratic constraint. Should be positive semidefinite.
- Parameter
b
: The linear coefficient of the quadratic constraint.
- Parameter
c
: The constant term of the quadratic constraint.
- Parameter
vars
: x in the documentation above.
- Parameter
psd_tol
: If the minimal eigenvalue of Q is smaller than -psd_tol, then throw an exception. $*Default:* = 0.
- AddQuadraticCost(*args, **kwargs)
Overloaded function.
AddQuadraticCost(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression, is_convex: Optional[bool] = None) -> pydrake.solvers.Binding[QuadraticCost]
Add a quadratic cost term of the form 0.5*x’*Q*x + b’*x + c. Notice that in the optimization program, the constant term
c
in the cost is ignored.- Parameter
e
: A quadratic symbolic expression.
- Parameter
is_convex
: Whether the cost is already known to be convex. If is_convex=nullopt (the default), then Drake will determine if
e
is a convex quadratic cost or not. To improve the computation speed, the user can set is_convex if the user knows whether the cost is convex or not.
- Raises
RuntimeError if the expression is not quadratic. –
- Returns
The newly added cost together with the bound variables.
AddQuadraticCost(self: pydrake.solvers.MathematicalProgram, Q: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]], is_convex: Optional[bool] = None) -> pydrake.solvers.Binding[QuadraticCost]
Adds a cost term of the form 0.5*x’*Q*x + b’x Applied to subset of the variables.
- Parameter
is_convex
: Whether the cost is already known to be convex. If is_convex=nullopt (the default), then Drake will determine if this is a convex quadratic cost or not. To improve the computation speed, the user can set is_convex if the user knows whether the cost is convex or not.
AddQuadraticCost(self: pydrake.solvers.MathematicalProgram, Q: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], c: float, vars: numpy.ndarray[object[m, 1]], is_convex: Optional[bool] = None) -> pydrake.solvers.Binding[QuadraticCost]
Adds a cost term of the form 0.5*x’*Q*x + b’x + c Applied to subset of the variables.
- Parameter
is_convex
: Whether the cost is already known to be convex. If is_convex=nullopt (the default), then Drake will determine if this is a convex quadratic cost or not. To improve the computation speed, the user can set is_convex if the user knows whether the cost is convex or not.
- AddQuadraticErrorCost(self: pydrake.solvers.MathematicalProgram, Q: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], x_desired: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) pydrake.solvers.Binding[QuadraticCost]
Adds a cost term of the form (x-x_desired)’*Q*(x-x_desired).
- AddRotatedLorentzConeConstraint(*args, **kwargs)
Overloaded function.
AddRotatedLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, linear_expression1: pydrake.symbolic.Expression, linear_expression2: pydrake.symbolic.Expression, quadratic_expression: pydrake.symbolic.Expression, tol: float = 0) -> pydrake.solvers.Binding[RotatedLorentzConeConstraint]
Adds rotated Lorentz cone constraint on the linear expression v1, v2 and quadratic expression u, such that v1 * v2 >= u, v1 >= 0, v2 >= 0
- Parameter
linear_expression1
: The linear expression v1.
- Parameter
linear_expression2
: The linear expression v2.
- Parameter
quadratic_expression
: The quadratic expression u.
- Parameter
tol
: The tolerance to determine if the matrix in v2 is positive semidefinite or not.
See also
DecomposePositiveQuadraticForm for more explanation. $*Default:* is 0.
- Returns
binding
: The newly added rotated Lorentz cone constraint, together with the bound variables.
Precondition: 1.
linear_expression1
is a linear (affine) expression, in the form ofv1 = c1’*x + d1.
linear_expression2
is a linear (affine) expression, in the form of v2 = c2’*x + d2.
quadratic_expression
is a quadratic expression, in the form of
u = x'*Q*x + b'x + a
Also the quadratic expression has to be convex, namely Q is a positive semidefinite matrix, and the quadratic expression needs to be non-negative for any x.
- Raises
RuntimeError if the preconditions are not satisfied. –
For example, to add the rotated Lorentz cone constraint
(x+1)(x+y) >= x²+z²+2z+5 x+1 >= 0 x+y >= 0 The user could call
{cc} prog.AddRotatedLorentzConeConstraint(x+1, x+y, pow(x, 2) + pow(z, 2) + 2*z+5);
AddRotatedLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, v: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[RotatedLorentzConeConstraint]
Adds a constraint that a symbolic expression
- Parameter
v
: is in the rotated Lorentz cone, i.e.,
\[v_0v_1 \ge v_2^2 + ... + v_{n-1}^2\\]v_0 ge 0, v_1 ge 0
- Parameter
v
: A linear expression of variables, \(v = A x + b\), where \(A, b\) are given matrices of the correct size, \(x\) is the vector of decision variables.
- Returns
binding
: The newly added rotated Lorentz cone constraint, together with the bound variables.
For example, to add the rotated Lorentz cone constraint
(x+1)(x+y) >= x²+z²+2z+5 = x² + (z+1)² + 2² x+1 >= 0 x+y >= 0 The user could call
{cc} Eigen::Matrix<symbolic::Expression, 5, 1> v; v << x+1, x+y, x, z+1, 2; prog.AddRotatedLorentzConeConstraint(v);
AddRotatedLorentzConeConstraint(self: pydrake.solvers.MathematicalProgram, A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], vars: numpy.ndarray[object[m, 1]]) -> pydrake.solvers.Binding[RotatedLorentzConeConstraint]
Adds a rotated Lorentz cone constraint referencing potentially a subset of decision variables, The linear expression \(z=Ax+b\) is in rotated Lorentz cone. A vector \(z \in\mathbb{R}^n\) is in the rotated Lorentz cone, if
\[z_0z_1 \ge z_2^2 + ... + z_{n-1}^2\]where \(A\in\mathbb{R}^{n\times m}, b\in\mathbb{R}^n\) are given matrices.
- Parameter
A
: A matrix whose number of columns equals to the size of the decision variables.
- Parameter
b
: A vector whose number of rows equals to the size of the decision variables.
- Parameter
vars
: The decision variables on which the constraint is imposed.
- AddScaledDiagonallyDominantMatrixConstraint(*args, **kwargs)
Overloaded function.
AddScaledDiagonallyDominantMatrixConstraint(self: pydrake.solvers.MathematicalProgram, X: numpy.ndarray[object[m, n], flags.f_contiguous]) -> List[List[numpy.ndarray[object[2, 2]]]]
This is an overloaded variant of addsdd “scaled diagonally dominant matrix constraint”
- Parameter
X
: The matrix X to be constrained scaled diagonally dominant. X.
- Precondition:
X(i, j) should be a linear expression of decision variables.
- Returns
M A vector of vectors of 2 x 2 symmetric matrices M. For i < j, M[i][j] is
[Mⁱʲ(i, i), Mⁱʲ(i, j)] [Mⁱʲ(i, j), Mⁱʲ(j, j)].
Note that M[i][j](0, 1) = Mⁱʲ(i, j) = (X(i, j) + X(j, i)) / 2 for i >= j, M[i][j] is the zero matrix.
AddScaledDiagonallyDominantMatrixConstraint(self: pydrake.solvers.MathematicalProgram, X: numpy.ndarray[object[m, n], flags.f_contiguous]) -> List[List[numpy.ndarray[object[2, 2]]]]
This is an overloaded variant of addsdd “scaled diagonally dominant matrix constraint”
- Parameter
X
: The symmetric matrix X to be constrained scaled diagonally dominant.
- Returns
M For i < j M[i][j] contains the slack variables, mentioned in addsdd “scaled diagonally dominant matrix constraint”. For i >= j, M[i][j] contains dummy variables.
- AddSosConstraint(*args, **kwargs)
Overloaded function.
AddSosConstraint(self: pydrake.solvers.MathematicalProgram, p: pydrake.symbolic.Polynomial, monomial_basis: numpy.ndarray[object[m, 1]], type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>, gram_name: str = ‘S’) -> numpy.ndarray[object[m, n]]
Adds constraints that a given polynomial
p
is a sums-of-squares (SOS), that is,p
can be decomposed intomᵀQm
, where m is themonomial_basis
. It returns the coefficients matrix Q, which is positive semidefinite.- Parameter
type
: The type of the polynomial. $*Default:* is kSos, but the user can also use kSdsos and kDsos. Refer to NonnegativePolynomial for details on different types of sos polynomials.
- Parameter
gram_name
: The name of the gram matrix for print out.
Note
It calls
Reparse
to enforcep
to have this MathematicalProgram’s indeterminates if necessary.AddSosConstraint(self: pydrake.solvers.MathematicalProgram, p: pydrake.symbolic.Polynomial, type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>, gram_name: str = ‘S’) -> Tuple[numpy.ndarray[object[m, n]], numpy.ndarray[object[m, 1]]]
Adds constraints that a given polynomial
p
is a sums-of-squares (SOS), that is,p
can be decomposed intomᵀQm
, where m is a monomial basis selected from the sparsity ofp
. It returns a pair of constraint bindings expressing: - The coefficients matrix Q, which is positive semidefinite. - The monomial basis m.- Parameter
type
: The type of the polynomial. $*Default:* is kSos, but the user can also use kSdsos and kDsos. Refer to NonnegativePolynomial for the details on different type of sos polynomials.
- Parameter
gram_name
: The name of the gram matrix for print out.
Note
It calls
Reparse
to enforcep
to have this MathematicalProgram’s indeterminates if necessary.AddSosConstraint(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression, monomial_basis: numpy.ndarray[object[m, 1]], type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>, gram_name: str = ‘S’) -> numpy.ndarray[object[m, n]]
Adds constraints that a given symbolic expression
e
is a sums-of-squares (SOS), that is,p
can be decomposed intomᵀQm
, where m is themonomial_basis
. Note that it decomposese
into a polynomial with respect toindeterminates()
in this mathematical program. It returns the coefficients matrix Q, which is positive semidefinite.- Parameter
type
: Refer to NonnegativePolynomial class documentation.
- Parameter
gram_name
: The name of the gram matrix for print out.
AddSosConstraint(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression, type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>, gram_name: str = ‘S’) -> Tuple[numpy.ndarray[object[m, n]], numpy.ndarray[object[m, 1]]]
Adds constraints that a given symbolic expression
e
is a sums-of-squares (SOS), that is,e
can be decomposed intomᵀQm
. Note that it decomposese
into a polynomial with respect toindeterminates()
in this mathematical program. It returns a pair expressing: - The coefficients matrix Q, which is positive semidefinite. - The monomial basis m.- Parameter
type
: Refer to NonnegativePolynomial class documentation.
- Parameter
gram_name
: The name of the gram matrix for print out.
- AddVisualizationCallback(self: pydrake.solvers.MathematicalProgram, arg0: Callable[[numpy.ndarray[numpy.float64[m, 1]]], None], arg1: numpy.ndarray[object[m, 1]]) pydrake.solvers.Binding[VisualizationCallback]
Adds a callback method to visualize intermediate results of the optimization.
Note
Just like other costs/constraints, not all solvers support callbacks. Adding a callback here will force MathematicalProgram::Solve to select a solver that support callbacks. For instance, adding a visualization callback to a quadratic programming problem may result in using a nonlinear programming solver as the default solver.
- Parameter
callback
: a std::function that accepts an Eigen::Vector of doubles representing the bound decision variables.
- Parameter
vars
: the decision variables that should be passed to the callback.
- Parameter
- bounding_box_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[BoundingBoxConstraint]]
Getter for all bounding box constraints
- CheckSatisfied(*args, **kwargs)
Overloaded function.
CheckSatisfied(self: pydrake.solvers.MathematicalProgram, binding: pydrake.solvers.Binding[Constraint], prog_var_vals: numpy.ndarray[numpy.float64[m, 1]], tol: float = 1e-06) -> bool
Evaluates CheckSatisfied for the constraint in
binding
using the value of ALL of the decision variables in this program.- Raises
RuntimeError if the size of prog_var_vals is invalid. –
CheckSatisfied(self: pydrake.solvers.MathematicalProgram, bindings: List[pydrake.solvers.Binding[Constraint]], prog_var_vals: numpy.ndarray[numpy.float64[m, 1]], tol: float = 1e-06) -> bool
Evaluates CheckSatisfied for the all of the constraints in
binding
using the value of ALL of the decision variables in this program.- Returns
true iff all of the constraints are satisfied.
- Raises
RuntimeError if the size of prog_var_vals is invalid. –
- CheckSatisfiedAtInitialGuess(*args, **kwargs)
Overloaded function.
CheckSatisfiedAtInitialGuess(self: pydrake.solvers.MathematicalProgram, binding: pydrake.solvers.Binding[Constraint], tol: float = 1e-06) -> bool
Evaluates CheckSatisfied for the constraint in
binding
at the initial guess.CheckSatisfiedAtInitialGuess(self: pydrake.solvers.MathematicalProgram, bindings: List[pydrake.solvers.Binding[Constraint]], tol: float = 1e-06) -> bool
Evaluates CheckSatisfied for the all of the constraints in
bindings
at the initial guess.- Returns
true iff all of the constraints are satisfied.
- ClearVariableScaling(self: pydrake.solvers.MathematicalProgram) None
Clears the scaling factors for decision variables.
See variable_scaling “Variable scaling” for more information.
- decision_variable(self: pydrake.solvers.MathematicalProgram, i: int) pydrake.symbolic.Variable
Getter for the decision variable with index
i
in the program.
- decision_variable_index(self: pydrake.solvers.MathematicalProgram) Dict[int, int]
Returns the mapping from a decision variable ID to its index in the vector containing all the decision variables in the mathematical program.
- decision_variables(self: pydrake.solvers.MathematicalProgram) numpy.ndarray[object[m, 1]]
Getter for all decision variables in the program.
- EvalBinding(*args, **kwargs)
Overloaded function.
EvalBinding(self: pydrake.solvers.MathematicalProgram, binding: pydrake.solvers.Binding[EvaluatorBase], prog_var_vals: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]
Evaluates the value of some binding, for some input value for all decision variables.
- Parameter
binding
: A Binding whose variables are decision variables in this program.
- Parameter
prog_var_vals
: The value of all the decision variables in this program.
- Raises
RuntimeError if the size of prog_var_vals is invalid. –
EvalBinding(self: pydrake.solvers.MathematicalProgram, binding: pydrake.solvers.Binding[EvaluatorBase], prog_var_vals: numpy.ndarray[object[m, 1]]) -> numpy.ndarray[object[m, 1]]
Evaluates the value of some binding, for some input value for all decision variables.
- Parameter
binding
: A Binding whose variables are decision variables in this program.
- Parameter
prog_var_vals
: The value of all the decision variables in this program.
- Raises
RuntimeError if the size of prog_var_vals is invalid. –
- EvalBindings(*args, **kwargs)
Overloaded function.
EvalBindings(self: pydrake.solvers.MathematicalProgram, bindings: List[pydrake.solvers.Binding[EvaluatorBase]], prog_var_vals: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]
Evaluates a set of bindings (plural version of
EvalBinding
).- Parameter
bindings
: List of bindings.
- Parameter
prog
: $Parameter
prog_var_vals
:
The value of all the decision variables in this program.
- Returns
All binding values, concatenated into a single vector.
- Raises
RuntimeError if the size of prog_var_vals is invalid. –
EvalBindings(self: pydrake.solvers.MathematicalProgram, bindings: List[pydrake.solvers.Binding[EvaluatorBase]], prog_var_vals: numpy.ndarray[object[m, 1]]) -> numpy.ndarray[object[m, 1]]
Evaluates a set of bindings (plural version of
EvalBinding
).- Parameter
bindings
: List of bindings.
- Parameter
prog
: $Parameter
prog_var_vals
:
The value of all the decision variables in this program.
- Returns
All binding values, concatenated into a single vector.
- Raises
RuntimeError if the size of prog_var_vals is invalid. –
- EvalBindingVectorized(self: pydrake.solvers.MathematicalProgram, binding: pydrake.solvers.Binding[EvaluatorBase], prog_var_vals: numpy.ndarray[numpy.float64[m, n]]) numpy.ndarray[numpy.float64[m, n]]
A “vectorized” version of EvalBinding. It evaluates the binding for every column of
prog_var_vals
.
- exponential_cone_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[ExponentialConeConstraint]]
Getter for exponential cone constraints.
- FindDecisionVariableIndex(self: pydrake.solvers.MathematicalProgram, var: pydrake.symbolic.Variable) int
Returns the index of the decision variable. Internally the solvers thinks all variables are stored in an array, and it accesses each individual variable using its index. This index is used when adding constraints and costs for each solver.
- Precondition:
{
var
is a decision variable in the mathematical program, otherwise this function throws a runtime error.}
- FindDecisionVariableIndices(self: pydrake.solvers.MathematicalProgram, vars: numpy.ndarray[object[m, 1]]) List[int]
Returns the indices of the decision variables. Internally the solvers thinks all variables are stored in an array, and it accesses each individual variable using its index. This index is used when adding constraints and costs for each solver.
- Precondition:
{
vars
are decision variables in the mathematical program, otherwise this function throws a runtime error.}
- FindIndeterminateIndex(self: pydrake.solvers.MathematicalProgram, var: pydrake.symbolic.Variable) int
Returns the index of the indeterminate. Internally a solver thinks all indeterminates are stored in an array, and it accesses each individual indeterminate using its index. This index is used when adding constraints and costs for each solver.
- Precondition:
var
is a indeterminate in the mathematical program, otherwise this function throws a runtime error.
- generic_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[Constraint]]
Getter for all generic constraints
- generic_costs(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[Cost]]
Getter for all generic costs.
- GetAllConstraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[Constraint]]
Getter for returning all constraints.
- Returns
Vector of all constraint bindings.
Note
The group ordering may change as more constraint types are added.
- GetAllCosts(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[Cost]]
Getter returning all costs.
- Returns
Vector of all cost bindings.
Note
The group ordering may change as more cost types are added.
- GetBindingVariableValues(self: pydrake.solvers.MathematicalProgram, binding: pydrake.solvers.Binding[EvaluatorBase], prog_var_vals: numpy.ndarray[numpy.float64[m, 1]]) numpy.ndarray[numpy.float64[m, 1]]
Given the value of all decision variables, namely this.decision_variable(i) takes the value prog_var_vals(i), returns the vector that contains the value of the variables in binding.variables().
- Parameter
binding
: binding.variables() must be decision variables in this MathematicalProgram.
- Parameter
prog_var_vals
: The value of ALL the decision variables in this program.
- Returns
binding_variable_vals binding_variable_vals(i) is the value of binding.variables()(i) in prog_var_vals.
- Parameter
- GetInitialGuess(*args, **kwargs)
Overloaded function.
GetInitialGuess(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.symbolic.Variable) -> float
Gets the initial guess for a single variable.
- Precondition:
decision_variable
has been registered in the optimization program.
- Raises
RuntimeError if the pre condition is not satisfied. –
GetInitialGuess(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[object[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]
Gets the initial guess for some variables.
- Precondition:
Each variable in
decision_variable_mat
has been registered in the optimization program.
- Raises
RuntimeError if the pre condition is not satisfied. –
GetInitialGuess(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[object[m, n]]) -> numpy.ndarray[numpy.float64[m, n]]
Gets the initial guess for some variables.
- Precondition:
Each variable in
decision_variable_mat
has been registered in the optimization program.
- Raises
RuntimeError if the pre condition is not satisfied. –
- GetLinearConstraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LinearConstraint]]
Getter returning all linear constraints (both linear equality and inequality constraints).
- Returns
Vector of all linear constraint bindings.
- GetSolverOptions(*args, **kwargs)
Overloaded function.
GetSolverOptions(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.solvers.SolverId) -> dict
GetSolverOptions(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.solvers.SolverType) -> dict
- GetVariableScaling(self: pydrake.solvers.MathematicalProgram) Dict[int, float]
Returns the mapping from a decision variable index to its scaling factor.
See variable_scaling “Variable scaling” for more information.
- indeterminate(self: pydrake.solvers.MathematicalProgram, i: int) pydrake.symbolic.Variable
Getter for the indeterminate with index
i
in the program.
- indeterminates(self: pydrake.solvers.MathematicalProgram) numpy.ndarray[object[m, 1]]
Getter for all indeterminates in the program.
- indeterminates_index(self: pydrake.solvers.MathematicalProgram) Dict[int, int]
Returns the mapping from an indeterminate ID to its index in the vector containing all the indeterminates in the mathematical program.
- initial_guess(self: pydrake.solvers.MathematicalProgram) numpy.ndarray[numpy.float64[m, 1]]
Getter for the initial guess
- l2norm_costs(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[L2NormCost]]
Getter for l2norm costs.
- linear_complementarity_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LinearComplementarityConstraint]]
Getter for all linear complementarity constraints.
- linear_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LinearConstraint]]
Getter for linear constraints.
- linear_costs(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LinearCost]]
Getter for linear costs.
- linear_equality_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LinearEqualityConstraint]]
Getter for linear equality constraints.
- linear_matrix_inequality_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LinearMatrixInequalityConstraint]]
Getter for linear matrix inequality constraints.
- lorentz_cone_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[LorentzConeConstraint]]
Getter for Lorentz cone constraints.
- MakePolynomial(self: pydrake.solvers.MathematicalProgram, e: pydrake.symbolic.Expression) pydrake.symbolic.Polynomial
Creates a symbolic polynomial from the given expression
e
. It uses this MathematicalProgram’sindeterminates()
in constructing the polynomial.This method helps a user create a polynomial with the right set of indeterminates which are declared in this MathematicalProgram. We recommend users to use this method over an explicit call to Polynomial constructors to avoid a possible mismatch between this MathematicalProgram’s indeterminates and the user-specified indeterminates (or unspecified, which then includes all symbolic variables in the expression
e
). Consider the following example.e = ax + bx + c
MP.indeterminates() = {x} MP.decision_variables() = {a, b}
MP.MakePolynomial(e)
create a polynomial,(a + b)x + c
. Here onlyx
is an indeterminate of this polynomial.In contrast,
symbolic::Polynomial(e)
returnsax + bx + c
where all variables{a, b, x}
are indeterminates. Note that this is problematic as its indeterminates,{a, b, x}
and the MathematicalProgram’s decision variables,{a, b}
overlap.
Note
This function does not require that the decision variables in
e
is a subset of the decision variables in MathematicalProgram.
- NewBinaryVariables(*args, **kwargs)
Overloaded function.
NewBinaryVariables(self: pydrake.solvers.MathematicalProgram, rows: int, name: str = ‘b’) -> numpy.ndarray[object[m, 1]]
Adds binary variables to this MathematicalProgram. The new variables are viewed as a column vector, with size
rows
x 1.See also
NewBinaryVariables(int rows, int cols, const std::vector<std::string>& names);
NewBinaryVariables(self: pydrake.solvers.MathematicalProgram, rows: int, cols: int, name: str = ‘b’) -> numpy.ndarray[object[m, n]]
Adds binary variables, appending them to an internal vector of any existing vars. The initial guess values for the new variables are set to NaN, to indicate that an initial guess has not been assigned. Callers are expected to add costs and/or constraints to have any effect during optimization. Callers can also set the initial guess of the decision variables through SetInitialGuess() or SetInitialGuessForAllVariables().
- Template parameter
Rows
: The number of rows in the new variables.
- Template parameter
Cols
: The number of columns in the new variables.
- Parameter
rows
: The number of rows in the new variables.
- Parameter
cols
: The number of columns in the new variables.
- Parameter
name
: The commonly shared name of the new variables.
- Returns
The MatrixDecisionVariable of size rows x cols, containing the new vars (not all the vars stored).
Example:
MathematicalProgram prog; auto b = prog.NewBinaryVariables(2, 3, "b");
This adds a 2 x 3 matrix decision variables into the program.
The name of the variable is only used for the user in order to ease readability.
- NewContinuousVariables(*args, **kwargs)
Overloaded function.
NewContinuousVariables(self: pydrake.solvers.MathematicalProgram, rows: int, name: str = ‘x’) -> numpy.ndarray[object[m, 1]]
Adds continuous variables, appending them to an internal vector of any existing vars. The initial guess values for the new variables are set to NaN, to indicate that an initial guess has not been assigned. Callers are expected to add costs and/or constraints to have any effect during optimization. Callers can also set the initial guess of the decision variables through SetInitialGuess() or SetInitialGuessForAllVariables().
- Parameter
rows
: The number of rows in the new variables.
- Parameter
name
: The name of the newly added variables
- Returns
The VectorDecisionVariable of size rows x 1, containing the new vars (not all the vars stored).
Example:
MathematicalProgram prog; auto x = prog.NewContinuousVariables(2, "x");
This adds a 2 x 1 vector containing decision variables into the program. The names of the variables are “x(0)” and “x(1)”.
The name of the variable is only used for the user in order to ease readability.
NewContinuousVariables(self: pydrake.solvers.MathematicalProgram, rows: int, cols: int, name: str = ‘x’) -> numpy.ndarray[object[m, n]]
Adds continuous variables, appending them to an internal vector of any existing vars. The initial guess values for the new variables are set to NaN, to indicate that an initial guess has not been assigned. Callers are expected to add costs and/or constraints to have any effect during optimization. Callers can also set the initial guess of the decision variables through SetInitialGuess() or SetInitialGuessForAllVariables().
- Template parameter
Rows
: The number of rows of the new variables, in the compile time.
- Template parameter
Cols
: The number of columns of the new variables, in the compile time.
- Parameter
rows
: The number of rows in the new variables. When Rows is not Eigen::Dynamic, rows is ignored.
- Parameter
cols
: The number of columns in the new variables. When Cols is not Eigen::Dynamic, cols is ignored.
- Parameter
name
: All variables will share the same name, but different index.
- Returns
The MatrixDecisionVariable of size Rows x Cols, containing the new vars (not all the vars stored).
Example:
MathematicalProgram prog; auto x = prog.NewContinuousVariables(2, 3, "X"); auto y = prog.NewContinuousVariables<2, 3>(2, 3, "X");
This adds a 2 x 3 matrix decision variables into the program.
The name of the variable is only used for the user in order to ease readability.
- NewEvenDegreeDsosPolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int) Tuple[pydrake.symbolic.Polynomial, numpy.ndarray[object[m, n]], numpy.ndarray[object[m, n]]]
see even_degree_nonnegative_polynomial for details. Variant that produces a DSOS polynomial. Same as NewEvenDegreeSosPolynomial, except the returned polynomial is diagonally dominant sum of squares (dsos).
- NewEvenDegreeFreePolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int, coeff_name: str = 'a') pydrake.symbolic.Polynomial
Returns a free polynomial that only contains even degree monomials. A monomial is even degree if its total degree (sum of all variables’ degree) is even. For example, xy is an even degree monomial (degree 2) while x²y is not (degree 3).
- Parameter
indeterminates
: The monomial basis is over these indeterminates.
- Parameter
degree
: The highest degree of the polynomial.
- Parameter
coeff_name
: The coefficients of the polynomial are decision variables with this name as a base. The variable name would be “a1”, “a2”, etc.
- Parameter
- NewEvenDegreeNonnegativePolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int, type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial) Tuple[pydrake.symbolic.Polynomial, numpy.ndarray[object[m, n]], numpy.ndarray[object[m, n]]]
See even_degree_nonnegative_polynomial for more details. Variant that produces different non-negative polynomials depending on
type
.- Parameter
type
: The returned polynomial p(x) can be either SOS, SDSOS or DSOS, depending on
type
.
- Parameter
- NewEvenDegreeSdsosPolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int) Tuple[pydrake.symbolic.Polynomial, numpy.ndarray[object[m, n]], numpy.ndarray[object[m, n]]]
see even_degree_nonnegative_polynomial for details. Variant that produces an SDSOS polynomial.
- NewEvenDegreeSosPolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int) Tuple[pydrake.symbolic.Polynomial, numpy.ndarray[object[m, n]], numpy.ndarray[object[m, n]]]
See even_degree_nonnegative_polynomial for more details. Variant that produces a SOS polynomial.
- NewFreePolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, deg: int, coeff_name: str = 'a') pydrake.symbolic.Polynomial
Returns a free polynomial in a monomial basis over
indeterminates
of a givendegree
. It usescoeff_name
to make new decision variables and use them as coefficients. For example,NewFreePolynomial({x₀, x₁}, 2)
returns a₀x₁² + a₁x₀x₁ + a₂x₀² + a₃x₁ + a₄x₀ + a₅.
- NewIndeterminates(*args, **kwargs)
Overloaded function.
NewIndeterminates(self: pydrake.solvers.MathematicalProgram, rows: int, name: str = ‘x’) -> numpy.ndarray[object[m, 1]]
Adds indeterminates to this MathematicalProgram, with default name “x”.
See also
NewIndeterminates(int rows, int cols, const std::vector<std::string>& names);
NewIndeterminates(self: pydrake.solvers.MathematicalProgram, rows: int, cols: int, name: str = ‘X’) -> numpy.ndarray[object[m, n]]
Adds indeterminates to this MathematicalProgram, with default name “X”. The new variables are returned and viewed as a matrix, with size
rows
xcols
.See also
NewIndeterminates(int rows, int cols, const std::vector<std::string>& names);
- NewOddDegreeFreePolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int, coeff_name: str = 'a') pydrake.symbolic.Polynomial
Returns a free polynomial that only contains odd degree monomials. A monomial is odd degree if its total degree (sum of all variables’ degree) is even. For example, xy is not an odd degree monomial (degree 2) while x²y is (degree 3).
- Parameter
indeterminates
: The monomial basis is over these indeterminates.
- Parameter
degree
: The highest degree of the polynomial.
- Parameter
coeff_name
: The coefficients of the polynomial are decision variables with this name as a base. The variable name would be “a1”, “a2”, etc.
- Parameter
- NewSosPolynomial(*args, **kwargs)
Overloaded function.
NewSosPolynomial(self: pydrake.solvers.MathematicalProgram, monomial_basis: numpy.ndarray[object[m, 1]], type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>, gram_name: str = ‘S’) -> Tuple[pydrake.symbolic.Polynomial, numpy.ndarray[object[m, n]]]
Returns a pair of a SOS polynomial p = mᵀQm and the Gramian matrix Q, where m is the
monomial
basis. For example,NewSosPolynomial(Vector2<Monomial>{x,y})
returns a polynomial p = Q₍₀,₀₎x² + 2Q₍₁,₀₎xy + Q₍₁,₁₎y² and Q. Depending on the type of the polynomial, we will impose different constraint on the polynomial. - if type = kSos, we impose the polynomial being SOS. - if type = kSdsos, we impose the polynomial being SDSOS. - if type = kDsos, we impose the polynomial being DSOS.- Parameter
gram_name
: The name of the gram matrix for print out.
Note
Q is a symmetric monomial_basis.rows() x monomial_basis.rows() matrix.
NewSosPolynomial(self: pydrake.solvers.MathematicalProgram, gramian: numpy.ndarray[object[m, n], flags.f_contiguous], monomial_basis: numpy.ndarray[object[m, 1]], type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>) -> pydrake.symbolic.Polynomial
Overloads NewSosPolynomial, except the Gramian matrix Q is an input instead of an output.
NewSosPolynomial(self: pydrake.solvers.MathematicalProgram, indeterminates: pydrake.symbolic.Variables, degree: int, type: pydrake.solvers.MathematicalProgram.NonnegativePolynomial = <NonnegativePolynomial.kSos: 1>, gram_name: str = ‘S’) -> Tuple[pydrake.symbolic.Polynomial, numpy.ndarray[object[m, n]]]
Overloads NewSosPolynomial. Returns a pair of a SOS polynomial p = m(x)ᵀQm(x) of degree
degree
and the Gramian matrix Q that should be PSD, where m(x) is the result of callingMonomialBasis(indeterminates, degree/2)
. For example,NewSosPolynomial({x}, 4)
returns a pair of a polynomial p = Q₍₀,₀₎x⁴ + 2Q₍₁,₀₎ x³ + (2Q₍₂,₀₎ + Q₍₁,₁₎)x² + 2Q₍₂,₁₎x + Q₍₂,₂₎ and Q.- Parameter
type
: Depending on the type of the polynomial, we will impose different constraint on the polynomial. - if type = kSos, we impose the polynomial being SOS. - if type = kSdsos, we impose the polynomial being SDSOS. - if type = kDsos, we impose the polynomial being DSOS.
- Parameter
gram_name
: The name of the gram matrix for print out.
- Raises
RuntimeError if degree is not a positive even integer. –
See also
MonomialBasis.
- NewSymmetricContinuousVariables(self: pydrake.solvers.MathematicalProgram, rows: int, name: str = 'Symmetric') numpy.ndarray[object[m, n]]
Adds a runtime sized symmetric matrix as decision variables to this MathematicalProgram. The optimization will only use the stacked columns of the lower triangular part of the symmetric matrix as decision variables.
- Parameter
rows
: The number of rows in the symmetric matrix.
- Parameter
name
: The name of the matrix. It is only used the for user to understand the optimization program. The default name is “Symmetric”, and each variable will be named as
Symmetric(0, 0) Symmetric(1, 0) ... Symmetric(rows-1, 0) Symmetric(1, 0) Symmetric(1, 1) ... Symmetric(rows-1, 1) ... Symmetric(rows-1,0) Symmetric(rows-1,1) ... Symmetric(rows-1, rows-1)
Notice that the (i,j)’th entry and (j,i)’th entry has the same name.
- Returns
The newly added decision variables.
- Parameter
- class NonnegativePolynomial
Types of non-negative polynomial that can be found through conic optimization. We currently support SOS, SDSOS and DSOS. For more information about these polynomial types, please refer to “DSOS and SDSOS Optimization: More Tractable Alternatives to Sum of Squares and Semidefinite Optimization” by Amir Ali Ahmadi and Anirudha Majumdar, with arXiv link https://arxiv.org/abs/1706.02586
Members:
kSos : A sum-of-squares polynomial.
kSdsos : A scaled-diagonally dominant sum-of-squares polynomial.
kDsos : A diagonally dominant sum-of-squares polynomial.
- __init__(self: pydrake.solvers.MathematicalProgram.NonnegativePolynomial, value: int) None
- kDsos = <NonnegativePolynomial.kDsos: 3>
- kSdsos = <NonnegativePolynomial.kSdsos: 2>
- kSos = <NonnegativePolynomial.kSos: 1>
- property name
- property value
- num_indeterminates(self: pydrake.solvers.MathematicalProgram) int
Gets the number of indeterminates in the optimization program
- num_vars(self: pydrake.solvers.MathematicalProgram) int
Getter for number of variables in the optimization program
- positive_semidefinite_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[PositiveSemidefiniteConstraint]]
Getter for positive semidefinite constraints.
- quadratic_costs(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[QuadraticCost]]
Getter for quadratic costs.
- RemoveConstraint(self: pydrake.solvers.MathematicalProgram, constraint: pydrake.solvers.Binding[Constraint]) int
Removes
constraint
from this mathematical program. See remove_cost_constraint “Remove costs or constraints” for more details.- Returns
number of constraint objects removed from this program. If this program doesn’t contain
constraint
, then returns 0. If this program contains multipleconstraint
objects, then returns the repetition ofconstraint
in this program.
- RemoveCost(self: pydrake.solvers.MathematicalProgram, cost: pydrake.solvers.Binding[Cost]) int
Removes
cost
from this mathematical program. See remove_cost_constraint “Remove costs or constraints” for more details.- Returns
number of cost objects removed from this program. If this program doesn’t contain
cost
, then returns 0. If this program contains multiplecost
objects, then returns the repetition ofcost
in this program.
- Reparse(self: pydrake.solvers.MathematicalProgram, p: pydrake.symbolic.Polynomial) None
Reparses the polynomial
p
using this MathematicalProgram’s indeterminates.
- rotated_lorentz_cone_constraints(self: pydrake.solvers.MathematicalProgram) List[pydrake.solvers.Binding[RotatedLorentzConeConstraint]]
Getter for rotated Lorentz cone constraints.
- SetDecisionVariableValueInVector(*args, **kwargs)
Overloaded function.
SetDecisionVariableValueInVector(self: pydrake.solvers.MathematicalProgram, decision_variable: pydrake.symbolic.Variable, decision_variable_new_value: float, values: Optional[numpy.ndarray[numpy.float64[m, 1], flags.writeable]]) -> None
Updates the value of a single
decision_variable
inside thevalues
vector to bedecision_variable_new_value
. The other decision variables’ values invalues
are unchanged.- Parameter
decision_variable
: a registered decision variable in this program.
- Parameter
decision_variable_new_value
: the variable’s new values.
- Parameter
values
: The vector to be tweaked; must be of size num_vars().
SetDecisionVariableValueInVector(self: pydrake.solvers.MathematicalProgram, decision_variables: numpy.ndarray[object[m, n], flags.f_contiguous], decision_variables_new_values: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], values: Optional[numpy.ndarray[numpy.float64[m, 1], flags.writeable]]) -> None
Updates the values of some
decision_variables
inside thevalues
vector to bedecision_variables_new_values
. The other decision variables’ values invalues
are unchanged.- Parameter
decision_variables
: registered decision variables in this program.
- Parameter
decision_variables_new_values
: the variables’ respective new values; must have the same rows() and cols() sizes and
decision_variables
.- Parameter
values
: The vector to be tweaked; must be of size num_vars().
- SetInitialGuess(*args, **kwargs)
Overloaded function.
SetInitialGuess(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.symbolic.Variable, arg1: float) -> None
Sets the initial guess for a single variable
decision_variable
. The guess is stored as part of this program.- Precondition:
decision_variable is a registered decision variable in the program.
- Raises
RuntimeError if precondition is not satisfied. –
SetInitialGuess(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[object[m, n]], arg1: numpy.ndarray[numpy.float64[m, n]]) -> None
Sets the initial guess for the decision variables stored in
decision_variable_mat
to bex0
. The guess is stored as part of this program.
- SetInitialGuessForAllVariables(self: pydrake.solvers.MathematicalProgram, arg0: numpy.ndarray[numpy.float64[m, 1]]) None
Set the initial guess for ALL decision variables. Note that variables begin with a default initial guess of NaN to indicate that no guess is available.
- Parameter
x0
: A vector of appropriate size (num_vars() x 1).
- Parameter
- SetSolverOption(*args, **kwargs)
Overloaded function.
SetSolverOption(self: pydrake.solvers.MathematicalProgram, solver_id: pydrake.solvers.SolverId, solver_option: str, option_value: float) -> None
See set_solver_option for more details. Set the double-valued options.
SetSolverOption(self: pydrake.solvers.MathematicalProgram, solver_id: pydrake.solvers.SolverId, solver_option: str, option_value: int) -> None
See set_solver_option for more details. Set the integer-valued options.
SetSolverOption(self: pydrake.solvers.MathematicalProgram, solver_id: pydrake.solvers.SolverId, solver_option: str, option_value: str) -> None
See set_solver_option for more details. Set the string-valued options.
SetSolverOption(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.solvers.SolverType, arg1: str, arg2: float) -> None
See set_solver_option for more details. Set the double-valued options.
SetSolverOption(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.solvers.SolverType, arg1: str, arg2: int) -> None
See set_solver_option for more details. Set the integer-valued options.
SetSolverOption(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.solvers.SolverType, arg1: str, arg2: str) -> None
See set_solver_option for more details. Set the string-valued options.
- SetSolverOptions(self: pydrake.solvers.MathematicalProgram, arg0: pydrake.solvers.SolverOptions) None
Overwrite the stored solver options inside MathematicalProgram with the provided solver options.
- SetVariableScaling(self: pydrake.solvers.MathematicalProgram, var: pydrake.symbolic.Variable, s: float) None
Setter for the scaling
s
of decision variablevar
.- Parameter
var
: the decision variable to be scaled.
- Parameter
s
: scaling factor (must be positive).
See variable_scaling “Variable scaling” for more information.
- Parameter
- class pydrake.solvers.MathematicalProgramResult
The result returned by MathematicalProgram::Solve(). It stores the solvers::SolutionResult (whether the program is solved to optimality, detected infeasibility, etc), the optimal value for the decision variables, the optimal cost, and solver specific details.
- __init__(self: pydrake.solvers.MathematicalProgramResult) None
Constructs the result.
Note
The solver_details is set to nullptr.
- EvalBinding(self: pydrake.solvers.MathematicalProgramResult, arg0: pydrake.solvers.Binding[EvaluatorBase]) numpy.ndarray[numpy.float64[m, 1]]
Evaluate a Binding at the solution.
- Parameter
binding
: A binding between a constraint/cost and the variables.
- Precondition:
The binding.variables() must be the within the decision variables in the MathematicalProgram that generated this MathematicalProgramResult.
- Precondition:
The user must have called set_decision_variable_index() function.
- Parameter
- get_optimal_cost(self: pydrake.solvers.MathematicalProgramResult) float
Gets the optimal cost.
- get_solution_result(self: pydrake.solvers.MathematicalProgramResult) drake::solvers::SolutionResult
Gets SolutionResult.
- get_solver_details(self: pydrake.solvers.MathematicalProgramResult) object
Gets the solver details for the
Solver
that solved the program. Throws an error if the solver_details has not been set.
- get_solver_id(self: pydrake.solvers.MathematicalProgramResult) pydrake.solvers.SolverId
Gets the solver ID.
- get_suboptimal_objective(self: pydrake.solvers.MathematicalProgramResult, solution_number: int) float
Gets the suboptimal objective value. See solution_pools “solution pools”.
- Parameter
solution_number
: The index of the sub-optimal solution.
- Precondition:
solution_number
should be in the range [0, num_suboptimal_solution()).
- Parameter
- get_x_val(self: pydrake.solvers.MathematicalProgramResult) numpy.ndarray[numpy.float64[m, 1]]
Gets the decision variable values.
- GetDualSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: pydrake.solvers.Binding[EvaluatorBase]) numpy.ndarray[numpy.float64[m, 1]]
Gets the dual solution associated with a constraint.
For constraints in the form lower <= f(x) <= upper (including linear inequality, linear equality, bounding box constraints, and general nonlinear constraints), we interpret the dual variable value as the “shadow price” of the original problem. Namely if we change the constraint bound by one unit (each unit is infinitesimally small), the change of the optimal cost is the value of the dual solution times the unit. Mathematically dual_solution = ∂optimal_cost / ∂bound.
For a linear equality constraint Ax = b where b ∈ ℝⁿ, the vector of dual variables has n rows, and dual_solution(i) is the value of the dual variable for the constraint A(i,:)*x = b(i).
For a linear inequality constraint lower <= A*x <= upper where lower and upper ∈ ℝⁿ, dual_solution also has n rows. dual_solution(i) is the value of the dual variable for constraint lower(i) <= A(i,:)*x <= upper(i). If neither side of the constraint is active, then dual_solution(i) is 0. If the left hand-side lower(i) <= A(i, :)*x is active (meaning lower(i) = A(i, :)*x at the solution), then dual_solution(i) is non-negative (because the objective is to minimize a cost, increasing the lower bound means the constraint set is tighter, hence the optimal solution cannot decrease. Thus the shadow price is non-negative). If the right hand-side A(i, :)*x<=upper(i) is active (meaning A(i,:)*x=upper(i) at the solution), then dual_solution(i) is non-positive.
For a bounding box constraint lower <= x <= upper, the interpretation of the dual solution is the same as the linear inequality constraint.
For a Lorentz cone or rotated Lorentz cone constraint that Ax + b is in the cone, depending on the solver, the dual solution has different meanings: 1. If the solver is Gurobi, then the user can only obtain the dual solution by explicitly setting the options for computing dual solution.
auto constraint = prog.AddLorentzConeConstraint(...); GurobiSolver solver; // Explicitly tell the solver to compute the dual solution for Lorentz // cone or rotated Lorentz cone constraint, check // https://www.gurobi.com/documentation/9.5/refman/qcpdual.html for // more information. SolverOptions options; options.SetOption(GurobiSolver::id(), "QCPDual", 1); MathematicalProgramResult result = solver.Solve(prog, {}, options); Eigen::VectorXd dual_solution = result.GetDualSolution(constraint);
The dual solution has size 1, dual_solution(0) is the shadow price for the constraint z₁² + … +zₙ² ≤ z₀² for Lorentz cone constraint, and the shadow price for the constraint z₂² + … +zₙ² ≤ z₀z₁ for rotated Lorentz cone constraint, where z is the slack variable representing z = A*x+b and z in the Lorentz cone/rotated Lorentz cone. 2. For nonlinear solvers like IPOPT, the dual solution for Lorentz cone constraint (with EvalType::kConvex) is the shadow price for z₀ - sqrt(z₁² + … +zₙ²) ≥ 0, where z = Ax+b. 3. For other convex conic solver such as SCS, MOSEK™, CSDP, etc, the dual solution to the (rotated) Lorentz cone constraint doesn’t have the “shadow price” interpretation, but should lie in the dual cone, and satisfy the KKT condition. For more information, refer to https://docs.mosek.com/10.0/capi/prob-def-conic.html#duality-for-conic-optimization as an explanation.
The interpretation for the dual variable to conic constraint x ∈ K can be different. Here K is a convex cone, including exponential cone, power cone, psd cone, etc. When the problem is solved by a convex solver (like SCS, MOSEK™, CSDP, etc), often it has a dual variable z ∈ K*, where K* is the dual cone. Here the dual variable DOESN’T have the interpretation of “shadow price”, but should satisfy the KKT condition, while the dual variable stays inside the dual cone.
When K is a psd cone, the returned dual solution is the lower triangle of the dual symmetric psd matrix. Namely for the primal problem
min trace(C*X) s.t A(X) = b X is psd
the dual is
max b’*y s.t A’(y) - C = Z Z is psd.
We return the lower triangular part of Z. You can call drake::math::ToSymmetricMatrixFromLowerTriangularColumns to get the matrix Z.
- GetInfeasibleConstraintNames(self: pydrake.solvers.MathematicalProgramResult, prog: drake::solvers::MathematicalProgram, tol: Optional[float] = None) List[str]
See get_infeasible_constraints for more information.
- Parameter
prog
: The MathematicalProgram that was solved to obtain
this
MathematicalProgramResult.- Parameter
tolerance
: A positive tolerance to check the constraint violation. If no tolerance is provided, this method will attempt to obtain the constraint tolerance from the solver, or insert a conservative default tolerance.
Note: Currently most constraints have the empty string as the description, so the NiceTypeName of the Constraint is used instead. Use e.g.
prog.AddConstraint(x == 1).evaluator().set_description(str)
to make this method more specific/useful.- Parameter
- GetInfeasibleConstraints(self: pydrake.solvers.MathematicalProgramResult, prog: drake::solvers::MathematicalProgram, tol: Optional[float] = None) List[pydrake.solvers.Binding[Constraint]]
See get_infeasible_constraints for more information.
- Parameter
prog
: The MathematicalProgram that was solved to obtain
this
MathematicalProgramResult.- Parameter
tolerance
: A positive tolerance to check the constraint violation. If no tolerance is provided, this method will attempt to obtain the constraint tolerance from the solver, or insert a conservative default tolerance.
- Returns
infeasible_bindings A vector of all infeasible bindings (constraints together with the associated variables) at the best-effort solution.
- Parameter
- GetSolution(*args, **kwargs)
Overloaded function.
GetSolution(self: pydrake.solvers.MathematicalProgramResult) -> numpy.ndarray[numpy.float64[m, 1]]
Gets the solution of all decision variables.
GetSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: pydrake.symbolic.Variable) -> float
Gets the solution of a single decision variable.
- Parameter
var
: The decision variable.
- Returns
The value of the decision variable after solving the problem.
- Raises
RuntimeError if var is not captured in the mapping –
decision_variable_index`, as the input argument o –
set_decision_variable_index() –
GetSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: numpy.ndarray[object[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]
Gets the solution of an Eigen matrix of decision variables.
- Template parameter
Derived
: An Eigen matrix containing Variable.
- Parameter
var
: The decision variables.
- Returns
The value of the decision variable after solving the problem.
GetSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: numpy.ndarray[object[m, n]]) -> numpy.ndarray[numpy.float64[m, n]]
Gets the solution of an Eigen matrix of decision variables.
- Template parameter
Derived
: An Eigen matrix containing Variable.
- Parameter
var
: The decision variables.
- Returns
The value of the decision variable after solving the problem.
GetSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: pydrake.symbolic.Expression) -> pydrake.symbolic.Expression
Substitutes the value of all decision variables into the Expression.
- Parameter
e
: The decision variable.
- Returns
the Expression that is the result of the substitution.
GetSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: pydrake.symbolic.Polynomial) -> pydrake.symbolic.Polynomial
Substitutes the value of all decision variables into the coefficients of the symbolic polynomial.
- Parameter
p
: A symbolic polynomial. Its indeterminates can’t intersect with the set of decision variables of the MathematicalProgram from which this result is obtained.
- Returns
the symbolic::Polynomial as the result of the substitution.
GetSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: numpy.ndarray[object[m, n]]) -> numpy.ndarray[object[m, n]]
- GetSuboptimalSolution(*args, **kwargs)
Overloaded function.
GetSuboptimalSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: pydrake.symbolic.Variable, arg1: int) -> float
Gets the suboptimal solution of a decision variable. See solution_pools “solution pools”
- Parameter
var
: The decision variable.
- Parameter
solution_number
: The index of the sub-optimal solution.
- Precondition:
solution_number
should be in the range [0, num_suboptimal_solution()).
- Returns
The suboptimal value of the decision variable after solving the problem.
GetSuboptimalSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: numpy.ndarray[object[m, 1]], arg1: int) -> numpy.ndarray[numpy.float64[m, 1]]
@name Solution Pools Some solvers (like Gurobi, Cplex, etc) can store a pool of (suboptimal) solutions for mixed integer programming model. Gets the suboptimal solution corresponding to a matrix of decision variables. See solution_pools “solution pools”
- Parameter
var
: The decision variables.
- Parameter
solution_number
: The index of the sub-optimal solution.
- Precondition:
solution_number
should be in the range [0, num_suboptimal_solution()).
- Returns
The suboptimal values of the decision variables after solving the problem.
GetSuboptimalSolution(self: pydrake.solvers.MathematicalProgramResult, arg0: numpy.ndarray[object[m, n]], arg1: int) -> numpy.ndarray[numpy.float64[m, n]]
@name Solution Pools Some solvers (like Gurobi, Cplex, etc) can store a pool of (suboptimal) solutions for mixed integer programming model. Gets the suboptimal solution corresponding to a matrix of decision variables. See solution_pools “solution pools”
- Parameter
var
: The decision variables.
- Parameter
solution_number
: The index of the sub-optimal solution.
- Precondition:
solution_number
should be in the range [0, num_suboptimal_solution()).
- Returns
The suboptimal values of the decision variables after solving the problem.
- is_success(self: pydrake.solvers.MathematicalProgramResult) bool
Returns true if the optimization problem is solved successfully; false otherwise. For more information on the solution status, the user could call get_solver_details() to obtain the solver-specific solution status.
- num_suboptimal_solution(self: pydrake.solvers.MathematicalProgramResult) int
Number of suboptimal solutions stored inside MathematicalProgramResult. See solution_pools “solution pools”.
- set_solution_result(self: pydrake.solvers.MathematicalProgramResult, arg0: drake::solvers::SolutionResult) None
Sets SolutionResult.
- set_x_val(self: pydrake.solvers.MathematicalProgramResult, x_val: numpy.ndarray[numpy.float64[m, 1]]) None
Sets the decision variable values.
- class pydrake.solvers.MixedIntegerBranchAndBound
Given a mixed-integer optimization problem (MIP) (or more accurately, mixed binary problem), solve this problem through branch-and-bound process. We will first replace all the binary variables with continuous variables, and relax the integral constraint on the binary variables z ∈ {0, 1} with continuous constraints 0 ≤ z ≤ 1. In the subsequent steps, at each node of the tree, we will fix some binary variables to either 0 or 1, and solve the rest of the variables. Notice that we will create a new set of variables in the branch-and-bound process, since we need to replace the binary variables with continuous variables.
- __init__(self: pydrake.solvers.MixedIntegerBranchAndBound, prog: pydrake.solvers.MathematicalProgram, solver_id: pydrake.solvers.SolverId) None
Construct a branch-and-bound tree from a mixed-integer optimization program.
- Parameter
prog
: A mixed-integer optimization program.
- Parameter
solver_id
: The ID of the solver for the optimization.
- Parameter
- GetOptimalCost(self: pydrake.solvers.MixedIntegerBranchAndBound) float
Get the optimal cost.
- GetSolution(*args, **kwargs)
Overloaded function.
GetSolution(self: pydrake.solvers.MixedIntegerBranchAndBound, mip_var: pydrake.symbolic.Variable, nth_best_solution: int = 0) -> float
Get the n’th best integral solution for a variable. The best solutions are sorted in the ascending order based on their costs. Each solution is found in a separate node in the branch-and-bound tree, so the values of the binary variables are different in each solution.
- Parameter
mip_var
: A variable in the original MIP.
- Parameter
nth_best_solution
: . The index of the best integral solution.
- Precondition:
mip_var
is a variable in the original MIP.- Precondition:
nth_best_solution
is between 0 and solutions().size().
- Raises
RuntimeError if the preconditions are not satisfied. –
GetSolution(self: pydrake.solvers.MixedIntegerBranchAndBound, mip_vars: numpy.ndarray[object[m, 1]], nth_best_solution: int = 0) -> numpy.ndarray[numpy.float64[m, 1]]
Get the n’th best integral solution for some variables. The best solutions are sorted in the ascending order based on their costs. Each solution is found in a separate node in the branch-and-bound tree, so
- Parameter
mip_vars
: Variables in the original MIP.
- Parameter
nth_best_solution
: . The index of the best integral solution.
- Precondition:
mip_vars
are variables in the original MIP.- Precondition:
nth_best_solution
is between 0 and solutions().size().
- Raises
RuntimeError if the preconditions are not satisfied. –
GetSolution(self: pydrake.solvers.MixedIntegerBranchAndBound, mip_vars: numpy.ndarray[object[m, n]], nth_best_solution: int = 0) -> numpy.ndarray[numpy.float64[m, n]]
Get the n’th best integral solution for some variables. The best solutions are sorted in the ascending order based on their costs. Each solution is found in a separate node in the branch-and-bound tree, so
- Parameter
mip_vars
: Variables in the original MIP.
- Parameter
nth_best_solution
: . The index of the best integral solution.
- Precondition:
mip_vars
are variables in the original MIP.- Precondition:
nth_best_solution
is between 0 and solutions().size().
- Raises
RuntimeError if the preconditions are not satisfied. –
- GetSubOptimalCost(self: pydrake.solvers.MixedIntegerBranchAndBound, nth_suboptimal_cost: int) float
Get the n’th sub-optimal cost. The costs are sorted in the ascending order. The sub-optimal costs do not include the optimal cost.
- Parameter
nth_suboptimal_cost
: The n’th sub-optimal cost.
- Precondition:
nth_suboptimal_cost
is between 0 and solutions().size() - 1.
- Raises
RuntimeError if the precondition is not satisfied. –
- Parameter
- Solve(self: pydrake.solvers.MixedIntegerBranchAndBound) pydrake.solvers.SolutionResult
Solve the mixed-integer problem (MIP) through a branch and bound process.
- Returns
solution_result
: If solution_result=SolutionResult::kSolutionFound, then the best solutions are stored inside solutions(). The user can access the value of each variable(s) through GetSolution(…). If solution_result=SolutionResult::kInfeasibleConstraints, then the mixed-integer problem is primal infeasible. If solution_result=SolutionResult::kUnbounded, then the mixed-integer problem is primal unbounded.
- Returns
- class pydrake.solvers.MixedIntegerRotationConstraintGenerator
We relax the non-convex SO(3) constraint on rotation matrix R to mixed-integer linear constraints. The formulation of these constraints are described in Global Inverse Kinematics via Mixed-integer Convex Optimization by Hongkai Dai, Gregory Izatt and Russ Tedrake, ISRR, 2017
The SO(3) constraint on a rotation matrix R = [r₁, r₂, r₃], rᵢ∈ℝ³ is
rᵢᵀrᵢ = 1 (1) rᵢᵀrⱼ = 0 (2) r₁ x r₂ = r₃ (3)
To relax SO(3) constraint on rotation matrix R, we divide the range [-1, 1] (the range of each entry in R) into smaller intervals [φ(i), φ(i+1)], and then relax the SO(3) constraint within each interval. We provide 3 approaches for relaxation 1. By replacing each bilinear product in constraint (1), (2) and (3) with a new variable, in the McCormick envelope of the bilinear product w = x * y. 2. By considering the intersection region between axis-aligned boxes, and the surface of a unit sphere in 3D. 3. By combining the two approaches above. This will result in a tighter relaxation.
These three approaches give different relaxation of SO(3) constraint (the feasible sets for each relaxation are different), and different computation speed. The users can switch between the approaches to find the best fit for their problem.
Note
If you have several rotation matrices that all need to be relaxed through mixed-integer constraint, then you can create a single MixedIntegerRotationConstraintGenerator object, and add the mixed-integer constraint to each rotation matrix, by calling AddToProgram() function repeatedly.
- __init__(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator, approach: pydrake.solvers.MixedIntegerRotationConstraintGenerator.Approach, num_intervals_per_half_axis: int, interval_binning: pydrake.solvers.IntervalBinning) None
Constructor
- Parameter
approach
: Refer to MixedIntegerRotationConstraintGenerator::Approach for the details.
- Parameter
num_intervals_per_half_axis
: We will cut the range [-1, 1] evenly to 2 *
num_intervals_per_half_axis
small intervals. The number of binary variables will depend on the number of intervals.- Parameter
interval_binning
: The binning scheme we use to add SOS2 constraint with binary variables. If interval_binning = kLinear, then we will add 9 * 2 *
num_intervals_per_half_axis binary
variables; if interval_binning = kLogarithmic, then we will add 9 * (1 + log₂(num_intervals_per_half_axis)) binary variables. Refer to AddLogarithmicSos2Constraint and AddSos2Constraint for more details.
- Parameter
- AddToProgram(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator, R: numpy.ndarray[object[3, 3], flags.f_contiguous], prog: pydrake.solvers.MathematicalProgram) pydrake.solvers.MixedIntegerRotationConstraintGenerator.ReturnType
Add the mixed-integer linear constraints to the optimization program, as a relaxation of SO(3) constraint on the rotation matrix
R
.- Parameter
R
: The rotation matrix on which the SO(3) constraint is imposed.
- Parameter
prog
: The optimization program to which the mixed-integer constraints (and additional variables) are added.
- Parameter
- class Approach
Members:
kBoxSphereIntersection : Relax SO(3) constraint by considering the intersection between boxes
and the unit sphere surface.
kBilinearMcCormick : Relax SO(3) constraint by considering the McCormick envelope on the
bilinear product.
kBoth : Relax SO(3) constraint by considering both the intersection between
boxes and the unit sphere surface, and the McCormick envelope on the bilinear product.
- __init__(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator.Approach, value: int) None
- kBilinearMcCormick = <Approach.kBilinearMcCormick: 1>
- kBoth = <Approach.kBoth: 2>
- kBoxSphereIntersection = <Approach.kBoxSphereIntersection: 0>
- property name
- property value
- interval_binning(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator) pydrake.solvers.IntervalBinning
- num_intervals_per_half_axis(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator) int
- phi(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator) numpy.ndarray[numpy.float64[m, 1]]
Getter for φ.
- phi_nonnegative(self: pydrake.solvers.MixedIntegerRotationConstraintGenerator) numpy.ndarray[numpy.float64[m, 1]]
Getter for φ₊, the non-negative part of φ.
- class ReturnType
- __init__(*args, **kwargs)
- property B_
B_ contains the new binary variables added to the program. B_`i][j] represents in which interval R(i, j) lies. If we use linear binning, then B_[i][j] is of length 2 * num_intervals_per_half_axis_. B_[i][j <k>`_ = 1 => φ(k) ≤ R(i, j) ≤ φ(k + 1) B_`i][j <k>`_ = 0 => R(i, j) ≥ φ(k + 1) or R(i, j) ≤ φ(k) If we use logarithmic binning, then B_[i][j] is of length 1 + log₂(num_intervals_per_half_axis_). If B_[i][j] represents integer k in reflected Gray code, then R(i, j) is in the interval [φ(k), φ(k+1)].
- property lambda_
λ contains part of the new continuous variables added to the program. λ_`i][j] is of length 2 * num_intervals_per_half_axis_ + 1, such that R(i, j) = φᵀ * λ_[i][j]. Notice that λ_[i][j] satisfies the special ordered set of type 2 (SOS2) constraint. Namely at most two entries in λ_[i][j] can be strictly positive, and these two entries have to be consecutive. Mathematically
∑ₖ λ_[i][j <k>`_ = 1 λ_`i][j <k>`_ ≥ 0 ∀ k ∃ m s.t λ_`i][j <n>`_ = 0 if n ≠ m and n ≠ m+1
- class pydrake.solvers.MosekSolver
Bases:
pydrake.solvers.SolverInterface
An implementation of SolverInterface for the commercially-licensed MOSEK™ solver (https://www.mosek.com/).
The default build of Drake is not configured to use MOSEK™, so therefore SolverInterface::available() will return false. You must compile Drake from source in order to link against MOSEK™. For details, refer to the documentation at https://drake.mit.edu/bazel.html#mosek.
The MOSEKLM_LICENSE_FILE environment variable controls whether or not SolverInterface::enabled() returns true. Iff it is set to any non-empty value, then the solver is enabled; otherwise, the solver is not enabled.
Note
MOSEK™ only cares about the initial guess of integer variables. The initial guess of continuous variables are not passed to MOSEK™. If all the integer variables are set to some integer values, then MOSEK™ will be forced to compute the remaining continuous variable values as the initial guess. (MOSEK™ might change the values of the integer/binary variables in the subsequent iterations.) If the specified integer solution is infeasible or incomplete, MOSEK™ will simply ignore it. For more details, check https://docs.mosek.com/10.0/capi/tutorial-mio-shared.html?highlight=initial
MOSEK™ supports many solver parameters. You can refer to the full list of parameters in https://docs.mosek.com/10.0/capi/param-groups.html#doc-param-groups. On top of these parameters, we also provide the following additional parameters 1. “writedata”, set to a file name so that MOSEK™ solver will write the optimization model to this file. check https://docs.mosek.com/10.0/capi/solver-io.html#saving-a-problem-to-a-file for more details. The supported file extensions are listed in https://docs.mosek.com/10.0/capi/supported-file-formats.html#doc-shared-file-formats. Set this parameter to “” if you don’t want to write to a file. Default is not to write to a file.
- __init__(self: pydrake.solvers.MosekSolver) None
- static AcquireLicense() pydrake.solvers.MosekSolver.License
This acquires a MOSEK™ license environment shared among all MosekSolver instances; the environment will stay valid as long as at least one shared_ptr returned by this function is alive. Call this ONLY if you must use different MathematicalProgram instances at different instances in time, and repeatedly acquiring the license is costly (e.g., requires contacting a license server).
- static id() pydrake.solvers.SolverId
- class License
Context-manageable license from
MosekSolver.AcquireLicense()
.- __init__(*args, **kwargs)
- is_valid(self: pydrake.solvers.MosekSolver.License) bool
Indicates that this has a valid license that has not been released.
- class pydrake.solvers.MosekSolverDetails
The MOSEK™ solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<MosekSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property optimizer_time
The MOSEK™ optimization time. Please refer to MSK_DINF_OPTIMIZER_TIME in https://docs.mosek.com/10.0/capi/constants.html?highlight=msk_dinf_optimizer_time
- property rescode
The response code returned from MOSEK™ solver. Check https://docs.mosek.com/10.0/capi/response-codes.html for the meaning on the response code.
- property solution_status
The solution status after solving the problem. Check https://docs.mosek.com/10.0/capi/accessing-solution.html and https://docs.mosek.com/10.0/capi/constants.html#mosek.solsta for the meaning on the solution status.
- class pydrake.solvers.NloptSolver
Bases:
pydrake.solvers.SolverInterface
- __init__(self: pydrake.solvers.NloptSolver) None
- static AlgorithmName() str
The key name for the string-valued algorithm.
- static ConstraintToleranceName() str
The key name for the double-valued constraint tolerance.
- static id() pydrake.solvers.SolverId
- static MaxEvalName() str
The key name for int-valued maximum number of evaluations.
- static XAbsoluteToleranceName() str
The key name for double-valued x absolute tolerance.
- static XRelativeToleranceName() str
The key name for double-valued x relative tolerance.
- class pydrake.solvers.NloptSolverDetails
The NLopt solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<NloptSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property status
The return status of NLopt solver. Please refer to https://nlopt.readthedocs.io/en/latest/NLopt_Reference/#return-values.
- class pydrake.solvers.OsqpSolver
Bases:
pydrake.solvers.SolverInterface
- __init__(self: pydrake.solvers.OsqpSolver) None
- static id() pydrake.solvers.SolverId
- class pydrake.solvers.OsqpSolverDetails
The OSQP solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<OsqpSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property dual_res
Norm of dual residue.
- property iter
Number of iterations taken.
- property polish_time
Time taken for polish phase (seconds).
- property primal_res
Norm of primal residue.
- property run_time
Total OSQP time (seconds).
- property setup_time
Time taken for setup phase (seconds).
- property solve_time
Time taken for solve phase (seconds).
- property status_val
Status of the solver at termination. Please refer to https://github.com/oxfordcontrol/osqp/blob/master/include/constants.h
- property y
y contains the solution for the Lagrangian multiplier associated with l <= Ax <= u. The Lagrangian multiplier is set only when OSQP solves the problem. Notice that the order of the linear constraints are linear inequality first, and then linear equality constraints.
- class pydrake.solvers.PerspectiveQuadraticCost
Bases:
pydrake.solvers.Cost
If z = Ax + b, implements a cost of the form: (z_1^2 + z_2^2 + … + z_{n-1}^2) / z_0. Note that this cost is convex when we additionally constrain z_0 > 0. It is treated as a generic nonlinear objective by most solvers.
- __init__(self: pydrake.solvers.PerspectiveQuadraticCost, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]]) None
Construct a cost of the form (z_1^2 + z_2^2 + … + z_{n-1}^2) / z_0 where z = Ax + b.
- Parameter
A
: Linear term.
- Parameter
b
: Constant term.
- Parameter
- A(self: pydrake.solvers.PerspectiveQuadraticCost) numpy.ndarray[numpy.float64[m, n]]
- b(self: pydrake.solvers.PerspectiveQuadraticCost) numpy.ndarray[numpy.float64[m, 1]]
- UpdateCoefficients(self: pydrake.solvers.PerspectiveQuadraticCost, new_A: numpy.ndarray[numpy.float64[m, n]], new_b: numpy.ndarray[numpy.float64[m, 1]]) None
Updates the coefficients of the cost. Note that the number of variables (columns of A) cannot change.
- Parameter
new_A
: New linear term.
- Parameter
new_b
: New constant term.
- Parameter
- class pydrake.solvers.PositiveSemidefiniteConstraint
Bases:
pydrake.solvers.Constraint
Implements a positive semidefinite constraint on a symmetric matrix S
\[\text{ S is p.s.d\]}
namely, all eigen values of S are non-negative.
- __init__(self: pydrake.solvers.PositiveSemidefiniteConstraint, rows: int) None
Impose the constraint that a symmetric matrix with size
rows
xrows
is positive semidefinite.See also
MathematicalProgram::AddPositiveSemidefiniteConstraint() for how to use this constraint on some decision variables. We currently use this constraint as a place holder in MathematicalProgram, to indicate the positive semidefiniteness of some decision variables.
- Parameter
rows
: The number of rows (and columns) of the symmetric matrix.
Example:
// Create a MathematicalProgram object. auto prog = MathematicalProgram(); // Add a 2 x 2 symmetric matrix S to optimization program as new decision // variables. auto S = prog.NewSymmetricContinuousVariables<2>("S"); // Impose a positive semidefinite constraint on S. std::shared_ptr<PositiveSemidefiniteConstraint> psd_constraint = prog.AddPositiveSemidefiniteConstraint(S); ///////////////////////////////////////////////////////////// // Add more constraints to make the program more interesting, // but this is not needed. // Add the constraint that S(1, 0) = 1. prog.AddBoundingBoxConstraint(1, 1, S(1, 0)); // Minimize S(0, 0) + S(1, 1). prog.AddLinearCost(Eigen::RowVector2d(1, 1), {S.diagonal()}); ///////////////////////////////////////////////////////////// // Now solve the program. auto result = Solve(prog); // Retrieve the solution of matrix S. auto S_value = GetSolution(S, result); // Compute the eigen values of the solution, to see if they are // all non-negative. Eigen::Vector4d S_stacked; S_stacked << S_value.col(0), S_value.col(1); Eigen::VectorXd S_eigen_values; psd_constraint->Eval(S_stacked, S_eigen_values); std::cout<<"S solution is: " << S << std::endl; std::cout<<"The eigen value of S is " << S_eigen_values << std::endl;
- Parameter
- matrix_rows(self: pydrake.solvers.PositiveSemidefiniteConstraint) int
- class pydrake.solvers.ProgramType
A coarse categorization of the optimization problem based on the type of constraints/costs/variables. Notice that Drake chooses the solver based on a finer category; for example we have a specific solver for equality-constrained convex QP.
Members:
kLP : Linear Programming, with a linear cost and linear constraints.
kQP : Quadratic Programming, with a convex quadratic cost and linear
constraints.
kSOCP : Second-order Cone Programming, with a linear cost and second-order
cone constraints.
kSDP : Semidefinite Programming, with a linear cost and positive semidefinite
matrix constraints.
kGP : Geometric Programming, with a linear cost and exponential cone
constraints.
kCGP : Conic Geometric Programming, this is a superset that unifies GP and
SDP. Refer to http://people.lids.mit.edu/pari/cgp_preprint.pdf for more details.
kMILP : Mixed-integer Linear Programming. LP with some variables taking binary
values.
kMIQP : Mixed-integer Quadratic Programming. QP with some variables taking
binary values.
kMISOCP : Mixed-integer Second-order Cone Programming. SOCP with some variables
taking binary values.
kMISDP : Mixed-integer Semidefinite Programming. SDP with some variables taking
binary values.
kQuadraticCostConicConstraint : convex quadratic cost with nonlinear conic constraints.
kNLP : nonlinear programming. Programs with generic costs or constraints.
kLCP : Linear Complementarity Programs. Programs with linear complementary
constraints and no cost.
kUnknown : Does not fall into any of the types above.
- __init__(self: pydrake.solvers.ProgramType, value: int) None
- kCGP = <ProgramType.kCGP: 5>
- kGP = <ProgramType.kGP: 4>
- kLCP = <ProgramType.kLCP: 12>
- kLP = <ProgramType.kLP: 0>
- kMILP = <ProgramType.kMILP: 6>
- kMIQP = <ProgramType.kMIQP: 7>
- kMISDP = <ProgramType.kMISDP: 9>
- kMISOCP = <ProgramType.kMISOCP: 8>
- kNLP = <ProgramType.kNLP: 11>
- kQP = <ProgramType.kQP: 1>
- kQuadraticCostConicConstraint = <ProgramType.kQuadraticCostConicConstraint: 10>
- kSDP = <ProgramType.kSDP: 3>
- kSOCP = <ProgramType.kSOCP: 2>
- kUnknown = <ProgramType.kUnknown: 13>
- property name
- property value
- class pydrake.solvers.PyFunctionConstraint
Bases:
pydrake.solvers.Constraint
Constraint with its evaluator as a Python function
- __init__(*args, **kwargs)
- set_bounds(self: pydrake.solvers.PyFunctionConstraint, lower_bound: numpy.ndarray[numpy.float64[m, 1]], upper_bound: numpy.ndarray[numpy.float64[m, 1]]) None
Set both the lower and upper bounds of the constraint.
- UpdateLowerBound(self: pydrake.solvers.PyFunctionConstraint, new_lb: numpy.ndarray[numpy.float64[m, 1]]) None
Update the lower bound of the constraint.
- UpdateUpperBound(self: pydrake.solvers.PyFunctionConstraint, new_ub: numpy.ndarray[numpy.float64[m, 1]]) None
Update the upper bound of the constraint.
- class pydrake.solvers.QuadraticConstraint
Bases:
pydrake.solvers.Constraint
lb ≤ .5 xᵀQx + bᵀx ≤ ub Without loss of generality, the class stores a symmetric matrix Q. For a non-symmetric matrix Q₀, we can define Q = (Q₀ + Q₀ᵀ) / 2, since xᵀQ₀x = xᵀQ₀ᵀx = xᵀ*(Q₀+Q₀ᵀ)/2 *x. The first equality holds because the transpose of a scalar is the scalar itself. Hence we can always convert a non-symmetric matrix Q₀ to a symmetric matrix Q.
- __init__(self: pydrake.solvers.QuadraticConstraint, Q0: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], b: numpy.ndarray[numpy.float64[m, 1]], lb: float, ub: float) None
Construct a quadratic constraint.
- Template parameter
DerivedQ
: The type for Q.
- Template parameter
Derivedb
: The type for b.
- Parameter
Q0
: The square matrix. Notice that Q₀ does not have to be symmetric.
- Parameter
b
: The linear coefficient.
- Parameter
lb
: The lower bound.
- Parameter
ub
: The upper bound.
- Template parameter
- b(self: pydrake.solvers.QuadraticConstraint) numpy.ndarray[numpy.float64[m, 1]]
- Q(self: pydrake.solvers.QuadraticConstraint) numpy.ndarray[numpy.float64[m, n]]
The symmetric matrix Q, being the Hessian of this constraint.
- class pydrake.solvers.QuadraticCost
Bases:
pydrake.solvers.Cost
Implements a cost of the form
\[.5 x'Qx + b'x + c\].
- __init__(self: pydrake.solvers.QuadraticCost, Q: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]], c: float, is_convex: Optional[bool] = None) None
Constructs a cost of the form
\[.5 x'Qx + b'x + c\].
- Parameter
Q
: Quadratic term.
- Parameter
b
: Linear term.
- Parameter
c
: (optional) Constant term.
- Parameter
is_hessian_psd
: (optional) Indicates if the Hessian matrix Q is positive semidefinite (psd) or not. If set to true, then the user guarantees that Q is psd; if set to false, then the user guarantees that Q is not psd. If set to std::nullopt, then the constructor will check if Q is psd or not. The default is std::nullopt. To speed up the constructor, set is_hessian_psd to either true or false.
- Parameter
- b(self: pydrake.solvers.QuadraticCost) numpy.ndarray[numpy.float64[m, 1]]
- c(self: pydrake.solvers.QuadraticCost) float
- is_convex(self: pydrake.solvers.QuadraticCost) bool
Returns true if this cost is convex. A quadratic cost if convex if and only if its Hessian matrix Q is positive semidefinite.
- Q(self: pydrake.solvers.QuadraticCost) numpy.ndarray[numpy.float64[m, n]]
Returns the symmetric matrix Q, as the Hessian of the cost.
- UpdateCoefficients(self: pydrake.solvers.QuadraticCost, new_Q: numpy.ndarray[numpy.float64[m, n]], new_b: numpy.ndarray[numpy.float64[m, 1]], new_c: float = 0, is_convex: Optional[bool] = None) None
Updates the quadratic and linear term of the constraint. The new matrices need to have the same dimension as before.
- Parameter
new_Q
: New quadratic term.
- Parameter
new_b
: New linear term.
- Parameter
new_c
: (optional) New constant term.
- Parameter
is_hessian_psd
: (optional) Indicates if the Hessian matrix Q is positive semidefinite (psd) or not. If set to true, then the user guarantees that Q is psd; if set to false, then the user guarantees that Q is not psd. If set to std::nullopt, then this function will check if Q is psd or not. The default is std::nullopt. To speed up the computation, set is_hessian_psd to either true or false.
- Parameter
- class pydrake.solvers.RemoveFreeVariableMethod
SDPA format doesn’t accept free variables, namely the problem it solves is in this form P1
max tr(C * X) s.t tr(Aᵢ*X) = aᵢ X ≽ 0.
Notice that the decision variable X has to be in the proper cone X ≽ 0, and it doesn’t accept free variable (without the conic constraint). On the other hand, most real-world applications require free variables, namely problems in this form P2
max tr(C * X) + dᵀs s.t tr(Aᵢ*X) + bᵢᵀs = aᵢ X ≽ 0 s is free.
In order to remove the free variables, we consider three approaches. 1. Replace a free variable s with two variables s = p - q, p ≥ 0, q ≥ 0. 2. First write the dual of the problem P2 as D2
min aᵀy s.t ∑ᵢ yᵢAᵢ - C = Z Z ≽ 0 Bᵀ * y = d,
where bᵢᵀ is the i’th row of B. The last constraint Bᵀ * y = d means y = ŷ + Nt, where Bᵀ * ŷ = d, and N is the null space of Bᵀ. Hence, D2 is equivalent to the following problem, D3
min aᵀNt + aᵀŷ s.t ∑ᵢ tᵢFᵢ - (C -∑ᵢ ŷᵢAᵢ) = Z Z ≽ 0,
where Fᵢ = ∑ⱼ NⱼᵢAⱼ. D3 is the dual of the following primal problem P3 without free variables
max tr((C-∑ᵢ ŷᵢAᵢ)*X̂) + aᵀŷ s.t tr(FᵢX̂) = (Nᵀa)(i) X̂ ≽ 0.
Then (X, s) = (X̂, B⁻¹(a - tr(Aᵢ X̂))) is the solution to the original problem P2. 3. Add a slack variable t, with the Lorentz cone constraint t ≥ sqrt(sᵀs).
Members:
kNullspace : Approach 2, reformulate the dual problem by considering the nullspace
of the linear constraint in the dual.
kTwoSlackVariables : Approach 1, replace a free variable s as s = y⁺ - y⁻, y⁺ ≥ 0, y⁻ ≥ 0.
kLorentzConeSlack : Approach 3, add a slack variable t with the lorentz cone constraint t
≥ sqrt(sᵀs).
- __init__(self: pydrake.solvers.RemoveFreeVariableMethod, value: int) None
- kLorentzConeSlack = <RemoveFreeVariableMethod.kLorentzConeSlack: 3>
- kNullspace = <RemoveFreeVariableMethod.kNullspace: 2>
- kTwoSlackVariables = <RemoveFreeVariableMethod.kTwoSlackVariables: 1>
- property name
- property value
- class pydrake.solvers.RotatedLorentzConeConstraint
Bases:
pydrake.solvers.Constraint
Constraining that the linear expression \(z=Ax+b\) lies within rotated Lorentz cone. A vector z ∈ ℝ ⁿ lies within rotated Lorentz cone, if
\[z_0 \ge 0\\]z_1 ge 0z_0 z_1 ge z_2^2 + z_3^2 + … + z_{n-1}^2
where A ∈ ℝ ⁿˣᵐ, b ∈ ℝ ⁿ are given matrices.
For more information and visualization, please refer to https://docs.mosek.com/modeling-cookbook/cqo.html (Fig 3.1)
- __init__(self: pydrake.solvers.RotatedLorentzConeConstraint, A: numpy.ndarray[numpy.float64[m, n]], b: numpy.ndarray[numpy.float64[m, 1]]) None
- A(self: pydrake.solvers.RotatedLorentzConeConstraint) scipy.sparse.csc_matrix[numpy.float64]
Getter for A.
- b(self: pydrake.solvers.RotatedLorentzConeConstraint) numpy.ndarray[numpy.float64[m, 1]]
Getter for b.
- UpdateCoefficients(self: pydrake.solvers.RotatedLorentzConeConstraint, new_A: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], new_b: numpy.ndarray[numpy.float64[m, 1]]) None
Updates the coefficients, the updated constraint is z=new_A * x + new_b in the rotated Lorentz cone.
- Raises
RuntimeError if the new_A.cols() != A.cols(), namely the variable –
size should not change. –
- Precondition:
new_A.rows() >= 3 and new_A.rows() == new_b.rows().
- class pydrake.solvers.ScsSolver
Bases:
pydrake.solvers.SolverInterface
- __init__(self: pydrake.solvers.ScsSolver) None
- static id() pydrake.solvers.SolverId
- class pydrake.solvers.ScsSolverDetails
The SCS solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<ScsSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property dual_objective
Dual objective value at termination. Equal to SCS_INFO.dobj
- property duality_gap
duality gap. Equal to SCS_INFO.gap.
- property iter
These are the information returned by SCS at termination, please refer to “SCS_INFO” struct in https://github.com/cvxgrp/scs/blob/master/include/scs.h Number of iterations taken at termination. Equal to SCS_INFO.iter
- property primal_objective
Primal objective value at termination. Equal to SCS_INFO.pobj
- property primal_residue
Primal equality residue. Equal to SCS_INFO.res_pri
- property residue_infeasibility
infeasibility certificate residue. Equal to SCS_INFO.res_infeas
- property residue_unbounded_a
unbounded certificate residue. Equal to SCS_INFO.res_unbdd_a
- property residue_unbounded_p
unbounded certificate residue. Equal to SCS_INFO.res_unbdd_p
- property s
The primal equality constraint slack, namely Ax + s = b where x is the primal variable.
- property scs_setup_time
Time taken for SCS to setup in milliseconds. Equal to SCS_INFO.setup_time.
- property scs_solve_time
Time taken for SCS to solve in millisecond. Equal to SCS_INFO.solve_time.
- property scs_status
The status of the solver at termination. Please refer to https://github.com/cvxgrp/scs/blob/master/include/glbopts.h Note that the SCS code on github master might be slightly more up-to-date than the version used in Drake.
- property y
The dual variable values at termination.
- class pydrake.solvers.SnoptSolver
Bases:
pydrake.solvers.SolverInterface
An implementation of SolverInterface for the commercially-licensed SNOPT solver (https://ccom.ucsd.edu/~optimizers/solvers/snopt/).
Builds of Drake from source do not compile SNOPT by default, so therefore SolverInterface::available() will return false. You must opt-in to build SNOPT per the documentation at https://drake.mit.edu/bazel.html#snopt.
Drake’s pre-compiled binary releases do incorporate SNOPT, so therefore SolverInterface::available() will return true. Thanks to Philip E. Gill and Elizabeth Wong for their kind support.
There is no license configuration required to use SNOPT, so SolverInterface::enabled() will always return true.
- __init__(self: pydrake.solvers.SnoptSolver) None
- static id() pydrake.solvers.SolverId
- class pydrake.solvers.SnoptSolverDetails
The SNOPT solver details after calling Solve() function. The user can call MathematicalProgramResult::get_solver_details<SnoptSolver>() to obtain the details.
- __init__(*args, **kwargs)
- property F
The final value of the vector of problem functions F(x).
- property Fmul
The final value of the dual variables (Lagrange multipliers) for the general constraints F_lower <= F(x) <= F_upper.
- property info
The snopt INFO field. Please refer to section 8.6 in “User’s Guide for SNOPT Version 7: Software for Large-Scale Nonlinear Programming” (https://web.stanford.edu/group/SOL/guides/sndoc7.pdf) by Philip E. Gill to interpret the INFO field.
- property xmul
The final value of the dual variables for the bound constraint x_lower <= x <= x_upper.
- class pydrake.solvers.SolutionResult
Members:
kSolutionFound : Found the optimal solution.
kInvalidInput : Invalid input.
kInfeasibleConstraints : The primal is infeasible.
kUnbounded : The primal is unbounded.
kUnknownError : Unknown error.
kInfeasibleOrUnbounded :
kIterationLimit : Reaches the iteration limits.
kDualInfeasible : Dual problem is infeasible. In this case we cannot
- __init__(self: pydrake.solvers.SolutionResult, value: int) None
- kDualInfeasible = <SolutionResult.kDualInfeasible: -7>
- kInfeasibleConstraints = <SolutionResult.kInfeasibleConstraints: -2>
- kInfeasibleOrUnbounded = <SolutionResult.kInfeasibleOrUnbounded: -5>
- kInvalidInput = <SolutionResult.kInvalidInput: -1>
- kIterationLimit = <SolutionResult.kIterationLimit: -6>
- kSolutionFound = <SolutionResult.kSolutionFound: 0>
- kUnbounded = <SolutionResult.kUnbounded: -3>
- kUnknownError = <SolutionResult.kUnknownError: -4>
- property name
- property value
- pydrake.solvers.Solve(prog: pydrake.solvers.MathematicalProgram, initial_guess: Optional[numpy.ndarray[numpy.float64[m, 1]]] = None, solver_options: Optional[pydrake.solvers.SolverOptions] = None) pydrake.solvers.MathematicalProgramResult
Solves an optimization program, with optional initial guess and solver options. This function first chooses the best solver depending on the availability of the solver and the program formulation; it then constructs that solver and call the Solve function of that solver. The optimization result is stored in the return argument.
- Parameter
prog
: Contains the formulation of the program, and possibly solver options.
- Parameter
initial_guess
: The initial guess for the decision variables.
- Parameter
solver_options
: The options in addition to those stored in
prog
. For each option entry (like print out), there are 4 ways to set that option, and the priority given to the solver options is as follows (from lowest / least, to highest / most): 1. common option set on the MathematicalProgram itself 2. common option passed as an argument to Solve 3. solver-specific option set on the MathematicalProgram itself 4. solver-specific option passed as an argument to Solve
- Returns
result The result of solving the program through the solver.
- Parameter
- class pydrake.solvers.SolverId
Identifies a SolverInterface implementation.
A moved-from instance is guaranteed to be empty and will not compare equal to any non-empty ID.
- __init__(self: pydrake.solvers.SolverId, name: str) None
Constructs a specific, known solver type. Internally, a hidden identifier is allocated and assigned to this instance; all instances that share an identifier (including copies of this instance) are considered equal. The solver names are not enforced to be unique, though we recommend that they remain so in practice.
- name(self: pydrake.solvers.SolverId) str
- class pydrake.solvers.SolverInterface
Interface used by implementations of individual solvers.
- __init__(self: pydrake.solvers.SolverInterface) None
- AreProgramAttributesSatisfied(self: pydrake.solvers.SolverInterface, prog: drake::solvers::MathematicalProgram) bool
Returns true iff the program’s attributes are compatible with this solver’s capabilities.
- available(self: pydrake.solvers.SolverInterface) bool
Returns true iff support for this solver has been compiled into Drake. When this method returns false, the Solve method will throw.
Most solver implementations will always return true, but certain solvers may have been excluded at compile-time due to licensing restrictions, or to narrow Drake’s dependency footprint. In Drake’s default build, only commercially-licensed solvers might return false.
Contrast this with enabled(), which reflects whether a solver has been configured for use at runtime (not compile-time).
For details on linking commercial solvers, refer to the solvers’ class overview documentation, e.g., SnoptSolver, MosekSolver, GurobiSolver.
- enabled(self: pydrake.solvers.SolverInterface) bool
Returns true iff this solver is properly configured for use at runtime. When this method returns false, the Solve method will throw.
Most solver implementation will always return true, but certain solvers require additional configuration before they may be used, e.g., setting an environment variable to specify a license file or license server. In Drake’s default build, only commercially-licensed solvers might return false.
Contrast this with available(), which reflects whether a solver has been incorporated into Drake at compile-time (and has nothing to do with the runtime configuration). A solver where available() returns false may still return true for enabled() if it is properly configured.
The mechanism to configure a particular solver implementation is specific to the solver in question, but typically uses an environment variable. For details on configuring commercial solvers, refer to the solvers’ class overview documentation, e.g., SnoptSolver, MosekSolver, GurobiSolver.
- ExplainUnsatisfiedProgramAttributes(self: pydrake.solvers.SolverInterface, prog: drake::solvers::MathematicalProgram) str
Describes the reasons (if any) why the program is incompatible with this solver’s capabilities. If AreProgramAttributesSatisfied would return true for the program, then this function returns the empty string.
- Solve(*args, **kwargs)
Overloaded function.
Solve(self: pydrake.solvers.SolverInterface, prog: drake::solvers::MathematicalProgram, initial_guess: Optional[numpy.ndarray[numpy.float64[m, 1]]], solver_options: Optional[drake::solvers::SolverOptions], result: drake::solvers::MathematicalProgramResult) -> None
Solves an optimization program with optional initial guess and solver options. Note that these initial guess and solver options are not written to
prog
. If theprog
has set an option for a solver, andsolver_options
contains a different value for the same option on the same solver, thensolver_options
takes priority. Derived implementations of this interface may elect to throw RuntimeError for badly formed programs.Solve(self: pydrake.solvers.SolverInterface, prog: drake::solvers::MathematicalProgram, initial_guess: Optional[numpy.ndarray[numpy.float64[m, 1]]] = None, solver_options: Optional[drake::solvers::SolverOptions] = None) -> drake::solvers::MathematicalProgramResult
Like SolverInterface::Solve(), but the result is a return value instead of an output argument.
- solver_id(self: pydrake.solvers.SolverInterface) drake::solvers::SolverId
Returns the identifier of this solver.
- solver_type(self: pydrake.solvers.SolverInterface) Optional[drake::solvers::SolverType]
- SolverName(self: pydrake.solvers.SolverInterface) str
- class pydrake.solvers.SolverOptions
Stores options for multiple solvers. This interface does not do any verification of solver parameters. It does not even verify that the specified solver exists. Use this only when you have particular knowledge of what solver is being invoked, and exactly what tuning is required.
Supported solver names/options:
“SNOPT” – Parameter names and values as specified in SNOPT User’s Guide section 7.7 “Description of the optional parameters”, used as described in section 7.5 for snSet(). The SNOPT user guide can be obtained from https://web.stanford.edu/group/SOL/guides/sndoc7.pdf
“IPOPT” – Parameter names and values as specified in IPOPT users guide section “Options Reference” https://coin-or.github.io/Ipopt/OPTIONS.html
“NLOPT” – Parameter names and values are specified in https://nlopt.readthedocs.io/en/latest/NLopt_C-plus-plus_Reference/ (in the Stopping criteria section). Besides these parameters, the user can specify “algorithm” using a string of the algorithm name. The complete set of algorithms is listed in “nlopt_algorithm_to_string()” function in github.com/stevengj/nlopt/blob/master/src/api/general.c. If you would like to use certain algorithm, for example NLOPT_LD_SLSQP, call
SetOption(NloptSolver::id(), NloptSolver::AlgorithmName(), "LD_SLSQP");
“GUROBI” – Parameter name and values as specified in Gurobi Reference Manual, section 10.2 “Parameter Descriptions” https://www.gurobi.com/documentation/9.5/refman/parameters.html
“SCS” – Parameter name and values as specified in the struct SCS_SETTINGS in SCS header file https://github.com/cvxgrp/scs/blob/master/include/scs.h Note that the SCS code on github master might be more up-to-date than the version used in Drake.
“MOSEK™” – Parameter name and values as specified in Mosek Reference https://docs.mosek.com/9.3/capi/parameters.html
“OSQP” – Parameter name and values as specified in OSQP Reference https://osqp.org/docs/interfaces/solver_settings.html#solver-settings
- __init__(self: pydrake.solvers.SolverOptions) None
- common_solver_options(self: pydrake.solvers.SolverOptions) Dict[drake::solvers::CommonSolverOption, Union[float, int, str]]
Gets the common options for all solvers. Refer to CommonSolverOption for more details.
- get_print_file_name(self: pydrake.solvers.SolverOptions) str
Returns the kPrintFileName set via CommonSolverOption, or else an empty string if the option has not been set.
- get_print_to_console(self: pydrake.solvers.SolverOptions) bool
Returns the kPrintToConsole set via CommonSolverOption, or else false if the option has not been set.
- GetOptions(self: pydrake.solvers.SolverOptions, solver_id: pydrake.solvers.SolverId) dict
- SetOption(*args, **kwargs)
Overloaded function.
SetOption(self: pydrake.solvers.SolverOptions, solver_id: pydrake.solvers.SolverId, solver_option: str, option_value: float) -> None
Sets a double-valued solver option for a specific solver.
SetOption(self: pydrake.solvers.SolverOptions, solver_id: pydrake.solvers.SolverId, solver_option: str, option_value: int) -> None
Sets an integer-valued solver option for a specific solver.
SetOption(self: pydrake.solvers.SolverOptions, solver_id: pydrake.solvers.SolverId, solver_option: str, option_value: str) -> None
Sets a string-valued solver option for a specific solver.
SetOption(self: pydrake.solvers.SolverOptions, key: drake::solvers::CommonSolverOption, value: Union[float, int, str]) -> None
Sets a common option for all solvers supporting that option (for example, printing the progress in each iteration). If the solver doesn’t support the option, the option is ignored.
- class pydrake.solvers.SolverType
This type only exists for backwards compatibility, and should not be used in new code.
Members:
kClp :
kCsdp :
kEqualityConstrainedQP :
kGurobi :
kIpopt :
kLinearSystem :
kMobyLCP :
kMosek :
kNlopt :
kOsqp :
kScs :
kSnopt :
- __init__(self: pydrake.solvers.SolverType, value: int) None
- kClp = <SolverType.kClp: 0>
- kCsdp = <SolverType.kCsdp: 1>
- kEqualityConstrainedQP = <SolverType.kEqualityConstrainedQP: 2>
- kGurobi = <SolverType.kGurobi: 3>
- kIpopt = <SolverType.kIpopt: 4>
- kLinearSystem = <SolverType.kLinearSystem: 5>
- kMobyLCP = <SolverType.kMobyLCP: 6>
- kMosek = <SolverType.kMosek: 7>
- kNlopt = <SolverType.kNlopt: 8>
- kOsqp = <SolverType.kOsqp: 9>
- kScs = <SolverType.kScs: 11>
- kSnopt = <SolverType.kSnopt: 10>
- property name
- property value
- class pydrake.solvers.VisualizationCallback
Bases:
pydrake.solvers.EvaluatorBase
Defines a simple evaluator with no outputs that takes a callback function pointer. This is intended for debugging / visualization of intermediate results during an optimization (for solvers that support it).
- __init__(*args, **kwargs)