This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/packages/CLPBN/horus/HorusYap.cpp

601 lines
16 KiB
C++
Raw Normal View History

2013-02-07 20:09:10 +00:00
#include <cassert>
2012-05-23 14:56:01 +01:00
#include <vector>
2013-02-07 20:09:10 +00:00
#include <unordered_map>
#include <string>
2012-05-23 14:56:01 +01:00
#include <iostream>
#include <sstream>
#include <YapInterface.h>
#include "ParfactorList.h"
#include "FactorGraph.h"
#include "LiftedOperations.h"
#include "LiftedVe.h"
#include "VarElim.h"
#include "LiftedBp.h"
#include "CountingBp.h"
2012-06-19 15:10:57 +01:00
#include "BeliefProp.h"
#include "LiftedKc.h"
2012-05-23 14:56:01 +01:00
#include "ElimGraph.h"
#include "BayesBall.h"
namespace Horus {
2012-05-23 14:56:01 +01:00
namespace {
2012-05-23 14:56:01 +01:00
2012-11-16 17:10:04 +00:00
Parfactor* readParfactor (YAP_Term);
2012-05-23 14:56:01 +01:00
2013-02-16 01:54:11 +00:00
ObservedFormulas* readLiftedEvidence (YAP_Term);
2012-05-23 14:56:01 +01:00
2013-02-16 01:54:11 +00:00
std::vector<unsigned> readUnsignedList (YAP_Term);
2012-05-23 14:56:01 +01:00
2012-11-16 17:10:04 +00:00
Params readParameters (YAP_Term);
2012-05-23 14:56:01 +01:00
2013-02-16 01:54:11 +00:00
YAP_Term fillSolutionList (const std::vector<Params>&);
2012-05-23 14:56:01 +01:00
}
typedef std::pair<ParfactorList*, ObservedFormulas*> LiftedNetwork;
2012-05-23 14:56:01 +01:00
2012-06-19 15:29:09 +01:00
int
createLiftedNetwork()
2012-05-23 14:56:01 +01:00
{
Parfactors parfactors;
YAP_Term parfactorList = YAP_ARG1;
while (parfactorList != YAP_TermNil()) {
YAP_Term pfTerm = YAP_HeadOfTerm (parfactorList);
parfactors.push_back (readParfactor (pfTerm));
parfactorList = YAP_TailOfTerm (parfactorList);
2012-05-23 14:56:01 +01:00
}
// LiftedUtils::printSymbolDictionary();
if (Globals::verbosity > 2) {
Util::printHeader ("INITIAL PARFACTORS");
2012-05-24 22:55:20 +01:00
for (size_t i = 0; i < parfactors.size(); i++) {
2012-05-23 14:56:01 +01:00
parfactors[i]->print();
2013-02-07 13:37:15 +00:00
std::cout << std::endl;
2012-05-23 14:56:01 +01:00
}
}
ParfactorList* pfList = new ParfactorList (parfactors);
2012-12-20 23:19:10 +00:00
if (Globals::verbosity > 2) {
Util::printHeader ("SHATTERED PARFACTORS");
2012-05-23 14:56:01 +01:00
pfList->print();
}
// read evidence
2013-02-16 01:54:11 +00:00
ObservedFormulas* obsFormulas = readLiftedEvidence (YAP_ARG2);
2012-05-23 14:56:01 +01:00
LiftedNetwork* network = new LiftedNetwork (pfList, obsFormulas);
YAP_Int p = (YAP_Int) (network);
2012-05-23 14:56:01 +01:00
return YAP_Unify (YAP_MkIntTerm (p), YAP_ARG3);
}
int
createGroundNetwork()
2012-05-23 14:56:01 +01:00
{
2013-02-07 13:37:15 +00:00
std::string factorsType ((char*) YAP_AtomName (YAP_AtomOfTerm (YAP_ARG1)));
FactorGraph* fg = new FactorGraph();
if (factorsType == "bayes") {
fg->setFactorsAsBayesian();
}
2012-05-23 14:56:01 +01:00
YAP_Term factorList = YAP_ARG2;
while (factorList != YAP_TermNil()) {
YAP_Term factor = YAP_HeadOfTerm (factorList);
// read the var ids
VarIds varIds = readUnsignedList (YAP_ArgOfTerm (1, factor));
// read the ranges
Ranges ranges = readUnsignedList (YAP_ArgOfTerm (2, factor));
// read the parameters
2012-12-20 23:19:10 +00:00
Params params = readParameters (YAP_ArgOfTerm (3, factor));
2012-05-23 14:56:01 +01:00
// read dist id
unsigned distId = (unsigned) YAP_IntOfTerm (YAP_ArgOfTerm (4, factor));
fg->addFactor (Factor (varIds, ranges, params, distId));
factorList = YAP_TailOfTerm (factorList);
}
unsigned nrObservedVars = 0;
YAP_Term evidenceList = YAP_ARG3;
while (evidenceList != YAP_TermNil()) {
YAP_Term evTerm = YAP_HeadOfTerm (evidenceList);
unsigned vid = (unsigned) YAP_IntOfTerm ((YAP_ArgOfTerm (1, evTerm)));
unsigned ev = (unsigned) YAP_IntOfTerm ((YAP_ArgOfTerm (2, evTerm)));
assert (fg->getVarNode (vid));
fg->getVarNode (vid)->setEvidence (ev);
evidenceList = YAP_TailOfTerm (evidenceList);
nrObservedVars ++;
}
if (FactorGraph::exportToLibDai()) {
fg->exportToLibDai ("model.fg");
}
if (FactorGraph::exportToUai()) {
fg->exportToUai ("model.uai");
}
if (FactorGraph::exportGraphViz()) {
fg->exportToGraphViz ("model.dot");
}
if (FactorGraph::printFactorGraph()) {
fg->print();
}
if (Globals::verbosity > 0) {
2013-02-07 13:37:15 +00:00
std::cout << "factor graph contains " ;
std::cout << fg->nrVarNodes() << " variables and " ;
std::cout << fg->nrFacNodes() << " factors " << std::endl;
2012-05-23 14:56:01 +01:00
}
YAP_Int p = (YAP_Int) (fg);
return YAP_Unify (YAP_MkIntTerm (p), YAP_ARG4);
}
int
runLiftedSolver()
2012-05-23 14:56:01 +01:00
{
LiftedNetwork* network = (LiftedNetwork*) YAP_IntOfTerm (YAP_ARG1);
ParfactorList copy (*network->first);
LiftedOperations::absorveEvidence (copy, *network->second);
2012-12-20 23:19:10 +00:00
2012-11-16 16:50:19 +00:00
LiftedSolver* solver = 0;
switch (Globals::liftedSolver) {
case LiftedSolverType::lveSolver: solver = new LiftedVe (copy); break;
case LiftedSolverType::lbpSolver: solver = new LiftedBp (copy); break;
case LiftedSolverType::lkcSolver: solver = new LiftedKc (copy); break;
2012-11-16 16:50:19 +00:00
}
2012-12-17 18:39:42 +00:00
if (Globals::verbosity > 0) {
2012-11-16 16:50:19 +00:00
solver->printSolverFlags();
2013-02-07 13:37:15 +00:00
std::cout << std::endl;
2012-11-16 16:50:19 +00:00
}
2012-12-17 18:39:42 +00:00
2012-11-16 16:50:19 +00:00
YAP_Term taskList = YAP_ARG2;
2013-02-07 13:37:15 +00:00
std::vector<Params> results;
2012-05-23 14:56:01 +01:00
while (taskList != YAP_TermNil()) {
Grounds queryVars;
YAP_Term jointList = YAP_HeadOfTerm (taskList);
while (jointList != YAP_TermNil()) {
YAP_Term ground = YAP_HeadOfTerm (jointList);
if (YAP_IsAtomTerm (ground)) {
2013-02-07 13:37:15 +00:00
std::string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ground)));
2012-05-23 14:56:01 +01:00
queryVars.push_back (Ground (LiftedUtils::getSymbol (name)));
} else {
assert (YAP_IsApplTerm (ground));
YAP_Functor yapFunctor = YAP_FunctorOfTerm (ground);
2013-02-07 13:37:15 +00:00
std::string name ((char*) (YAP_AtomName (
YAP_NameOfFunctor (yapFunctor))));
2012-05-23 14:56:01 +01:00
unsigned arity = (unsigned) YAP_ArityOfFunctor (yapFunctor);
Symbol functor = LiftedUtils::getSymbol (name);
Symbols args;
for (unsigned i = 1; i <= arity; i++) {
YAP_Term ti = YAP_ArgOfTerm (i, ground);
assert (YAP_IsAtomTerm (ti));
2013-02-07 13:37:15 +00:00
std::string arg ((char *) YAP_AtomName (YAP_AtomOfTerm (ti)));
2012-05-23 14:56:01 +01:00
args.push_back (LiftedUtils::getSymbol (arg));
}
queryVars.push_back (Ground (functor, args));
}
jointList = YAP_TailOfTerm (jointList);
}
2012-11-16 16:50:19 +00:00
results.push_back (solver->solveQuery (queryVars));
2012-05-23 14:56:01 +01:00
taskList = YAP_TailOfTerm (taskList);
}
2012-11-16 16:50:19 +00:00
delete solver;
2013-02-16 01:54:11 +00:00
return YAP_Unify (fillSolutionList (results), YAP_ARG3);
2012-05-23 14:56:01 +01:00
}
int
runGroundSolver()
2012-05-23 14:56:01 +01:00
{
FactorGraph* fg = (FactorGraph*) YAP_IntOfTerm (YAP_ARG1);
2012-12-20 23:19:10 +00:00
2013-02-07 13:37:15 +00:00
std::vector<VarIds> tasks;
2012-05-23 14:56:01 +01:00
YAP_Term taskList = YAP_ARG2;
while (taskList != YAP_TermNil()) {
tasks.push_back (readUnsignedList (YAP_HeadOfTerm (taskList)));
taskList = YAP_TailOfTerm (taskList);
}
FactorGraph* mfg = fg;
if (fg->bayesianFactors()) {
2012-11-16 22:38:14 +00:00
std::set<VarId> vids;
for (size_t i = 0; i < tasks.size(); i++) {
Util::addToSet (vids, tasks[i]);
2012-11-16 22:38:14 +00:00
}
2012-06-19 15:10:57 +01:00
mfg = BayesBall::getMinimalFactorGraph (
2012-06-19 15:29:09 +01:00
*fg, VarIds (vids.begin(), vids.end()));
2012-05-23 14:56:01 +01:00
}
2012-06-19 15:29:09 +01:00
2012-11-16 16:50:19 +00:00
GroundSolver* solver = 0;
2012-12-27 23:21:32 +00:00
CountingBp::setFindIdenticalFactorsFlag (false);
switch (Globals::groundSolver) {
case GroundSolverType::veSolver: solver = new VarElim (*mfg); break;
case GroundSolverType::bpSolver: solver = new BeliefProp (*mfg); break;
case GroundSolverType::CbpSolver: solver = new CountingBp (*mfg); break;
2012-05-23 14:56:01 +01:00
}
2012-06-19 15:29:09 +01:00
if (Globals::verbosity > 0) {
2012-05-23 14:56:01 +01:00
solver->printSolverFlags();
2013-02-07 13:37:15 +00:00
std::cout << std::endl;
2012-05-23 14:56:01 +01:00
}
2012-06-19 15:29:09 +01:00
2013-02-07 13:37:15 +00:00
std::vector<Params> results;
2012-05-23 14:56:01 +01:00
results.reserve (tasks.size());
2012-05-24 22:55:20 +01:00
for (size_t i = 0; i < tasks.size(); i++) {
2012-05-23 14:56:01 +01:00
results.push_back (solver->solveQuery (tasks[i]));
}
2012-06-19 15:29:09 +01:00
delete solver;
if (fg->bayesianFactors()) {
2012-06-19 15:10:57 +01:00
delete mfg;
2012-05-23 14:56:01 +01:00
}
2012-06-19 15:29:09 +01:00
2013-02-16 01:54:11 +00:00
return YAP_Unify (fillSolutionList (results), YAP_ARG3);
2012-05-23 14:56:01 +01:00
}
int
setParfactorsParams()
2012-05-23 14:56:01 +01:00
{
LiftedNetwork* network = (LiftedNetwork*) YAP_IntOfTerm (YAP_ARG1);
ParfactorList* pfList = network->first;
2012-12-18 22:47:43 +00:00
YAP_Term distIdsList = YAP_ARG2;
YAP_Term paramsList = YAP_ARG3;
2013-02-07 13:37:15 +00:00
std::unordered_map<unsigned, Params> paramsMap;
2012-12-18 22:47:43 +00:00
while (distIdsList != YAP_TermNil()) {
unsigned distId = (unsigned) YAP_IntOfTerm (
YAP_HeadOfTerm (distIdsList));
assert (Util::contains (paramsMap, distId) == false);
2012-12-18 22:47:43 +00:00
paramsMap[distId] = readParameters (YAP_HeadOfTerm (paramsList));
distIdsList = YAP_TailOfTerm (distIdsList);
paramsList = YAP_TailOfTerm (paramsList);
2012-05-23 14:56:01 +01:00
}
ParfactorList::iterator it = pfList->begin();
while (it != pfList->end()) {
assert (Util::contains (paramsMap, (*it)->distId()));
2012-12-18 22:47:43 +00:00
(*it)->setParams (paramsMap[(*it)->distId()]);
2012-05-23 14:56:01 +01:00
++ it;
}
return TRUE;
}
int
setFactorsParams()
2012-05-23 14:56:01 +01:00
{
FactorGraph* fg = (FactorGraph*) YAP_IntOfTerm (YAP_ARG1);
2012-12-18 22:47:43 +00:00
YAP_Term distIdsList = YAP_ARG2;
YAP_Term paramsList = YAP_ARG3;
2013-02-07 13:37:15 +00:00
std::unordered_map<unsigned, Params> paramsMap;
2012-12-18 22:47:43 +00:00
while (distIdsList != YAP_TermNil()) {
unsigned distId = (unsigned) YAP_IntOfTerm (
YAP_HeadOfTerm (distIdsList));
assert (Util::contains (paramsMap, distId) == false);
2012-12-18 22:47:43 +00:00
paramsMap[distId] = readParameters (YAP_HeadOfTerm (paramsList));
distIdsList = YAP_TailOfTerm (distIdsList);
paramsList = YAP_TailOfTerm (paramsList);
2012-05-23 14:56:01 +01:00
}
const FacNodes& facNodes = fg->facNodes();
2012-05-24 22:55:20 +01:00
for (size_t i = 0; i < facNodes.size(); i++) {
2012-05-23 14:56:01 +01:00
unsigned distId = facNodes[i]->factor().distId();
assert (Util::contains (paramsMap, distId));
2012-05-23 14:56:01 +01:00
facNodes[i]->factor().setParams (paramsMap[distId]);
}
return TRUE;
}
int
setVarsInformation()
2012-05-23 14:56:01 +01:00
{
Var::clearVarsInfo();
2013-02-07 13:37:15 +00:00
std::vector<std::string> labels;
2012-05-23 14:56:01 +01:00
YAP_Term labelsL = YAP_ARG1;
while (labelsL != YAP_TermNil()) {
YAP_Atom atom = YAP_AtomOfTerm (YAP_HeadOfTerm (labelsL));
labels.push_back ((char*) YAP_AtomName (atom));
labelsL = YAP_TailOfTerm (labelsL);
}
unsigned count = 0;
YAP_Term stateNamesL = YAP_ARG2;
while (stateNamesL != YAP_TermNil()) {
States states;
YAP_Term namesL = YAP_HeadOfTerm (stateNamesL);
while (namesL != YAP_TermNil()) {
YAP_Atom atom = YAP_AtomOfTerm (YAP_HeadOfTerm (namesL));
states.push_back ((char*) YAP_AtomName (atom));
namesL = YAP_TailOfTerm (namesL);
}
Var::addVarInfo (count, labels[count], states);
count ++;
stateNamesL = YAP_TailOfTerm (stateNamesL);
}
return TRUE;
}
int
setHorusFlag()
2012-05-23 14:56:01 +01:00
{
2013-02-07 13:37:15 +00:00
std::string option ((char*) YAP_AtomName (YAP_AtomOfTerm (YAP_ARG1)));
std::string value;
if (option == "verbosity") {
2013-02-07 13:37:15 +00:00
std::stringstream ss;
2012-05-23 14:56:01 +01:00
ss << (int) YAP_IntOfTerm (YAP_ARG2);
ss >> value;
} else if (option == "bp_accuracy") {
2013-02-07 13:37:15 +00:00
std::stringstream ss;
2012-05-23 14:56:01 +01:00
ss << (float) YAP_FloatOfTerm (YAP_ARG2);
ss >> value;
} else if (option == "bp_max_iter") {
2013-02-07 13:37:15 +00:00
std::stringstream ss;
2012-05-23 14:56:01 +01:00
ss << (int) YAP_IntOfTerm (YAP_ARG2);
ss >> value;
} else {
value = ((char*) YAP_AtomName (YAP_AtomOfTerm (YAP_ARG2)));
}
return Util::setHorusFlag (option, value);
2012-05-23 14:56:01 +01:00
}
int
freeGroundNetwork()
2012-05-23 14:56:01 +01:00
{
delete (FactorGraph*) YAP_IntOfTerm (YAP_ARG1);
return TRUE;
}
int
freeLiftedNetwork()
2012-05-23 14:56:01 +01:00
{
LiftedNetwork* network = (LiftedNetwork*) YAP_IntOfTerm (YAP_ARG1);
delete network->first;
delete network->second;
delete network;
return TRUE;
}
namespace {
2012-11-16 17:10:04 +00:00
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;
2013-02-07 13:37:15 +00:00
std::unordered_map<YAP_Term, LogVar> lvMap;
2012-11-16 17:10:04 +00:00
YAP_Term pvList = YAP_ArgOfTerm (2, pfTerm);
while (pvList != YAP_TermNil()) {
YAP_Term formulaTerm = YAP_HeadOfTerm (pvList);
if (YAP_IsAtomTerm (formulaTerm)) {
2013-02-07 13:37:15 +00:00
std::string name ((char*) YAP_AtomName (YAP_AtomOfTerm (formulaTerm)));
2012-11-16 17:10:04 +00:00
Symbol functor = LiftedUtils::getSymbol (name);
formulas.push_back (ProbFormula (functor, ranges[count]));
} else {
LogVars logVars;
YAP_Functor yapFunctor = YAP_FunctorOfTerm (formulaTerm);
2013-03-09 17:14:00 +00:00
std::string name ((char*) YAP_AtomName (
YAP_NameOfFunctor (yapFunctor)));
2012-11-16 17:10:04 +00:00
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);
2013-02-07 13:37:15 +00:00
std::unordered_map<YAP_Term, LogVar>::iterator it = lvMap.find (ti);
2012-11-16 17:10:04 +00:00
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
Params params = readParameters (YAP_ArgOfTerm (4, pfTerm));
2012-11-16 17:10:04 +00:00
// 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) {
2013-02-07 13:37:15 +00:00
std::cerr << "Error: the constraint contains free variables." ;
std::cerr << std::endl;
exit (EXIT_FAILURE);
2012-11-16 17:10:04 +00:00
}
2013-02-07 13:37:15 +00:00
std::string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ti)));
2012-11-16 17:10:04 +00:00
tuple[i - 1] = LiftedUtils::getSymbol (name);
}
tuples.push_back (tuple);
tupleList = YAP_TailOfTerm (tupleList);
}
}
return new Parfactor (formulas, params, tuples, distId);
}
2013-02-16 01:54:11 +00:00
ObservedFormulas*
readLiftedEvidence (YAP_Term observedList)
2012-11-16 17:10:04 +00:00
{
2013-02-16 01:54:11 +00:00
ObservedFormulas* obsFormulas = new ObservedFormulas();
2012-11-16 17:10:04 +00:00
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)) {
2013-02-07 13:37:15 +00:00
std::string name ((char*) YAP_AtomName (YAP_AtomOfTerm (ground)));
2012-11-16 17:10:04 +00:00
functor = LiftedUtils::getSymbol (name);
} else {
assert (YAP_IsApplTerm (ground));
YAP_Functor yapFunctor = YAP_FunctorOfTerm (ground);
2013-02-07 13:37:15 +00:00
std::string name ((char*) (YAP_AtomName (
YAP_NameOfFunctor (yapFunctor))));
2012-11-16 17:10:04 +00:00
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));
2013-02-07 13:37:15 +00:00
std::string arg ((char *) YAP_AtomName (YAP_AtomOfTerm (ti)));
2012-11-16 17:10:04 +00:00
args.push_back (LiftedUtils::getSymbol (arg));
}
}
unsigned evidence = (unsigned) YAP_IntOfTerm (YAP_ArgOfTerm (2, pair));
bool found = false;
2013-02-16 01:54:11 +00:00
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);
2012-11-16 17:10:04 +00:00
found = true;
}
}
if (found == false) {
2013-02-16 01:54:11 +00:00
obsFormulas->push_back (ObservedFormula (functor, evidence, args));
2012-11-16 17:10:04 +00:00
}
observedList = YAP_TailOfTerm (observedList);
2012-12-20 23:19:10 +00:00
}
2013-02-16 01:54:11 +00:00
return obsFormulas;
2012-11-16 17:10:04 +00:00
}
2013-02-07 13:37:15 +00:00
std::vector<unsigned>
2012-11-16 17:10:04 +00:00
readUnsignedList (YAP_Term list)
{
2013-02-07 13:37:15 +00:00
std::vector<unsigned> vec;
2012-11-16 17:10:04 +00:00
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()) {
2013-04-07 14:18:13 +01:00
YAP_Term hd = YAP_HeadOfTerm (paramL);
2013-04-11 23:06:13 +01:00
if (YAP_IsFloatTerm (hd)) {
2013-04-07 14:18:13 +01:00
params.push_back ((double) YAP_FloatOfTerm (hd));
2013-04-11 23:06:13 +01:00
} else {
2013-04-07 14:18:13 +01:00
params.push_back ((double) YAP_IntOfTerm (hd));
2013-04-11 23:06:13 +01:00
}
2012-11-16 17:10:04 +00:00
paramL = YAP_TailOfTerm (paramL);
}
if (Globals::logDomain) {
Util::log (params);
2012-11-16 17:10:04 +00:00
}
return params;
}
YAP_Term
2013-02-16 01:54:11 +00:00
fillSolutionList (const std::vector<Params>& results)
2012-11-16 17:10:04 +00:00
{
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; ) {
2013-02-16 01:54:11 +00:00
YAP_Int sl = YAP_InitSlot (list);
2012-11-16 17:10:04 +00:00
YAP_Term belief = YAP_MkFloatTerm (beliefs[j]);
queryBeliefsL = YAP_MkPairTerm (belief, queryBeliefsL);
2013-02-16 01:54:11 +00:00
list = YAP_GetFromSlot (sl);
2014-05-25 09:57:17 +01:00
YAP_RecoverSlots (1, sl);
2012-11-16 17:10:04 +00:00
}
list = YAP_MkPairTerm (queryBeliefsL, list);
}
return list;
}
}
2012-11-16 17:10:04 +00:00
2012-05-23 14:56:01 +01:00
extern "C" void
init_predicates()
2012-05-23 14:56:01 +01:00
{
2012-12-18 22:47:43 +00:00
YAP_UserCPredicate ("cpp_create_lifted_network",
createLiftedNetwork, 3);
YAP_UserCPredicate ("cpp_create_ground_network",
createGroundNetwork, 4);
YAP_UserCPredicate ("cpp_run_lifted_solver",
runLiftedSolver, 3);
YAP_UserCPredicate ("cpp_run_ground_solver",
runGroundSolver, 3);
YAP_UserCPredicate ("cpp_set_parfactors_params",
setParfactorsParams, 3);
YAP_UserCPredicate ("cpp_set_factors_params",
setFactorsParams, 3);
YAP_UserCPredicate ("cpp_set_vars_information",
setVarsInformation, 2);
YAP_UserCPredicate ("cpp_set_horus_flag",
setHorusFlag, 2);
YAP_UserCPredicate ("cpp_free_lifted_network",
freeLiftedNetwork, 1);
YAP_UserCPredicate ("cpp_free_ground_network",
freeGroundNetwork, 1);
2012-05-23 14:56:01 +01:00
}
} // namespace Horus
2013-02-07 23:53:13 +00:00