Add const in some lambda functions on Solver& to stick to definition

Author: Lucas-Haubert

include/eigenpy/decompositions/SelfAdjointEigenSolver.hpp

@@ -35,12 +35,16 @@ struct SelfAdjointEigenSolverVisitor
 
         .def(
             "eigenvalues",
-            +[](Solver& c) -> const VectorType& { return c.eigenvalues(); },
+            +[](const Solver& c) -> const VectorType& {
+              return c.eigenvalues();
+            },
             "Returns the eigenvalues of given matrix.",
             bp::return_internal_reference<>())
         .def(
             "eigenvectors",
-            +[](Solver& c) -> const MatrixType& { return c.eigenvectors(); },
+            +[](const Solver& c) -> const MatrixType& {
+              return c.eigenvectors();
+            },
             "Returns the eigenvectors of given matrix.",
             bp::return_internal_reference<>())
 

include/eigenpy/decompositions/Tridiagonalization.hpp

@@ -49,7 +49,8 @@ struct TridiagonalizationVisitor : public boost::python::def_visitor<
             +[](const Solver &c) -> MatrixType { return c.matrixQ(); },
             "Returns the unitary matrix Q in the decomposition.")
         .def(
-            "matrixT", +[](Solver &c) -> MatrixType { return c.matrixT(); },
+            "matrixT",
+            +[](const Solver &c) -> MatrixType { return c.matrixT(); },
             "Returns an expression of the tridiagonal matrix T in the "
             "decomposition.")
 

include/eigenpy/solvers/IncompleteCholesky.hpp

@@ -63,36 +63,40 @@ struct IncompleteCholeskyVisitor : public boost::python::def_visitor<
 
         .def(
             "matrixL",
-            +[](Solver& self) -> const FactorType& { return self.matrixL(); },
+            +[](const Solver& self) -> const FactorType& {
+              return self.matrixL();
+            },
             bp::return_value_policy<bp::copy_const_reference>())
         .def(
             "scalingS",
-            +[](Solver& self) -> const VectorRx& { return self.scalingS(); },
+            +[](const Solver& self) -> const VectorRx& {
+              return self.scalingS();
+            },
             bp::return_value_policy<bp::copy_const_reference>())
         .def(
             "permutationP",
-            +[](Solver& self) -> const PermutationType& {
+            +[](const Solver& self) -> const PermutationType& {
               return self.permutationP();
             },
             bp::return_value_policy<bp::copy_const_reference>())
 
         .def(
             "solve",
-            +[](Solver const& self, const Eigen::Ref<DenseVectorXs const>& b)
+            +[](const Solver& self, const Eigen::Ref<DenseVectorXs const>& b)
                 -> DenseVectorXs { return self.solve(b); },
             bp::arg("b"),
             "Returns the solution x of A x = b using the current decomposition "
             "of A, where b is a right hand side vector.")
         .def(
             "solve",
-            +[](Solver const& self, const Eigen::Ref<DenseMatrixXs const>& B)
+            +[](const Solver& self, const Eigen::Ref<DenseMatrixXs const>& B)
                 -> DenseMatrixXs { return self.solve(B); },
             bp::arg("b"),
             "Returns the solution X of A X = B using the current decomposition "
             "of A where B is a right hand side matrix.")
         .def(
             "solve",
-            +[](Solver const& self, const MatrixType& B) -> MatrixType {
+            +[](const Solver& self, const MatrixType& B) -> MatrixType {
               DenseMatrixXs B_dense = DenseMatrixXs(B);
               DenseMatrixXs X_dense = self.solve(B_dense);
               return MatrixType(X_dense.sparseView());

include/eigenpy/solvers/IncompleteLUT.hpp

@@ -63,21 +63,21 @@ struct IncompleteLUTVisitor
 
         .def(
             "solve",
-            +[](Solver const& self, const Eigen::Ref<DenseVectorXs const>& b)
+            +[](const Solver& self, const Eigen::Ref<DenseVectorXs const>& b)
                 -> DenseVectorXs { return self.solve(b); },
             bp::arg("b"),
             "Returns the solution x of A x = b using the current decomposition "
             "of A, where b is a right hand side vector.")
         .def(
             "solve",
-            +[](Solver const& self, const Eigen::Ref<DenseMatrixXs const>& B)
+            +[](const Solver& self, const Eigen::Ref<DenseMatrixXs const>& B)
                 -> DenseMatrixXs { return self.solve(B); },
             bp::arg("b"),
             "Returns the solution X of A X = B using the current decomposition "
             "of A where B is a right hand side matrix.")
         .def(
             "solve",
-            +[](Solver const& self, const MatrixType& B) -> MatrixType {
+            +[](const Solver& self, const MatrixType& B) -> MatrixType {
               DenseMatrixXs B_dense = DenseMatrixXs(B);
               DenseMatrixXs X_dense = self.solve(B_dense);
               return MatrixType(X_dense.sparseView());