new version of bp

packages/CLPBN/clpbn/bp/Util.h

@@ -0,0 +1,244 @@
+#ifndef HORUS_UTIL_H
+#define HORUS_UTIL_H
+
+#include <vector>
+
+#include "Horus.h"
+
+using namespace std;
+
+namespace Util {
+
+void            toLog (Params&);
+void            fromLog (Params&);
+void            normalize (Params&);
+void            logSum (double&, double);
+void            multiply (Params&, const Params&);
+void            multiply (Params&, const Params&, unsigned);
+void            add (Params&, const Params&);
+void            add (Params&, const Params&, unsigned);
+void            pow (Params&, double);
+void            pow (Params&, unsigned);
+double          pow (double, unsigned);
+double          factorial (double);
+unsigned        nrCombinations (unsigned, unsigned);
+double          getL1Distance (const Params&, const Params&);
+double          getMaxNorm (const Params&, const Params&);
+unsigned        getNumberOfDigits (int);
+bool            isInteger (const string&);
+string          parametersToString (const Params&, unsigned = PRECISION);
+vector<string>  getJointStateStrings (const VarNodes&);
+double          tl (double);
+double          fl (double);
+double          multIdenty();
+double          addIdenty();
+double          withEvidence();
+double          noEvidence();
+double          one();
+double          zero();
+
+
+template <class T>
+std::string toString (const T& t)
+{
+  std::stringstream ss;
+  ss << t;
+  return ss.str();
+}
+
+};
+
+
+
+template <typename T> 
+std::ostream& operator << (std::ostream& os, const vector<T>& v)
+{
+  os << "[" ;
+  for (unsigned i = 0; i < v.size(); i++) {
+    os << ((i != 0) ? ", " : "") << v[i];
+  }
+  os << "]" ;
+  return os;
+}
+
+
+
+
+inline void
+Util::logSum (double& x, double y)
+{
+  x = log (exp (x) + exp (y)); return;
+  assert (isfinite (x) && isfinite (y));
+  // If one value is much smaller than the other, keep the larger value.
+  if (x < (y - log (1e200))) {
+    x = y;
+    return;
+  }
+  if (y < (x - log (1e200))) {
+    return;
+  }
+  double diff = x - y;
+  assert (isfinite (diff) && isfinite (x) && isfinite (y));
+  if (!isfinite (exp (diff))) { // difference is too large
+    x = x > y ? x : y;
+  } else { // otherwise return the sum.
+    x = y + log (static_cast<double>(1.0) + exp (diff));
+  }
+}
+
+
+
+inline void
+Util::multiply (Params& v1, const Params& v2)
+{
+  assert (v1.size() == v2.size());
+  for (unsigned i = 0; i < v1.size(); i++) {
+    v1[i] *= v2[i];
+  }
+}
+
+
+
+inline void
+Util::multiply (Params& v1, const Params& v2, unsigned repetitions)
+{
+  for (unsigned count = 0; count < v1.size(); ) {
+    for (unsigned i = 0; i < v2.size(); i++) {
+      for (unsigned r = 0; r < repetitions; r++) {
+        v1[count] *= v2[i];
+        count ++;
+      }
+    }
+  }
+}
+
+
+
+inline void
+Util::add (Params& v1, const Params& v2)
+{
+  assert (v1.size() == v2.size());
+  for (unsigned i = 0; i < v1.size(); i++) {
+    v1[i] += v2[i];
+  }
+}
+
+
+
+inline void
+Util::add (Params& v1, const Params& v2, unsigned repetitions)
+{
+  for (unsigned count = 0; count < v1.size(); ) {
+    for (unsigned i = 0; i < v2.size(); i++) {
+      for (unsigned r = 0; r < repetitions; r++) {
+        v1[count] += v2[i];
+        count ++;
+      }
+    }
+  }
+}
+
+
+
+inline double
+Util::tl (double v)
+{
+  return Globals::logDomain ? log(v) : v;
+}
+
+inline double
+Util::fl (double v) 
+{
+  return Globals::logDomain ? exp(v) : v;
+}
+
+inline double
+Util::multIdenty() {
+  return Globals::logDomain ? 0.0 : 1.0;
+}
+
+inline double
+Util::addIdenty()
+{
+  return Globals::logDomain ? INF : 0.0;
+}
+
+inline double
+Util::withEvidence()
+{
+  return Globals::logDomain ? 0.0 : 1.0;
+}
+
+inline double
+Util::noEvidence() {
+  return Globals::logDomain ? INF : 0.0;
+}
+
+inline double
+Util::one()
+{
+  return Globals::logDomain ? 0.0 : 1.0;
+}
+
+inline double
+Util::zero() {
+  return Globals::logDomain ? INF : 0.0 ;
+}
+
+
+struct NetInfo
+{
+  NetInfo (unsigned size, bool loopy, unsigned nIters, double time)
+  { 
+    this->size   = size;
+    this->loopy  = loopy;
+    this->nIters = nIters;
+    this->time   = time;
+  }
+  unsigned  size;
+  bool      loopy;
+  unsigned  nIters;
+  double    time;
+};
+
+
+struct CompressInfo
+{ 
+  CompressInfo (unsigned a, unsigned b, unsigned c, unsigned d, unsigned e)
+  {
+    nGroundVars     = a; 
+    nGroundFactors  = b; 
+    nClusterVars    = c;
+    nClusterFactors = d;
+    nWithoutNeighs  = e;
+  }
+  unsigned nGroundVars;
+  unsigned nGroundFactors;
+  unsigned nClusterVars;
+  unsigned nClusterFactors;
+  unsigned nWithoutNeighs;
+};
+
+
+class Statistics
+{
+  public:
+    static unsigned getSolvedNetworksCounting (void);
+    static void incrementPrimaryNetworksCounting (void);
+    static unsigned getPrimaryNetworksCounting (void);
+    static void updateStatistics (unsigned, bool, unsigned, double);
+    static void printStatistics (void);
+    static void writeStatisticsToFile (const char*);
+    static void updateCompressingStatistics (
+        unsigned, unsigned, unsigned, unsigned, unsigned);
+
+  private:
+    static string getStatisticString (void);
+
+    static vector<NetInfo> netInfo_;
+    static vector<CompressInfo> compressInfo_;
+    static unsigned primaryNetCount_;
+};
+
+#endif // HORUS_UTIL_H
+