/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="expression">Expression.</param>
/// <returns>True if the expression is logically true, false otherwise.</returns>
public virtual bool Visit(PredicateLiteralCNF expression)
{
IAtom groundedPredicateAtom = GroundingManager.GroundAtomDeep(expression.PredicateAtom, Substitution, ReferenceState);
bool evaluationResult = (RigidRelations.Contains(groundedPredicateAtom) || ReferenceState.HasPredicate(groundedPredicateAtom));
return(!expression.IsNegated == evaluationResult);
}
/// <summary>
/// Set the rigid properties of the corresponding planning problem.
/// </summary>
/// <param name="rigidRelations">Rigid relations of the planning problem.</param>
public void SetRigidRelations(RigidRelations rigidRelations)
{
RigidRelations = rigidRelations;
if (ExpressionEvaluator.IsValueCreated)
{
ExpressionEvaluator.Value.SetRigidRelations(RigidRelations);
}
else
{
ExpressionEvaluator = new Lazy <ExpressionEvaluator>(() => new ExpressionEvaluator(GroundingManager, RigidRelations));
}
if (ConditionsCNFEvaluator.IsValueCreated)
{
ConditionsCNFEvaluator.Value.SetRigidRelations(RigidRelations);
}
else
{
ConditionsCNFEvaluator = new Lazy <ConditionsCNFEvaluator>(() => new ConditionsCNFEvaluator(GroundingManager, RigidRelations));
}
if (RigidRelationsComplianceEvaluator.IsValueCreated)
{
RigidRelationsComplianceEvaluator.Value.SetRigidRelations(RigidRelations);
}
else
{
RigidRelationsComplianceEvaluator = new Lazy <RigidRelationsComplianceEvaluator>(() => new RigidRelationsComplianceEvaluator(GroundingManager, RigidRelations));
}
}
/// <summary>
/// Visits and evaluates predicate expression.
/// </summary>
/// <param name="expression">Predicate expression.</param>
/// <returns>True if the specified expression evaluates as true, false otherwise.</returns>
public bool Visit(PredicateExpression expression)
{
// if the predicate is a rigid relation, then check whether it has the correct value
if (RigidRelations.IsPredicateRigidRelation(expression.PredicateAtom))
{
IAtom predicateAtom = GroundingManager.GroundAtom(expression.PredicateAtom, Substitution);
return(RigidRelations.Contains(predicateAtom));
}
return(true);
}
/// <summary>
/// Constructs the evaluation manager.
/// </summary>
/// <param name="groundingManager">Grounding manager.</param>
/// <param name="rigidRelations">Rigid relations.</param>
public EvaluationManager(GroundingManager groundingManager, RigidRelations rigidRelations = null)
{
ExpressionEvaluator = new Lazy <ExpressionEvaluator>(() => new ExpressionEvaluator(groundingManager, rigidRelations));
ConditionsCNFEvaluator = new Lazy <ConditionsCNFEvaluator>(() => new ConditionsCNFEvaluator(groundingManager, rigidRelations));
RigidRelationsComplianceEvaluator = new Lazy <RigidRelationsComplianceEvaluator>(() => new RigidRelationsComplianceEvaluator(groundingManager, rigidRelations));
NotAccomplishedConstraintsCounter = new Lazy <NotAccomplishedConstraintsCounter>(() => new NotAccomplishedConstraintsCounter(groundingManager, ExpressionEvaluator));
NotAccomplishedConstraintsCounterCNF = new Lazy <NotAccomplishedConstraintsCounterCNF>(() => new NotAccomplishedConstraintsCounterCNF(ConditionsCNFEvaluator));
PlanningGraphOperatorLabelEvaluator = new Lazy <PlanningGraphOperatorLabelEvaluator>(() => new PlanningGraphOperatorLabelEvaluator(groundingManager));
PlanningGraphOperatorLabelEvaluatorCNF = new Lazy <PlanningGraphOperatorLabelEvaluatorCNF>(() => new PlanningGraphOperatorLabelEvaluatorCNF(groundingManager));
SatisfyingAtomsEvaluator = new Lazy <SatisfyingAtomsEvaluator>(() => new SatisfyingAtomsEvaluator(groundingManager, rigidRelations));
ConditionsParametersRenamer = new Lazy <ConditionsParametersRenamer>(() => new ConditionsParametersRenamer());
ConditionsUsedPredicatesCollector = new Lazy <ConditionsUsedPredicatesCollector>(() => new ConditionsUsedPredicatesCollector());
RigidRelations = rigidRelations;
GroundingManager = groundingManager;
}
/// <summary>
/// Constructs the PDDL planning problem from the input data.
/// </summary>
/// <param name="inputData">Input data.</param>
public Problem(InputData.PDDLInputData inputData)
{
DomainName = inputData.Domain.Name;
ProblemName = inputData.Problem.Name;
OriginalInputData = inputData;
IdManager = new IdManager(inputData);
EvaluationManager = new EvaluationManager(new GroundingManager(inputData, IdManager));
Operators = new LiftedOperators(inputData.Domain.Actions, IdManager, EvaluationManager);
InitialState = new State(inputData.Problem.Init, IdManager);
GoalConditions = new Conditions(inputData.Problem.Goal, null, IdManager, EvaluationManager);
RigidRelations = new RigidRelations(InitialState, Operators);
TransitionsGenerator = new Lazy <TransitionsGenerator>(() => new TransitionsGenerator(this));
EvaluationManager.SetRigidRelations(RigidRelations);
}
/// <summary>
/// Evaluates the expression.
/// </summary>
/// <param name="expression">Expression.</param>
/// <returns>True if the expression is logically true, false otherwise.</returns>
public override bool Visit(PredicateLiteralCNF expression)
{
IAtom groundedPredicateAtom = GroundingManager.GroundAtomDeep(expression.PredicateAtom, Substitution, ReferenceState);
if (RigidRelations.Contains(groundedPredicateAtom))
{
// satisfied or failed by rigid relation
return(!expression.IsNegated);
}
bool hasPredicate = ReferenceState.HasPredicate(groundedPredicateAtom);
if (hasPredicate == expression.IsNegated)
{
// failed by state predicate
return(false);
}
// satisfied by state predicate -> store this atom
Atoms.Add(groundedPredicateAtom);
return(true);
}
/// <summary>
/// Set the rigid properties of the corresponding planning problem.
/// </summary>
/// <param name="rigidRelations">Rigid relations of the planning problem.</param>
public void SetRigidRelations(RigidRelations rigidRelations)
{
RigidRelations = rigidRelations;
}
/// <summary>
/// Constructs the evaluator.
/// </summary>
/// <param name="groundingManager">Grounding manager.</param>
/// <param name="rigidRelations">Rigid relations.</param>
public RigidRelationsComplianceEvaluator(GroundingManager groundingManager, RigidRelations rigidRelations = null)
{
GroundingManager = groundingManager;
RigidRelations = rigidRelations ?? new RigidRelations();
}
/// <summary>
/// Checks whether the specified predicate is a rigid relation of the planning problem.
/// </summary>
/// <param name="predicateAtom">Predicate atom.</param>
/// <returns>True if the predicate is of rigid relation, false otherwise.</returns>
public bool IsPredicateRigidRelation(IAtom predicateAtom)
{
return(RigidRelations.IsPredicateRigidRelation(predicateAtom));
}
/// <summary>
/// Constructs the evaluator.
/// </summary>
/// <param name="groundingManager">Grounding manager.</param>
/// <param name="rigidRelations">Rigid relations.</param>
public SatisfyingAtomsEvaluator(GroundingManager groundingManager, RigidRelations rigidRelations) : base(groundingManager, rigidRelations)
{
}
/// <summary>
/// Visits and evaluates predicate expression.
/// </summary>
/// <param name="expression">Predicate expression.</param>
/// <returns>True if the specified expression evaluates as true, false otherwise.</returns>
public bool Visit(PredicateExpression expression)
{
IAtom groundedPredicateAtom = GroundingManager.GroundAtomDeep(expression.PredicateAtom, Substitution, ReferenceState);
return(RigidRelations.Contains(groundedPredicateAtom) || ReferenceState.HasPredicate(groundedPredicateAtom));
}
/// <summary>
/// Constructs the logical evaluator.
/// </summary>
/// <param name="groundingManager">Grounding manager.</param>
/// <param name="rigidRelations">Rigid relations.</param>
public ExpressionEvaluator(GroundingManager groundingManager, RigidRelations rigidRelations = null)
{
GroundingManager = groundingManager;
NumericEvaluator = new Lazy <NumericExpressionEvaluator>(() => new NumericExpressionEvaluator(groundingManager));
RigidRelations = rigidRelations ?? new RigidRelations();
}