codac2_CtcUnion.h

Go to the documentation of this file.

 
#pragma once
 
#include <tuple>
#include <type_traits>
#include "codac2_CtcWrapper.h"
#include "codac2_Collection.h"
#include "codac2_template_tools.h"
 
namespace codac2
{
  template<typename... X>
  class CtcUnion : public Ctc<CtcUnion<X...>,X...>
  {
    public:
 
      explicit CtcUnion(Index n)
        : Ctc<CtcUnion<X...>,X...>(n)
      {
        if constexpr(std::is_same_v<X...,Interval>)
          assert_release(n == 1);
      }
 
      template<typename C>
        requires (IsCtcBaseOrPtr<C,X...> && !std::is_same_v<CtcUnion<X...>,C>)
      CtcUnion(const C& c)
        : Ctc<CtcUnion<X...>,X...>(size_of(c)), _ctcs(c)
      { }
 
      template<typename... C>
        requires (IsCtcBaseOrPtr<C,X...> && ...)
      CtcUnion(const C&... c)
        : Ctc<CtcUnion<X...>,X...>(size_first_item(c...)), _ctcs(c...)
      {
        assert_release(all_same_size(c...));
      }
 
      CtcUnion(const Collection<CtcBase<X...>>& ctcs)
        : Ctc<CtcUnion<X...>,X...>(ctcs.front()->size()), _ctcs(ctcs)
      {
        for(const auto& ci : _ctcs)
        {
          (void)ci;
          assert_release(ci->size() == this->size());
        }
      }
      
      template<typename C>
        requires IsCtcBaseOrPtr<C,X...>
      CtcUnion(std::initializer_list<C> ctcs)
        : CtcUnion(Collection<CtcBase<X...>>(ctcs))
      { }
 
      size_t nb() const
      {
        return _ctcs.size();
      }
 
      void contract(X&... x) const
      {
        const auto input = std::tuple<X...>(x...);
 
        auto result = input;
        std::apply([](auto&... xi)
        {
          (xi.set_empty(), ...);
        }, result);
 
        auto accumulate_union = [&]<std::size_t... I>(const std::tuple<X...>& y, std::index_sequence<I...>)
        {
          ((std::get<I>(result) |= std::get<I>(y)), ...);
        };
 
        for(const auto& ci : _ctcs)
        {
          auto saved = input;
 
          std::apply([&](auto&... xi)
          {
            ci->contract(xi...);
          }, saved);
 
          accumulate_union(saved, std::index_sequence_for<X...>{});
 
          // Each contractor is contractant, hence every remaining branch
          // can only return a subset of input. Once the accumulated union
          // has reached input, the final result is already known.
          if(result == input)
            return;
        }
 
        std::tie(x...) = result;
      }
 
      template<typename C>
        requires IsCtcBaseOrPtr<C,X...>
      CtcUnion<X...>& operator|=(const C& c)
      {
        assert_release(size_of(c) == this->size());
        _ctcs.push_back(c);
        return *this;
      }
 
    protected:
 
      Collection<CtcBase<X...>> _ctcs;
  };
 
  template <>
  class CtcUnion<> : public CtcUnion<IntervalVector>
  { };
 
  template<typename Tuple>
  struct CtcUnionType;
 
  template<typename... T>
  struct CtcUnionType<std::tuple<T...>> {
    using Ctc = CtcUnion<T...>;
  };
 
  template<typename C1,typename C2>
  typename CtcUnionType<typename C1::ContractedTypes>::Ctc operator|(const C1& c1, const C2& c2)
  {
    return { c1, c2 };
  }
 
  template<typename C1,typename C2>
  typename CtcUnionType<typename C1::ContractedTypes>::Ctc operator|(const std::shared_ptr<C1>& c1, const std::shared_ptr<C2>& c2)
  {
    return { c1, c2 };
  }
 
  template<typename C1,typename C2>
  typename CtcUnionType<typename C1::ContractedTypes>::Ctc operator|(const std::shared_ptr<C1>& c1, const C2& c2)
  {
    return { c1, c2 };
  }
 
  template<typename C1,typename C2>
  typename CtcUnionType<typename C1::ContractedTypes>::Ctc operator|(const C1& c1, const std::shared_ptr<C2>& c2)
  {
    return { c1, c2 };
  }
 
  template<typename C2>
    requires std::is_base_of_v<CtcBase<IntervalVector>,C2>
  inline CtcUnion<IntervalVector> operator|(const IntervalVector& c1, const C2& c2)
  {
    assert_release(c1.size() == c2.size());
    return CtcUnion<IntervalVector>(CtcWrapper(c1),c2);
  }
 
  template<typename C1>
    requires std::is_base_of_v<CtcBase<IntervalVector>,C1>
  inline CtcUnion<IntervalVector> operator|(const C1& c1, const IntervalVector& c2)
  {
    assert_release(c1.size() == c2.size());
    return CtcUnion<IntervalVector>(c1,CtcWrapper(c2));
  }
 
  // Template deduction guides
  CtcUnion(Index) -> CtcUnion<IntervalVector>;
 
  template<typename... C>
    requires (IsCtcBaseOrPtr<C,IntervalVector> && ...)
  CtcUnion(const C&...) -> CtcUnion<IntervalVector>;
 
  template<typename C>
  CtcUnion(std::initializer_list<C>) -> CtcUnion<IntervalVector>;
}