Merge pull request #183 from SimonRohou/codac2_dev

Updates

Author: SimonRohou

doc/CMakeLists.txt

@@ -11,7 +11,7 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/mathjax_stmaryrd.js
 
   if(WITH_PYTHON)
 
-    find_package(Doxygen 1.0.0)
+    find_package(Doxygen)
 
     if(NOT DOXYGEN_FOUND)
 

doc/manual/development/info_dev.rst

@@ -36,13 +36,23 @@ If you simply want to use the latest Codac release in Python, you can download t
 1. **Ensure the following prerequisites are met**:
 
    - the prerequisites for the :ref:`C++ installation of Codac <sec-install-cpp-prerequisites>`.
-   - a recent `Doxygen <https://www.doxygen.nl>`_ version. On Linux systems, Debian packages are available:
+   - a supported version of Python (>=3.6).
+   - a recent `Doxygen <https://www.doxygen.nl>`_ version (for instance, release 1.13.0 or newest). On Linux systems, latest releases are not available as Debian packages, so we advice to install Doxygen from the sources:
 
    .. code-block:: bash
 
-      sudo apt-get install -y doxygen
+      cd $HOME
+      git clone https://github.com/doxygen/doxygen
+      cd doxygen
+      git checkout Release_1_13_0 # 1.13.0, or any newer release
+      mkdir build ; cd build
+      cmake -DCMAKE_INSTALL_PREFIX=$HOME/doxygen/build_install ..
+      make ; make install
+
+   .. admonition:: About the use of Doxygen
+      
+      Doxygen software extracts C++ documentation from header files into XML format. We then convert this data into docstring format before embedding it into the binding binaries. In this way, the writing of the documentation is centralized in a single location in the C++ header files.
 
-   - a supported version of Python (>=3.6).
 
 2. **Configure IBEX prior to compiling Codac**:
 
@@ -58,8 +68,7 @@ If you simply want to use the latest Codac release in Python, you can download t
       
       cd $HOME/ibex-lib/build
       cmake -DCMAKE_CXX_FLAGS="-fPIC" -DCMAKE_C_FLAGS="-fPIC" -DCMAKE_INSTALL_PREFIX=$HOME/ibex-lib/build_install -DCMAKE_BUILD_TYPE=Release ..
-      make
-      make install
+      make ; make install
 
 3. **Compile Codac with Python binding**:
 
@@ -78,7 +87,7 @@ If you simply want to use the latest Codac release in Python, you can download t
       git submodule init ; git submodule update
       # Configure CMake
       cmake -DCMAKE_CXX_FLAGS="-fPIC" -DCMAKE_C_FLAGS="-fPIC" -DWITH_PYTHON=ON -DCMAKE_INSTALL_PREFIX=$HOME/codac/build_install -DCMAKE_PREFIX_PATH=$HOME/ibex-lib/build_install -DCMAKE_BUILD_TYPE=Release ..
-      make
+      make ; make install
 
 4. **Configure your Python environment**:
 
@@ -89,6 +98,12 @@ If you simply want to use the latest Codac release in Python, you can download t
       cd $HOME/codac/build/python/python_package
       python setup.py develop --user
 
+   And update your configuration file (for instance, ``$HOME/.bashrc`` on Linux systems) with:
+
+   .. code-block:: bash
+      
+      export PYTHONPATH="${PYTHONPATH}:$HOME/codac/build/python/python_package/"
+
 5. **Verify the installation** (optional):
 
    To ensure that the installation has worked properly, the unit tests of the library can be run:
@@ -110,11 +125,6 @@ If you simply want to use the latest Codac release in Python, you can download t
    You should obtain a graphical output corresponding to a set inversion.
 
 
-.. admonition:: About the use of Doxygen
-   
-   Doxygen software extracts C++ documentation from header files into XML format. We then convert this data into docstring format before embedding it into the binding binaries. In this way, the writing of the documentation is centralized in a single location in the C++ header files.
-
-
 .. admonition:: For admins
 
    The command for uploading the generated wheels on PyPi is:

