codac_ContractorNetwork.h

Go to the documentation of this file.

#ifndef __CODAC_CONTRACTORNETWORK_H__
#define __CODAC_CONTRACTORNETWORK_H__

#include <deque>
#include <initializer_list>
#include <unordered_map>
#include "codac_Ctc.h"
#include "codac_DynCtc.h"
#include "codac_Domain.h"
#include "codac_CtcDeriv.h"
#include "codac_Hashcode.h"
#include "codac_Contractor.h"
#include "codac_Variable.h"

namespace ibex
{
  class Ctc;
}

namespace codac
{
  class Variable;
  class Domain;
  class DynCtc;
  class CtcDeriv;
  class DomainHashcode;
  class ContractorHashcode;

  class ContractorNetwork
  {
    public:


      ContractorNetwork();

      ~ContractorNetwork();

      int nb_ctc() const;

      int nb_dom() const;

      bool emptiness() const;


      Interval& create_interm_var(const Interval& i);
      Interval& create_dom(const Interval& i); // deprecated

      IntervalVector& create_interm_var(const IntervalVector& iv);
      IntervalVector& create_dom(const IntervalVector& iv); // deprecated

      Tube& create_interm_var(const Tube& t);
      Tube& create_dom(const Tube& t); // deprecated

      TubeVector& create_interm_var(const TubeVector& tv);
      TubeVector& create_dom(const TubeVector& tv); // deprecated

      IntervalVector& subvector(Vector& v, int start_index, int end_index);

      IntervalVector& subvector(IntervalVector& iv, int start_index, int end_index);

      // not yet suported: /**
      // not yet suported:  * \brief Creates a subvector of a TubeVector domain
      // not yet suported:  *
      // not yet suported:  * \param tv TubeVector domain
      // not yet suported:  * \param start_index first component index of the subvector to be returned
      // not yet suported:  * \param end_index last component index of the subvector to be returned
      // not yet suported:  * \return a reference to the created TubeVector extracted from the TubeVector domain
      // not yet suported:  */
      // not yet suported: TubeVector& subvector(TubeVector& tv, int start_index, int end_index);

      void add(Ctc& static_ctc, const std::vector<Domain>& v_domains);

      void add(DynCtc& dyn_ctc, const std::vector<Domain>& v_domains);


      void add(ContractorNetwork& cn);

      void add_data(Tube& x, double t, const Interval& y);

      void add_data(TubeVector& x, double t, const IntervalVector& y);


      double contract(bool verbose = false);

      double contract(const std::unordered_map<Domain,Domain>& var_dom, bool verbose = false);

      double contract_ordered_mode(bool verbose = false);

      double contract_during(double dt, bool verbose = false);

      void set_fixedpoint_ratio(float r);

      void trigger_all_contractors();

      void reset_interm_vars();

      int nb_ctc_in_stack() const;

      int iteration_nb() const;
      


      void set_name(Domain dom, const std::string& name);

      void set_name(Ctc& ctc, const std::string& name);

      void set_name(DynCtc& ctc, const std::string& name);

      int print_dot_graph(const std::string& cn_name = "cn", const std::string& layer_model = "fdp") const;

      friend std::ostream& operator<<(std::ostream& str, const ContractorNetwork& cn);


    protected:

      Domain* add_dom(const Domain& ad);

      Contractor* add_ctc(const Contractor& ac);

      void add_ctc_to_queue(Contractor *ac, std::deque<Contractor*>& ctc_deque);

      void reset_value(Domain *dom);

      void trigger_ctc_related_to_dom(Domain *dom, Contractor *ctc_to_avoid = nullptr);

      void replace_var_by_dom(Domain var, Domain dom);

    protected:

      std::map<DomainHashcode,Domain*> m_map_domains; 
      std::map<ContractorHashcode,Contractor*> m_map_ctc; 
      std::deque<Contractor*> m_deque; 

      int m_iteration_nb = 0;
      float m_fixedpoint_ratio = 0.0001; 
      double m_contraction_duration_max = std::numeric_limits<double>::infinity(); 

      CtcDeriv *m_ctc_deriv = nullptr; 
      std::list<std::pair<Domain*,Domain*> > m_domains_related_to_ctcderiv;

      friend class Domain;
      friend class Contractor;
  };
}

#endif