[py] revised CtcInverse* contractors

Author: SimonRohou

doc/manual/tuto/cp_robotics/lesson_c_dynamic_localization.rst

@@ -267,7 +267,7 @@ State estimation with constraint programming
           :dedent: 0
 
   **C.8.** **Fixpoint resolution.** Finally, the propagation loops need to be updated to incorporate the dynamic constraints.
-  Note that the contractors :math:`\mathcal{C}_\mathbf{f}` and :math:`\mathcal{C}_{\mathrm{deriv}}` apply to the whole tubes :math:`[\mathbf{x}](\cdot)` and :math:`[\mathbf{v}](\cdot)`. Furthermore, the class ``CtcInverse`` can contract tubes using the ``.contract_tube(..)`` method, exactly as we would do for boxes. Finally, a *restriction* on a tube (*i.e.* setting a value to a slice) can be done using the ``.set(y,t)`` method, for setting the interval vector value ``y`` at time ``t``.
+  Note that the contractors :math:`\mathcal{C}_\mathbf{f}` and :math:`\mathcal{C}_{\mathrm{deriv}}` apply to the whole tubes :math:`[\mathbf{x}](\cdot)` and :math:`[\mathbf{v}](\cdot)`. Furthermore, the class ``CtcInverse`` can contract tubes using the ``.contract(..)`` method, exactly as we would do for boxes. Finally, a *restriction* on a tube (*i.e.* setting a value to a slice) can be done using the ``.set(y,t)`` method, for setting the interval vector value ``y`` at time ``t``.
 
   .. container:: toggle, toggle-hidden
 

doc/manual/tuto/cp_robotics/src/lesson_C.cpp

@@ -191,7 +191,7 @@ int main()
       x.set(xi,yi[0]); // restriction on the tube x at time ti=yi[0]
     }
 
-    ctc_f.contract_tube(x,v);
+    ctc_f.contract(x,v);
     ctc_deriv.contract(x,v);
 
   }, x);

doc/manual/tuto/cp_robotics/src/lesson_C.m

@@ -178,7 +178,7 @@
         x.set(xi,yi(1));
     end
 
-    res_ctc_f = ctc_f.contract_tube(x,v);
+    res_ctc_f = ctc_f.contract(x,v);
     x = res_ctc_f{1};
     v = res_ctc_f{2};
 

doc/manual/tuto/cp_robotics/src/lesson_C.py

@@ -170,7 +170,7 @@ def ctc_all_obs(x):
     xi,yi,mi,ai,si = fixpoint(ctc_one_obs, xi,yi,mi,ai,si)
     x.set(xi,yi[0]) # restriction on the tube x at time ti=yi[0]
 
-  x,v = ctc_f.contract_tube(x,v)
+  x,v = ctc_f.contract(x,v)
   ctc_deriv.contract(x,v)
 
   return x

doc/manual/tuto/cp_robotics/src/lesson_D.py

@@ -74,7 +74,7 @@
 
 
 # [D-q7-beg]
-ctc_f.contract_tube(x,v)
+ctc_f.contract(x,v)
 ctc_deriv.contract(x,v)
 # [D-q7-end]
 
@@ -120,7 +120,7 @@
 # [D-q13-beg]
 def contractors_list(x,v):
   ctc_deriv.contract(x,v)
-  ctc_f.contract_tube(x,v)
+  ctc_f.contract(x,v)
   for yi in Y: # for each range-only measurement
     ti = yi[1]
     pi = x(ti)

python/codac/core/__init__.py

@@ -7,6 +7,7 @@
 
 from codac._core import *
 import sys
+import warnings
 
 
 def codac_error(message):
@@ -120,116 +121,28 @@ def copy(self):
     return super().copy()
 
 
