pdipm.hpp

Go to the documentation of this file.

#ifndef ROBOTOC_CONSTRAINTS_PDIPM_HPP_
#define ROBOTOC_CONSTRAINTS_PDIPM_HPP_
 
#include "Eigen/Core"
 
#include "robotoc/constraints/constraint_component_data.hpp"
 
 
namespace robotoc {
namespace pdipm {
 
void setSlackAndDualPositive(const double barrier_param, 
                             ConstraintComponentData& data);
 
void computeComplementarySlackness(const double barrier_param, 
                                   ConstraintComponentData& data);
 
void computeComplementarySlackness(const double barrier_param, 
                                   ConstraintComponentData& data,
                                   const int start, const int size);
 
template <int Size>
void computeComplementarySlackness(const double barrier_param, 
                                   ConstraintComponentData& data,
                                   const int start);
 
double computeComplementarySlackness(const double barrier_param, const double slack, 
                                     const double dual);
 
void computeCondensingCoeffcient(ConstraintComponentData& data);
 
void computeCondensingCoeffcient(ConstraintComponentData& data,
                                 const int start, const int size);
 
template <int Size>
void computeCondensingCoeffcient(ConstraintComponentData& data,
                                 const int start);
 
double computeCondensingCoeffcient(const double slack, const double dual,
                                   const double residual, const double cmpl);
 
double fractionToBoundarySlack(const double fraction_rate, 
                               const ConstraintComponentData& data);
 
double fractionToBoundaryDual(const double fraction_rate, 
                              const ConstraintComponentData& data);
 
double fractionToBoundary(const int dim, const double fraction_rate, 
                          const Eigen::VectorXd& vec,
                          const Eigen::VectorXd& dvec);
 
double fractionToBoundary(const double fraction_rate, 
                          const double var, const double dvar);
 
void computeDualDirection(ConstraintComponentData& data);
 
void computeDualDirection(ConstraintComponentData& data, 
                          const int start, const int size);
 
template <int Size>
void computeDualDirection(ConstraintComponentData& data, const int start);
 
double computeDualDirection(const double slack, const double dual,
                            const double dslack, const double cmpl);
 
template <typename VectorType>
double logBarrier(const double barrier_param, 
                   const Eigen::MatrixBase<VectorType>& vec);
 
} // namespace pdipm
} // namespace robotoc
 
#include "robotoc/constraints/pdipm.hxx"
 
#endif // ROBOTOC_CONSTRAINTS_PDIPM_HPP_