Add equivalent to eigenpy::register_symbolic_link_to_registered_type (#10)

Lucas-Haubert · web-flow · commit c3df6215a0d6 · 2025-04-28T19:29:19.000+02:00
* Add equivalent to eigenpy::register_symbolic_link_to_registered_type

* Re write the if condition with register_symbolic_link_to_registered_type

* Renamed register_symbolic_link_to_registered_type into check_registration_alias with attribute deprecated
diff --git a/.gitignore b/.gitignore
@@ -1,6 +1,7 @@
 build*/
 .cache/
 __pycache__
+.pytest_cache
 
 # pixi environments
 .pixi
diff --git a/cmake b/cmake
@@ -1 +1 @@
-Subproject commit 0136f02bbdc6bb32fa6a0ea28ca759434dc94b5a
+Subproject commit 2ede15d1cb9d66401ba96788444ad64c44ffccd8
diff --git a/include/nanoeigenpy/decompositions/col-piv-householder-qr.hpp b/include/nanoeigenpy/decompositions/col-piv-householder-qr.hpp
@@ -27,6 +27,10 @@ void exposeColPivHouseholderQRSolver(nb::module_ m, const char *name) {
   using Scalar = typename MatrixType::Scalar;
   using RealScalar = typename MatrixType::RealScalar;
   using VectorType = Eigen::Matrix<Scalar, -1, 1>;
+
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "This class performs a rank-revealing QR decomposition of a matrix A "
diff --git a/include/nanoeigenpy/decompositions/complete-orthogonal-decomposition.hpp b/include/nanoeigenpy/decompositions/complete-orthogonal-decomposition.hpp
@@ -31,6 +31,9 @@ void exposeCompleteOrthogonalDecompositionSolver(nb::module_ m,
   using RealScalar = typename MatrixType::RealScalar;
   using VectorType = Eigen::Matrix<Scalar, -1, 1>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "This class performs a rank-revealing complete orthogonal "
diff --git a/include/nanoeigenpy/decompositions/eigen-solver.hpp b/include/nanoeigenpy/decompositions/eigen-solver.hpp
@@ -15,8 +15,10 @@ void exposeEigenSolver(nb::module_ m, const char *name) {
   using MatrixType = _MatrixType;
   using Solver = Eigen::EigenSolver<MatrixType>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(m, name, "Eigen solver.")
-
       .def(nb::init<>(), "Default constructor.")
       .def(nb::init<Eigen::DenseIndex>(), nb::arg("size"),
            "Default constructor with memory preallocation.")
diff --git a/include/nanoeigenpy/decompositions/full-piv-householder-qr.hpp b/include/nanoeigenpy/decompositions/full-piv-householder-qr.hpp
@@ -28,6 +28,9 @@ void exposeFullPivHouseholderQRSolver(nb::module_ m, const char *name) {
   using RealScalar = typename MatrixType::RealScalar;
   using VectorType = Eigen::Matrix<Scalar, -1, 1>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "This class performs a rank-revealing QR decomposition of a matrix A "
diff --git a/include/nanoeigenpy/decompositions/householder-qr.hpp b/include/nanoeigenpy/decompositions/householder-qr.hpp
@@ -22,6 +22,9 @@ void exposeHouseholderQRSolver(nb::module_ m, const char *name) {
   using Scalar = typename MatrixType::Scalar;
   using VectorType = Eigen::Matrix<Scalar, -1, 1>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "This class performs a QR decomposition of a matrix A into matrices "
diff --git a/include/nanoeigenpy/decompositions/ldlt.hpp b/include/nanoeigenpy/decompositions/ldlt.hpp
@@ -22,6 +22,9 @@ void exposeLDLTSolver(nb::module_ m, const char *name) {
   using Scalar = typename MatrixType::Scalar;
   using VectorType = Eigen::Matrix<Scalar, -1, 1>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "Robust Cholesky decomposition of a matrix with pivoting.\n\n"
diff --git a/include/nanoeigenpy/decompositions/llt.hpp b/include/nanoeigenpy/decompositions/llt.hpp
@@ -21,6 +21,10 @@ void exposeLLTSolver(nb::module_ m, const char *name) {
   using Chol = Eigen::LLT<MatrixType>;
   using Scalar = typename MatrixType::Scalar;
   using VectorType = Eigen::Matrix<Scalar, -1, 1>;
+
+  if (check_registration_alias<Chol>(m)) {
+    return;
+  }
   nb::class_<Chol>(
       m, name,
       "Standard Cholesky decomposition (LL^T) of a matrix and associated "
diff --git a/include/nanoeigenpy/decompositions/permutation-matrix.hpp b/include/nanoeigenpy/decompositions/permutation-matrix.hpp
@@ -19,6 +19,9 @@ void exposePermutationMatrix(nb::module_ m, const char *name) {
   using VectorIndex = Eigen::Matrix<StorageIndex, SizeAtCompileTime, 1, 0,
                                     MaxSizeAtCompileTime, 1>;
 
+  if (check_registration_alias<PermutationMatrix>(m)) {
+    return;
+  }
   nb::class_<PermutationMatrix>(m, name,
                                 "Permutation matrix.\n"
                                 "This class represents a permutation matrix, "
diff --git a/include/nanoeigenpy/decompositions/self-adjoint-eigen-solver.hpp b/include/nanoeigenpy/decompositions/self-adjoint-eigen-solver.hpp
@@ -15,6 +15,9 @@ void exposeSelfAdjointEigenSolver(nb::module_ m, const char *name) {
   using MatrixType = _MatrixType;
   using Solver = Eigen::SelfAdjointEigenSolver<MatrixType>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(m, name, "Self adjoint Eigen Solver")
 
       .def(nb::init<>(), "Default constructor.")
diff --git a/include/nanoeigenpy/decompositions/sparse/accelerate/accelerate.hpp b/include/nanoeigenpy/decompositions/sparse/accelerate/accelerate.hpp
@@ -60,6 +60,9 @@ struct AccelerateImplVisitor
   }
 
   static void expose(nb::module_& m, const char* name, const char* doc) {
+    if (check_registration_alias<Solver>(m)) {
+      return;
+    }
     nb::class_<Solver>(m, name, doc)
         .def(AccelerateImplVisitor())
         .def(IdVisitor());
diff --git a/include/nanoeigenpy/decompositions/sparse/cholmod/cholmod-simplicial-ldlt.hpp b/include/nanoeigenpy/decompositions/sparse/cholmod/cholmod-simplicial-ldlt.hpp
@@ -13,6 +13,9 @@ void exposeCholmodSimplicialLDLT(nb::module_ m, const char *name) {
   using MatrixType = _MatrixType;
   using Solver = Eigen::CholmodSimplicialLDLT<_MatrixType, _UpLo>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "A simplicial direct Cholesky (LDLT) factorization and solver based on "
diff --git a/include/nanoeigenpy/decompositions/sparse/cholmod/cholmod-simplicial-llt.hpp b/include/nanoeigenpy/decompositions/sparse/cholmod/cholmod-simplicial-llt.hpp
@@ -13,6 +13,9 @@ void exposeCholmodSimplicialLLT(nb::module_ m, const char *name) {
   using MatrixType = _MatrixType;
   using Solver = Eigen::CholmodSimplicialLLT<_MatrixType, _UpLo>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "A simplicial direct Cholesky (LLT) factorization and solver based "
diff --git a/include/nanoeigenpy/decompositions/sparse/cholmod/cholmod-supernodal-llt.hpp b/include/nanoeigenpy/decompositions/sparse/cholmod/cholmod-supernodal-llt.hpp
@@ -13,6 +13,9 @@ void exposeCholmodSupernodalLLT(nb::module_ m, const char *name) {
   using MatrixType = _MatrixType;
   using Solver = Eigen::CholmodSupernodalLLT<_MatrixType, _UpLo>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "A supernodal direct Cholesky (LLT) factorization and solver based on "
diff --git a/include/nanoeigenpy/decompositions/sparse/simplicial-ldlt.hpp b/include/nanoeigenpy/decompositions/sparse/simplicial-ldlt.hpp
@@ -18,6 +18,9 @@ void exposeSimplicialLDLT(nb::module_ m, const char *name) {
   using DenseVectorXs =
       Eigen::Matrix<Scalar, Eigen::Dynamic, 1, MatrixType::Options>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "A direct sparse LDLT Cholesky factorizations.\n\n"
diff --git a/include/nanoeigenpy/decompositions/sparse/simplicial-llt.hpp b/include/nanoeigenpy/decompositions/sparse/simplicial-llt.hpp
@@ -13,6 +13,9 @@ void exposeSimplicialLLT(nb::module_ m, const char *name) {
   using MatrixType = _MatrixType;
   using Solver = Eigen::SimplicialLLT<MatrixType>;
 
+  if (check_registration_alias<Solver>(m)) {
+    return;
+  }
   nb::class_<Solver>(
       m, name,
       "A direct sparse LLT Cholesky factorizations.\n\n"
diff --git a/include/nanoeigenpy/fwd.hpp b/include/nanoeigenpy/fwd.hpp
@@ -4,6 +4,7 @@
 
 #include "nanoeigenpy/config.hpp"
 #include "nanoeigenpy/id.hpp"
+#include "nanoeigenpy/utils/helpers.hpp"
 #include <nanobind/nanobind.h>
 
 #include <Eigen/Core>
diff --git a/include/nanoeigenpy/geometry/angle-axis.hpp b/include/nanoeigenpy/geometry/angle-axis.hpp
@@ -44,6 +44,9 @@ void exposeAngleAxis(nb::module_ m, const char *name) {
   using Vector3 = typename AngleAxis::Vector3;
   using Matrix3 = typename AngleAxis::Matrix3;
 
+  if (check_registration_alias<AngleAxis>(m)) {
+    return;
+  }
   nb::class_<AngleAxis>(m, name, "Angle-axis representation of a 3D rotation.")
       .def(nb::init<>(), "Default constructor")
       .def(nb::init<const Scalar &, const Vector3 &>(), "angle"_a, "axis"_a,
diff --git a/include/nanoeigenpy/geometry/quaternion.hpp b/include/nanoeigenpy/geometry/quaternion.hpp
@@ -3,6 +3,7 @@
 #pragma once
 
 #include "detail/rotation-base.hpp"
+#include "nanoeigenpy/utils/helpers.hpp"
 #include <nanobind/nanobind.h>
 #include <nanobind/operators.h>
 
@@ -243,6 +244,9 @@ struct QuaternionVisitor : nb::def_visitor<QuaternionVisitor<Quaternion>> {
 
  public:
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Quaternion>(m)) {
+      return;
+    }
     nb::class_<Quaternion>(m, name).def(QuaternionVisitor());
   }
 };
diff --git a/include/nanoeigenpy/solvers/basic-preconditioners.hpp b/include/nanoeigenpy/solvers/basic-preconditioners.hpp
@@ -58,6 +58,9 @@ struct DiagonalPreconditionerVisitor
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Preconditioner>(m)) {
+      return;
+    }
     nb::class_<Preconditioner>(m, name).def(IdVisitor());
   }
 };
@@ -84,6 +87,9 @@ struct LeastSquareDiagonalPreconditionerVisitor
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Preconditioner>(m)) {
+      return;
+    }
     nb::class_<Preconditioner>(m, name).def(IdVisitor());
   }
 };
@@ -103,6 +109,9 @@ struct IdentityPreconditionerVisitor
   void execute(nb::class_<Scalar, Ts...>&) {}
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Preconditioner>(m)) {
+      return;
+    }
     nb::class_<Preconditioner>(m, name)
         .def(PreconditionerBaseVisitor<Preconditioner>())
         .def(IdVisitor());
diff --git a/include/nanoeigenpy/solvers/bfgs-preconditioners.hpp b/include/nanoeigenpy/solvers/bfgs-preconditioners.hpp
@@ -31,6 +31,9 @@ struct BFGSPreconditionerBaseVisitor
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Preconditioner>(m)) {
+      return;
+    }
     nb::class_<Preconditioner>(m, name)
         .def(BFGSPreconditionerBaseVisitor<Preconditioner>())
         .def(IdVisitor());
@@ -56,6 +59,9 @@ struct LimitedBFGSPreconditionerBaseVisitor
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Preconditioner>(m)) {
+      return;
+    }
     nb::class_<Preconditioner>(m, name)
         .def(LimitedBFGSPreconditionerBaseVisitor<Preconditioner>())
         .def(IdVisitor());
diff --git a/include/nanoeigenpy/solvers/conjugate-gradient.hpp b/include/nanoeigenpy/solvers/conjugate-gradient.hpp
@@ -28,6 +28,9 @@ struct ConjugateGradientVisitor
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<ConjugateGradient>(m)) {
+      return;
+    }
     nb::class_<ConjugateGradient>(m, name)
         .def(ConjugateGradientVisitor<ConjugateGradient>())
         .def(IdVisitor());
diff --git a/include/nanoeigenpy/solvers/least-squares-conjugate-gradient.hpp b/include/nanoeigenpy/solvers/least-squares-conjugate-gradient.hpp
@@ -28,6 +28,9 @@ struct LeastSquaresConjugateGradientVisitor
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<LeastSquaresConjugateGradient>(m)) {
+      return;
+    }
     nb::class_<LeastSquaresConjugateGradient>(m, name)
         .def(IterativeSolverVisitor<LeastSquaresConjugateGradient>())
         .def(LeastSquaresConjugateGradientVisitor<
diff --git a/include/nanoeigenpy/solvers/minres.hpp b/include/nanoeigenpy/solvers/minres.hpp
@@ -36,6 +36,9 @@ struct MINRESSolverVisitor : nb::def_visitor<MINRESSolverVisitor<_MatrixType>> {
   }
 
   static void expose(nb::module_& m, const char* name) {
+    if (check_registration_alias<Solver>(m)) {
+      return;
+    }
     nb::class_<Solver>(
         m, name,
         "A minimal residual solver for sparse symmetric problems.\n"
diff --git a/include/nanoeigenpy/utils/helpers.hpp b/include/nanoeigenpy/utils/helpers.hpp
@@ -0,0 +1,40 @@
+/// Copyright 2025 INRIA
+
+#pragma once
+
+#include <nanobind/nanobind.h>
+
+namespace nanoeigenpy {
+namespace nb = nanobind;
+
+/*! * Symlink to the current scope the already registered class T.
+ *
+ * @tparam T The class type to be symlinked.
+ * @param m nanobind module.
+ *
+ * \returns true if the type T is effectively symlinked.
+ */
+template <typename T>
+inline bool check_registration_alias(nb::module_& m) {
+  if (nb::handle py_type = nb::type<T>(); py_type.is_valid()) {
+    m.attr(py_type.attr("__name__")) = py_type;
+    return true;
+  }
+  return false;
+}
+
+/*! * Deprecated name of the function inspired by
+ * eigenpy::register_symbolic_link_to_registered_type.
+ *
+ * @tparam T The class type to be symlinked.
+ * @param m nanobind module.
+ *
+ * \returns true if the type T is effectively symlinked.
+ */
+template <typename T>
+[[deprecated("Use check_registration_alias<T>(m) instead.")]]
+inline bool register_symbolic_link_to_registered_type(nb::module_& m) {
+  return check_registration_alias<T>(m);
+}
+
+}  // namespace nanoeigenpy