-class CtcInverse(Ctc_IntervalVector):
-
-  def __init__(self, f, y, with_centered_form=True):
-
-    f = AnalyticFunction(f)
-
-    if f.nb_args() > 1:
-      total_var = VectorVar(f.input_size())
-
-      i = 0
-      f_args = []
-      for a in f.args():
-        if a.size() == 1:
-          f_args.append(total_var.get_item_0(i))
-          i = i + 1
-        else:
-          f_args.append(total_var.subvector_0(i, i + a.size() - 1))
-          i = i + a.size()
-
-      g = AnalyticFunction([total_var], f(*f_args))
-      CtcInverse.__init__(self, g, y, with_centered_form)
-
-    else:
-      Ctc_IntervalVector.__init__(self, f.input_size())
-      if isinstance(f, AnalyticFunction_Scalar):
-        if not (
-          isinstance(y, (int, float, Interval))
-          or (isinstance(y, list) and len(y) > 0 and len(y) <= 2 and isinstance(y[0], (int, float)))
-        ):
-          codac_error("CtcInverse: inverse argument 'y' should be a scalar type (float,Interval)")
-        self.c = CtcInverse_Interval(f, Interval(y), with_centered_form)
-      elif isinstance(f, AnalyticFunction_Vector):
-        if not isinstance(y, (Vector, IntervalVector, list, Ctc_IntervalVector, Ctc_IntervalVector_)):
-          codac_error(
-            "CtcInverse: inverse argument 'y' should be a vector type "
-            "(Vector,IntervalVector,Ctc_IntervalVector,Ctc_IntervalVector_)"
-          )
-        if isinstance(y, (Ctc_IntervalVector, Ctc_IntervalVector_)):
-          self.c = CtcInverse_IntervalVector(f, y, with_centered_form)
-        else:
-          self.c = CtcInverse_IntervalVector(f, IntervalVector(y), with_centered_form)
-      else:
-        codac_error("CtcInverse: can only build CtcInverse from scalar or vector functions")
-
-  def contract(self, *x):
-
-    if len(x) == 1:
-      return self.c.contract(x[0])
-
-    total = cart_prod(*x)
-    total = self.c.contract(total)
-    i = 0
-    for xi in x:
-      k = xi.size()
-      if k == 1:
-        xi &= total.get_item_0(i)
-      else:
-        xi &= total.subvector_0(i, i + k - 1)
-      i = i + k
-    return x
-
-  def contract_tube(self, *x):
-
-    if len(x) == 1:
-      return self.c.contract_tube(x[0])
-
-    total = tube_cart_prod(*x)
-    total = self.c.contract_tube(total)
-    i = 0
-    for xi in x:
-      k = xi.size()
-      if k == 1:
-        xi &= total.get_item_0(i)
-      else:
-        xi &= total.subvector_0(i, i + k - 1)
-      i = i + k
-    return x
+def CtcInverse(f, y, with_centered_form=True):
+  f = AnalyticFunction(f)
 
-  def copy(self):
-    return self.c.copy()
+  if isinstance(f, AnalyticFunction_Scalar):
+    return CtcInverse_Interval(f, y, with_centered_form)
 
-  def fnc(self):
-    return self.c.fnc()
+  if isinstance(f, AnalyticFunction_Vector):
+    return CtcInverse_IntervalVector(f, y, with_centered_form)
 
+  codac_error("CtcInverse: can only build CtcInverse from scalar or vector functions")
 
-class CtcInverseNotIn(Ctc_IntervalVector):
 
-  def __init__(self, f, y, with_centered_form=True):
-    f = AnalyticFunction(f)
+def CtcInverseNotIn(f, y, with_centered_form=True):
+  f = AnalyticFunction(f)
 
-    Ctc_IntervalVector.__init__(self, f.input_size())
-    if isinstance(f, AnalyticFunction_Scalar):
-      if not (
-        isinstance(y, (int, float, Interval))
-        or (isinstance(y, list) and len(y) > 0 and len(y) <= 2 and isinstance(y[0], (int, float)))
-      ):
-        codac_error("CtcInverseNotIn: inverse argument 'y' should be a scalar type (float,Interval)")
-      self.c = CtcInverseNotIn_Interval(f, Interval(y), with_centered_form)
-    elif isinstance(f, AnalyticFunction_Vector):
-      if not isinstance(y, (Vector, IntervalVector, list)):
-        codac_error("CtcInverseNotIn: inverse argument 'y' should be a vector type (Vector,IntervalVector)")
-      self.c = CtcInverseNotIn_IntervalVector(f, IntervalVector(y), with_centered_form)
-    else:
-      codac_error("CtcInverseNotIn: can only build CtcInverseNotIn from scalar or vector functions")
+  if isinstance(f, AnalyticFunction_Scalar):
+    return CtcInverseNotIn_Interval(f, y, with_centered_form)
 
-  def contract(self, x):
-    return self.c.contract(x)
+  if isinstance(f, AnalyticFunction_Vector):
+    return CtcInverseNotIn_IntervalVector(f, y, with_centered_form)
 
