Merge pull request #239 from jcarpent/devel

Fix issue for User Type conversion

cmake @ 09483408

-Subproject commit 3a52692a40839b10f38352c1b06ccfebc0b53f36
+Subproject commit 094834088ad9de32f1abdc2d56d29bca2190772c

include/eigenpy/numpy-type.hpp

@@ -7,6 +7,7 @@
 
 #include "eigenpy/fwd.hpp"
 #include "eigenpy/scalar-conversion.hpp"
+#include "eigenpy/register.hpp"
 
 #include <stdexcept>
 #include <typeinfo>
@@ -16,33 +17,15 @@ namespace eigenpy
 {
   namespace bp = boost::python;
 
-  // By default, the Scalar is considered as a Python object
-  template <typename Scalar> struct NumpyEquivalentType { enum  { type_code = NPY_USERDEF };};
-
-  template <> struct NumpyEquivalentType<float>   { enum { type_code = NPY_FLOAT  };};
-  template <> struct NumpyEquivalentType< std::complex<float> >   { enum { type_code = NPY_CFLOAT  };};
-  template <> struct NumpyEquivalentType<double>  { enum { type_code = NPY_DOUBLE };};
-  template <> struct NumpyEquivalentType< std::complex<double> >  { enum { type_code = NPY_CDOUBLE };};
-  template <> struct NumpyEquivalentType<long double>  { enum { type_code = NPY_LONGDOUBLE };};
-  template <> struct NumpyEquivalentType< std::complex<long double> >  { enum { type_code = NPY_CLONGDOUBLE };};
-  template <> struct NumpyEquivalentType<bool>    { enum { type_code = NPY_BOOL  };};
-  template <> struct NumpyEquivalentType<int>     { enum { type_code = NPY_INT    };};
-  template <> struct NumpyEquivalentType<long>    { enum { type_code = NPY_LONG    };};
-
-  template<typename Scalar>
-  bool isNumpyNativeType()
-  {
-    if((int)NumpyEquivalentType<Scalar>::type_code == NPY_USERDEF)
-      return false;
-    return true;
-  }
-
   template<typename Scalar>
   bool np_type_is_convertible_into_scalar(const int np_type)
   {
+    if(NumpyEquivalentType<Scalar>::type_code >= NPY_USERDEF)
+      return np_type == Register::getTypeCode<Scalar>();
+
     if(NumpyEquivalentType<Scalar>::type_code == np_type)
       return true;
-    
+
     switch(np_type)
     {
       case NPY_INT:

include/eigenpy/numpy.hpp

@@ -31,6 +31,28 @@ namespace eigenpy
 {
   void EIGENPY_DLLAPI import_numpy();
   int EIGENPY_DLLAPI PyArray_TypeNum(PyTypeObject * type);
+  
+  // By default, the Scalar is considered as a Python object
+  template <typename Scalar> struct NumpyEquivalentType { enum  { type_code = NPY_USERDEF };};
+
+  template <> struct NumpyEquivalentType<float>   { enum { type_code = NPY_FLOAT  };};
+  template <> struct NumpyEquivalentType< std::complex<float> >   { enum { type_code = NPY_CFLOAT  };};
+  template <> struct NumpyEquivalentType<double>  { enum { type_code = NPY_DOUBLE };};
+  template <> struct NumpyEquivalentType< std::complex<double> >  { enum { type_code = NPY_CDOUBLE };};
+  template <> struct NumpyEquivalentType<long double>  { enum { type_code = NPY_LONGDOUBLE };};
+  template <> struct NumpyEquivalentType< std::complex<long double> >  { enum { type_code = NPY_CLONGDOUBLE };};
+  template <> struct NumpyEquivalentType<bool>    { enum { type_code = NPY_BOOL  };};
+  template <> struct NumpyEquivalentType<int>     { enum { type_code = NPY_INT    };};
+  template <> struct NumpyEquivalentType<long>    { enum { type_code = NPY_LONG    };};
+
+  template<typename Scalar>
+  bool isNumpyNativeType()
+  {
+    if((int)NumpyEquivalentType<Scalar>::type_code == NPY_USERDEF)
+      return false;
+    return true;
+  }
+
 }
 
 #if defined _WIN32 || defined __CYGWIN__

include/eigenpy/register.hpp

@@ -6,7 +6,7 @@
 #define __eigenpy_register_hpp__
 
 #include "eigenpy/fwd.hpp"
-#include "eigenpy/numpy-type.hpp"
+#include "eigenpy/numpy.hpp"
 #include "eigenpy/exception.hpp"
 
 #include <algorithm>
@@ -36,6 +36,7 @@ namespace eigenpy
     template<typename Scalar>
     static PyTypeObject * getPyType()
     {
+      namespace bp = boost::python;
       if(!isNumpyNativeType<Scalar>())
       {
         const PyTypeObject * const_py_type_ptr = bp::converter::registered_pytype<Scalar>::get_pytype();

package.xml

 <?xml version="1.0"?>
 <package format="3">
   <name>eigenpy</name>
-  <version>2.6.3</version>
+  <version>2.6.4</version>
   <description>Bindings between Numpy and Eigen using Boost.Python</description>
   <maintainer email="justin.carpentier@inria.fr">Justin Carpentier</maintainer>
   <maintainer email="opensource@wolfgangmerkt.com">Wolfgang Merkt</maintainer>

unittest/user_type.cpp

@@ -9,6 +9,63 @@
 #include <iostream>
 #include <sstream>
 
+template<typename Scalar> struct CustomType;
+
+namespace Eigen
+{
+  /// @brief Eigen::NumTraits<> specialization for casadi::SX
+  ///
+  template<typename Scalar>
+  struct NumTraits< CustomType<Scalar> >
+  {
+    typedef CustomType<Scalar> Real;
+    typedef CustomType<Scalar> NonInteger;
+    typedef CustomType<Scalar> Literal;
+    typedef CustomType<Scalar> Nested;
+    
+    enum {
+      // does not support complex Base types
+      IsComplex             = 0 ,
+      // does not support integer Base types
+      IsInteger             = 0 ,
+      // only support signed Base types
+      IsSigned              = 1 ,
+      // must initialize an AD<Base> object
+      RequireInitialization = 1 ,
+      // computational cost of the corresponding operations
+      ReadCost              = 1 ,
+      AddCost               = 2 ,
+      MulCost               = 2
+    };
+    
+    static Scalar epsilon()
+    {
+      return CustomType<Scalar>(std::numeric_limits<Scalar>::epsilon());
+    }
+    
+    static CustomType<Scalar> dummy_precision()
+    {
+      return CustomType<Scalar>(NumTraits<Scalar>::dummy_precision());
+    }
+    
+    static CustomType<Scalar> highest()
+    {
+      return CustomType<Scalar>(std::numeric_limits<Scalar>::max());
+    }
+    
+    static CustomType<Scalar> lowest()
+    {
+      return CustomType<Scalar>(std::numeric_limits<Scalar>::min());
+    }
+    
+    static int digits10()
+    {
+      return std::numeric_limits<Scalar>::digits10;
+    }
+  };
+} // namespace Eigen
+
+
 template<typename Scalar>
 struct CustomType
 {
@@ -46,6 +103,12 @@ struct CustomType
     ss << "value: " << m_value << std::endl;
     return ss.str();
   }
+  
+  friend std::ostream & operator <<(std::ostream & os, const CustomType & X)
+  {
+    os << X.m_value;
+    return os;
+  }
  
 protected:
   
@@ -59,6 +122,12 @@ Eigen::Matrix<CustomType<Scalar>,Eigen::Dynamic,Eigen::Dynamic> create(int rows,
   return Matrix(rows,cols);
 }
 
+template<typename Scalar>
+void print(const Eigen::Matrix<CustomType<Scalar>,Eigen::Dynamic,Eigen::Dynamic> & mat)
+{
+  std::cout << mat << std::endl;
+}
+
 template<typename Scalar>
 Eigen::Matrix<Scalar,Eigen::Dynamic,Eigen::Dynamic> build_matrix(int rows, int cols)
 {
@@ -104,13 +173,17 @@ BOOST_PYTHON_MODULE(user_type)
   typedef CustomType<double> DoubleType;
   typedef Eigen::Matrix<DoubleType,Eigen::Dynamic,Eigen::Dynamic> DoubleMatrix;
   eigenpy::EigenToPyConverter<DoubleMatrix>::registration();
+  eigenpy::EigenFromPyConverter<DoubleMatrix>::registration();
   bp::def("create_double",create<double>);
   
   expose_custom_type<float>("CustomFloat");
   typedef CustomType<float> FloatType;
   typedef Eigen::Matrix<FloatType,Eigen::Dynamic,Eigen::Dynamic> FloatMatrix;
   eigenpy::EigenToPyConverter<FloatMatrix>::registration();
+  eigenpy::EigenFromPyConverter<FloatMatrix>::registration();
   bp::def("create_float",create<float>);
   
   bp::def("build_matrix",build_matrix<double>);
+  bp::def("print",print<double>);
+  bp::def("print",print<float>);
 }