[bindings] use auto generated names

dune/xt/la/bindings.cc

@@ -43,32 +43,26 @@ PYBIND11_PLUGIN(_la)
 
   LA::bind_Backends(m);
 
-  auto common_dense_vector_double = LA::bind_Vector<LA::CommonDenseVector<double>>(m, "CommonDenseVector_double");
+  auto common_dense_vector_double = LA::bind_Vector<LA::CommonDenseVector<double>>(m);
 #if HAVE_DUNE_ISTL
-  auto istl_dense_vector_double = LA::bind_Vector<LA::IstlDenseVector<double>>(m, "IstlDenseVector_double");
+  auto istl_dense_vector_double = LA::bind_Vector<LA::IstlDenseVector<double>>(m);
 #endif
 #if HAVE_EIGEN
-  auto eigen_dense_vector_double = LA::bind_Vector<LA::EigenDenseVector<double>>(m, "EigenDenseVector_double");
+  auto eigen_dense_vector_double = LA::bind_Vector<LA::EigenDenseVector<double>>(m);
 #endif
 
   LA::bind_SparsityPatternDefault(m);
 
-#define BIND_MATRIX(C, s, c, id) auto c = LA::bind_Matrix<C, s>(m, id);
+#define BIND_MATRIX(C, s, c) auto c = LA::bind_Matrix<C, s>(m);
 
-  BIND_MATRIX(LA::CommonDenseMatrix<double>, false, common_dense_matrix_double, "CommonDenseMatrix_double");
-//  BIND_MATRIX(LA::CommonSparseMatrix<double>, true, common_sparse_matrix_double, "CommonSparseMatrix_double");
+  BIND_MATRIX(LA::CommonDenseMatrix<double>, false, common_dense_matrix_double);
+//  BIND_MATRIX(LA::CommonSparseMatrix<double>, true, common_sparse_matrix_double);
 #if HAVE_DUNE_ISTL
-  BIND_MATRIX(LA::IstlRowMajorSparseMatrix<double>,
-              true,
-              istl_row_major_sparse_matrix_double,
-              "IstlRowMajorSparseMatrix_double");
+  BIND_MATRIX(LA::IstlRowMajorSparseMatrix<double>, true, istl_row_major_sparse_matrix_double);
 #endif
 #if HAVE_EIGEN
-  //  BIND_MATRIX(LA::EigenDenseMatrix<double>, false, eigen_dense_matrix_double, "EigenDenseMatrix_double");
-  BIND_MATRIX(LA::EigenRowMajorSparseMatrix<double>,
-              true,
-              eigen_row_major_sparse_matrix_double,
-              "EigenRowMajorSparseMatrix_double");
+  //  BIND_MATRIX(LA::EigenDenseMatrix<double>, false, eigen_dense_matrix_double);
+  BIND_MATRIX(LA::EigenRowMajorSparseMatrix<double>, true, eigen_row_major_sparse_matrix_double);
 #endif
 #undef BIND_MATRIX
   LA::addbind_Matrix_Vector_interaction(common_dense_matrix_double, common_dense_vector_double);
@@ -81,14 +75,14 @@ PYBIND11_PLUGIN(_la)
   LA::addbind_Matrix_Vector_interaction(eigen_row_major_sparse_matrix_double, eigen_dense_vector_double);
 #endif
 
-  LA::bind_Solver<LA::CommonDenseMatrix<double>>(m, "CommonDenseMatrix_double");
-//  LA::bind_Solver<LA::CommonSparseMatrix<double>>(m, "CommonSparseMatrix_double");
+  LA::bind_Solver<LA::CommonDenseMatrix<double>>(m);
+//  LA::bind_Solver<LA::CommonSparseMatrix<double>>(m);
 #if HAVE_DUNE_ISTL
-  LA::bind_Solver<LA::IstlRowMajorSparseMatrix<double>>(m, "IstlRowMajorSparseMatrix_double");
+  LA::bind_Solver<LA::IstlRowMajorSparseMatrix<double>>(m);
 #endif
 #if HAVE_EIGEN
