Drake
PositiveSemidefiniteConstraint Class Reference

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. More...

#include <solvers/constraint.h>

Inheritance diagram for PositiveSemidefiniteConstraint:
[legend]
Collaboration diagram for PositiveSemidefiniteConstraint:
[legend]

Public Member Functions

 PositiveSemidefiniteConstraint (int rows)
 Impose the constraint that a symmetric matrix with size rows x rows is positive semidefinite. More...
 
 ~PositiveSemidefiniteConstraint () override
 
int matrix_rows () const
 
Does not allow copy, move, or assignment
 PositiveSemidefiniteConstraint (const PositiveSemidefiniteConstraint &)=delete
 
PositiveSemidefiniteConstraintoperator= (const PositiveSemidefiniteConstraint &)=delete
 
 PositiveSemidefiniteConstraint (PositiveSemidefiniteConstraint &&)=delete
 
PositiveSemidefiniteConstraintoperator= (PositiveSemidefiniteConstraint &&)=delete
 
- Public Member Functions inherited from Constraint
template<typename DerivedLB , typename DerivedUB >
 Constraint (int num_constraints, int num_vars, const Eigen::MatrixBase< DerivedLB > &lb, const Eigen::MatrixBase< DerivedUB > &ub, const std::string &description="")
 Constructs a constraint which has num_constraints rows, with an input num_vars x 1 vector. More...
 
 Constraint (int num_constraints, int num_vars)
 Constructs a constraint which has num_constraints rows, with an input num_vars x 1 vector, with no bounds. More...
 
bool CheckSatisfied (const Eigen::Ref< const Eigen::VectorXd > &x, double tol=1E-6) const
 Return whether this constraint is satisfied by the given value, x. More...
 
bool CheckSatisfied (const Eigen::Ref< const AutoDiffVecXd > &x, double tol=1E-6) const
 
const Eigen::VectorXd & lower_bound () const
 
const Eigen::VectorXd & upper_bound () const
 
size_t num_constraints () const
 Number of rows in the output constraint. More...
 
template<typename Derived >
void UpdateLowerBound (const Eigen::MatrixBase< Derived > &new_lb)
 Updates the lower bound. More...
 
template<typename Derived >
void UpdateUpperBound (const Eigen::MatrixBase< Derived > &new_ub)
 Updates the upper bound. More...
 
template<typename DerivedL , typename DerivedU >
void set_bounds (const Eigen::MatrixBase< DerivedL > &lower_bound, const Eigen::MatrixBase< DerivedU > &upper_bound)
 Set the upper and lower bounds of the constraint. More...
 
 Constraint (const Constraint &)=delete
 
Constraintoperator= (const Constraint &)=delete
 
 Constraint (Constraint &&)=delete
 
Constraintoperator= (Constraint &&)=delete
 
- Public Member Functions inherited from EvaluatorBase
virtual ~EvaluatorBase ()
 
void Eval (const Eigen::Ref< const Eigen::VectorXd > &x, Eigen::VectorXd &y) const
 Evaluates the expression with a scalar type of double. More...
 
void Eval (const Eigen::Ref< const AutoDiffVecXd > &x, AutoDiffVecXd &y) const
 Evaluates the expression with a scalar type of AutoDiffXd. More...
 
void set_description (const std::string &description)
 Set a human-friendly description for the evaluator. More...
 
const std::string & get_description () const
 Getter for a human-friendly description for the evaluator. More...
 
int num_vars () const
 Getter for the number of variables, namely the number of rows in x, as used in Eval(x, y). More...
 
int num_outputs () const
 Getter for the number of outputs, namely the number of rows in y, as used in Eval(x, y). More...
 
 EvaluatorBase (const EvaluatorBase &)=delete
 
EvaluatorBaseoperator= (const EvaluatorBase &)=delete
 
 EvaluatorBase (EvaluatorBase &&)=delete
 
EvaluatorBaseoperator= (EvaluatorBase &&)=delete
 

Protected Member Functions

void DoEval (const Eigen::Ref< const Eigen::VectorXd > &x, Eigen::VectorXd &y) const override
 Evaluate the eigen values of the symmetric matrix. More...
 
void DoEval (const Eigen::Ref< const AutoDiffVecXd > &x, AutoDiffVecXd &y) const override
 
- Protected Member Functions inherited from Constraint
virtual bool DoCheckSatisfied (const Eigen::Ref< const Eigen::VectorXd > &x, const double tol) const
 
virtual bool DoCheckSatisfied (const Eigen::Ref< const AutoDiffVecXd > &x, const double tol) const
 
- Protected Member Functions inherited from EvaluatorBase
 EvaluatorBase (int num_outputs, int num_vars, const std::string &description="")
 Constructs a evaluator. More...
 

Detailed Description

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.

Constructor & Destructor Documentation

PositiveSemidefiniteConstraint ( int  rows)
inlineexplicit

Impose the constraint that a symmetric matrix with size rows x rows 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.
Parameters
rowsThe 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.
prog.Solve();
// Retrieve the solution of matrix S.
auto S_value = GetSolution(S);
// 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;
~PositiveSemidefiniteConstraint ( )
inlineoverride

Member Function Documentation

void DoEval ( const Eigen::Ref< const Eigen::VectorXd > &  x,
Eigen::VectorXd &  y 
) const
overrideprotectedvirtual

Evaluate the eigen values of the symmetric matrix.

Parameters
xThe stacked columns of the symmetric matrix.

Implements EvaluatorBase.

Here is the call graph for this function:

void DoEval ( const Eigen::Ref< const AutoDiffVecXd > &  x,
AutoDiffVecXd y 
) const
overrideprotectedvirtual
Parameters
xThe stacked columns of the symmetric matrix. This function is not supported yet, since Eigen's eigen value solver does not accept AutoDiffScalar.

Implements EvaluatorBase.

int matrix_rows ( ) const
inline

Here is the call graph for this function:


The documentation for this class was generated from the following files: