コード例 #1
0
/**
 * @brief if the Tuple passed as the second parameter is present in the AnswerSets passed as first parameter
 */
bool ActionPluginFinalCallback::thisAnswerSetContainsThisAction(
		const AnswerSetPtr& answerSetPtr, const Tuple& action_tuple) {

	// used to have only the Action Atoms
	InterpretationPtr intr = InterpretationPtr(new Interpretation(registryPtr));
	intr->getStorage() |= ctxData.myAuxiliaryPredicateMask.mask()->getStorage();
	intr->getStorage() &= answerSetPtr->interpretation->getStorage();

	Interpretation::TrueBitIterator bit, bit_end;
	for (boost::tie(bit, bit_end) = intr->trueBits(); bit != bit_end; ++bit) {

		const Tuple & tuple = registryPtr->ogatoms.getByAddress(*bit).tuple;

		if (tuple.size() - 5 == action_tuple.size()) {

			bool different = false;

			for (int i = 0; i < action_tuple.size() && !different; i++)
				if (tuple[i + 1] != action_tuple[i])
					different = true;

			if (!different)
				return true;

		}

	}

	return false;

}
コード例 #2
0
InterpretationPtr GuessAndCheckModelGenerator::generateNextModel()
{
    RegistryPtr reg = factory.reg;

    // now we have postprocessed input in postprocessedInput
    DLVHEX_BENCHMARK_REGISTER_AND_SCOPE(sidgcsolve, "guess and check loop");

    InterpretationPtr modelCandidate;
    do {
        AnswerSetPtr guessas = guessres->getNextAnswerSet();
        if( !guessas )
            return InterpretationPtr();
        modelCandidate = guessas->interpretation;

        DBGLOG_SCOPE(DBG,"gM", false);
        DBGLOG(DBG,"= got guess model " << *modelCandidate);

        DBGLOG(DBG, "doing compatibility check for model candidate " << *modelCandidate);
        assert(!factory.ctx.config.getOption("ExternalLearning") &&
            "cannot use external learning in (non-genuine) GuessAndCheckModelGenerator");
        bool compatible = isCompatibleSet(
            modelCandidate, postprocessedInput, factory.ctx,
            SimpleNogoodContainerPtr());
        DBGLOG(DBG, "Compatible: " << compatible);
        if (!compatible) continue;

        // FLP check
        if (factory.ctx.config.getOption("FLPCheck")) {
            DBGLOG(DBG, "FLP Check");
            if( !isSubsetMinimalFLPModel<ASMOrdinaryASPSolver>(
                modelCandidate, postprocessedInput, factory.ctx) )
                continue;
        }
        else {
            DBGLOG(DBG, "Skipping FLP Check");
        }

        // remove edb and the guess (from here we don't need the guess anymore)
        modelCandidate->getStorage() -= factory.gpMask.mask()->getStorage();
        modelCandidate->getStorage() -= factory.gnMask.mask()->getStorage();

        modelCandidate->getStorage() -= mask->getStorage();

        DBGLOG(DBG,"= final model candidate " << *modelCandidate);
        return modelCandidate;
    }
    while(true);
}
コード例 #3
0
/**
 * @brief function that fill the multimap (passed as parameter) with Precedence attribute and Action Tuple checking the Action Option attribute
 */
