delassus-operator.hpp

//
// Copyright (c) 2024 INRIA
//
 
#ifndef __pinocchio_python_algorithm_delssus_operator_hpp__
#define __pinocchio_python_algorithm_delssus_operator_hpp__
 
#include <eigenpy/memory.hpp>
#include "pinocchio/algorithm/delassus-operator-base.hpp"
 
namespace pinocchio
{
  namespace python
  {
    namespace bp = boost::python;
 
    template<typename DelassusOperator>
    struct DelassusOperatorBasePythonVisitor
    : public boost::python::def_visitor<DelassusOperatorBasePythonVisitor<DelassusOperator>>
    {
      typedef DelassusOperator Self;
      typedef typename DelassusOperator::Scalar Scalar;
      typedef context::MatrixXs Matrix;
      typedef typename DelassusOperator::Vector Vector;
 
      template<class PyClass>
      void visit(PyClass & cl) const
      {
        cl.def(bp::self * bp::other<Matrix>())
          .def(
            "__matmul__",
            +[](const DelassusOperator & self, const Matrix & other) -> Matrix {
              return self * other;
            },
            bp::args("self", "other"),
            "Matrix multiplication between self and another matrix. Returns the result of Delassus "
            "* matrix.")
 
          .def(
            "solve", &DelassusOperator::template solve<Matrix>, bp::args("self", "mat"),
            "Returns the solution x of Delassus * x = mat using the current decomposition of "
            "the Delassus matrix.")
 
          .def(
            "computeLargestEigenValue",
            (Scalar(DelassusOperator::*)(const bool, const int, const Scalar)
               const)&DelassusOperator::computeLargestEigenValue,
            (bp::arg("self"), bp::arg("reset") = true, bp::arg("max_it") = 10,
             bp::arg("prec") = Scalar(1e-8)),
            "Compute the largest eigenvalue associated to the underlying Delassus matrix.")
          .def(
            "computeLowestEigenValue",
            (Scalar(DelassusOperator::*)(const bool, const bool, const int, const Scalar)
               const)&DelassusOperator::computeLowestEigenValue,
            (bp::arg("self"), bp::arg("reset") = true, bp::arg("compute_largest") = true,
             bp::arg("max_it") = 10, bp::arg("prec") = Scalar(1e-8)),
            "Compute the lowest eigenvalue associated to the underlying Delassus matrix.")
 
          .def(
            "updateDamping",
            (void(DelassusOperator::*)(const Scalar &)) & DelassusOperator::updateDamping,
            bp::args("self", "mu"),
            "Add a damping term to the diagonal of the Delassus matrix. The damping term should "
            "be positive.")
          .def(
            "updateDamping", &DelassusOperator::template updateDamping<Vector>,
            bp::args("self", "mus"),
            "Add a damping term to the diagonal of the Delassus matrix. The damping terms "
            "should be all positive.")
 
          .def(
            "matrix", &DelassusOperator::matrix, bp::arg("self"),
            "Returns the Delassus expression as a dense matrix.")
          .def(
            "inverse", &DelassusOperator::inverse, bp::arg("self"),
            "Returns the inverse of the Delassus expression as a dense matrix.")
 
          .def(
            "size", &DelassusOperator::size, bp::arg("self"),
            "Returns the size of the decomposition.")
          .def("rows", &DelassusOperator::rows, bp::arg("self"), "Returns the number of rows.")
          .def("cols", &DelassusOperator::cols, bp::arg("self"), "Returns the number of columns.");
      }
    };
 
  } // namespace python
} // namespace pinocchio
 
#endif // ifndef __pinocchio_python_algorithm_delssus_operator_hpp__