Enhance portability and flexibility

.github/workflows/cmake.yml → .github/workflows/ci-ubuntu.yml

@@ -38,7 +38,7 @@ jobs:
         export PYTHONPATH=$PYTHONPATH:/opt/openrobots/lib/python3/site-packages:/opt/openrobots/lib/python3/dist-packages
         export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/openrobots/lib64:/opt/openrobots/lib/x86_64-linux-gnu:/opt/openrobots/lib/plugin:/opt/openrobots/lib
         export PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/opt/openrobots/lib/pkgconfig:/opt/openrobots/share/pkgconfig:/opt/openrobots/lib/x86_64-linux-gnu/pkgconfig:/opt/openrobots/lib64/pkgconfig
-        cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DPYTHON_EXECUTABLE=$(which python3) -DCMAKE_PREFIX_PATH=/opt/openrobots -DBUILD_CODEGEN_BINDINGS=ON
+        cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DPYTHON_EXECUTABLE=$(which python3) -DCMAKE_PREFIX_PATH=/opt/openrobots -DBUILD_WITH_CPPAD_CODEGEN_BINDINGS=ON
 
     - name: Build
       # Build your program with the given configuration

CMakeLists.txt

@@ -7,9 +7,9 @@ CMAKE_MINIMUM_REQUIRED(VERSION 3.1)
 SET(PROJECT_NAME pycppad)
 SET(PROJECT_DESCRIPTION "Python bindings for CppAD and CppADCodeGen using Boost.Python")
 SET(PROJECT_URL "https://github.com/simple-robotics/pycppad")
+SET(PROJECT_CUSTOM_HEADER_EXTENSION "hpp")
+SET(PROJECT_USE_CMAKE_EXPORT TRUE)
 
-# Project options
-OPTION(SUFFIX_SO_VERSION "Suffix library name with its version" ON)
 
 # Project configuration
 SET(PROJECT_USE_CMAKE_EXPORT TRUE)
@@ -33,44 +33,52 @@ COMPUTE_PROJECT_ARGS(PROJECT_ARGS LANGUAGES CXX)
 PROJECT(${PROJECT_NAME} ${PROJECT_ARGS})
 CHECK_MINIMAL_CXX_STANDARD(11 ENFORCE)
 
+# Project options
+OPTION(SUFFIX_SO_VERSION "Suffix library name with its version" ON)
+OPTION(BUILD_WITH_CPPAD_CODEGEN_BINDINGS "Build the python bindings for code generation (via CppADCodeGen)" OFF)
+
 FINDPYTHON()
 
 SET_BOOST_DEFAULT_OPTIONS()
 ADD_PROJECT_DEPENDENCY(Boost REQUIRED)
 SEARCH_FOR_BOOST_PYTHON(REQUIRED)
 EXPORT_BOOST_DEFAULT_OPTIONS()
 
+IF(BUILD_WITH_CPPAD_CODEGEN_BINDINGS)
+  ADD_PROJECT_DEPENDENCY(cppadcg 2.4.1 REQUIRED PKG_CONFIG_REQUIRES "cppadcg >= 2.4.1") # CppADCodeGen 2.4.1 is the first version to check the minimal version of CppAD
+  ADD_DEFINITIONS(-DPYCPPAD_WITH_CPPAD_CODEGEN_BINDINGS) 
+ENDIF(BUILD_WITH_CPPAD_CODEGEN_BINDINGS)
+
 ADD_PROJECT_DEPENDENCY(cppad 20180000.0 REQUIRED PKG_CONFIG_REQUIRES "cppad >= 20180000.0")
 ADD_PROJECT_DEPENDENCY(Eigen3 REQUIRED PKG_CONFIG_REQUIRES "eigen3 >= 3.0.5")
 ADD_PROJECT_DEPENDENCY(eigenpy 2.6.6 REQUIRED)
 
-OPTION(BUILD_CODEGEN_BINDINGS "Build the python bindings for code generation (via CppADCodeGen)" OFF)
-
-IF(BUILD_CODEGEN_BINDINGS)
-  ADD_PROJECT_DEPENDENCY(cppadcg 2.4.1 REQUIRED PKG_CONFIG_REQUIRES "cppadcg >= 2.4.1") # CppADCodeGen 2.4.1 is the first version to check the minimal version of CppAD
-  ADD_DEFINITIONS(-DPYCPPAD_BUILD_CPPAD_CODEGEN_BINDINGS) 
-ENDIF(BUILD_CODEGEN_BINDINGS)
-
 SET(${PROJECT_NAME}_HEADERS
   include/${PROJECT_NAME}/fwd.hpp
   include/${PROJECT_NAME}/ad.hpp
   include/${PROJECT_NAME}/independent.hpp
   include/${PROJECT_NAME}/ad_fun.hpp
+  include/${PROJECT_NAME}/cast.hpp
   include/${PROJECT_NAME}/cppad.hpp
   include/${PROJECT_NAME}/cppad-scalar.hpp
+  include/${PROJECT_NAME}/utils/scope.hpp
+
+  # Generated headers
+  ${${PROJECT_NAME}_BINARY_DIR}/include/${PROJECT_NAME}/config.hpp
+  ${${PROJECT_NAME}_BINARY_DIR}/include/${PROJECT_NAME}/deprecated.hpp
+  ${${PROJECT_NAME}_BINARY_DIR}/include/${PROJECT_NAME}/warning.hpp
   )
 
 SET(${PROJECT_NAME}_SOURCES
   src/cppad.cpp
   )
 
