refactor HorusYap

packages/CLPBN/horus/HorusYap.cpp

@@ -24,25 +24,15 @@ using namespace std;
 
 typedef std::pair<ParfactorList*, ObservedFormulas*> LiftedNetwork;
 
-Params readParameters (YAP_Term);
+Parfactor* readParfactor (YAP_Term);
-
-vector<unsigned> readUnsignedList (YAP_Term);
 
 void readLiftedEvidence (YAP_Term, ObservedFormulas&);
 
-Parfactor* readParfactor (YAP_Term);
+vector<unsigned> readUnsignedList (YAP_Term list);
 
+Params readParameters (YAP_Term);
 
-vector<unsigned>
+YAP_Term fillAnswersPrologList (vector<Params>& results);
-readUnsignedList (YAP_Term list)
-{
-  vector<unsigned> vec;
-  while (list != YAP_TermNil()) {
-    vec.push_back ((unsigned) YAP_IntOfTerm (YAP_HeadOfTerm (list)));
-    list = YAP_TailOfTerm (list);
-  }
-  return vec;
-}
 
 
 
@@ -85,132 +75,6 @@ createLiftedNetwork (void)
 
 
 
-Parfactor*
-readParfactor (YAP_Term pfTerm)
-{
-  // read dist id
-  unsigned distId = YAP_IntOfTerm (YAP_ArgOfTerm (1, pfTerm));
-
-  // read the ranges
-  Ranges ranges;
-  YAP_Term rangeList = YAP_ArgOfTerm (3, pfTerm);
-  while (rangeList != YAP_TermNil()) {
-    unsigned range = (unsigned) YAP_IntOfTerm (YAP_HeadOfTerm (rangeList));
-    ranges.push_back (range);
-    rangeList = YAP_TailOfTerm (rangeList);
-  }
-
-  // read parametric random vars
-  ProbFormulas formulas;
-  unsigned count = 0;
-  unordered_map<YAP_Term, LogVar> lvMap;
-  YAP_Term pvList = YAP_ArgOfTerm (2, pfTerm);
-  while (pvList != YAP_TermNil()) {
-    YAP_Term formulaTerm = YAP_HeadOfTerm (pvList);
-    if (YAP_IsAtomTerm (formulaTerm)) {
-      string name ((char*) YAP_AtomName (YAP_AtomOfTerm (formulaTerm)));
-      Symbol functor = LiftedUtils::getSymbol (name);
-      formulas.push_back (ProbFormula (functor, ranges[count]));
-    } else {
-      LogVars logVars;
-      YAP_Functor yapFunctor = YAP_FunctorOfTerm (formulaTerm);
-      string name ((char*) YAP_AtomName (YAP_NameOfFunctor (yapFunctor)));
-      Symbol functor = LiftedUtils::getSymbol (name);
-      unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
-      for (unsigned i = 1; i <= arity; i++) {
-        YAP_Term ti = YAP_ArgOfTerm (i, formulaTerm);
-        unordered_map<YAP_Term, LogVar>::iterator it = lvMap.find (ti);
-        if (it != lvMap.end()) {
-          logVars.push_back (it->second);
-        } else {
-         unsigned newLv = lvMap.size();
-         lvMap[ti] = newLv;
-         logVars.push_back (newLv);
-        }
-      }
-      formulas.push_back (ProbFormula (functor, logVars, ranges[count]));
-    }
-    count ++;
-    pvList = YAP_TailOfTerm (pvList);
-  }
-
-  // read the parameters
-  const Params& params = readParameters (YAP_ArgOfTerm (4, pfTerm)); 
-
-  // read the constraint
-  Tuples tuples;
-  if (lvMap.size() >= 1) {
-    YAP_Term tupleList = YAP_ArgOfTerm (5, pfTerm);
-    while (tupleList != YAP_TermNil()) {
-      YAP_Term term = YAP_HeadOfTerm (tupleList);
-      assert (YAP_IsApplTerm (term));
-      YAP_Functor yapFunctor = YAP_FunctorOfTerm (term);
-      unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
-      assert (lvMap.size() == arity);
-      Tuple tuple (arity);
-      for (unsigned i = 1; i <= arity; i++) {
-        YAP_Term ti = YAP_ArgOfTerm (i, term);
-        if (YAP_IsAtomTerm (ti) == false) {
-          cerr << "error: constraint has free variables" << endl;
-          abort();
-        }
-        string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ti)));
-        tuple[i - 1] = LiftedUtils::getSymbol (name);
-      }
-      tuples.push_back (tuple);
-      tupleList = YAP_TailOfTerm (tupleList);
-    }
-  }
-  return new Parfactor (formulas, params, tuples, distId);
-}
-
-
-
-void
-readLiftedEvidence (
-    YAP_Term observedList,
-    ObservedFormulas& obsFormulas)
-{
-  while (observedList != YAP_TermNil()) {
-    YAP_Term pair = YAP_HeadOfTerm (observedList);
-    YAP_Term ground = YAP_ArgOfTerm (1, pair);
-    Symbol functor;
-    Symbols args;
-    if (YAP_IsAtomTerm (ground)) {
-      string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ground)));
-      functor = LiftedUtils::getSymbol (name);
-    } else {
-      assert (YAP_IsApplTerm (ground));
-      YAP_Functor yapFunctor = YAP_FunctorOfTerm (ground);
-      string name ((char*) (YAP_AtomName (YAP_NameOfFunctor (yapFunctor))));
-      functor = LiftedUtils::getSymbol (name);
-      unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
-      for (unsigned i = 1; i <= arity; i++) {
-        YAP_Term ti = YAP_ArgOfTerm (i, ground);
-        assert (YAP_IsAtomTerm (ti));
-        string arg ((char *) YAP_AtomName (YAP_AtomOfTerm (ti)));
-        args.push_back (LiftedUtils::getSymbol (arg));
-      }
-    }
-    unsigned evidence = (unsigned) YAP_IntOfTerm (YAP_ArgOfTerm (2, pair));
-    bool found = false;
-    for (size_t i = 0; i < obsFormulas.size(); i++) {
-      if (obsFormulas[i].functor()  == functor &&
-          obsFormulas[i].arity()    == args.size() &&
-          obsFormulas[i].evidence() == evidence) {
-        obsFormulas[i].addTuple (args);
-        found = true;
-      }
-    }
-    if (found == false) {
-      obsFormulas.push_back (ObservedFormula (functor, evidence, args));
-    }
-    observedList = YAP_TailOfTerm (observedList);
-  } 
-}
-
-
-
 int
 createGroundNetwork (void)
 {
@@ -256,23 +120,6 @@ createGroundNetwork (void)
 
 
 
-Params
-readParameters (YAP_Term paramL)
-{
-  Params params;
-  assert (YAP_IsPairTerm (paramL));
-  while (paramL != YAP_TermNil()) {
-    params.push_back ((double) YAP_FloatOfTerm (YAP_HeadOfTerm (paramL)));
-    paramL = YAP_TailOfTerm (paramL);
-  }
-  if (Globals::logDomain) {
-    Util::log (params);
-  }
-  return params;
-}
-
-
-
 int
 runLiftedSolver (void)
 {
@@ -325,21 +172,7 @@ runLiftedSolver (void)
 
   delete solver;
 
-  YAP_Term list = YAP_TermNil();
+  return YAP_Unify (fillAnswersPrologList (results), YAP_ARG3);
-  for (size_t i = results.size(); i-- > 0; ) {
-    const Params& beliefs = results[i];
-    YAP_Term queryBeliefsL = YAP_TermNil();
-    for (size_t j = beliefs.size(); j-- > 0; ) {
-      YAP_Int sl1      = YAP_InitSlot (list);
-      YAP_Term belief  = YAP_MkFloatTerm (beliefs[j]);
-      queryBeliefsL    = YAP_MkPairTerm (belief, queryBeliefsL);
-      list             = YAP_GetFromSlot (sl1);
-      YAP_RecoverSlots (1);
-    }
-    list = YAP_MkPairTerm (queryBeliefsL, list);
-  }
- 
-  return YAP_Unify (list, YAP_ARG3);
 }
 
 
@@ -391,20 +224,7 @@ runGroundSolver (void)
     delete mfg;
   }
 
