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,15 +63,19 @@ 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>())