graphChangesSelector4DiGraph.h

Go to the documentation of this file.

#ifndef GUM_LEARNING_GRAPH_CHANGES_SELECTOR_4_DIGRAPH_H
#define GUM_LEARNING_GRAPH_CHANGES_SELECTOR_4_DIGRAPH_H

#include <vector>

#include <agrum/agrum.h>
#include <agrum/core/priorityQueue.h>
#include <agrum/core/sequence.h>
#include <agrum/core/set.h>
#include <agrum/graphs/diGraph.h>
#include <agrum/learning/scores_and_tests/score.h>
#include <agrum/learning/structureUtils/graphChange.h>

namespace gum {

  namespace learning {

    template < typename STRUCTURAL_CONSTRAINT,
               typename GRAPH_CHANGES_GENERATOR,
               template < typename > class ALLOC = std::allocator >
    class GraphChangesSelector4DiGraph {
      public:
      using GeneratorType = GRAPH_CHANGES_GENERATOR;

      // ##########################################################################
      // ##########################################################################

      GraphChangesSelector4DiGraph(Score< ALLOC >&          score,
                                   STRUCTURAL_CONSTRAINT&   constraint,
                                   GRAPH_CHANGES_GENERATOR& changes_generator);

      GraphChangesSelector4DiGraph(
         const GraphChangesSelector4DiGraph< STRUCTURAL_CONSTRAINT,
                                             GRAPH_CHANGES_GENERATOR,
                                             ALLOC >& from);

      GraphChangesSelector4DiGraph(
         GraphChangesSelector4DiGraph< STRUCTURAL_CONSTRAINT,
                                       GRAPH_CHANGES_GENERATOR,
                                       ALLOC >&& from);

      ~GraphChangesSelector4DiGraph();


      // ##########################################################################
      // ##########################################################################

      GraphChangesSelector4DiGraph< STRUCTURAL_CONSTRAINT,
                                    GRAPH_CHANGES_GENERATOR,
                                    ALLOC >&
         operator=(const GraphChangesSelector4DiGraph< STRUCTURAL_CONSTRAINT,
                                                       GRAPH_CHANGES_GENERATOR,
                                                       ALLOC >& from);

      GraphChangesSelector4DiGraph< STRUCTURAL_CONSTRAINT,
                                    GRAPH_CHANGES_GENERATOR,
                                    ALLOC >&
         operator=(GraphChangesSelector4DiGraph< STRUCTURAL_CONSTRAINT,
                                                 GRAPH_CHANGES_GENERATOR,
                                                 ALLOC >&& from);


      // ##########################################################################
      // ##########################################################################

      GeneratorType& graphChangeGenerator() const noexcept;

      bool empty();

      bool empty(const NodeId i);


      const GraphChange& bestChange();


      const GraphChange& bestChange(const NodeId i);


      double bestScore();


      double bestScore(const NodeId i);

      void applyChange(const GraphChange& change);


      void applyChangeWithoutScoreUpdate(const GraphChange& change);


      void updateScoresAfterAppliedChanges();

      bool isChangeValid(const GraphChange& change) const;

      void setGraph(DiGraph& graph);

      std::vector< std::pair< NodeId, double > > nodesSortedByBestScore() const;

      std::vector< std::pair< NodeId, double > > nodesUnsortedWithScore() const;


      private:
      Score< ALLOC >* __score;

      STRUCTURAL_CONSTRAINT* __constraint;

      GRAPH_CHANGES_GENERATOR* __changes_generator;

      Sequence< GraphChange > __changes;


      std::vector< std::pair< double, double > > __change_scores;


      NodeProperty< PriorityQueue< std::size_t, double, std::greater< double > > >
         __change_queue_per_node;

      PriorityQueue< NodeId, double, std::greater< double > > __node_queue;


      Set< std::size_t > __illegal_changes;

      NodeProperty< double > __node_current_scores;

      NodeProperty< std::vector< NodeId, ALLOC< NodeId > > > __parents;

      bool __queues_valid{false};

      Set< NodeId > __queues_to_update;

      bool __isChangeValid(const std::size_t index) const;

      void __invalidateChange(const std::size_t change_index);

      void __illegal2LegalChanges(Set< std::size_t >& changes_to_recompute);

      void
         __findLegalChangesNeedingUpdate(Set< std::size_t >& changes_to_recompute,
                                         const NodeId        target_node);

      void __updateScores(const Set< std::size_t >& changes_to_recompute);

      void __getNewChanges();
    };

  } /* namespace learning */

} /* namespace gum */

#include <agrum/learning/structureUtils/graphChangesSelector4DiGraph_tpl.h>

#endif /* GUM_LEARNING_GRAPH_CHANGES_SELECTOR_4_DIGRAPH_H */