split_riccati_factorization.hpp

Go to the documentation of this file.

#ifndef ROBOTOC_SPLIT_RICCATI_FACTORIZATION_HPP_
#define ROBOTOC_SPLIT_RICCATI_FACTORIZATION_HPP_
 
#include "Eigen/Core"
 
#include "robotoc/robot/robot.hpp"
 
 
namespace robotoc {
 
class SplitRiccatiFactorization {
public:
  SplitRiccatiFactorization(const Robot& robot);
 
  SplitRiccatiFactorization();
 
  ~SplitRiccatiFactorization();
 
  SplitRiccatiFactorization(const SplitRiccatiFactorization&) = default;
 
  SplitRiccatiFactorization& operator=(
      const SplitRiccatiFactorization&) = default;
 
  SplitRiccatiFactorization(
      SplitRiccatiFactorization&&) noexcept = default;
 
  SplitRiccatiFactorization& operator=(
      SplitRiccatiFactorization&&) noexcept = default;
 
  Eigen::MatrixXd P;
 
  Eigen::VectorXd s;
 
  Eigen::Block<Eigen::MatrixXd> Pqq() {
    return P.topLeftCorner(dimv_, dimv_); 
  }
 
  const Eigen::Block<const Eigen::MatrixXd> Pqq() const {
    return P.topLeftCorner(dimv_, dimv_); 
  }
 
  Eigen::Block<Eigen::MatrixXd> Pqv() {
    return P.topRightCorner(dimv_, dimv_); 
  }
 
  const Eigen::Block<const Eigen::MatrixXd> Pqv() const {
    return P.topRightCorner(dimv_, dimv_); 
  }
 
  Eigen::Block<Eigen::MatrixXd> Pvq() {
    return P.bottomLeftCorner(dimv_, dimv_); 
  }
 
  const Eigen::Block<const Eigen::MatrixXd> Pvq() const {
    return P.bottomLeftCorner(dimv_, dimv_); 
  }
 
  Eigen::Block<Eigen::MatrixXd> Pvv() {
    return P.bottomRightCorner(dimv_, dimv_); 
  }
 
  const Eigen::Block<const Eigen::MatrixXd> Pvv() const {
    return P.bottomRightCorner(dimv_, dimv_); 
  }
 
  Eigen::VectorBlock<Eigen::VectorXd> sq() {
    return s.head(dimv_);
  }
 
  const Eigen::VectorBlock<const Eigen::VectorXd> sq() const {
    return s.head(dimv_);
  }
 
  Eigen::VectorBlock<Eigen::VectorXd> sv() {
    return s.tail(dimv_);
  }
 
  const Eigen::VectorBlock<const Eigen::VectorXd> sv() const {
    return s.tail(dimv_);
  }
 
  Eigen::VectorXd psi_x;
 
  Eigen::VectorXd psi_u;
 
  Eigen::VectorXd Psi;
 
  Eigen::VectorXd phi_x;
 
  Eigen::VectorXd phi_u;
 
  Eigen::VectorXd Phi;
 
  double xi;
 
  double chi;
 
  double rho;
 
  double eta;
 
  double iota;
 
  void setConstraintDimension(const int dims=0);
 
  int dims() const;
 
  Eigen::Block<Eigen::MatrixXd> M();
 
  const Eigen::Block<const Eigen::MatrixXd> M() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> m();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> m() const;
 
  Eigen::VectorBlock<Eigen::VectorXd> mt();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> mt() const;
 
    Eigen::VectorBlock<Eigen::VectorXd> mt_next();
 
  const Eigen::VectorBlock<const Eigen::VectorXd> mt_next() const;
 
  void setZero();
 
  void setRandom();
 
  bool isApprox(const SplitRiccatiFactorization& other) const;
 
  bool hasNaN() const;
 
  static SplitRiccatiFactorization Random(const Robot& robot);
 
  void disp(std::ostream& os) const;
 
  friend std::ostream& operator<<(std::ostream& os, 
                                  const SplitRiccatiFactorization& riccati);
 
private:
  Eigen::MatrixXd M_full_;
  Eigen::VectorXd m_full_, mt_full_, mt_next_full_;
  int dimv_, dimx_, dims_;
};
 
} // namespace robotoc 
 
#include "robotoc/riccati/split_riccati_factorization.hxx"
 
#endif // ROBOTOC_SPLIT_RICCATI_FACTORIZATION_HPP_