Reformulate constructors with optional arguments

Author: Lucas-Haubert

include/nanoeigenpy/decompositions/bdcsvd.hpp

@@ -40,14 +40,11 @@ void exposeBDCSVD(nb::module_ m, const char *name) {
 
       .def(nb::init<>(), "Default constructor.")
       .def(nb::init<Eigen::DenseIndex, Eigen::DenseIndex, unsigned int>(),
-           "rows"_a, "cols"_a, "computationOptions"_a,
+           "rows"_a, "cols"_a, "computationOptions"_a = 0,
            "Default constructor with memory preallocation.")
-      .def(nb::init<Eigen::DenseIndex, Eigen::DenseIndex>(), "rows"_a, "cols"_a,
-           "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &>(), "matrix"_a,
-           "Constructs a SVD factorization from a given matrix.")
+
       .def(nb::init<const MatrixType &, unsigned int>(), "matrix"_a,
-           "computationOptions"_a,
+           "computationOptions"_a = 0,
            "Constructs a SVD factorization from a given matrix.")
 
       .def(SVDBaseVisitor())

include/nanoeigenpy/decompositions/complex-eigen-solver.hpp

@@ -22,10 +22,8 @@ void exposeComplexEigenSolver(nb::module_ m, const char *name) {
       .def(nb::init<>(), "Default constructor.")
       .def(nb::init<Eigen::DenseIndex>(), "size"_a,
            "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &>(), "matrix"_a,
-           "Computes eigendecomposition of given matrix")
       .def(nb::init<const MatrixType &, bool>(), "matrix"_a,
-           "computeEigenvectors"_a,
+           "computeEigenvectors"_a = true,
            "Computes eigendecomposition of given matrix")
 
       .def("eigenvalues", &Solver::eigenvalues,

include/nanoeigenpy/decompositions/complex-schur.hpp

@@ -21,8 +21,6 @@ void exposeComplexSchur(nb::module_ m, const char *name) {
 
       .def(nb::init<Eigen::DenseIndex>(), "size"_a,
            "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &>(), "matrix"_a,
-           "Constructor; computes Schur decomposition of given matrix.")
       .def(nb::init<const MatrixType &, bool>(), "matrix"_a,
            "computeU"_a = true,
            "Constructor; computes Schur decomposition of given matrix.")

include/nanoeigenpy/decompositions/generalized-eigen-solver.hpp

@@ -22,12 +22,8 @@ void exposeGeneralizedEigenSolver(nb::module_ m, const char *name) {
       .def(nb::init<>(), "Default constructor.")
       .def(nb::init<Eigen::DenseIndex>(), "size"_a,
            "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &, const MatrixType &>(), "A"_a, "B"_a,
-           "Constructor; computes the generalized eigendecomposition of given "
-           "matrix pair.")
       .def(nb::init<const MatrixType &, const MatrixType &, bool>(), "A"_a,
-           "B"_a,
-           "computeEigenvectors"_a
+           "B"_a, "computeEigenvectors"_a = true,
            "Constructor; computes the generalized eigendecomposition of given "
            "matrix pair.")
 

include/nanoeigenpy/decompositions/generalized-self-adjoint-eigen-solver.hpp

@@ -22,11 +22,8 @@ void exposeGeneralizedSelfAdjointEigenSolver(nb::module_ m, const char *name) {
       .def(nb::init<>(), "Default constructor.")
       .def(nb::init<Eigen::DenseIndex>(), nb::arg("size"),
            "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &, const MatrixType &>(), "matA"_a,
-           "matB"_a,
-           "Computes the generalized eigendecomposition of given matrix pencil")
       .def(nb::init<const MatrixType &, const MatrixType &, int>(), "matA"_a,
-           "matB"_a, "options"_a,
+           "matB"_a, "options"_a = Eigen::ComputeEigenvectors | Eigen::Ax_lBx,
            "Computes the generalized eigendecomposition of given matrix pencil")
 
       .def(

include/nanoeigenpy/decompositions/jacobi-svd.hpp

@@ -26,14 +26,10 @@ struct JacobiSVDVisitor : nb::def_visitor<JacobiSVDVisitor<JacobiSVD>> {
     using namespace nb::literals;
     cl.def(nb::init<>(), "Default constructor.")
         .def(nb::init<Eigen::DenseIndex, Eigen::DenseIndex, unsigned int>(),
-             "rows"_a, "cols"_a, "computationOptions"_a,
+             "rows"_a, "cols"_a, "computationOptions"_a = 0,
              "Default constructor with memory preallocation.")
-        .def(nb::init<Eigen::DenseIndex, Eigen::DenseIndex>(), "rows"_a,
-             "cols"_a, "Default constructor with memory preallocation.")
-        .def(nb::init<const MatrixType &>(), "matrix"_a,
-             "Constructs a SVD factorization from a given matrix.")
         .def(nb::init<const MatrixType &, unsigned int>(), "matrix"_a,
-             "computationOptions"_a,
+             "computationOptions"_a = 0,
              "Constructs a SVD factorization from a given matrix.")
 
         .def(SVDBaseVisitor())

include/nanoeigenpy/decompositions/real-qz.hpp

@@ -21,10 +21,8 @@ void exposeRealQZ(nb::module_ m, const char *name) {
 
       .def(nb::init<Eigen::DenseIndex>(), "size"_a,
            "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &, const MatrixType &>(), "A"_a, "B"_a,
-           "Constructor; computes real QZ decomposition of given matrices.")
       .def(nb::init<const MatrixType &, const MatrixType &, bool>(), "A"_a,
-           "B"_a, "computeQZ"_a,
+           "B"_a, "computeQZ"_a = true,
            "Constructor; computes real QZ decomposition of given matrices.")
 
       .def("matrixQ", &Solver::matrixQ,

include/nanoeigenpy/decompositions/real-schur.hpp

@@ -21,9 +21,8 @@ void exposeRealSchur(nb::module_ m, const char *name) {
 
       .def(nb::init<Eigen::DenseIndex>(), "size"_a,
            "Default constructor with memory preallocation.")
-      .def(nb::init<const MatrixType &>(), "matrix"_a,
-           "Constructor; computes real Schur decomposition of given matrices.")
-      .def(nb::init<const MatrixType &, bool>(), "matrix"_a, "computeU"_a,
+      .def(nb::init<const MatrixType &, bool>(), "matrix"_a,
+           "computeU"_a = true,
            "Constructor; computes real Schur decomposition of given matrices.")
 
       .def("matrixU", &Solver::matrixU,