//add a constant tuple to the list of constant tuples inline void Clause::addConstantTuple(const Domain* const & domain, const Database* const & db, const Clause * const & varClause, Array<int> * const & constants, Array<Variable *> * const & eqVars, ClauseToSuperClauseMap* const & clauseToSuperClause, bool useImplicit) { // used to detect duplicates PredicateSet predSet; PredicateSet::iterator iter; Predicate *predicate; Clause *clause = new Clause(); //first make sure the clause is not satisfied (because of presence of two //identical gnd preds with opposite senses) for (int i = 0; i < predicates_->size(); i++) { predicate = (*predicates_)[i]; assert(predicate->isGrounded()); /* if (db->getValue(predicate) == UNKNOWN) { clause->appendPredicate(varClause->getPredicate(i)); if ( (iter=predSet.find(predicate)) != predSet.end() ) { // the two gnd preds are of opp sense, so clause must be satisfied if ((*iter)->getSense() != predicate->getSense()) { clause->removeAllPredicates(); delete clause; return; } // since the two gnd preds are identical, no point adding a dup continue; } else predSet.insert(predicate); } */ //- this so that it matches the hypercube representation. //There is no real need to simplify the clause! if (db->getValue(predicate) == UNKNOWN) { clause->appendPredicate(varClause->getPredicate(i)); } } SuperClause *superClause; ClauseToSuperClauseMap::iterator itr; Clause *keyClause; Array<int> * varIdToCanonicalVarId; Array<int> * canonicalConstants; Array<Variable *> * canonicalEqVars; //Slightly different Imeplementation for SuperClause bool useCT = false; IntArrayHashArray *neqConstraints = NULL; //nothing to do if the clause has no predicate if (clause->getNumPredicates() == 0) { delete clause; return; } itr = clauseToSuperClause->find(clause); if (itr == clauseToSuperClause->end()) { //it is best to create a completely new copy of the clause //at this point keyClause = new Clause(*clause); keyClause->setWt(this->getWt()); keyClause->setUtil(this->getUtil()); keyClause->setAction(this->isActionFactor()); //keyClause->setWt(1); int varCnt = constants->size(); varIdToCanonicalVarId = new Array<int>(varCnt, -1); keyClause->canonicalize(varIdToCanonicalVarId); canonicalEqVars = getCanonicalArray(eqVars, varIdToCanonicalVarId); //Slightly different Imeplementation for SuperClause superClause = new SuperClause(keyClause, neqConstraints, varIdToCanonicalVarId, useCT, wt_); (*clauseToSuperClause)[clause] = superClause; delete canonicalEqVars; //delete varIdToCanonicalVarId; } else { superClause = itr->second; //sort of a hack, but it works: //may need to increase the size of varIdToCanonicalVarId map int varCnt = constants->size(); varIdToCanonicalVarId = superClause->getVarIdToCanonicalVarId(); varIdToCanonicalVarId->growToSize(varCnt,-1); //delete the clause. Predicates should not be deleted, as //they belong to the varClause clause->removeAllPredicates(); delete clause; } varIdToCanonicalVarId = superClause->getVarIdToCanonicalVarId(); canonicalConstants = getCanonicalArray(constants, varIdToCanonicalVarId); //superClause->addNewConstantsAndIncrementCount(canonicalConstants,this->getWt()); superClause->addNewConstantsAndIncrementCount(canonicalConstants,1); //clean up delete canonicalConstants; }