new version of bp

2012-03-22 11:33:24 +00:00
parent 6e36498cac
commit 21d317b223
91 changed files with 1255511 additions and 3840 deletions
--- a/packages/CLPBN/clpbn/bp/ConstraintTree.h
+++ b/packages/CLPBN/clpbn/bp/ConstraintTree.h
@@ -0,0 +1,189 @@
+#ifndef HORUS_CONSTRAINTTREE_H
+#define HORUS_CONSTRAINTTREE_H
+
+#include <cassert>
+#include <algorithm>
+
+#include <iostream>
+#include <sstream>
+
+#include "TinySet.h"
+#include "LiftedUtils.h"
+
+using namespace std;
+
+
+class CTNode;
+typedef vector<CTNode*> CTNodes;
+
+class ConstraintTree;
+typedef vector<ConstraintTree*> ConstraintTrees;
+
+
+
+
+class CTNode
+{
+  public:
+    CTNode (const CTNode& n) : symbol_(n.symbol()), level_(n.level()) { }
+
+    CTNode (Symbol s, unsigned l) : symbol_(s) , level_(l) { }
+
+    unsigned level (void) const { return level_; }
+
+    void setLevel (unsigned level) { level_ = level; }
+
+    Symbol symbol (void) const { return symbol_; }
+
+    void setSymbol (const Symbol s) { symbol_ = s; }
+
+    CTNodes& childs (void) { return childs_; }
+
+    const CTNodes& childs (void) const { return childs_; }
+ 
+    unsigned nrChilds (void) const { return childs_.size(); }
+
+    bool isRoot (void) const { return level_ == 0; }
+
+    bool isLeaf (void) const { return childs_.empty(); }
+
+    void                addChild (CTNode*, bool = true);
+    void                removeChild (CTNode*);
+    SymbolSet           childSymbols (void) const;
+
+  private:
+    void                updateChildLevels (CTNode*, unsigned);
+
+    Symbol              symbol_;
+    CTNodes             childs_;
+    unsigned            level_;
+};
+
+
+
+ostream& operator<< (ostream &out, const CTNode&);
+
+
+class ConstraintTree
+{
+  public:
+    ConstraintTree (const LogVars&);
+    ConstraintTree (const LogVars&, const Tuples&);
+    ConstraintTree (const ConstraintTree&);
+   ~ConstraintTree (void);
+
+    CTNode* root (void) const { return root_; }
+    
+    bool empty (void) const { return root_->childs().empty(); }
+
+    const LogVars& logVars (void) const
+    {
+      assert (LogVarSet (logVars_) == logVarSet_);
+      return logVars_;
+    }
+
+    const LogVarSet& logVarSet (void) const
+    {
+      assert (LogVarSet (logVars_) == logVarSet_);
+      return logVarSet_;
+    }
+   
+    unsigned nrLogVars (void) const
+    {
+      return logVars_.size();
+      assert (LogVarSet (logVars_) == logVarSet_);
+    }
+  
+    void               addTuple (const Tuple&);
+    bool               containsTuple (const Tuple&);
+    void               moveToTop (const LogVars&);
+    void               moveToBottom (const LogVars&);
+    void               join (ConstraintTree*, bool = false);
+    unsigned           getLevel (LogVar) const;
+    void               rename (LogVar, LogVar);
+    void               applySubstitution (const Substitution&);
+    void               project (const LogVarSet&);
+    void               remove (const LogVarSet&);
+    bool               isSingleton (LogVar);
+    LogVarSet          singletons (void);
+    TupleSet           tupleSet (unsigned = 0) const;
+    TupleSet           tupleSet (const LogVars&);
+    unsigned           size (void) const;
+    unsigned           nrSymbols (LogVar);
+    void               exportToGraphViz (const char*, bool = false) const;
+    bool               isCountNormalized (const LogVarSet&);
+    unsigned           getConditionalCount (const LogVarSet&);
+    TinySet<unsigned>  getConditionalCounts (const LogVarSet&);
+    bool               isCarteesianProduct (const LogVarSet&) const;
+
+    std::pair<ConstraintTree*, ConstraintTree*> split (
+                           const Tuple&,
+                           unsigned);
+
+    std::pair<ConstraintTree*, ConstraintTree*> split (
+                           const ConstraintTree*,
+                           unsigned) const;
+
+    ConstraintTrees    countNormalize (const LogVarSet&);
+
+    ConstraintTrees jointCountNormalize (
+                           ConstraintTree*,
+                           ConstraintTree*,
+                           LogVar,
+                           LogVar,
+                           LogVar);
+
+    static bool        identical (
+                           const ConstraintTree*,
+                           const ConstraintTree*,
+                           unsigned);
+
+    static bool        overlap (
+                           const ConstraintTree*,
+                           const ConstraintTree*,
+                           unsigned);
+
+    LogVars            expand (LogVar);
+    ConstraintTrees    ground (LogVar);
+   
+  private:
+    unsigned           countTuples (const CTNode*) const;
+    CTNodes            getNodesBelow (CTNode*) const;
+    CTNodes            getNodesAtLevel (unsigned) const;
+    void               swapLogVar (LogVar);
+    bool               join (CTNode*, const Tuple&, unsigned, CTNode*);
+
+    bool               indenticalSubtrees (
+                           const CTNode*,
+                           const CTNode*,
+                           bool) const;
+
+    void               getTuples (
+                           CTNode*,
+                           Tuples,
+                           unsigned,
+                           Tuples&,
+                           CTNodes&) const;
+
+    vector<std::pair<CTNode*, unsigned>> countNormalize (
+                           const CTNode*,
+                           unsigned);
+
+    static void        split (
+                           CTNode*,
+                           CTNode*,
+                           CTNodes&,
+                           unsigned);
+
+    static bool        overlap (const CTNode*, const CTNode*, unsigned);
+    static CTNode*     copySubtree (const CTNode*);
+    static void        deleteSubtree (CTNode*);
+
+    CTNode*            root_;
+    LogVars            logVars_;
+    LogVarSet          logVarSet_;
+};
+
+
+#endif // HORUS_CONSTRAINTTREE_H
+