doc/manual/manual/installation/cpp.rst

@@ -88,7 +88,7 @@ Steps
 
       # Configure IBEX before installation
       cd $HOME/ibex-lib
-      mkdir build && cd build
+      mkdir build ; cd build
       cmake -DCMAKE_INSTALL_PREFIX=$HOME/ibex-lib/build_install -DCMAKE_BUILD_TYPE=Release ..
 
       # Building + installing
@@ -113,7 +113,7 @@ Steps
       cd $HOME/codac
       # Get automatically pybind11 and eigen submodules:
       git submodule init ; git submodule update 
-      mkdir build && cd build
+      mkdir build ; cd build
       cmake -DCMAKE_INSTALL_PREFIX=$HOME/codac/build_install -DCMAKE_PREFIX_PATH=$HOME/ibex-lib/build_install -DCMAKE_BUILD_TYPE=Release ..
 
       # Building + installing
@@ -147,7 +147,7 @@ Steps
    .. code-block:: bash
 
       cd $HOME/codac/examples/01_batman
-      mkdir build && cd build
+      mkdir build ; cd build
       cmake ..
       make
 

doc/manual/manual/installation/python.rst

@@ -3,6 +3,10 @@
 Python installation
 ===================
 
+.. error::
+
+  The following instructions are not valid at the moment: Codac v2 is not yet available on PyPi. To get Codac v2 in Python, please :ref:`compile your own binaries locally on your machine <sec-dev-info-binding>`.
+
 In case you want to use Codac only with Python, then the installation procedure is simply:
 
 1. **Dependencies**: Ensure you have a supported version of Python (>=3.6).

python/src/core/codac2_py_cast.h

@@ -11,6 +11,7 @@
 #pragma once
 
 #include <pybind11/pybind11.h>
+#include <codac2_AnalyticTraj.h>
 
 namespace py = pybind11;
 using namespace pybind11::literals;
@@ -33,6 +34,25 @@ namespace codac2
       return x.cast<const T&>();
     }
 
+  // Casting to trajectory types
+
+    template<typename T>
+      requires std::is_same_v<T,AnalyticTraj<VectorType>>
+    bool is_instance(const py::object& x)
+    {
+      const py::object& x_traj = x.attr("traj");
+      return x_traj && py::isinstance<T>(x_traj);
+    }
+
+    template<typename T>
+      requires std::is_same_v<T,AnalyticTraj<VectorType>>
+    const T& cast(const py::object& x)
+    {
+      assert(is_instance<T>(x));
+      const py::object& x_traj = x.attr("traj");
+      return x_traj.cast<const T&>();
+    }
+
   // Casting to function/expression types
 
     template<typename T>

python/src/core/functions/analytic/codac2_py_AnalyticFunction.h

@@ -90,7 +90,7 @@ using namespace pybind11::literals;
   \
   ; \
 