-IF(BUILD_CODEGEN_BINDINGS)
+IF(BUILD_WITH_CPPAD_CODEGEN_BINDINGS)
   LIST(APPEND ${PROJECT_NAME}_HEADERS
     include/${PROJECT_NAME}/codegen/cg.hpp
-    include/${PROJECT_NAME}/codegen/ad.hpp
     include/${PROJECT_NAME}/codegen/cppadcg-scalar.hpp
     )
-ENDIF(BUILD_CODEGEN_BINDINGS)
+ENDIF(BUILD_WITH_CPPAD_CODEGEN_BINDINGS)
 
 ADD_LIBRARY(${PROJECT_NAME} SHARED ${${PROJECT_NAME}_SOURCES} ${${PROJECT_NAME}_HEADERS})
 
@@ -79,10 +87,17 @@ IF(SUFFIX_SO_VERSION)
 ENDIF(SUFFIX_SO_VERSION)
 
 TARGET_LINK_BOOST_PYTHON(${PROJECT_NAME} PUBLIC)
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC ${cppad_LIBRARY} eigenpy::eigenpy)
+IF(BUILD_WITH_CPPAD_CODEGEN_BINDINGS)
+  TARGET_INCLUDE_DIRECTORIES(${PROJECT_NAME} 
+    SYSTEM PUBLIC
+    ${cppadcg_INCLUDE_DIR}
+  )
+  TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC ${CMAKE_DL_LIBS})
+ENDIF(BUILD_WITH_CPPAD_CODEGEN_BINDINGS)
 
 TARGET_INCLUDE_DIRECTORIES(${PROJECT_NAME} 
   SYSTEM PUBLIC
-  ${cppad_INCLUDE_DIR}
   ${Boost_INCLUDE_DIRS}
   ${EIGEN3_INCLUDE_DIR}
   ${PYTHON_INCLUDE_DIRS} 

include/pycppad/ad.hpp

@@ -6,8 +6,10 @@
 #define __pycppad_ad_hpp__
 
 #include "pycppad/fwd.hpp"
-#include "eigenpy/user-type.hpp"
-#include "eigenpy/ufunc.hpp"
+#include "pycppad/cast.hpp"
+
+#include <eigenpy/user-type.hpp>
+#include <eigenpy/ufunc.hpp>
 
 namespace pycppad
 {
@@ -27,7 +29,7 @@ namespace pycppad
       cl
       .def(bp::init<>(bp::arg("self"),"Default constructor"))
       .def(bp::init<Scalar>(bp::args("self","value"),
-                            std::string("Constructor from a ").append(typeid(Scalar).name()).c_str()))
+                            std::string("Constructor from a ").append(bp::type_id<Scalar>().name()).c_str()))
       .def(bp::init<AD>(bp::args("self","other"),"Copy constructor"))
       .def(bp::self + bp::self)
       .def(bp::self - bp::self)
@@ -71,7 +73,7 @@ namespace pycppad
       .def("__repr__",&print)
 
       .def("__float__",&::CppAD::Value<Scalar>)
-      .def("__int__",&__int__)
+      .def("__int__",&internal::Cast<AD,int64_t>::run)
       ;
     }
 
@@ -83,11 +85,6 @@ namespace pycppad
       ss << get_class_name() << "(" << self <<")";
       return ss.str();
     }
-
-    static int64_t __int__(const AD & self)
-    {
-      return static_cast<int>(::CppAD::Value<Scalar>(self));
-    }
 
   protected:
 
@@ -109,7 +106,7 @@ namespace pycppad
     {
       set_class_name(class_name);
       bp::class_<AD>(class_name.c_str(),
-                     std::string("AD type corresponding to the scalar type ").append(typeid(Scalar).name()).c_str(),
+                     std::string("AD type corresponding to the scalar type ").append(bp::type_id<Scalar>().name()).c_str(),
                      bp::no_init)
       .def(ADVisitor<Scalar>());
 

include/pycppad/cast.hpp

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2021 INRIA
+ */
+
+#ifndef __pycppad_cast_hpp__
+#define __pycppad_cast_hpp__
+
+#include "pycppad/fwd.hpp"
+
+namespace pycppad
+{
+  namespace internal
+  {
+
+    template<typename From, typename To>
+    struct Cast
+    {
+      static To run(const From & from)
+      {
+        return static_cast<To>(from);
+      }
+    };
+
+    template<typename Scalar>
+    struct CppADValue
+    {
+      static Scalar get(const ::CppAD::AD<Scalar> & v)
+      {
+        return ::CppAD::Value<Scalar>(v);
+      }
+    };
+
+    template<typename Scalar, typename To>
+    struct Cast<::CppAD::AD<Scalar>,To>
+    {
+      typedef ::CppAD::AD<Scalar> From;
+      static To run(const From & from)
+      {
+        return static_cast<To>(CppADValue<Scalar>::get(from));
+      }
+    };
+  } // namespace internal
+} // namespace pycppad
+
+#endif //#ifndef __pycppad_cast_hpp__