codac_CtcUnion.h

Go to the documentation of this file.

#ifndef __CODAC_CTCUNION_H__
#define __CODAC_CTCUNION_H__

#include <memory>
//#include "ibex_CtcUnion.h"
#include "codac_Ctc.h"

namespace codac
{
  class MultiCtc : public Ctc
  {
    public:

      MultiCtc(int nb_var) : Ctc(nb_var)
      { }

      template<typename C1>
      MultiCtc(const C1& c1) : Ctc(c1.nb_var)
      {
        add_shared_ptr(std::make_shared<C1>(c1));
      }

      template<typename C1,typename... C>
      MultiCtc(const C1& c1, const C&... c) : MultiCtc(c1)
      {
        (add_shared_ptr(std::make_shared<C>(c)), ...);
        for(const auto& ci : _v_ctc) { assert(ci->nb_var == nb_var); }
      }

      template<typename T>
      void add_shared_ptr(std::shared_ptr<T> shrd_ptr)
      {
        _v_ctc.push_back(shrd_ptr);
        _v_ctc_ptrs.push_back(shrd_ptr.get());
      }

      void add_raw_ptr(Ctc *c)
      {
        _v_ctc_ptrs.push_back(c);
      }

    protected:

      std::vector<std::shared_ptr<Ctc>> _v_ctc;
      std::vector<Ctc*> _v_ctc_ptrs;
  };

  class CtcUnion : public MultiCtc
  {
    public:

      CtcUnion(int nb_var) : MultiCtc(nb_var)
      { }

      template<typename C1>
      CtcUnion(const C1& c1) : MultiCtc(c1)
      { }

      template<typename C1,typename... C>
      CtcUnion(const C1& c1, const C&... c) : MultiCtc(c1, c...)
      { }

      void contract(IntervalVector& x)
      {
        IntervalVector result(nb_var, Interval::empty_set());

        for(auto& ci : _v_ctc_ptrs)
        {
          IntervalVector saved_x = x;
          ci->contract(saved_x);
          result |= saved_x;
        }

        x = result;
      }

      template<typename C>
      CtcUnion& operator|=(const C& c)
      {
        assert(c.nb_var == nb_var);
        add_shared_ptr(std::make_shared<C>(c));
        return *this;
      }
  };
}

#endif