-  LA::bind_Solver<LA::EigenDenseMatrix<double>>(m, "EigenDenseMatrix");
-  LA::bind_Solver<LA::EigenRowMajorSparseMatrix<double>>(m, "EigenRowMajorSparseMatrix");
+  LA::bind_Solver<LA::EigenDenseMatrix<double>>(m);
+  LA::bind_Solver<LA::EigenRowMajorSparseMatrix<double>>(m);
 #endif
 
   m.def("init_logger",

dune/xt/la/container/matrix-interface.pbh

@@ -87,15 +87,16 @@ struct addbind_Matrix<T, true>
 
 
 template <class C, bool sparse>
-typename std::enable_if<is_matrix<C>::value, pybind11::class_<C>>::type bind_Matrix(pybind11::module& m,
-                                                                                    const std::string& id)
+typename std::enable_if<is_matrix<C>::value, pybind11::class_<C>>::type bind_Matrix(pybind11::module& m)
 {
   namespace py = pybind11;
   using namespace pybind11::literals;
 
   typedef typename C::ScalarType S;
 
-  py::class_<C> c(m, std::string(id).c_str(), std::string(id).c_str(), py::metaclass());
+  const auto ClassName = Common::to_camel_case(bindings::container_name<C>::value());
+
+  py::class_<C> c(m, ClassName.c_str(), ClassName.c_str(), py::metaclass());
 
   addbind_ProvidesBackend(c);
 
@@ -132,9 +133,9 @@ typename std::enable_if<is_matrix<C>::value, pybind11::class_<C>>::type bind_Mat
         "cols"_a,
         "pattern"_a);
 
-  c.def("__repr__", [id](const C& self) {
+  c.def("__repr__", [ClassName](const C& self) {
     std::stringstream ss;
-    ss << id << "(" << self << ")";
+    ss << ClassName << "(" << self << ")";
     return ss.str();
   });
 

dune/xt/la/container/vector-interface.pbh

@@ -21,18 +21,19 @@
 #include <dune/xt/common/string.hh>
 
 #include <dune/xt/la/type_traits.hh>
+#include <dune/xt/la/container.bindings.hh>
 
 #include "vector-interface.hh"
 #include "container-interface.pbh"
 
+
 namespace Dune {
 namespace XT {
 namespace LA {
 
 
 template <class C>
-typename std::enable_if<is_vector<C>::value, pybind11::class_<C>>::type bind_Vector(pybind11::module& m,
-                                                                                    const std::string& id)
+typename std::enable_if<is_vector<C>::value, pybind11::class_<C>>::type bind_Vector(pybind11::module& m)
 {
   namespace py = pybind11;
   using namespace pybind11::literals;
@@ -40,7 +41,9 @@ typename std::enable_if<is_vector<C>::value, pybind11::class_<C>>::type bind_Vec
   typedef typename C::ScalarType S;
   typedef typename C::RealType R;
 
-  py::class_<C> c = bind_ProvidesDataAccess<C>(m, id, id);
+  const auto ClassName = Common::to_camel_case(bindings::container_name<C>::value());
+
+  py::class_<C> c = bind_ProvidesDataAccess<C>(m, ClassName, ClassName);
   addbind_ProvidesBackend(c);
 
   c.def("__init__",
@@ -74,9 +77,9 @@ typename std::enable_if<is_vector<C>::value, pybind11::class_<C>>::type bind_Vec
         "Assigns the elements of the iterable to the vector.");
 
   c.def("__repr__",
-        [id](const C& self) {
+        [ClassName](const C& self) {
           std::stringstream ss;
-          ss << id << "([";
+          ss << ClassName << "([";
           if (self.size() > 0)
             ss << self[0];
           for (size_t ii = 1; ii < std::min(size_t(3), self.size()); ++ii)
@@ -94,9 +97,9 @@ typename std::enable_if<is_vector<C>::value, pybind11::class_<C>>::type bind_Vec
         },
         "A compact representation of the vector (only the first and last three elements).");
   c.def("__str__",
-        [id](const C& self) {
+        [ClassName](const C& self) {
           std::stringstream ss;
-          ss << id << "([";
+          ss << ClassName << "([";
           if (self.size() > 0)
             ss << self[0];
           for (size_t ii = 1; ii < self.size(); ++ii)

dune/xt/la/solver.pbh

@@ -27,16 +27,16 @@ namespace LA {
 
 
 template <class M, class V = typename Container<typename M::ScalarType, M::vector_type>::VectorType>
-typename std::enable_if<is_matrix<M>::value, pybind11::class_<Solver<M>>>::type bind_Solver(pybind11::module& m,
-                                                                                            const std::string& id)
+typename std::enable_if<is_matrix<M>::value, pybind11::class_<Solver<M>>>::type bind_Solver(pybind11::module& m)
 {
   typedef Solver<M> C;
 
   namespace py = pybind11;
   using namespace pybind11::literals;
 
-  std::string name = "Solver__" + id;
-  py::class_<C> c(m, std::string(name).c_str(), std::string(name).c_str());
+  const auto ClassName = Common::to_camel_case(bindings::container_name<M>::value() + "_solver");
+
+  py::class_<C> c(m, ClassName.c_str(), ClassName.c_str());
 
   c.def_static("types", &C::types);
   c.def_static("options", &C::options);