diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use pointers to refer to clauses for better performance

Browse Source
This commit is contained in:
Tiago Gomes 2012-12-08 19:17:19 +00:00
parent 73b3594c97
commit 4edbcf86b8
4 changed files with 185 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

277
packages/CLPBN/horus/LiftedCircuit.cpp
View File

@ -77,28 +77,27 @@ IncExcNode::weight (void) const
double double
LeafNode::weight (void) const LeafNode::weight (void) const
{ {
assert (clause_.isUnit()); assert (clause_->isUnit());
Clause c = clause_; double weight = clause_->literals()[0].isPositive()
double weight = c.literals()[0].isPositive() ? lwcnf_.posWeight (clause_->literals().front().lid())
? lwcnf_.posWeight (c.literals().front().lid()) : lwcnf_.negWeight (clause_->literals().front().lid());
: lwcnf_.negWeight (c.literals().front().lid()); LogVarSet lvs = clause_->constr().logVarSet();
LogVarSet lvs = c.constr().logVarSet(); lvs -= clause_->ipgLogVars();
lvs -= c.ipgLogVars(); lvs -= clause_->posCountedLogVars();
lvs -= c.posCountedLogVars(); lvs -= clause_->negCountedLogVars();
lvs -= c.negCountedLogVars();
unsigned nrGroundings = 1; unsigned nrGroundings = 1;
if (lvs.empty() == false) { if (lvs.empty() == false) {
ConstraintTree ct = c.constr(); ConstraintTree ct = clause_->constr();
ct.project (lvs); ct.project (lvs);
nrGroundings = ct.size(); nrGroundings = ct.size();
} }
if (c.posCountedLogVars().empty() == false) { if (clause_->posCountedLogVars().empty() == false) {
nrGroundings *= std::pow (SetOrNode::nrPositives(), nrGroundings *= std::pow (SetOrNode::nrPositives(),
c.nrPosCountedLogVars()); clause_->nrPosCountedLogVars());
} }
if (c.negCountedLogVars().empty() == false) { if (clause_->negCountedLogVars().empty() == false) {
nrGroundings *= std::pow (SetOrNode::nrNegatives(), nrGroundings *= std::pow (SetOrNode::nrNegatives(),
c.nrNegCountedLogVars()); clause_->nrNegCountedLogVars());
} }
return Globals::logDomain return Globals::logDomain
? weight * nrGroundings ? weight * nrGroundings
@ -113,25 +112,25 @@ SmoothNode::weight (void) const
Clauses cs = clauses(); Clauses cs = clauses();
double totalWeight = LogAware::multIdenty(); double totalWeight = LogAware::multIdenty();
for (size_t i = 0; i < cs.size(); i++) { for (size_t i = 0; i < cs.size(); i++) {
double posWeight = lwcnf_.posWeight (cs[i].literals()[0].lid()); double posWeight = lwcnf_.posWeight (cs[i]->literals()[0].lid());
double negWeight = lwcnf_.negWeight (cs[i].literals()[0].lid()); double negWeight = lwcnf_.negWeight (cs[i]->literals()[0].lid());
LogVarSet lvs = cs[i].constr().logVarSet(); LogVarSet lvs = cs[i]->constr().logVarSet();
lvs -= cs[i].ipgLogVars(); lvs -= cs[i]->ipgLogVars();
lvs -= cs[i].posCountedLogVars(); lvs -= cs[i]->posCountedLogVars();
lvs -= cs[i].negCountedLogVars(); lvs -= cs[i]->negCountedLogVars();
unsigned nrGroundings = 1; unsigned nrGroundings = 1;
if (lvs.empty() == false) { if (lvs.empty() == false) {
ConstraintTree ct = cs[i].constr(); ConstraintTree ct = cs[i]->constr();
ct.project (lvs); ct.project (lvs);
nrGroundings = ct.size(); nrGroundings = ct.size();
} }
if (cs[i].posCountedLogVars().empty() == false) { if (cs[i]->posCountedLogVars().empty() == false) {
nrGroundings *= std::pow (SetOrNode::nrPositives(), nrGroundings *= std::pow (SetOrNode::nrPositives(),
cs[i].nrPosCountedLogVars()); cs[i]->nrPosCountedLogVars());
} }
if (cs[i].negCountedLogVars().empty() == false) { if (cs[i]->negCountedLogVars().empty() == false) {
nrGroundings *= std::pow (SetOrNode::nrNegatives(), nrGroundings *= std::pow (SetOrNode::nrNegatives(),
cs[i].nrNegCountedLogVars()); cs[i]->nrNegCountedLogVars());
} }
if (Globals::logDomain) { if (Globals::logDomain) {
totalWeight += Util::logSum (posWeight, negWeight) * nrGroundings; totalWeight += Util::logSum (posWeight, negWeight) * nrGroundings;
@ -162,12 +161,14 @@ CompilationFailedNode::weight (void) const
Clauses copyClauses (const Clauses& clauses);
LiftedCircuit::LiftedCircuit (const LiftedWCNF* lwcnf) LiftedCircuit::LiftedCircuit (const LiftedWCNF* lwcnf)
: lwcnf_(lwcnf) : lwcnf_(lwcnf)
{ {
root_ = 0; root_ = 0;
compilationSucceeded_ = true; compilationSucceeded_ = true;
Clauses clauses = lwcnf->clauses(); Clauses clauses = copyClauses (lwcnf->clauses());
compile (&root_, clauses); compile (&root_, clauses);
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
smoothCircuit (root_); smoothCircuit (root_);
@ -231,7 +232,7 @@ LiftedCircuit::compile (
return; return;
} }
if (clauses.size() == 1 && clauses[0].isUnit()) { if (clauses.size() == 1 && clauses[0]->isUnit()) {
*follow = new LeafNode (clauses[0], *lwcnf_); *follow = new LeafNode (clauses[0], *lwcnf_);
return; return;
} }
@ -269,6 +270,18 @@ LiftedCircuit::compile (
} }
// TODO
Clauses copyClauses (const Clauses& clauses)
{
Clauses copy;
copy.reserve (clauses.size());
for (size_t i = 0; i < clauses.size(); i++) {
copy.push_back (new Clause (*clauses[i]));
}
return copy;
}
bool bool
LiftedCircuit::tryUnitPropagation ( LiftedCircuit::tryUnitPropagation (
@ -276,40 +289,52 @@ LiftedCircuit::tryUnitPropagation (
Clauses& clauses) Clauses& clauses)
{ {
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
backupClauses_ = clauses; backupClauses_ = copyClauses (clauses);
} }
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
if (clauses[i].isUnit()) { if (clauses[i]->isUnit()) {
Clauses newClauses; Clauses propagClauses;
for (size_t j = 0; j < clauses.size(); j++) { for (size_t j = 0; j < clauses.size(); j++) {
if (i != j) { if (i != j) {
LiteralId lid = clauses[i].literals()[0].lid(); LiteralId lid = clauses[i]->literals()[0].lid();
LogVarTypes types = clauses[i].logVarTypes (0); LogVarTypes types = clauses[i]->logVarTypes (0);
if (clauses[i].literals()[0].isPositive()) { if (clauses[i]->literals()[0].isPositive()) {
if (clauses[j].containsPositiveLiteral (lid, types) == false) { if (clauses[j]->containsPositiveLiteral (lid, types) == false) {
Clause newClause = clauses[j]; clauses[j]->removeNegativeLiterals (lid, types);
newClause.removeNegativeLiterals (lid, types); if (clauses[j]->nrLiterals() > 0) {
newClauses.push_back (newClause); propagClauses.push_back (clauses[j]);
} else {
delete clauses[j];
} }
} else if (clauses[i].literals()[0].isNegative()) { } else {
if (clauses[j].containsNegativeLiteral (lid, types) == false) { delete clauses[j];
Clause newClause = clauses[j]; }
newClause.removePositiveLiterals (lid, types); } else if (clauses[i]->literals()[0].isNegative()) {
newClauses.push_back (newClause); if (clauses[j]->containsNegativeLiteral (lid, types) == false) {
clauses[j]->removePositiveLiterals (lid, types);
if (clauses[j]->nrLiterals() > 0) {
propagClauses.push_back (clauses[j]);
} else {
delete clauses[j];
}
} else {
delete clauses[j];
} }
} }
} }
} }
AndNode* andNode = new AndNode(); AndNode* andNode = new AndNode();
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
originClausesMap_[andNode] = backupClauses_; originClausesMap_[andNode] = backupClauses_;
stringstream explanation; stringstream explanation;
explanation << " UP on>" << clauses[i].literals()[0]; explanation << " UP on " << clauses[i]->literals()[0];
explanationMap_[andNode] = explanation.str(); explanationMap_[andNode] = explanation.str();
} }
Clauses leftClauses = {clauses[i]};
compile (andNode->leftBranch(), leftClauses); Clauses unitClause = { clauses[i] };
compile (andNode->rightBranch(), newClauses); compile (andNode->leftBranch(), unitClause);
compile (andNode->rightBranch(), propagClauses);
(*follow) = andNode; (*follow) = andNode;
return true; return true;
} }
@ -336,7 +361,7 @@ LiftedCircuit::tryIndependence (
while (finish == false) { while (finish == false) {
finish = true; finish = true;
for (size_t i = 0; i < indepClauses.size(); i++) { for (size_t i = 0; i < indepClauses.size(); i++) {
if (independentClause (indepClauses[i], depClauses) == false) { if (independentClause (*indepClauses[i], depClauses) == false) {
depClauses.push_back (indepClauses[i]); depClauses.push_back (indepClauses[i]);
indepClauses.erase (indepClauses.begin() + i); indepClauses.erase (indepClauses.begin() + i);
finish = false; finish = false;
@ -366,24 +391,22 @@ LiftedCircuit::tryShannonDecomp (
Clauses& clauses) Clauses& clauses)
{ {
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
backupClauses_ = clauses; backupClauses_ = copyClauses (clauses);
} }
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
const Literals& literals = clauses[i].literals(); const Literals& literals = clauses[i]->literals();
for (size_t j = 0; j < literals.size(); j++) { for (size_t j = 0; j < literals.size(); j++) {
if (literals[j].isGround (clauses[i].constr(),clauses[i].ipgLogVars())) { if (literals[j].isGround (
Literal posLit (literals[j], false); clauses[i]->constr(), clauses[i]->ipgLogVars())) {
Literal negLit (literals[j], true);
ConstraintTree ct1 = clauses[i].constr(); Clause* c1 = lwcnf_->createClause (literals[j].lid());
ConstraintTree ct2 = clauses[i].constr(); Clause* c2 = new Clause (*c1);
Clause c1 (ct1); c2->literals().front().complement();
Clause c2 (ct2);
c1.addLiteral (posLit); Clauses otherClauses = copyClauses (clauses);
c2.addLiteral (negLit); clauses.push_back (c1);
Clauses leftClauses = { c1 }; otherClauses.push_back (c2);
Clauses rightClauses = { c2 };
leftClauses.insert (leftClauses.end(), clauses.begin(), clauses.end());
rightClauses.insert (rightClauses.end(), clauses.begin(), clauses.end());
OrNode* orNode = new OrNode(); OrNode* orNode = new OrNode();
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
originClausesMap_[orNode] = backupClauses_; originClausesMap_[orNode] = backupClauses_;
@ -391,8 +414,9 @@ LiftedCircuit::tryShannonDecomp (
explanation << " SD on " << literals[j]; explanation << " SD on " << literals[j];
explanationMap_[orNode] = explanation.str(); explanationMap_[orNode] = explanation.str();
} }
compile (orNode->leftBranch(), leftClauses);
compile (orNode->rightBranch(), rightClauses); compile (orNode->leftBranch(), clauses);
compile (orNode->rightBranch(), otherClauses);
(*follow) = orNode; (*follow) = orNode;
return true; return true;
} }
@ -409,12 +433,12 @@ LiftedCircuit::tryInclusionExclusion (
Clauses& clauses) Clauses& clauses)
{ {
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
backupClauses_ = clauses; backupClauses_ = copyClauses (clauses);
} }
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
Literals depLits = { clauses[i].literals().front() }; Literals depLits = { clauses[i]->literals().front() };
Literals indepLits (clauses[i].literals().begin() + 1, Literals indepLits (clauses[i]->literals().begin() + 1,
clauses[i].literals().end()); clauses[i]->literals().end());
bool finish = false; bool finish = false;
while (finish == false) { while (finish == false) {
finish = true; finish = true;
@ -432,34 +456,36 @@ LiftedCircuit::tryInclusionExclusion (
for (size_t j = 0; j < depLits.size(); j++) { for (size_t j = 0; j < depLits.size(); j++) {
lvs1 |= depLits[j].logVarSet(); lvs1 |= depLits[j].logVarSet();
} }
if (clauses[i].constr().isCountNormalized (lvs1) == false) { if (clauses[i]->constr().isCountNormalized (lvs1) == false) {
break; break;
} }
LogVarSet lvs2; LogVarSet lvs2;
for (size_t j = 0; j < indepLits.size(); j++) { for (size_t j = 0; j < indepLits.size(); j++) {
lvs2 |= indepLits[j].logVarSet(); lvs2 |= indepLits[j].logVarSet();
} }
if (clauses[i].constr().isCountNormalized (lvs2) == false) { if (clauses[i]->constr().isCountNormalized (lvs2) == false) {
break; break;
} }
Clause c1 (clauses[i].constr().projectedCopy (lvs1)); Clause* c1 = new Clause (clauses[i]->constr().projectedCopy (lvs1));
for (size_t j = 0; j < depLits.size(); j++) { for (size_t j = 0; j < depLits.size(); j++) {
c1.addLiteral (depLits[j]); c1->addLiteral (depLits[j]);
} }
Clause c2 (clauses[i].constr().projectedCopy (lvs2)); Clause* c2 = new Clause (clauses[i]->constr().projectedCopy (lvs2));
for (size_t j = 0; j < indepLits.size(); j++) { for (size_t j = 0; j < indepLits.size(); j++) {
c2.addLiteral (indepLits[j]); c2->addLiteral (indepLits[j]);
} }
Clauses plus1Clauses = clauses; Clauses plus1Clauses = copyClauses (clauses);
Clauses plus2Clauses = clauses; Clauses plus2Clauses = copyClauses (clauses);
Clauses minusClauses = clauses;
plus1Clauses.erase (plus1Clauses.begin() + i); plus1Clauses.erase (plus1Clauses.begin() + i);
plus2Clauses.erase (plus2Clauses.begin() + i); plus2Clauses.erase (plus2Clauses.begin() + i);
minusClauses.erase (minusClauses.begin() + i); clauses.erase (clauses.begin() + i);
plus1Clauses.push_back (c1); plus1Clauses.push_back (c1);
plus2Clauses.push_back (c2); plus2Clauses.push_back (c2);
minusClauses.push_back (c1); clauses.push_back (c1);
minusClauses.push_back (c2); clauses.push_back (c2);
IncExcNode* ieNode = new IncExcNode(); IncExcNode* ieNode = new IncExcNode();
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
originClausesMap_[ieNode] = backupClauses_; originClausesMap_[ieNode] = backupClauses_;
@ -469,7 +495,7 @@ LiftedCircuit::tryInclusionExclusion (
} }
compile (ieNode->plus1Branch(), plus1Clauses); compile (ieNode->plus1Branch(), plus1Clauses);
compile (ieNode->plus2Branch(), plus2Clauses); compile (ieNode->plus2Branch(), plus2Clauses);
compile (ieNode->minusBranch(), minusClauses); compile (ieNode->minusBranch(), clauses);
*follow = ieNode; *follow = ieNode;
return true; return true;
} }
@ -487,18 +513,17 @@ LiftedCircuit::tryIndepPartialGrounding (
// assumes that all literals have logical variables // assumes that all literals have logical variables
// else, shannon decomp was possible // else, shannon decomp was possible
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
backupClauses_ = clauses; backupClauses_ = copyClauses (clauses);
} }
LogVars rootLogVars; LogVars rootLogVars;
LogVarSet lvs = clauses[0].ipgCandidates(); LogVarSet lvs = clauses[0]->ipgCandidates();
for (size_t i = 0; i < lvs.size(); i++) { for (size_t i = 0; i < lvs.size(); i++) {
rootLogVars.clear(); rootLogVars.clear();
rootLogVars.push_back (lvs[i]); rootLogVars.push_back (lvs[i]);
ConstraintTree ct = clauses[0].constr().projectedCopy ({lvs[i]}); ConstraintTree ct = clauses[0]->constr().projectedCopy ({lvs[i]});
if (tryIndepPartialGroundingAux (clauses, ct, rootLogVars)) { if (tryIndepPartialGroundingAux (clauses, ct, rootLogVars)) {
Clauses newClauses = clauses;
for (size_t j = 0; j < clauses.size(); j++) { for (size_t j = 0; j < clauses.size(); j++) {
newClauses[j].addIpgLogVar (rootLogVars[j]); clauses[j]->addIpgLogVar (rootLogVars[j]);
} }
SetAndNode* setAndNode = new SetAndNode (ct.size()); SetAndNode* setAndNode = new SetAndNode (ct.size());
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
@ -506,7 +531,7 @@ LiftedCircuit::tryIndepPartialGrounding (
explanationMap_[setAndNode] = " IPG" ; explanationMap_[setAndNode] = " IPG" ;
} }
*follow = setAndNode; *follow = setAndNode;
compile (setAndNode->follow(), newClauses); compile (setAndNode->follow(), clauses);
return true; return true;
} }
} }
@ -522,9 +547,9 @@ LiftedCircuit::tryIndepPartialGroundingAux (
LogVars& rootLogVars) LogVars& rootLogVars)
{ {
for (size_t i = 1; i < clauses.size(); i++) { for (size_t i = 1; i < clauses.size(); i++) {
LogVarSet lvs = clauses[i].ipgCandidates(); LogVarSet lvs = clauses[i]->ipgCandidates();
for (size_t j = 0; j < lvs.size(); j++) { for (size_t j = 0; j < lvs.size(); j++) {
ConstraintTree ct2 = clauses[i].constr().projectedCopy ({lvs[j]}); ConstraintTree ct2 = clauses[i]->constr().projectedCopy ({lvs[j]});
if (ct.tupleSet() == ct2.tupleSet()) { if (ct.tupleSet() == ct2.tupleSet()) {
rootLogVars.push_back (lvs[j]); rootLogVars.push_back (lvs[j]);
break; break;
@ -537,7 +562,7 @@ LiftedCircuit::tryIndepPartialGroundingAux (
// verifies if the IPG logical vars appear in the same positions // verifies if the IPG logical vars appear in the same positions
unordered_map<LiteralId, size_t> positions; unordered_map<LiteralId, size_t> positions;
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
const Literals& literals = clauses[i].literals(); const Literals& literals = clauses[i]->literals();
for (size_t j = 0; j < literals.size(); j++) { for (size_t j = 0; j < literals.size(); j++) {
size_t idx = literals[j].indexOfLogVar (rootLogVars[i]); size_t idx = literals[j].indexOfLogVar (rootLogVars[i]);
assert (idx != literals[j].nrLogVars()); assert (idx != literals[j].nrLogVars());
@ -563,34 +588,36 @@ LiftedCircuit::tryAtomCounting (
Clauses& clauses) Clauses& clauses)
{ {
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
if (clauses[i].nrPosCountedLogVars() > 0 if (clauses[i]->nrPosCountedLogVars() > 0
|| clauses[i].nrNegCountedLogVars() > 0) { || clauses[i]->nrNegCountedLogVars() > 0) {
// only allow one atom counting node per branch // only allow one atom counting node per branch
return false; return false;
} }
} }
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
backupClauses_ = clauses; backupClauses_ = copyClauses (clauses);
} }
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
Literals literals = clauses[i].literals(); Literals literals = clauses[i]->literals();
for (size_t j = 0; j < literals.size(); j++) { for (size_t j = 0; j < literals.size(); j++) {
if (literals[j].nrLogVars() == 1 if (literals[j].nrLogVars() == 1
&& ! clauses[i].isIpgLogVar (literals[j].logVars().front()) && ! clauses[i]->isIpgLogVar (literals[j].logVars().front())
&& ! clauses[i].isCountedLogVar (literals[j].logVars().front())) { && ! clauses[i]->isCountedLogVar (literals[j].logVars().front())) {
unsigned nrGroundings = clauses[i].constr().projectedCopy ( unsigned nrGroundings = clauses[i]->constr().projectedCopy (
literals[j].logVars()).size(); literals[j].logVars()).size();
SetOrNode* setOrNode = new SetOrNode (nrGroundings); SetOrNode* setOrNode = new SetOrNode (nrGroundings);
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
originClausesMap_[setOrNode] = backupClauses_; originClausesMap_[setOrNode] = backupClauses_;
explanationMap_[setOrNode] = " AC" ; explanationMap_[setOrNode] = " AC" ;
} }
Clause c1 (clauses[i].constr().projectedCopy (literals[j].logVars())); Clause* c1 = new Clause (
Clause c2 (clauses[i].constr().projectedCopy (literals[j].logVars())); clauses[i]->constr().projectedCopy (literals[j].logVars()));
c1.addLiteral (literals[j]); Clause* c2 = new Clause (
c2.addLiteralComplemented (literals[j]); clauses[i]->constr().projectedCopy (literals[j].logVars()));
c1.addPosCountedLogVar (literals[j].logVars().front()); c1->addLiteral (literals[j]);
c2.addNegCountedLogVar (literals[j].logVars().front()); c2->addLiteralComplemented (literals[j]);
c1->addPosCountedLogVar (literals[j].logVars().front());
c2->addNegCountedLogVar (literals[j].logVars().front());
clauses.push_back (c1); clauses.push_back (c1);
clauses.push_back (c2); clauses.push_back (c2);
shatterCountedLogVars (clauses); shatterCountedLogVars (clauses);
@ -635,26 +662,26 @@ LiftedCircuit::shatterCountedLogVarsAux (
size_t idx1, size_t idx1,
size_t idx2) size_t idx2)
{ {
Literals lits1 = clauses[idx1].literals(); Literals lits1 = clauses[idx1]->literals();
Literals lits2 = clauses[idx2].literals(); Literals lits2 = clauses[idx2]->literals();
for (size_t i = 0; i < lits1.size(); i++) { for (size_t i = 0; i < lits1.size(); i++) {
for (size_t j = 0; j < lits2.size(); j++) { for (size_t j = 0; j < lits2.size(); j++) {
if (lits1[i].lid() == lits2[j].lid()) { if (lits1[i].lid() == lits2[j].lid()) {
LogVars lvs1 = lits1[i].logVars(); LogVars lvs1 = lits1[i].logVars();
LogVars lvs2 = lits2[j].logVars(); LogVars lvs2 = lits2[j].logVars();
for (size_t k = 0; k < lvs1.size(); k++) { for (size_t k = 0; k < lvs1.size(); k++) {
if (clauses[idx1].isCountedLogVar (lvs1[k]) if (clauses[idx1]->isCountedLogVar (lvs1[k])
&& clauses[idx2].isCountedLogVar (lvs2[k]) == false) { && clauses[idx2]->isCountedLogVar (lvs2[k]) == false) {
clauses.push_back (clauses[idx2]); clauses.push_back (new Clause (*clauses[idx2]));
clauses[idx2].addPosCountedLogVar (lvs2[k]); clauses[idx2]->addPosCountedLogVar (lvs2[k]);
clauses.back().addNegCountedLogVar (lvs2[k]); clauses.back()->addNegCountedLogVar (lvs2[k]);
return true; return true;
} }
if (clauses[idx2].isCountedLogVar (lvs2[k]) if (clauses[idx2]->isCountedLogVar (lvs2[k])
&& clauses[idx1].isCountedLogVar (lvs1[k]) == false) { && clauses[idx1]->isCountedLogVar (lvs1[k]) == false) {
clauses.push_back (clauses[idx1]); clauses.push_back (new Clause (*clauses[idx1]));
clauses[idx1].addPosCountedLogVar (lvs1[k]); clauses[idx1]->addPosCountedLogVar (lvs1[k]);
clauses.back().addNegCountedLogVar (lvs1[k]); clauses.back()->addNegCountedLogVar (lvs1[k]);
return true; return true;
} }
} }
@ -672,7 +699,7 @@ LiftedCircuit::independentClause (
Clauses& otherClauses) const Clauses& otherClauses) const
{ {
for (size_t i = 0; i < otherClauses.size(); i++) { for (size_t i = 0; i < otherClauses.size(); i++) {
if (Clause::independentClauses (clause, otherClauses[i]) == false) { if (Clause::independentClauses (clause, *otherClauses[i]) == false) {
return false; return false;
} }
} }
@ -781,8 +808,8 @@ LiftedCircuit::smoothCircuit (CircuitNode* node)
case CircuitNodeType::LEAF_NODE: { case CircuitNodeType::LEAF_NODE: {
LeafNode* casted = dynamic_cast<LeafNode*>(node); LeafNode* casted = dynamic_cast<LeafNode*>(node);
propagLits.insert (LitLvTypes ( propagLits.insert (LitLvTypes (
casted->clause().literals()[0].lid(), casted->clause()->literals()[0].lid(),
casted->clause().logVarTypes(0))); casted->clause()->logVarTypes(0)));
} }
default: default:
@ -802,22 +829,22 @@ LiftedCircuit::createSmoothNode (
if (missingLits.empty() == false) { if (missingLits.empty() == false) {
if (Globals::verbosity > 1) { if (Globals::verbosity > 1) {
// assert (Util::contains (originClausesMap_, prev)); // assert (Util::contains (originClausesMap_, prev));
backupClauses_ = originClausesMap_[*prev]; backupClauses_ = originClausesMap_[*prev]; // TODO copyClauses ?
} }
Clauses clauses; Clauses clauses;
for (size_t i = 0; i < missingLits.size(); i++) { for (size_t i = 0; i < missingLits.size(); i++) {
LiteralId lid = missingLits[i].lid(); LiteralId lid = missingLits[i].lid();
const LogVarTypes& types = missingLits[i].logVarTypes(); const LogVarTypes& types = missingLits[i].logVarTypes();
Clause c = lwcnf_->createClause (lid); Clause* c = lwcnf_->createClause (lid);
for (size_t j = 0; j < types.size(); j++) { for (size_t j = 0; j < types.size(); j++) {
LogVar X = c.literals().front().logVars()[j]; LogVar X = c->literals().front().logVars()[j];
if (types[j] == LogVarType::POS_LV) { if (types[j] == LogVarType::POS_LV) {
c.addPosCountedLogVar (X); c->addPosCountedLogVar (X);
} else if (types[j] == LogVarType::NEG_LV) { } else if (types[j] == LogVarType::NEG_LV) {
c.addNegCountedLogVar (X); c->addNegCountedLogVar (X);
} }
} }
c.addLiteralComplemented (c.literals()[0]); c->addLiteralComplemented (c->literals()[0]);
clauses.push_back (c); clauses.push_back (c);
} }
SmoothNode* smoothNode = new SmoothNode (clauses, *lwcnf_); SmoothNode* smoothNode = new SmoothNode (clauses, *lwcnf_);
@ -1109,7 +1136,7 @@ LiftedCircuit::printClauses (
os << " [shape=box," << extraOptions << "label=\"" ; os << " [shape=box," << extraOptions << "label=\"" ;
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
if (i != 0) os << "\\n" ; if (i != 0) os << "\\n" ;
os << clauses[i]; os << *clauses[i];
} }
os << "\"]" ; os << "\"]" ;
os << endl; os << endl;

8
packages/CLPBN/horus/LiftedCircuit.h
View File

@ -130,17 +130,17 @@ class IncExcNode : public CircuitNode
class LeafNode : public CircuitNode class LeafNode : public CircuitNode
{ {
public: public:
LeafNode (const Clause& clause, const LiftedWCNF& lwcnf) LeafNode (Clause* clause, const LiftedWCNF& lwcnf)
: CircuitNode(), clause_(clause), lwcnf_(lwcnf) { } : CircuitNode(), clause_(clause), lwcnf_(lwcnf) { }
const Clause& clause (void) const { return clause_; } const Clause* clause (void) const { return clause_; }
Clause& clause (void) { return clause_; } Clause* clause (void) { return clause_; }
double weight (void) const; double weight (void) const;
private: private:
Clause clause_; Clause* clause_;
const LiftedWCNF& lwcnf_; const LiftedWCNF& lwcnf_;
}; };

43
packages/CLPBN/horus/LiftedWCNF.cpp
View File

@ -312,7 +312,7 @@ void
Clause::printClauses (const Clauses& clauses) Clause::printClauses (const Clauses& clauses)
{ {
for (size_t i = 0; i < clauses.size(); i++) { for (size_t i = 0; i < clauses.size(); i++) {
cout << clauses[i] << endl; cout << *clauses[i] << endl;
} }
} }
@ -448,23 +448,24 @@ LiftedWCNF::prvGroupLiterals (PrvGroup prvGroup)
Clause Clause*
LiftedWCNF::createClause (LiteralId lid) const LiftedWCNF::createClause (LiteralId lid) const
{ {
for (size_t i = 0; i < clauses_.size(); i++) { for (size_t i = 0; i < clauses_.size(); i++) {
const Literals& literals = clauses_[i].literals(); const Literals& literals = clauses_[i]->literals();
for (size_t j = 0; j < literals.size(); j++) { for (size_t j = 0; j < literals.size(); j++) {
if (literals[j].lid() == lid) { if (literals[j].lid() == lid) {
ConstraintTree ct = clauses_[i].constr(); // TODO projectedCopy ?
ConstraintTree ct = clauses_[i]->constr();
ct.project (literals[j].logVars()); ct.project (literals[j].logVars());
Clause clause (ct); Clause* c = new Clause (ct);
clause.addLiteral (literals[j]); c->addLiteral (literals[j]);
return clause; return c;
} }
} }
} }
abort(); // we should not reach this point abort(); // we should not reach this point
return Clause (ConstraintTree({})); return 0;
} }
@ -488,10 +489,10 @@ LiftedWCNF::addIndicatorClauses (const ParfactorList& pfList)
if (Util::contains (map_, formulas[i].group()) == false) { if (Util::contains (map_, formulas[i].group()) == false) {
ConstraintTree tempConstr = *(*it)->constr(); ConstraintTree tempConstr = *(*it)->constr();
tempConstr.project (formulas[i].logVars()); tempConstr.project (formulas[i].logVars());
Clause clause (tempConstr); Clause* clause = new Clause (tempConstr);
vector<LiteralId> lids; vector<LiteralId> lids;
for (size_t j = 0; j < formulas[i].range(); j++) { for (size_t j = 0; j < formulas[i].range(); j++) {
clause.addLiteral (Literal (freeLiteralId_, formulas[i].logVars())); clause->addLiteral (Literal (freeLiteralId_, formulas[i].logVars()));
lids.push_back (freeLiteralId_); lids.push_back (freeLiteralId_);
freeLiteralId_ ++; freeLiteralId_ ++;
} }
@ -500,9 +501,9 @@ LiftedWCNF::addIndicatorClauses (const ParfactorList& pfList)
for (size_t k = j + 1; k < formulas[i].range(); k++) { for (size_t k = j + 1; k < formulas[i].range(); k++) {
ConstraintTree tempConstr2 = *(*it)->constr(); ConstraintTree tempConstr2 = *(*it)->constr();
tempConstr2.project (formulas[i].logVars()); tempConstr2.project (formulas[i].logVars());
Clause clause2 (tempConstr2); Clause* clause2 = new Clause (tempConstr2);
clause2.addLiteralComplemented (Literal (clause.literals()[j])); clause2->addLiteralComplemented (Literal (clause->literals()[j]));
clause2.addLiteralComplemented (Literal (clause.literals()[k])); clause2->addLiteralComplemented (Literal (clause->literals()[k]));
clauses_.push_back (clause2); clauses_.push_back (clause2);
} }
} }
@ -532,22 +533,22 @@ LiftedWCNF::addParameterClauses (const ParfactorList& pfList)
double posWeight = (**it)[indexer]; double posWeight = (**it)[indexer];
addWeight (paramVarLid, posWeight, 1.0); addWeight (paramVarLid, posWeight, 1.0);
Clause clause1 (*(*it)->constr()); Clause* clause1 = new Clause (*(*it)->constr());
for (unsigned i = 0; i < groups.size(); i++) { for (unsigned i = 0; i < groups.size(); i++) {
LiteralId lid = getLiteralId (groups[i], indexer[i]); LiteralId lid = getLiteralId (groups[i], indexer[i]);
clause1.addLiteralComplemented ( clause1->addLiteralComplemented (
Literal (lid, (*it)->argument(i).logVars())); Literal (lid, (*it)->argument(i).logVars()));
ConstraintTree ct = *(*it)->constr(); ConstraintTree ct = *(*it)->constr();
Clause tempClause (ct); Clause* tempClause = new Clause (ct);
tempClause.addLiteralComplemented (Literal ( tempClause->addLiteralComplemented (Literal (
paramVarLid, (*it)->constr()->logVars())); paramVarLid, (*it)->constr()->logVars()));
tempClause.addLiteral (Literal (lid, (*it)->argument(i).logVars())); tempClause->addLiteral (Literal (lid, (*it)->argument(i).logVars()));
clauses_.push_back (tempClause); clauses_.push_back (tempClause);
} }
clause1.addLiteral (Literal (paramVarLid, (*it)->constr()->logVars())); clause1->addLiteral (Literal (paramVarLid, (*it)->constr()->logVars()));
clauses_.push_back (clause1); clauses_.push_back (clause1);
freeLiteralId_ ++; freeLiteralId_ ++;
++ indexer; ++ indexer;
@ -601,8 +602,6 @@ LiftedWCNF::printWeights (void) const
void void
LiftedWCNF::printClauses (void) const LiftedWCNF::printClauses (void) const
{ {
for (unsigned i = 0; i < clauses_.size(); i++) { Clause::printClauses (clauses_);
cout << clauses_[i] << endl;
}
} }

10
packages/CLPBN/horus/LiftedWCNF.h
View File

@ -75,6 +75,10 @@ class Clause
const Literals& literals (void) const { return literals_; } const Literals& literals (void) const { return literals_; }
Literals& literals (void) { return literals_; }
size_t nrLiterals (void) const { return literals_.size(); }
const ConstraintTree& constr (void) const { return constr_; } const ConstraintTree& constr (void) const { return constr_; }
ConstraintTree constr (void) { return constr_; } ConstraintTree constr (void) { return constr_; }
@ -129,7 +133,7 @@ class Clause
static bool independentClauses (Clause& c1, Clause& c2); static bool independentClauses (Clause& c1, Clause& c2);
static void printClauses (const vector<Clause>& clauses); static void printClauses (const vector<Clause*>& clauses);
friend std::ostream& operator<< (ostream &os, const Clause& clause); friend std::ostream& operator<< (ostream &os, const Clause& clause);
@ -143,7 +147,7 @@ class Clause
ConstraintTree constr_; ConstraintTree constr_;
}; };
typedef vector<Clause> Clauses; typedef vector<Clause*> Clauses;
@ -199,7 +203,7 @@ class LiftedWCNF
vector<LiteralId> prvGroupLiterals (PrvGroup prvGroup); vector<LiteralId> prvGroupLiterals (PrvGroup prvGroup);
Clause createClause (LiteralId lid) const; Clause* createClause (LiteralId lid) const;
void printFormulaIndicators (void) const; void printFormulaIndicators (void) const;