-  def copy(self):
-    return self.c.copy()
+  codac_error("CtcInverseNotIn: can only build CtcInverseNotIn from scalar or vector functions")
 
 
 def Approx(x, eps=sys.float_info.epsilon*10):

python/src/core/CMakeLists.txt

@@ -26,7 +26,6 @@
     contractors/codac2_py_CtcIdentity.cpp
     contractors/codac2_py_CtcInter.cpp
     contractors/codac2_py_CtcInverse.h
-    contractors/codac2_py_CtcInverseNotIn.h
     contractors/codac2_py_CtcLazy.cpp
     contractors/codac2_py_CtcLohner.cpp
     contractors/codac2_py_CtcNot.cpp

python/src/core/codac2_py_core.cpp

@@ -19,7 +19,6 @@
 #include "codac2_py_Sep.h"
 #include "codac2_py_AnalyticFunction.h"
 #include "codac2_py_CtcInverse.h"
-#include "codac2_py_CtcInverseNotIn.h"
 #include "codac2_py_MatrixBlock.h"
 #include "codac2_py_Slice.h"
 
@@ -193,10 +192,12 @@ PYBIND11_MODULE(_core, m)
   export_CtcIdentity(m, py_ctc_iv);
   export_CtcInnerOuter(m, py_ctc_iv);
   export_CtcInter(m, py_ctc_iv);
-  export_CtcInverse<ScalarType>(m,"CtcInverse_Interval",py_ctc_iv);
-  export_CtcInverse<VectorType>(m,"CtcInverse_IntervalVector",py_ctc_iv);
-  export_CtcInverseNotIn<ScalarType>(m,"CtcInverseNotIn_Interval",py_ctc_iv);
-  export_CtcInverseNotIn<VectorType>(m,"CtcInverseNotIn_IntervalVector",py_ctc_iv);
+
+  export_CtcInverse<CtcInverse<Interval>>(m,"CtcInverse_Interval",py_ctc_iv);
+  export_CtcInverse<CtcInverse<IntervalVector>>(m,"CtcInverse_IntervalVector",py_ctc_iv);
+  export_CtcInverse<CtcInverseNotIn<Interval>>(m,"CtcInverseNotIn_Interval",py_ctc_iv);
+  export_CtcInverse<CtcInverseNotIn<IntervalVector>>(m,"CtcInverseNotIn_IntervalVector",py_ctc_iv);
+
   export_CtcLazy(m, py_ctc_iv);
   export_CtcLohner(m);
   export_CtcNot(m, py_ctc_iv);

python/src/core/contractors/codac2_py_Ctc.h

@@ -22,9 +22,38 @@ namespace py = pybind11;
 using namespace py::literals;
 
 
+template<typename C>
+const CtcBase<IntervalVector>& as_ctc_base(const C& c)
+{
+  static_assert(std::is_base_of_v<CtcBase<IntervalVector>, C>,
+    "bind_contract_overloads requires C to derive from CtcBase<IntervalVector>");
+  return static_cast<const CtcBase<IntervalVector>&>(c);
+}
+
+#define CONTRACT_METHODS(exp,clss,doc) \
+  exp \
+    .def("contract", \
+      [](const clss& c, IntervalVector& x) -> const IntervalVector& \
+      { as_ctc_base<clss>(c).contract(x); return x; }, \
+      doc, "x"_a) \
+    .def("contract", \
+      [](const clss& c, SlicedTube<IntervalVector>& x) -> const SlicedTube<IntervalVector>& \
+      { as_ctc_base<clss>(c).contract(x); return x; }, \
+      doc, "x"_a) \
+    /* Deprecated: */ \
+    .def("contract_tube", \
+      [](const clss& c, SlicedTube<IntervalVector>& x) -> const SlicedTube<IntervalVector>& \
+      { \
+        std::cout << "CtcInverse.contract_tube(...) is deprecated; use CtcInverse.contract(...) with SlicedTube arguments instead" << std::endl; \
+        as_ctc_base<clss>(c).contract(x); return x; \
+      }, \
+      doc, "x"_a) \
+  ; \
+
 #define CONTRACT_BOX_METHOD(clss,doc) \
   "contract", [](const clss& c, IntervalVector& x) -> const IntervalVector& { c.contract(x); return x; }, doc, "x"_a
 
+
 class pyCtcIntervalVector : public CtcBase<IntervalVector>
 {
   public: