Merge pull request #21 from proyan/devel

[code-handler] use Eigen::Ref for the independent and dependent variables in generateCode and makeVariables

Author: jcarpent

.github/workflows/ci-windows-clang.yml

@@ -2,11 +2,11 @@ name: PyCppAD CI for Windows - Clang
 on:
   pull_request:
   push:
-      
+
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
   BUILD_TYPE: Release
-  
+
 jobs:
   build:
     runs-on: ${{ matrix.os }}
@@ -35,7 +35,7 @@ jobs:
     - name: Install cmake and update conda
       run: |
         conda install cmake -c main
-    - name: Build CppADCodeGen, CppAD, PyCppAD
+    - name: Build PyCppAD
       shell: cmd /C CALL {0}
       env:
         ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
@@ -47,22 +47,23 @@ jobs:
         set PATH=%PATH:C:\hostedtoolcache\windows\Boost\1.72.0;=%
 
         call "%programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" amd64
-    
-        :: Create build directory
-        git clone --recursive https://github.com/proyan/CppAD
+
+        :: Install CppAD
+        git clone --recursive https://github.com/jcarpent/CppAD
         cd CppAD
+        git checkout topic/windows
         mkdir build
         pushd build
         cmake ^
           -G "Visual Studio 16 2019" -T "ClangCl" -DCMAKE_GENERATOR_PLATFORM=x64 ^
           -DCMAKE_INSTALL_PREFIX=%CONDA_PREFIX%\Library ^
           -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ^
           ..
-        cmake --build ${{github.workspace}}/CppAD/build --config ${{env.BUILD_TYPE}} --target check install
-        cd ${{github.workspace}}/CppAD/build/
+        cmake --build ${{github.workspace}}/CppAD/build --config ${{env.BUILD_TYPE}} --target install
 
         cd ${{github.workspace}}
 
+        :: Install CppADCodeGen
         git clone --recursive https://github.com/joaoleal/CppADCodeGen
         cd CppADCodeGen
         mkdir build
@@ -74,13 +75,12 @@ jobs:
           -DGOOGLETEST_GIT=ON ^
           ..
         cmake --build ${{github.workspace}}/CppADCodeGen/build --config ${{env.BUILD_TYPE}} --target install
-        cd ${{github.workspace}}
 
+        cd ${{github.workspace}}
 
         mkdir build
         pushd build
 
-
         :: Configure
         cmake ^
           -G "Visual Studio 16 2019" -T "ClangCl" -DCMAKE_GENERATOR_PLATFORM=x64 ^

.github/workflows/ci-windows-v142.yml

@@ -2,11 +2,11 @@ name: PyCppAD CI for Windows - (v142)
 on:
   pull_request:
   push:
-      
+
 env:
   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
   BUILD_TYPE: Release
-  
+
 jobs:
   build:
     runs-on: ${{ matrix.os }}
@@ -34,7 +34,8 @@ jobs:
     - name: Install cmake and update conda
       run: |
         conda install cmake -c main
-    
+        conda install cppadcodegen -c conda-forge
+
     - name: Build PyCppAD
       shell: cmd /C CALL {0}
       env:
@@ -47,7 +48,7 @@ jobs:
         set PATH=%PATH:C:\hostedtoolcache\windows\Boost\1.72.0;=%
 
         call "%programfiles(x86)%\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" amd64
-    
+
         :: Create build directory
         mkdir build
         pushd build

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "cmake"]
 	path = cmake
-	url = git://github.com/jrl-umi3218/jrl-cmakemodules.git
+	url = https://github.com/jrl-umi3218/jrl-cmakemodules.git

.pre-commit-config.yaml

@@ -0,0 +1,8 @@
+repos:
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.2.0
+    hooks:
+    -   id: check-json
+    -   id: check-symlinks
+    -   id: check-toml
+    -   id: check-yaml

example/cppadcg_c_codegen.py

@@ -42,4 +42,8 @@
 langC = LanguageC("double", 3)
 nameGen = LangCDefaultVariableNameGenerator("y","x","v","array","sarray")
 code = handler.generateCode(langC, jac, nameGen, "source")
+output = code.splitlines()
+assert(output[0]=='   y[1] = 0.5 * x[1] + 0.5 * x[1];')
+assert(output[1]=='   // dependent variables without operations')
+assert(output[2]=='   y[0] = 0.5;')
 print(code)

include/pycppad/ad_fun.hpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021 INRIA
+ * Copyright 2021-2022 INRIA
  */
 
 #ifndef __pycppad_ad_fun_hpp__
@@ -68,9 +68,11 @@ namespace pycppad
       x = x_; y = y_;
     }
 
-    static ADFun* constructor(const ADVector & x, const ADVector & y)
+    static ADFun* constructor(RefADVector x, RefADVector y)
     {
-      ADFun * f = new ADFun(x,y);
+      ADVector x_(x),y_(y);
+      ADFun * f = new ADFun(x_,y_);
+      x = x_; y = y_;
       return f;
     }
 

include/pycppad/codegen/code-handler.hpp

@@ -27,31 +27,37 @@ namespace pycppad
       typedef Eigen::Matrix<AD,Eigen::Dynamic,1> VectorAD;
       typedef Eigen::Matrix<ADCG,1,Eigen::Dynamic> RowVectorADCG;
       typedef Eigen::Matrix<CG,Eigen::Dynamic,1> VectorCG;
