[ctc] improved genericity of contractors (Ctc, CtcInverse, CtcInverseNotIn), again

Author: SimonRohou

src/core/contractors/codac2_Ctc.h

@@ -46,7 +46,7 @@ namespace codac2
       virtual void contract(SlicedTube<X>&... x) const;
       // -> is defined in codac2_SlicedTube.h
 
-      //virtual void contract_tube(SlicedTube<X>&... x) const;
+      virtual void contract_tube(SlicedTube<X>&... x) const;
       // -> is defined in codac2_SlicedTube.h
 
       virtual std::shared_ptr<CtcBase<X...>> copy() const = 0;

src/core/contractors/codac2_CtcInverse.h

@@ -21,42 +21,43 @@ namespace codac2
 {
   class CtcNot;
 
-  template<typename Y, typename... X>
-    requires (sizeof...(X) > 0)
-  class CtcInverse : public Ctc<CtcInverse<Y,X...>,X...>
+  template<typename Y_, typename X0=IntervalVector, typename... X>
+  class CtcInverse : public Ctc<CtcInverse<Y_,X0,X...>,X0,X...>
   {
     public:
 
-      using Ctc<CtcInverse<Y,X...>,X...>::contract;
+      //using Ctc<CtcInverse<Y,X0,X...>,X0,X...>::contract;
+      using Y = typename Wrapper<Y_>::Domain; // Y_ is a possible Eigen expr. type
+      using OutputType = typename ExprType<Y>::Type;
 
       template<typename C>
         requires IsCtcBaseOrPtr<C,Y>
-      CtcInverse(const AnalyticFunction<typename ExprType<Y>::Type>& f, const C& ctc_y, bool with_centered_form = true, bool is_not_in = false)
-        : Ctc<CtcInverse<Y,X...>,X...>(f.input_size()), _f(f), _ctc_y(ctc_y), _with_centered_form(with_centered_form), _is_not_in(is_not_in)
+      CtcInverse(const AnalyticFunction<OutputType>& f, const C& ctc_y, bool with_centered_form = true, bool is_not_in = false)
+        : Ctc<CtcInverse<Y,X0,X...>,X0,X...>(f.input_size()), _f(f), _ctc_y(ctc_y), _with_centered_form(with_centered_form), _is_not_in(is_not_in)
       {
         assert_release([&]() { return f.output_size() == size_of(ctc_y); }()
           && "CtcInverse: invalid dimension of image argument ('y' or 'ctc_y')");
       }
 
-      CtcInverse(const AnalyticFunction<typename ExprType<Y>::Type>& f, const Y& y, bool with_centered_form = true, bool is_not_in = false)
+      CtcInverse(const AnalyticFunction<OutputType>& f, const Y& y, bool with_centered_form = true, bool is_not_in = false)
         : CtcInverse(f, CtcWrapper<Y,Y>(y), with_centered_form, is_not_in)
       { }
 
-      void contract(X&... x) const
+      void contract(X0& x0, X&... x) const
       {
-        return contract_(*_ctc_y.front(), x...);
+        return contract_(*_ctc_y.front(), x0, x...);
       }
 
-      void contract_(const Y& y, X&... x) const
+      void contract_(const Y& y, X0& x0, X&... x) const
       {
-        return contract_(CtcWrapper<Y,Y>(y), x...);
+        return contract_(CtcWrapper<Y,Y>(y), x0, x...);
       }
 
-      void contract_(const CtcBase<Y>& ctc_y, X&... x) const
+      void contract_(const CtcBase<Y>& ctc_y, X0& x0, X&... x) const
       {
         ValuesMap v;
         // Setting user values into a map before the tree evaluation
-        _f.fill_from_args(v, x...);
+        _f.fill_from_args(v, x0, x...);
 
         // Forward/backward algorithm:
 
@@ -83,12 +84,10 @@ namespace codac2
           {
             // todo: the above condition !val_expr.da.is_unbounded() should not be necesary,
             // possible bug in MulOp in case of unbounded domain?
-            using X0 = std::tuple_element_t<0,std::tuple<X...>>;
 
-            if constexpr(sizeof...(X) == 1 && std::is_same_v<X0,IntervalVector>)
+            if constexpr(sizeof...(X) == 0 && std::is_same_v<X0,IntervalVector>)
             {
-              X0& x_ = std::get<0>(std::tie(x...));
-              X0 x_mid = X0(x_.mid());
+              X0 x_mid = X0(x0.mid());
 
               assert(val_expr.a.size() == val_expr.m.size());
               IntervalVector fm { val_expr.a - val_expr.m };
@@ -100,9 +99,9 @@ namespace codac2
 
               else
               {
-                IntervalVector p = x_ - x_mid;
+                IntervalVector p = x0 - x_mid;
                 MulOp::bwd(fm, val_expr.da, p);
-                x_ &= p + x_mid;
+                x0 &= p + x_mid;
               }
             }
 
@@ -114,17 +113,17 @@ namespace codac2
 
         // [4/4] Backward evaluation
         _f.expr()->bwd_eval(v); // recursive backward from the root to the leaves
-        _f.intersect_from_args(v, x...); // updating input values
+        _f.intersect_from_args(v, x0, x...); // updating input values
       }
 
-      const AnalyticFunction<typename ExprType<Y>::Type>& fnc() const
+      const AnalyticFunction<OutputType>& fnc() const
       {
         return _f;
       }
 
     protected:
 
-      const AnalyticFunction<typename ExprType<Y>::Type> _f;
+      const AnalyticFunction<OutputType> _f;
       const Collection<CtcBase<Y>> _ctc_y;
       bool _with_centered_form;
       bool _is_not_in = false;

src/core/contractors/codac2_CtcInverseNotIn.h

@@ -15,12 +15,15 @@
 
 namespace codac2
 {
-  template<typename Y,typename X0=IntervalVector,typename... X>
+  template<typename Y_, typename X0=IntervalVector, typename... X>
   class CtcInverseNotIn : public CtcUnion<X0,X...>
   {
     public:
 
-      CtcInverseNotIn(const AnalyticFunction<typename ExprType<Y>::Type>& f, const Y& y, bool with_centered_form = true)
+      using Y = typename Wrapper<Y_>::Domain; // Y_ is a possible Eigen expr. type
+      using OutputType = typename ExprType<Y>::Type;
+
+      CtcInverseNotIn(const AnalyticFunction<OutputType>& f, const Y& y, bool with_centered_form = true)
         : CtcUnion<X0,X...>(f.input_size())
       {
         const bool is_not_in = true;
@@ -35,7 +38,7 @@ namespace codac2
 
       template<typename C>
         requires IsCtcBaseOrPtr<C,Y>
-      CtcInverseNotIn(const AnalyticFunction<typename ExprType<Y>::Type>& f, const C& ctc_compl, bool with_centered_form = true)
+      CtcInverseNotIn(const AnalyticFunction<OutputType>& f, const C& ctc_compl, bool with_centered_form = true)
         : CtcUnion<X0,X...>(f.input_size())
       {
         const bool is_not_in = true;