simplicialSet.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Christophe GONZALES and Pierre-Henri WUILLEMIN  *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GUM_SIMPLICIAL_SET_H
#define GUM_SIMPLICIAL_SET_H

#include <iostream>
#include <utility>

#include <agrum/agrum.h>

#include <agrum/core/priorityQueue.h>
#include <agrum/graphs/cliqueGraph.h>

#define GUM_QUASI_RATIO 0.99
#define GUM_WEIGHT_THRESHOLD 0.0

namespace gum {

  /* ===========================================================================
   */
  /* ===  CLASS FOR RETRIEVING SIMPLICIAL, ALMOST AND QUASI SIMPLICIAL NODES ===
   */
  /* ===========================================================================
   */
  /* ===========================================================================
   */
  class SimplicialSet {
    public:
    // ############################################################################
    // ############################################################################


    explicit SimplicialSet(UndiGraph*                    graph,
                           const NodeProperty< double >* log_domain_sizes,
                           NodeProperty< double >*       log_weights,
                           double theRatio = GUM_QUASI_RATIO,
                           double theThreshold = GUM_WEIGHT_THRESHOLD);


    SimplicialSet(const SimplicialSet&          simplicial_from,
                  UndiGraph*                    graph,
                  const NodeProperty< double >* log_domain_sizes,
                  NodeProperty< double >*       log_weights,
                  bool                          avoid_check = false);

    SimplicialSet(SimplicialSet&& from);

    ~SimplicialSet();


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


    void makeClique(const NodeId id);


    void eraseClique(const NodeId id);


    void eraseNode(const NodeId id);


    void eraseEdge(const Edge& edge);


    void addEdge(NodeId first, NodeId second);


    bool isSimplicial(const NodeId id);


    bool hasSimplicialNode();

    bool hasAlmostSimplicialNode();

    bool hasQuasiSimplicialNode();


    NodeId bestSimplicialNode();


    const PriorityQueue< NodeId, double >& allSimplicialNodes();

    NodeId bestAlmostSimplicialNode();


    const PriorityQueue< NodeId, double >& allAlmostSimplicialNodes();

    NodeId bestQuasiSimplicialNode();


    const PriorityQueue< NodeId, double >& allQuasiSimplicialNodes();


    void setFillIns(bool on_off);

    const EdgeSet& fillIns() const;


    void setGraph(UndiGraph*                    graph,
                  const NodeProperty< double >* log_domain_sizes,
                  NodeProperty< double >*       log_weights,
                  double                        theRatio = GUM_QUASI_RATIO,
                  double theThreshold = GUM_WEIGHT_THRESHOLD);


    void replaceLogWeights(NodeProperty< double >* old_weigths,
                           NodeProperty< double >* new_weights);



    private:
    UndiGraph* __graph;

    NodeProperty< double >* __log_weights;

    const NodeProperty< double >* __log_domain_sizes;

    PriorityQueue< NodeId, double > __simplicial_nodes;

    PriorityQueue< NodeId, double > __almost_simplicial_nodes;

    PriorityQueue< NodeId, double > __quasi_simplicial_nodes;

    enum class __Belong : char {
      SIMPLICIAL,
      ALMOST_SIMPLICIAL,
      QUASI_SIMPLICIAL,
      NO_LIST
    };
    NodeProperty< __Belong > __containing_list;

    EdgeProperty< Size > __nb_triangles;

    NodeProperty< Size > __nb_adjacent_neighbours;


    double __log_tree_width;

    double __quasi_ratio;

    double __log_threshold;

    NodeSet __changed_status;

    bool __we_want_fill_ins{false};

    EdgeSet __fill_ins_list;


    void __updateList(const NodeId id);

    void __updateAllNodes();

    void __initialize();


    SimplicialSet& operator=(const SimplicialSet&);


    SimplicialSet(const SimplicialSet&);
  };

} /* namespace gum */

#ifndef GUM_NO_INLINE
#  include <agrum/graphs/algorithms/simplicialSet_inl.h>
#endif /* GUM_NO_INLINE */

#endif /* GUM_SIMPLICIAL_SET_H */