-      typedef Eigen::Matrix<CG,1,Eigen::Dynamic> RowVectorCG;      
+      typedef Eigen::Matrix<CG,1,Eigen::Dynamic> RowVectorCG;
+      typedef Eigen::Ref<VectorCG> RefVectorCG;
+      typedef Eigen::Ref<RowVectorCG> RefRowVectorCG;
       typedef ::CppAD::cg::CodeHandler<Scalar> CodeHandler;
       typedef ::CppAD::cg::LanguageC<Scalar> LanguageC;
       typedef ::CppAD::cg::LangCDefaultVariableNameGenerator<Scalar> LangCDefaultVariableNameGenerator;
 
 
     protected:
-      template<typename VectorType>
-      static void makeVariables(CodeHandler& self, const VectorType& x)
+
+      template<typename Vector>
+      static void makeVariables(CodeHandler& self, Eigen::Ref<Vector> x)
       {
-        VectorType& x_= const_cast<VectorType&>(x);
-        self.makeVariables(x_);
+        Vector x_(x);
+        ::CppAD::cg::ArrayView<typename Vector::Scalar> independent_av(x_.data(), x_.size());
+        self.makeVariables(independent_av);
+        x = x_;
         return;
       }
 
-      template<typename VectorType, typename LangType, typename NameGenType>
+      template<typename LangType, typename NameGenType>
       static std::string generateCode(CodeHandler& self,
                                       LangType& lang,
-                                      const VectorType& dependent,
+                                      RefVectorCG dependent,
                                       NameGenType& nameGen,
                                       const std::string& jobName)
       {
         std::ostringstream oss;
-        VectorType& dependent_= const_cast<VectorType&>(dependent);
-        ::CppAD::cg::ArrayView<typename VectorType::Scalar> dependent_av(dependent_.data(), dependent_.size());
+        VectorCG dependent_(dependent);
+        ::CppAD::cg::ArrayView<CG> dependent_av(dependent_.data(), dependent_.size());
+        dependent = dependent_;
         self.generateCode(oss, lang, dependent_av, nameGen, jobName);
         return oss.str();
       }
@@ -86,19 +92,7 @@ namespace pycppad
                "Parameters:\n"
                "\tvariables: the vector of variables that will become independent variables")
           .def("makeVariables",
-               &CodeHandler::template makeVariables<RowVectorADCG>,
-               bp::args("self", "variables"),
-               "Marks the provided variables as being independent variables.\n"
-               "Parameters:\n"
-               "\tvariables: the vector of variables that will become independent variables")
-          .def("makeVariables",
-               &CodeHandler::template makeVariables<VectorCG>,
-               bp::args("self", "variables"),
-               "Marks the provided variables as being independent variables.\n"
-               "Parameters:\n"
-               "\tvariables: the vector of variables that will become independent variables")
-          .def("makeVariables",
-               &CodeHandler::template makeVariables<RowVectorCG>,
+               &makeVariables<VectorADCG>,
                bp::args("self", "variables"),
                "Marks the provided variables as being independent variables.\n"
                "Parameters:\n"
@@ -122,18 +116,7 @@ namespace pycppad
                "\tid:  the atomic function ID.")
           //.def("getExternalFuncMaxForwardOrder", &CodeHandler::getExternalFuncMaxForwardOrder, bp::arg("self"))
           //.def("getExternalFuncMaxReverseOrder", &CodeHandler::getExternalFuncMaxReverseOrder, bp::arg("self"))
-          .def("generateCode", &generateCode<VectorCG, LanguageC, LangCDefaultVariableNameGenerator>,
-               (bp::arg("self"), bp::arg("lang"), bp::arg("dependent"), bp::arg("nameGen"), bp::arg("jobName")="source"),
-               "Creates the source code from the operations registered so far.\n"
-               "Parameters:\n"
-               "\tlang: The targeted language.\n"
-               "\tdependent: The dependent variables for which the source code\n"
-               "             should be generated. By defining this vector the \n"
-               "             number of operations in the source code can be\n"
-               "             reduced and thus providing a more optimized code.\n"
-               "\tnameGen: Provides the rules for variable name creation. data related to the model\n"
-               "\tjobName: Name of this job.")
-          .def("generateCode", &generateCode<RowVectorCG, LanguageC, LangCDefaultVariableNameGenerator>,
+          .def("generateCode", &generateCode<LanguageC, LangCDefaultVariableNameGenerator>,
                (bp::arg("self"), bp::arg("lang"), bp::arg("dependent"), bp::arg("nameGen"), bp::arg("jobName")="source"),
                "Creates the source code from the operations registered so far.\n"
                "Parameters:\n"

include/pycppad/independent.hpp

@@ -27,11 +27,8 @@ namespace pycppad
                             const bool record_compare_)
     {
       ADVector x_(x), dynamic(0);
-      size_t abort_op_index = abort_op_index_;
-      bool record_compare = record_compare_;
-      ::CppAD::Independent(x_, abort_op_index, record_compare, dynamic);
+      ::CppAD::Independent(x_, abort_op_index_, record_compare_, dynamic);
       x = x_;
-      return;
     }
 
     static void expose(const std::string & func_name = "Independent")