Merge pull request #361 from jcarpent/devel

Remove support of numpy.matrix class

Author: jcarpent

README.md

@@ -10,14 +10,17 @@ EigenPy — Efficient Python bindings between Numpy/Eigen
   <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code style: black"></a>
 </p>
 
-**EigenPy** is an open source framework which allows to bind the famous [Eigen](http://eigen.tuxfamily.org) C++ library in Python.
+**EigenPy** is an open source framework which allows to bind the famous [Eigen](http://eigen.tuxfamily.org) C++ library in Python via Boost.Python.
 
 **EigenPy** provides:
  - full memory sharing between Numpy and Eigen avoiding memory allocation
  - full support Eigen::Ref avoiding memory allocation
+ - full support of the Eigen::Tensor module
  - exposition of the Geometry module of Eigen for easy code prototyping
  - standard matrix decomposion routines of Eigen such as the Cholesky decomposition, SVD decomposition, QR decomposition, and etc.
  - full support of SWIG objects
+ - full support of runtime declaration of Numpy scalar types
+ - extended API to expose std::vector types
 
 ## Setup
 
@@ -26,9 +29,10 @@ The installation of **EigenPy** on your computer is made easy for Linux/BSD, Mac
 ### The Conda approach
 
 You simply need this simple line:
-```
+```bash
 conda install eigenpy -c conda-forge
 ```
+
 ### Ubuntu
 
 You can easily install **EigenPy** from binairies.
@@ -43,18 +47,14 @@ sudo sh -c "echo 'deb [arch=amd64] http://robotpkg.openrobots.org/packages/debia
 curl http://robotpkg.openrobots.org/packages/debian/robotpkg.key | sudo apt-key add -
 ```
 3. You need to run at least once apt update to fetch the package descriptions:
-```
+```bash
 sudo apt-get update
 ```
+
 #### Install EigenPy
 4. The installation of **EigenPy** and its dependencies is made through the line:
 
-For Python 2.7
-```
-sudo apt install robotpkg-py27-eigenpy
-```
-or for Python 3.{5,6,7}
-```
+```bash
 sudo apt install robotpkg-py35-eigenpy
 ```
 where 35 should be replaced by the python 3 you want to work this (e.g. `robotpkg-py36-eigenpy` to work with Python 3.6).
@@ -81,6 +81,7 @@ The following people have been involved in the development of **EigenPy**:
 - [Wolfgang Merkt](http://www.wolfgangmerkt.com/) (University of Edinburgh): ROS integration and support
 - [Sean Yen](https://www.linkedin.com/in/seanyentw) (Microsoft): Windows integration
 - [Loïc Estève](https://github.com/lesteve) (INRIA): Conda integration
+- [Wilson Jallet](https://manifoldfr.github.io/) (INRIA/LAAS-CNRS): core developer
 
 If you have taken part to the development of **EigenPy**, feel free to add your name and contribution here.
 

benchmarks/bench-switch.py

@@ -24,23 +24,6 @@
 ipython.magic(cmd2)
 print("\n")
 
-eigenpy.switchToNumpyMatrix()
-print("----------------------")
-print("switch to numpy matrix")
-print("----------------------")
-print("\n")
-
-cmd3 = "timeit quat.coeffs()"
-print(cmd3)
-ipython.magic(cmd3)
-print("\n")
-
-eigenpy.switchToNumpyArray()
-print("---------------------")
-print("switch to numpy array")
-print("---------------------")
-print("\n")
-
 cmd4 = "timeit quat.coeffs()"
 print(cmd4)
 ipython.magic(cmd4)

include/eigenpy/eigen-to-python.hpp

@@ -101,9 +101,8 @@ struct eigen_to_py_impl_matrix {
     PyArrayObject* pyArray;
     // Allocate Python memory
     if ((((!(C == 1) != !(R == 1)) && !MatrixDerived::IsVectorAtCompileTime) ||
-         MatrixDerived::IsVectorAtCompileTime) &&
-        NumpyType::getType() ==
-            ARRAY_TYPE)  // Handle array with a single dimension
+         MatrixDerived::IsVectorAtCompileTime))  // Handle array with a single
+                                                 // dimension
     {
       npy_intp shape[1] = {C == 1 ? R : C};
       pyArray = NumpyAllocator<MatType>::allocate(

include/eigenpy/numpy-type.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2020 INRIA
+ * Copyright 2018-2023 INRIA
  */
 
 #ifndef __eigenpy_numpy_type_hpp__
@@ -45,54 +45,30 @@ bool np_type_is_convertible_into_scalar(const int np_type) {
   }
 }
 
-enum NP_TYPE { MATRIX_TYPE, ARRAY_TYPE };
-
 struct EIGENPY_DLLAPI NumpyType {
   static NumpyType& getInstance();
 
-  operator bp::object() { return getInstance().CurrentNumpyType; }
-
   static bp::object make(PyArrayObject* pyArray, bool copy = false);
 
   static bp::object make(PyObject* pyObj, bool copy = false);
 
-  static void setNumpyType(bp::object& obj);
-
   static void sharedMemory(const bool value);
 
   static bool sharedMemory();
 
-  static void switchToNumpyArray();
-
-  static void switchToNumpyMatrix();
-
-  static NP_TYPE& getType();
-
   static bp::object getNumpyType();
 
-  static const PyTypeObject* getNumpyMatrixType();
-
   static const PyTypeObject* getNumpyArrayType();
 
-  static bool isMatrix();
-
-  static bool isArray();
-
  protected:
   NumpyType();
 
-  bp::object CurrentNumpyType;
   bp::object pyModule;
 
   // Numpy types
-  bp::object NumpyMatrixObject;
-  PyTypeObject* NumpyMatrixType;
-  // bp::object NumpyAsMatrixObject; PyTypeObject * NumpyAsMatrixType;
   bp::object NumpyArrayObject;
   PyTypeObject* NumpyArrayType;
 
-  NP_TYPE np_type;
-
   bool shared_memory;
 };
 }  // namespace eigenpy

src/eigenpy.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright 2014-2019, CNRS
- * Copyright 2018-2021, INRIA
+ * Copyright 2018-2023, INRIA
  */
 
 #include "eigenpy/eigenpy.hpp"
@@ -30,20 +30,6 @@ void enableEigenPy() {
 
   Exception::registerException();
 
-  bp::def(
-      "setNumpyType", &NumpyType::setNumpyType, bp::arg("numpy_type"),
-      "Change the Numpy type returned by the converters from an Eigen object.");
-
-  bp::def(
-      "getNumpyType", &NumpyType::getNumpyType,
-      "Get the Numpy type returned by the converters from an Eigen object.");
-
-  bp::def("switchToNumpyArray", &NumpyType::switchToNumpyArray,
-          "Set the conversion from Eigen::Matrix to numpy.ndarray.");
-
-  bp::def("switchToNumpyMatrix", &NumpyType::switchToNumpyMatrix,
-          "Set the conversion from Eigen::Matrix to numpy.matrix.");
-
   bp::def("sharedMemory", (void (*)(const bool))NumpyType::sharedMemory,
           bp::arg("value"),
           "Share the memory when converting from Eigen to Numpy.");

src/numpy-type.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018-2020 INRIA
+ * Copyright 2018-2023 INRIA
  */
 
 #include "eigenpy/numpy-type.hpp"
@@ -17,70 +17,24 @@ bp::object NumpyType::make(PyArrayObject* pyArray, bool copy) {
   return make((PyObject*)pyArray, copy);
 }
 
-bp::object NumpyType::make(PyObject* pyObj, bool copy) {
+bp::object NumpyType::make(PyObject* pyObj, bool /*copy*/) {
   bp::object m;
-  if (isMatrix())
-    m = getInstance().NumpyMatrixObject(bp::object(bp::handle<>(pyObj)),
-                                        bp::object(), copy);
-  //    m = NumpyAsMatrixObject(bp::object(bp::handle<>(pyObj)));
-  else if (isArray())
-    m = bp::object(bp::handle<>(pyObj));  // nothing to do here
+  m = bp::object(bp::handle<>(pyObj));  // nothing to do here
 
   Py_INCREF(m.ptr());
   return m;
 }
 
-void NumpyType::setNumpyType(bp::object& obj) {
-  PyTypeObject* obj_type = PyType_Check(obj.ptr())
-                               ? reinterpret_cast<PyTypeObject*>(obj.ptr())
-                               : obj.ptr()->ob_type;
-  if (PyType_IsSubtype(obj_type, getInstance().NumpyMatrixType))
-    switchToNumpyMatrix();
-  else if (PyType_IsSubtype(obj_type, getInstance().NumpyArrayType))
-    switchToNumpyArray();
-}
-
 void NumpyType::sharedMemory(const bool value) {
   getInstance().shared_memory = value;
 }
 
 bool NumpyType::sharedMemory() { return getInstance().shared_memory; }
 
-void NumpyType::switchToNumpyArray() {
-  getInstance().CurrentNumpyType = getInstance().NumpyArrayObject;
-  getInstance().getType() = ARRAY_TYPE;
-}
-
-void NumpyType::switchToNumpyMatrix() {
-  getInstance().CurrentNumpyType = getInstance().NumpyMatrixObject;
-  getInstance().getType() = MATRIX_TYPE;
-}
-
-NP_TYPE& NumpyType::getType() { return getInstance().np_type; }
-
-bp::object NumpyType::getNumpyType() { return getInstance().CurrentNumpyType; }
-
-const PyTypeObject* NumpyType::getNumpyMatrixType() {
-  return getInstance().NumpyMatrixType;
-}
-
 const PyTypeObject* NumpyType::getNumpyArrayType() {
   return getInstance().NumpyArrayType;
 }
 
-bool NumpyType::isMatrix() {
-  return PyType_IsSubtype(
-      reinterpret_cast<PyTypeObject*>(getInstance().CurrentNumpyType.ptr()),
-      getInstance().NumpyMatrixType);
-}
-
-bool NumpyType::isArray() {
-  if (getInstance().isMatrix()) return false;
-  return PyType_IsSubtype(
-      reinterpret_cast<PyTypeObject*>(getInstance().CurrentNumpyType.ptr()),
-      getInstance().NumpyArrayType);
-}
-
 NumpyType::NumpyType() {
   pyModule = bp::import("numpy");
 
@@ -90,16 +44,8 @@ NumpyType::NumpyType() {
   Py_INCREF(pyModule.ptr());
 #endif
 
-  NumpyMatrixObject = pyModule.attr("matrix");
-  NumpyMatrixType = reinterpret_cast<PyTypeObject*>(NumpyMatrixObject.ptr());
   NumpyArrayObject = pyModule.attr("ndarray");
   NumpyArrayType = reinterpret_cast<PyTypeObject*>(NumpyArrayObject.ptr());
-  // NumpyAsMatrixObject = pyModule.attr("asmatrix");
-  // NumpyAsMatrixType =
-  // reinterpret_cast<PyTypeObject*>(NumpyAsMatrixObject.ptr());
-
-  CurrentNumpyType = NumpyArrayObject;  // default conversion
-  np_type = ARRAY_TYPE;
 
   shared_memory = true;
 }

unittest/CMakeLists.txt

@@ -80,10 +80,6 @@ if(NOT NUMPY_WITH_BROKEN_UFUNC_SUPPORT)
                        "unittest")
 endif()
 
-add_python_unit_test("py-switch" "unittest/python/test_switch.py"
-                     "python;unittest")
-set_tests_properties("py-switch" PROPERTIES DEPENDS ${PYWRAP})
-
 add_python_unit_test("py-dimensions" "unittest/python/test_dimensions.py"
                      "python;unittest")
 set_tests_properties("py-dimensions" PROPERTIES DEPENDS ${PYWRAP})