C++ (Cpp) Clause::getNumPredicates Examples

Example #1

File: domain.cpp Project: aduitsis/alchemy-2

/**
 * The constants of this domain are replaced by new constants. The new set of
 * constants must be a superset of the original one. New constants are marked
 * as external.
 */
void Domain::updatePerOldToNewIds(MLN* const & mln,
                                  hash_map<int,int> & oldToNewConstIds)
{
    //ensure that the constants in MLN clauses have the new ids 
  const ClauseHashArray* clauses = mln->getClauses();
  for (int i = 0; i < clauses->size(); i++)
  {
    Clause* c = (*clauses)[i];
    for (int i = 0; i < c->getNumPredicates(); i++)
      changePredTermsToNewIds(c->getPredicate(i), oldToNewConstIds);
  }

  const Array<Clause*>* hclauses = mln->getHybridClauses();
  for (int i = 0; i < hclauses->size(); i++)
  {
    Clause* c = (*hclauses)[i];
    for (int i = 0; i < c->getNumPredicates(); i++)
      changePredTermsToNewIds(c->getPredicate(i), oldToNewConstIds);
  }

    // Change the const ids in the pred blocks
  for (int i = 0; i < predBlocks_->size(); i++)
  {
    changePredTermsToNewIds((*predBlocks_)[i], oldToNewConstIds);
  }
  for (int i = 0; i < truePredsInBlock_->size(); i++)
  {
    changePredTermsToNewIds((*truePredsInBlock_)[i], oldToNewConstIds);
  }

    // Change the const ids in the database
  if (db_)
  {
    db_->changeConstantsToNewIds(oldToNewConstIds);
  }
}

Example #2

File: clause.cpp Project: Artemid/alchemy-2

//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;
}