-FunctionArgsList create_FunctionArgsList(const std::vector<py::object>& l)
+inline FunctionArgsList create_FunctionArgsList(const std::vector<py::object>& l)
 {
   FunctionArgsList args {};
   Index i = 0;

python/src/core/paver/codac2_py_pave.cpp

@@ -21,21 +21,20 @@ using namespace pybind11::literals;
 
 void export_pave(py::module& m)
 {
-  m.def("pave", (PavingOut (*)(const IntervalVector&,const CtcBase<IntervalVector>&,double))&codac2::pave,
-    PAVINGOUT_PAVE_CONST_INTERVALVECTOR_REF_CONST_CTCBASE_INTERVALVECTOR_REF_DOUBLE,
-    "x"_a, "c"_a, "eps"_a);
+  m.def("pave", (PavingOut (*)(const IntervalVector&,const CtcBase<IntervalVector>&,double,bool))&codac2::pave,
+    PAVINGOUT_PAVE_CONST_INTERVALVECTOR_REF_CONST_CTCBASE_INTERVALVECTOR_REF_DOUBLE_BOOL,
+    "x"_a, "c"_a, "eps"_a, "verbose"_a=false);
 
-  m.def("pave", (PavingInOut (*)(const IntervalVector&,const SepBase&,double))&codac2::pave,
-    PAVINGINOUT_PAVE_CONST_INTERVALVECTOR_REF_CONST_SEPBASE_REF_DOUBLE,
-    "x"_a, "s"_a, "eps"_a);
+  m.def("pave", (PavingInOut (*)(const IntervalVector&,const SepBase&,double,bool))&codac2::pave,
+    PAVINGINOUT_PAVE_CONST_INTERVALVECTOR_REF_CONST_SEPBASE_REF_DOUBLE_BOOL,
+    "x"_a, "s"_a, "eps"_a, "verbose"_a=false);
 
   m.def("sivia",
       [](const IntervalVector& x, const py::object& f, const py::object& y, double eps, bool verbose)
       {
         if(!is_instance<AnalyticFunction<ScalarType>>(f)
           && !is_instance<AnalyticFunction<VectorType>>(f)
-          && !is_instance<AnalyticFunction<VectorType>>(f))
-        {
+          && !is_instance<AnalyticFunction<VectorType>>(f)) {
           assert_release("sivia: invalid function type");
         }
 

python/src/graphics/figures/codac2_py_Figure2D.cpp

@@ -10,11 +10,11 @@
 #include <pybind11/pybind11.h>
 #include <pybind11/operators.h>
 #include <pybind11/stl.h>
+#include <codac2_Paving.h>
 #include <codac2_Figure2D.h>
 #include "codac2_py_Figure2D_docs.h" // Generated file from Doxygen XML (doxygen2docstring.py):
 #include "codac2_py_matlab.h"
 #include "codac2_py_cast.h"
-#include <codac2_Paving.h>
 
 using namespace std;
 using namespace codac2;
@@ -135,22 +135,36 @@ void export_Figure2D(py::module& m)
       VOID_FIGURE2D_DRAW_ELLIPSE_CONST_VECTOR_REF_CONST_VECTOR_REF_DOUBLE_CONST_STYLEPROPERTIES_REF,
       "c"_a, "ab"_a, "theta"_a, "s"_a=StyleProperties())
 
-    .def("draw_trajectory", (void(Figure2D::*)(const AnalyticTraj<VectorType>&,const StyleProperties&))&Figure2D::draw_trajectory,
-      VOID_FIGURE2D_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_STYLEPROPERTIES_REF,
-      "x"_a, "s"_a=StyleProperties())
-
     .def("draw_trajectory", (void(Figure2D::*)(const SampledTraj<Vector>&,const StyleProperties&))&Figure2D::draw_trajectory,
       VOID_FIGURE2D_DRAW_TRAJECTORY_CONST_SAMPLEDTRAJ_VECTOR_REF_CONST_STYLEPROPERTIES_REF,
       "x"_a, "s"_a=StyleProperties())
 
-    .def("draw_trajectory", (void(Figure2D::*)(const AnalyticTraj<VectorType>&,const ColorMap&))&Figure2D::draw_trajectory,
-      VOID_FIGURE2D_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_COLORMAP_REF,
-      "x"_a, "cmap"_a)
+    .def("draw_trajectory", [](Figure2D& fig, const py::object& x, const StyleProperties& s)
+        {
+          if(!is_instance<AnalyticTraj<VectorType>>(x)) {
+            assert_release("draw_trajectory: invalid function type");
+          }
+
+          fig.draw_trajectory(cast<AnalyticTraj<VectorType>>(x), s);
+        },
+      VOID_FIGURE2D_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_STYLEPROPERTIES_REF,
+      "x"_a, "s"_a=StyleProperties())
 
     .def("draw_trajectory", (void(Figure2D::*)(const SampledTraj<Vector>&,const ColorMap&))&Figure2D::draw_trajectory,
       VOID_FIGURE2D_DRAW_TRAJECTORY_CONST_SAMPLEDTRAJ_VECTOR_REF_CONST_COLORMAP_REF,
       "x"_a, "cmap"_a)
 
+    .def("draw_trajectory", [](Figure2D& fig, const py::object& x, const ColorMap& cmap)
+        {
+          if(!is_instance<AnalyticTraj<VectorType>>(x)) {
+            assert_release("draw_trajectory: invalid function type");
+          }
+
+          fig.draw_trajectory(cast<AnalyticTraj<VectorType>>(x), cmap);
+        },
+      VOID_FIGURE2D_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_COLORMAP_REF,
+      "x"_a, "cmap"_a)
+
     // Robots
 
     .def("draw_tank", &Figure2D::draw_tank,
@@ -230,22 +244,36 @@ void export_Figure2D(py::module& m)
       STATIC_VOID_DEFAULTVIEW_DRAW_PIE_CONST_VECTOR_REF_CONST_INTERVAL_REF_CONST_INTERVAL_REF_CONST_STYLEPROPERTIES_REF,
       "c"_a, "r"_a, "theta"_a, "s"_a=StyleProperties())
 
-    .def_static("draw_trajectory", (void(*)(const AnalyticTraj<VectorType>&,const StyleProperties&))&DefaultView::draw_trajectory,
-      STATIC_VOID_DEFAULTVIEW_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_STYLEPROPERTIES_REF,
-      "x"_a, "s"_a=StyleProperties())
-
     .def_static("draw_trajectory", (void(*)(const SampledTraj<Vector>&,const StyleProperties&))&DefaultView::draw_trajectory,
       STATIC_VOID_DEFAULTVIEW_DRAW_TRAJECTORY_CONST_SAMPLEDTRAJ_VECTOR_REF_CONST_STYLEPROPERTIES_REF,
       "x"_a, "s"_a=StyleProperties())
 
-    .def_static("draw_trajectory", (void(*)(const AnalyticTraj<VectorType>&,const ColorMap&))&DefaultView::draw_trajectory,
-      STATIC_VOID_DEFAULTVIEW_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_COLORMAP_REF,
-      "x"_a, "cmap"_a)
+    .def_static("draw_trajectory", [](const py::object& x, const StyleProperties& s)
+        {
+          if(!is_instance<AnalyticTraj<VectorType>>(x)) {
+            assert_release("draw_trajectory: invalid function type");
+          }
+
+          DefaultView::draw_trajectory(cast<AnalyticTraj<VectorType>>(x), s);
+        },
+      STATIC_VOID_DEFAULTVIEW_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_STYLEPROPERTIES_REF,
+      "x"_a, "s"_a=StyleProperties())
 
     .def_static("draw_trajectory", (void(*)(const SampledTraj<Vector>&,const ColorMap&))&DefaultView::draw_trajectory,
       STATIC_VOID_DEFAULTVIEW_DRAW_TRAJECTORY_CONST_SAMPLEDTRAJ_VECTOR_REF_CONST_COLORMAP_REF,
       "x"_a, "cmap"_a)
 
+    .def_static("draw_trajectory", [](const py::object& x, const ColorMap& cmap)
+        {
+          if(!is_instance<AnalyticTraj<VectorType>>(x)) {
+            assert_release("draw_trajectory: invalid function type");
+          }
+
+          DefaultView::draw_trajectory(cast<AnalyticTraj<VectorType>>(x), cmap);
+        },
+      STATIC_VOID_DEFAULTVIEW_DRAW_TRAJECTORY_CONST_ANALYTICTRAJ_VECTORTYPE_REF_CONST_COLORMAP_REF,
+      "x"_a, "cmap"_a)
+
     // Robots
 
     .def_static("draw_tank", &DefaultView::draw_tank,

src/core/paver/codac2_pave.cpp

@@ -14,17 +14,20 @@ using namespace codac2;
 
 namespace codac2
 {
-  PavingOut pave(const IntervalVector& x, std::shared_ptr<const CtcBase<IntervalVector>> c, double eps)
+  PavingOut pave(const IntervalVector& x, std::shared_ptr<const CtcBase<IntervalVector>> c, double eps, bool verbose)
   {
-    return pave(x, *c, eps);
+    return pave(x, *c, eps, verbose);
   }
 
-  PavingOut pave(const IntervalVector& x, const CtcBase<IntervalVector>& c, double eps)
+  PavingOut pave(const IntervalVector& x, const CtcBase<IntervalVector>& c, double eps, bool verbose)
   {
     assert_release(eps > 0.);
     assert_release(!x.is_empty());
     assert_release(c.size() >= 2 && "cannot reveal 1d contractors");
 
+    clock_t t_start = clock();
+    Index n_boundary = 0;
+
     PavingOut p(x);
     // In order to be able to reconstruct the initial box, the first level represents the
     // initial domain x (the left node is x, the right one is an empty box).
@@ -42,28 +45,40 @@ namespace codac2
 
       c.contract(get<0>(n->boxes()));
 
-      if(!get<0>(n->boxes()).is_empty() && get<0>(n->boxes()).max_diam() > eps)
+      if(!get<0>(n->boxes()).is_empty())
       {
-        n->bisect();
-        l.push_back(n->left());
-        l.push_back(n->right());
+        if(get<0>(n->boxes()).max_diam() > eps)
+        {
+          n->bisect();
+          l.push_back(n->left());
+          l.push_back(n->right());
+        }
+        
+        else if(verbose)
+          n_boundary++;
       }
-    }
+    }    
 
+    if(verbose)
+      printf("Computation time: %.4fs, %ld boxes\n",
+        (double)(clock()-t_start)/CLOCKS_PER_SEC, n_boundary);
     return p;
   }
 
-  PavingInOut pave(const IntervalVector& x, std::shared_ptr<const SepBase> s, double eps)
+  PavingInOut pave(const IntervalVector& x, std::shared_ptr<const SepBase> s, double eps, bool verbose)
   {
-    return pave(x, *s, eps);
+    return pave(x, *s, eps, verbose);
   }
 
-  PavingInOut pave(const IntervalVector& x, const SepBase& s, double eps)
+  PavingInOut pave(const IntervalVector& x, const SepBase& s, double eps, bool verbose)
   {
     assert_release(eps > 0.);
     assert_release(!x.is_empty());
     assert_release(s.size() >= 2 && "cannot reveal 1d separators");
 
+    clock_t t_start = clock();
+    Index n_boundary = 0;
+
     PavingInOut p(x);
     std::shared_ptr<PavingInOut_Node> n;
     list<std::shared_ptr<PavingInOut_Node>> l { p.tree() };
@@ -77,14 +92,23 @@ namespace codac2
       auto boundary = (xs.inner & xs.outer);
       n->boxes() = { xs.outer, xs.inner };
 
-      if(!boundary.is_empty() && boundary.max_diam() > eps)
+      if(!boundary.is_empty())
       {
-        n->bisect();
-        l.push_back(n->left());
-        l.push_back(n->right());
+        if(boundary.max_diam() > eps)
+        {
+          n->bisect();
+          l.push_back(n->left());
+          l.push_back(n->right());
+        }
+
+        else
+          n_boundary++;
       }
     }
 
+    if(verbose)
+      printf("Computation time: %.4fs, %ld boundary boxes\n",
+        (double)(clock()-t_start)/CLOCKS_PER_SEC, n_boundary);
     return p;
   }
 }