void ActionPluginFinalCallback::executionModeController(
		std::multimap<int, Tuple>& multimapOfExecution) {

	const AnswerSetPtr& bestModel = (*(ctxData.iteratorBestModel));

	// used to have only the Action Atoms
	InterpretationPtr intr = InterpretationPtr(new Interpretation(registryPtr));
	intr->getStorage() |= ctxData.myAuxiliaryPredicateMask.mask()->getStorage();
	intr->getStorage() &= bestModel->interpretation->getStorage();

	Interpretation::TrueBitIterator bit, bit_end;
	for (boost::tie(bit, bit_end) = intr->trueBits(); bit != bit_end; ++bit) {

		const OrdinaryAtom& oatom = registryPtr->ogatoms.getByAddress(*bit);
		const Tuple & tuple = oatom.tuple;

		int precedence, precedence_position = tuple.size() - 3;
		dlvhex::ID id_actionOption = tuple[tuple.size() - 4];

		Tuple action_tuple;

		for (int i = 1; i < tuple.size() - 4; i++)
			action_tuple.push_back(tuple[i]);

		if (tuple[precedence_position].isIntegerTerm()
				&& id_actionOption.isConstantTerm()) {

			precedence = tuple[precedence_position].address;

			DBGLOG(DBG,
					"actionOption: "
							<< registryPtr->getTermStringByID(id_actionOption));
			DBGLOG(DBG, "Precedence: " << precedence);

			if (id_actionOption == ctxData.getIDBrave())
				;
			else if (id_actionOption == ctxData.getIDCautious())
				if (!isPresentInAllAnswerSets(action_tuple)) {
					std::stringstream ss;
					printTuple(ss, action_tuple, registryPtr);
					DBGLOG(DBG,
							"This action atom isn't present in all AnswerSet: "
									<< ss.str());
					continue;
				} else if (id_actionOption == ctxData.getIDPreferredCautious())
					if (!isPresentInAllTheBestModelsAnswerSets(action_tuple)) {
						std::stringstream ss;
						printTuple(ss, action_tuple, registryPtr);
						DBGLOG(DBG,
								"This action atom isn't present in all BestModels AnswerSet: "
										<< ss.str());
						continue;
					} else
						throw PluginError(
								"Error in the selection of brave, cautious or preferred_cautious");

			multimapOfExecution.insert(
					std::pair<int, Tuple>(precedence, action_tuple));

		} else
			throw PluginError(
					"Precedence isn't Integer term or actionOption haven't a valid value");

	}

}
コード例 #4
0
PlainModelGenerator::InterpretationPtr
PlainModelGenerator::generateNextModel()
{
  RegistryPtr reg = factory.ctx.registry();
  if( currentResults == 0 )
  {
    do // breakout possibility
    {
      // we need to create currentResults

      // create new interpretation as copy
      Interpretation::Ptr newint;
      if( input == 0 )
      {
        // empty construction
        newint.reset(new Interpretation(reg));
      }
      else
      {
        // copy construction
        newint.reset(new Interpretation(*input));
      }

      // augment input with edb
      newint->add(*factory.ctx.edb);

      // remember facts so far (we have to remove these from any output)
      InterpretationConstPtr mask(new Interpretation(*newint));

      // manage outer external atoms
      if( !factory.eatoms.empty() )
      {
        // augment input with result of external atom evaluation
        // use newint as input and as output interpretation
        IntegrateExternalAnswerIntoInterpretationCB cb(newint);
        evaluateExternalAtoms(factory.ctx, factory.eatoms, newint, cb);
        DLVHEX_BENCHMARK_REGISTER(sidcountexternalanswersets,
            "outer eatom computations");
        DLVHEX_BENCHMARK_COUNT(sidcountexternalanswersets,1);

        if( factory.xidb.empty() )
        {
          // we only have eatoms -> return singular result

          // remove EDB and direct input from newint
          // (keep local models as small as possible)
          newint->getStorage() -= mask->getStorage();

          PreparedResults* pr = new PreparedResults;
          currentResults.reset(pr);
          pr->add(AnswerSetPtr(new AnswerSet(newint)));
          break;
        }
      }

      // store in model generator and store as const
      postprocessedInput = newint;

      DLVHEX_BENCHMARK_REGISTER_AND_START(sidaspsolve,
          "initiating external solver");
      OrdinaryASPProgram program(reg,
          factory.xidb, postprocessedInput, factory.ctx.maxint, mask);
      ASPSolverManager mgr;
      currentResults = mgr.solve(*factory.externalEvalConfig, program);
      DLVHEX_BENCHMARK_STOP(sidaspsolve);
    }
    while(false); // end of breakout possibility
  }

  assert(currentResults != 0);
  AnswerSet::Ptr ret = currentResults->getNextAnswerSet();
  if( ret == 0 )
  {
    currentResults.reset();
    // the following is just for freeing memory early
    postprocessedInput.reset();
    return InterpretationPtr();
  }
  DLVHEX_BENCHMARK_REGISTER(sidcountplainanswersets, "PlainMG answer sets");
  DLVHEX_BENCHMARK_COUNT(sidcountplainanswersets,1);

  return ret->interpretation;
}