-  YAP_Term list = YAP_TermNil();
+  return YAP_Unify (fillAnswersPrologList (results), YAP_ARG3);
-  for (size_t i = results.size(); i-- > 0; ) {
-    const Params& beliefs = results[i];
-    YAP_Term queryBeliefsL = YAP_TermNil();
-    for (size_t j = beliefs.size(); j-- > 0; ) {
-      YAP_Int sl1      = YAP_InitSlot (list);
-      YAP_Term belief  = YAP_MkFloatTerm (beliefs[j]);
-      queryBeliefsL    = YAP_MkPairTerm (belief, queryBeliefsL);
-      list             = YAP_GetFromSlot (sl1);
-      YAP_RecoverSlots (1);
-    }
-    list = YAP_MkPairTerm (queryBeliefsL, list);
-  }
-  return YAP_Unify (list, YAP_ARG3);
 }
 
 
@@ -535,6 +355,183 @@ freeLiftedNetwork (void)
 
 
 
+Parfactor*
+readParfactor (YAP_Term pfTerm)
+{
+  // read dist id
+  unsigned distId = YAP_IntOfTerm (YAP_ArgOfTerm (1, pfTerm));
+
+  // read the ranges
+  Ranges ranges;
+  YAP_Term rangeList = YAP_ArgOfTerm (3, pfTerm);
+  while (rangeList != YAP_TermNil()) {
+    unsigned range = (unsigned) YAP_IntOfTerm (YAP_HeadOfTerm (rangeList));
+    ranges.push_back (range);
+    rangeList = YAP_TailOfTerm (rangeList);
+  }
+
+  // read parametric random vars
+  ProbFormulas formulas;
+  unsigned count = 0;
+  unordered_map<YAP_Term, LogVar> lvMap;
+  YAP_Term pvList = YAP_ArgOfTerm (2, pfTerm);
+  while (pvList != YAP_TermNil()) {
+    YAP_Term formulaTerm = YAP_HeadOfTerm (pvList);
+    if (YAP_IsAtomTerm (formulaTerm)) {
+      string name ((char*) YAP_AtomName (YAP_AtomOfTerm (formulaTerm)));
+      Symbol functor = LiftedUtils::getSymbol (name);
+      formulas.push_back (ProbFormula (functor, ranges[count]));
+    } else {
+      LogVars logVars;
+      YAP_Functor yapFunctor = YAP_FunctorOfTerm (formulaTerm);
+      string name ((char*) YAP_AtomName (YAP_NameOfFunctor (yapFunctor)));
+      Symbol functor = LiftedUtils::getSymbol (name);
+      unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
+      for (unsigned i = 1; i <= arity; i++) {
+        YAP_Term ti = YAP_ArgOfTerm (i, formulaTerm);
+        unordered_map<YAP_Term, LogVar>::iterator it = lvMap.find (ti);
+        if (it != lvMap.end()) {
+          logVars.push_back (it->second);
+        } else {
+         unsigned newLv = lvMap.size();
+         lvMap[ti] = newLv;
+         logVars.push_back (newLv);
+        }
+      }
+      formulas.push_back (ProbFormula (functor, logVars, ranges[count]));
+    }
+    count ++;
+    pvList = YAP_TailOfTerm (pvList);
+  }
+
+  // read the parameters
+  const Params& params = readParameters (YAP_ArgOfTerm (4, pfTerm)); 
+
+  // read the constraint
+  Tuples tuples;
+  if (lvMap.size() >= 1) {
+    YAP_Term tupleList = YAP_ArgOfTerm (5, pfTerm);
+    while (tupleList != YAP_TermNil()) {
+      YAP_Term term = YAP_HeadOfTerm (tupleList);
+      assert (YAP_IsApplTerm (term));
+      YAP_Functor yapFunctor = YAP_FunctorOfTerm (term);
+      unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
+      assert (lvMap.size() == arity);
+      Tuple tuple (arity);
+      for (unsigned i = 1; i <= arity; i++) {
+        YAP_Term ti = YAP_ArgOfTerm (i, term);
+        if (YAP_IsAtomTerm (ti) == false) {
+          cerr << "error: constraint has free variables" << endl;
+          abort();
+        }
+        string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ti)));
+        tuple[i - 1] = LiftedUtils::getSymbol (name);
+      }
+      tuples.push_back (tuple);
+      tupleList = YAP_TailOfTerm (tupleList);
+    }
+  }
+  return new Parfactor (formulas, params, tuples, distId);
+}
+
+
+
+void
+readLiftedEvidence (
+    YAP_Term observedList,
+    ObservedFormulas& obsFormulas)
+{
+  while (observedList != YAP_TermNil()) {
+    YAP_Term pair = YAP_HeadOfTerm (observedList);
+    YAP_Term ground = YAP_ArgOfTerm (1, pair);
+    Symbol functor;
+    Symbols args;
+    if (YAP_IsAtomTerm (ground)) {
+      string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ground)));
+      functor = LiftedUtils::getSymbol (name);
+    } else {
+      assert (YAP_IsApplTerm (ground));
+      YAP_Functor yapFunctor = YAP_FunctorOfTerm (ground);
+      string name ((char*) (YAP_AtomName (YAP_NameOfFunctor (yapFunctor))));
+      functor = LiftedUtils::getSymbol (name);
+      unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
+      for (unsigned i = 1; i <= arity; i++) {
+        YAP_Term ti = YAP_ArgOfTerm (i, ground);
+        assert (YAP_IsAtomTerm (ti));
+        string arg ((char *) YAP_AtomName (YAP_AtomOfTerm (ti)));
+        args.push_back (LiftedUtils::getSymbol (arg));
+      }
+    }
+    unsigned evidence = (unsigned) YAP_IntOfTerm (YAP_ArgOfTerm (2, pair));
+    bool found = false;
+    for (size_t i = 0; i < obsFormulas.size(); i++) {
+      if (obsFormulas[i].functor()  == functor &&
+          obsFormulas[i].arity()    == args.size() &&
+          obsFormulas[i].evidence() == evidence) {
+        obsFormulas[i].addTuple (args);
+        found = true;
+      }
+    }
+    if (found == false) {
+      obsFormulas.push_back (ObservedFormula (functor, evidence, args));
+    }
+    observedList = YAP_TailOfTerm (observedList);
+  } 
+}
+
+
+
+vector<unsigned>
+readUnsignedList (YAP_Term list)
+{
+  vector<unsigned> vec;
+  while (list != YAP_TermNil()) {
+    vec.push_back ((unsigned) YAP_IntOfTerm (YAP_HeadOfTerm (list)));
+    list = YAP_TailOfTerm (list);
+  }
+  return vec;
+}
+
+
+
+Params
+readParameters (YAP_Term paramL)
+{
+  Params params;
+  assert (YAP_IsPairTerm (paramL));
+  while (paramL != YAP_TermNil()) {
+    params.push_back ((double) YAP_FloatOfTerm (YAP_HeadOfTerm (paramL)));
+    paramL = YAP_TailOfTerm (paramL);
+  }
+  if (Globals::logDomain) {
+    Util::log (params);
+  }
+  return params;
+}
+
+
+
+YAP_Term
+fillAnswersPrologList (vector<Params>& results)
+{
+  YAP_Term list = YAP_TermNil();
+  for (size_t i = results.size(); i-- > 0; ) {
+    const Params& beliefs = results[i];
+    YAP_Term queryBeliefsL = YAP_TermNil();
+    for (size_t j = beliefs.size(); j-- > 0; ) {
+      YAP_Int sl1      = YAP_InitSlot (list);
+      YAP_Term belief  = YAP_MkFloatTerm (beliefs[j]);
+      queryBeliefsL    = YAP_MkPairTerm (belief, queryBeliefsL);
+      list             = YAP_GetFromSlot (sl1);
+      YAP_RecoverSlots (1);
+    }
+    list = YAP_MkPairTerm (queryBeliefsL, list);
+  }
+  return list;
+}
+
+
+
 extern "C" void
 init_predicates (void)
 {