/*
* Caller is responsible for deleting returned Predicate* if necessary
*/
Predicate* Domain::getNonEvidenceAtom(const int& index) const
{
int predId = -1;
int numAtomsPerPred;
int numAtoms = 0;
for (int i = 0; i < getNumPredicates(); i++)
{
numAtomsPerPred = (*numNonEvidAtomsPerPred_)[i];
if (numAtoms + numAtomsPerPred >= index + 1)
{
predId = i;
break;
}
numAtoms += numAtomsPerPred;
}
assert(predId >= 0);
// Get the newIndex-th grounding of f.o. pred with id predId
Predicate* pred = createPredicate(predId, false);
// Not all groundings of pred are non-evidence, so we need the while loop
bool foundNE = false;
while(!foundNE)
{
for (int i = 0; i < pred->getNumTerms(); i++)
{
int termType = pred->getTermTypeAsInt(i);
const Array<int>* constantsByType = getConstantsByType(termType);
int constIdx = random() % constantsByType->size();
pred->setTermToConstant(i, (*constantsByType)[constIdx]);
}
assert(pred->isGrounded());
if (!db_->getEvidenceStatus(pred)) foundNE = true;
}
return pred;
}
double Clause::getConstantTuples(const Domain* const & domain,
const Database* const & db,
Array<int>* const & mlnClauseTermIds,
const Clause* const & varClause,
PredicateTermToVariable * const & ptermToVar,
ClauseToSuperClauseMap* const & clauseToSuperClause,
bool useImplicit)
{
bool ignoreActivePreds = true;
double numTrueGndings = 0;
//initialize the constants tuple with the var Ids - we will fill them in
//with constants as we go along
Array<int> *constants = new Array<int>(*mlnClauseTermIds);
//Copy the literals so that their original order in the clause is
//not affected by the subsequent sorting
cout<<"***************************************************************"<<endl;
cout<<"Came to process the clause : "<<endl;
print(cout, domain);
cout<<endl;
createVarIdToVarsGroundedType(domain);
Array<Predicate*>* origClauseLits = new Array<Predicate*>(*predicates_);
// Array of partially grounded clauses achieved by using the inverted
// index
Array<Array<Predicate*>* > partGroundedClauses;
//Assign to each variable in clause, the corresponding variable class
//(stores the list of indexed constants). It is accessed through the
//predicates appearing in the clause
PredicateTermToVariable::iterator itr;
PredicateTerm *pterm;
Predicate *pred;
const Term *term;
Array<Variable *> *eqVars = new Array<Variable *>();
eqVars->growToSize(mlnClauseTermIds->size());
//initialize with NULL
for (int i = 0; i < eqVars->size(); i++)
(*eqVars)[i] = NULL;
if (useImplicit)
{
for (int predno = 0; predno < varClause->getNumPredicates(); predno++)
{
pred = varClause->getPredicate(predno);
int predId = pred->getId();
for (int termno = 0; termno < pred->getNumTerms(); termno++)
{
term = pred->getTerm(termno);
assert(!term->isConstant());
int termId = term->getId();
pterm = new PredicateTerm(predId, termno);
itr = ptermToVar->find(pterm);
assert(itr != ptermToVar->end());
assert(-termId < eqVars->size());
(*eqVars)[-termId] = itr->second;
delete pterm;
}
}
}
if (useInverseIndex)
{
// Put the indexable literals first and ground them
sortLiteralsByNegationAndArity(*origClauseLits, ignoreActivePreds, db);
groundIndexableLiterals(domain, db, *origClauseLits, partGroundedClauses,
ignoreActivePreds);
}
else
{
//Sort preds in decreasing order of #TrueGndOfLiteral/#numOfGroundings.
//The larger the number of true groundings of a literal, the more likely
//it is to be true, so put it in front so that we can decide whether the
//clause is true early.The larger the number of groundings of the
//literal, the larger the savings when we decide that preceding literals
//are true.
sortLiteralsByTrueDivTotalGroundings(*origClauseLits, domain, db);
// Put the original clause as the only clause into partGroundedClauses
Array<Predicate*>* clauseLitsCopy = new Array<Predicate*>;
clauseLitsCopy->growToSize(origClauseLits->size());
for (int i = 0; i < origClauseLits->size(); i++)
(*clauseLitsCopy)[i] = new Predicate(*(*origClauseLits)[i]);
partGroundedClauses.append(clauseLitsCopy);
}
// At this point partGroundedClauses holds the nodes of the branch and
// bound algorithm. This means nothing more is indexed and we must ground
// out the rest of the predicates
if (clausedebug)
{
cout << "Partially grounded clauses to be completed: " << endl;
for (int pgcIdx = 0; pgcIdx < partGroundedClauses.size(); pgcIdx++)
{
cout << "\t";
for (int i = 0; i < partGroundedClauses[pgcIdx]->size(); i++)
{
(*partGroundedClauses[pgcIdx])[i]->printWithStrVar(cout, domain);
cout << " ";
}
cout << endl;
}
}
bool skip;
// Go through each clause in partGroundedClauses (nodes of the branch and
// bound algorithm if using inverted index; otherwise, the original
// clause), ground them out and check truth values
for (int pgcIdx = 0; pgcIdx < partGroundedClauses.size(); pgcIdx++)
{
//intially, the list of constants is simply the mln term ids
constants->copyFrom(*mlnClauseTermIds);
skip = false;
// clauseLits is a sorted copy of predicates_
Array<Predicate*> clauseLits = *(partGroundedClauses[pgcIdx]);
assert(clauseLits.size() == origClauseLits->size());
// Set the var to groundings in this clause to be those in clauseLits
Array<int>* origVarIds = new Array<int>;
for (int i = 0; i < clauseLits.size(); i++)
{
assert(clauseLits[i]->getNumTerms() ==
(*origClauseLits)[i]->getNumTerms());
// Ground variables throughout clause
for (int j = 0; j < (*origClauseLits)[i]->getNumTerms(); j++)
{
const Term* oldTerm = (*origClauseLits)[i]->getTerm(j);
const Term* newTerm = clauseLits[i]->getTerm(j);
if (oldTerm->getType() == Term::VARIABLE)
{
int varId = oldTerm->getId();
origVarIds->append(varId);
if (newTerm->getType() == Term::CONSTANT)
{
int constId = newTerm->getId();
assert(constId >= 0);
Array<Term*>& vars = (*varIdToVarsGroundedType_)[-varId]->vars;
assert(constants->size() >= (-varId+1));
if (useImplicit)
{
int implicitIndex =
(*eqVars)[-varId]->getImplicitIndex(constId);
if (implicitIndex < 0)
{
(*constants)[-varId] = constId;
}
else
{
if (isRepresentativePartialTuple(constants, implicitIndex,
eqVars, varId))
{
(*constants)[-varId] = constId;
}
else
{
skip = true;
}
}
}
else
{
(*constants)[-varId] = constId;
}
for (int k = 0; k < vars.size(); k++) vars[k]->setId(constId);
}
}
}
// Set the preds in clauseLits to point to the original predicates_
delete clauseLits[i];
clauseLits[i] = (*origClauseLits)[i];
}
if (!skip)
{
//simulate a stack, back/front corresponds to top/bottom
//ivg stands for index, varIds, groundings
Array<LitIdxVarIdsGndings*> ivgArr;
createAllLitIdxVarsGndings(clauseLits, ivgArr, domain, true);
int ivgArrIdx = 0; //store current position in ivgArr
bool lookAtNextLit = false;
// while stack is not empty
while (ivgArrIdx >= 0)
{
// get variable groundings at top of stack
LitIdxVarIdsGndings* ivg = ivgArr[ivgArrIdx];
Predicate* lit = (*origClauseLits)[ivg->litIdx];
Array<int>& varIds = ivg->varIds;
ArraysAccessor<int>& varGndings = ivg->varGndings;
bool& litUnseen = ivg->litUnseen;
bool hasComb;
if (clausedebug)
{
cout << "Looking at lit: ";
lit->printWithStrVar(cout, domain);
cout << endl;
}
bool gotoNextComb = false;
// while there are groundings of literal's variables
while ((hasComb = varGndings.hasNextCombination()) || litUnseen)
{
// there may be no combinations if the literal is fully grounded
if (litUnseen) litUnseen = false;
if (hasComb)
{
//replace back the variables into the constants array
for (int v = 0; v < varIds.size(); v++)
{
(*constants)[-varIds[v]] = varIds[v];
}
//ground the literal's variables throughout the clause
int constId;
int v = 0; // index of varIds
//for each variable in literal
gotoNextComb = false;
while (varGndings.nextItemInCombination(constId))
{
int varId = varIds[v];
Array<Term*>& vars = (*varIdToVarsGroundedType_)[-varId]->vars;
//store the assignment to this variable
assert(constants->size() >= (-varId+1));
if (useImplicit)
{
int implicitIndex =
(*eqVars)[-varId]->getImplicitIndex(constId);
if (implicitIndex < 0)
{
(*constants)[-varId] = constId;
}
else
{
//in case of implicit constant, proceed only if
//substitution of this constant
//will form a representative tuple - see the body of the
//function for the details of
//what a representative tuple is
if (isRepresentativePartialTuple(constants, implicitIndex,
eqVars, varId))
{
(*constants)[-varId] = constId;
}
else
{
gotoNextComb = true;
}
}
}
else
{
(*constants)[-varId] = constId;
}
v++;
for (int i = 0; i < vars.size(); i++) vars[i]->setId(constId);
}
//a sanity check - for debugging purposes
assert(varIds.size() == v);
}
//removeRedundantPredicates();
if (clausedebug)
{
cout << "Clause is now: ";
printWithWtAndStrVar(cout, domain);
cout << endl;
}
if (gotoNextComb)
continue;
if (literalOrSubsequentLiteralsAreTrue(lit, ivg->subseqGndLits, db))
{
if (clausedebug)
cout << "Clause satisfied" << endl;
//count the number of combinations of remaining variables
double numComb = 1;
for (int i = ivgArrIdx + 1; i < ivgArr.size(); i++)
{
int numVar = ivgArr[i]->varGndings.getNumArrays();
for (int j = 0; j < numVar; j++)
numComb *= ivgArr[i]->varGndings.getArray(j)->size();
}
numTrueGndings += numComb;
}
else
{
// if there are more literals
if (ivgArrIdx + 1 < ivgArr.size())
{
if (clausedebug) cout << "Moving to next literal" << endl;
lookAtNextLit = true;
ivgArrIdx++; // move up stack
break;
}
//At this point all the literals are grounded, and they are
//either unknown or false (have truth values opposite of their
//senses).
//- this so that it matches the hypercube representation.
//There is no real need to simplify the clause!
if (false)
{
++numTrueGndings;
}
else
{
//Create a new constant tuple
addConstantTuple(domain, db, varClause, constants, eqVars,
clauseToSuperClause, useImplicit);
}
}
} //while there are groundings of literal's variables
//if we exit the while loop in order to look at next literal
//(i.e. without considering all groundings of current literal)
if (lookAtNextLit) { lookAtNextLit = false; }
//mv down stack
else
{
varGndings.reset();
litUnseen = true;
ivgArrIdx--;
//replace back the variables into the constants array
for (int v = 0; v < varIds.size(); v++)
{
(*constants)[-varIds[v]] = varIds[v];
}
}
} // while stack is not empty
deleteAllLitIdxVarsGndings(ivgArr);
} //end skip
// Restore variables
for (int i = 0; i < origVarIds->size(); i++)
{
int varId = (*origVarIds)[i];
assert(varId < 0);
Array<Term*>& vars = (*varIdToVarsGroundedType_)[-varId]->vars;
for (int j = 0; j < vars.size(); j++) vars[j]->setId(varId);
(*varIdToVarsGroundedType_)[-varId]->isGrounded = false;
}
delete origVarIds;
delete partGroundedClauses[pgcIdx];
}
delete origClauseLits;
delete constants;
return numTrueGndings;
}