/// <summary>
/// Creates the goal action node for the FF evaluation, from the specified goal conditions and the previous state layer.
/// </summary>
/// <param name="conditions">Conditions.</param>
/// <param name="state">Previous state layer.</param>
/// <returns>New action node.</returns>
protected override ActionNode CreateFFGoalActionNode(Planner.IConditions conditions, Planner.IState state)
{
Conditions cond = (Conditions)conditions;
List <IProposition> predecessors = new List <IProposition>();
foreach (var assignment in cond)
{
predecessors.Add(new Proposition(assignment));
}
return(new ActionNode(predecessors));
}
/// <summary>
/// Gets the calculated heuristic value for the specified conditions.
/// </summary>
/// <param name="conditions">Conditions.</param>
/// <returns>Heuristic value for the conditions.</returns>
public double GetValue(Planner.IConditions conditions)
{
throw new NotSupportedException("PDB heuristic for the backward search is not supported, at the moment.");
}
/// <summary>
/// Gets a random relevant predecessor (backwards transition) from the specified conditions.
/// </summary>
/// <param name="conditions">Original conditions.</param>
/// <returns>Random relevant predecessor from the specified conditions. Null if no valid predecessor found.</returns>
public IPredecessor GetRandomPredecessor(Planner.IConditions conditions)
{
return(TransitionsGenerator.Value.GetRandomPredecessor((IConditions)conditions));
}
/// <summary>
/// Enumeration method getting a list with a limited number of relevant predecessors (backward transitions) from the specified conditions. The
/// next call of this method returns new predecessors, until all of them are returned - then an empty collection is returned to signalize the
/// end of enumeration. The next call starts the enumeration again from the beginning. The returned collection is lazy evaluated.
/// </summary>
/// <param name="conditions">Original conditions.</param>
/// <param name="numberOfPredecessors">Number of predecessors to be returned.</param>
/// <returns>Lazy generated collection of relevant predecessors.</returns>
public IEnumerable <IPredecessor> GetNextPredecessors(Planner.IConditions conditions, int numberOfPredecessors)
{
return(TransitionsGenerator.Value.GetNextPredecessors((IConditions)conditions, numberOfPredecessors));
}
/// <summary>
/// Gets the number of not accomplished goals for the specified conditions (backward search).
/// </summary>
/// <param name="conditions">Conditions to be evaluated.</param>
/// <returns>Number of not accomplished goals.</returns>
public int GetNotAccomplishedGoalsCount(Planner.IConditions conditions)
{
return(((IConditions)conditions).GetNotAccomplishedConstraintsCount(InitialState));
}
/// <summary>
/// Checks whether the initial state of the planning problem is meeting specified conditions.
/// </summary>
/// <param name="conditions">Conditions to be checked.</param>
/// <returns>True if the given conditions are satisfied for the initial state of the problem, false otherwise.</returns>
public bool IsStartConditions(Planner.IConditions conditions)
{
return(conditions.Evaluate(InitialState));
}
/// <summary>
/// Sets the goal conditions of the planning problem.
/// </summary>
/// <param name="conditions">Goal conditions.</param>
public virtual void SetGoalConditions(Planner.IConditions conditions)
{
GoalConditions = (IConditions)conditions;
}
/// <summary>
/// Sets the goal conditions of the planning problem.
/// </summary>
/// <param name="conditions">Conditions.</param>
public override void SetGoalConditions(Planner.IConditions conditions)
{
ComplexGoalConditions = (IConditions)conditions;
}
/// <summary>
/// Applies the operator backwards to the given target conditions. The result is a new set of conditions.
/// </summary>
/// <param name="conditions">Target conditions.</param>
/// <returns>Preceding conditions.</returns>
public Planner.IConditions ApplyBackwards(Planner.IConditions conditions)
{
return(Effects.ApplyBackwards((IConditions)conditions, Preconditions));
}
/// <summary>
/// Checks whether the operator is relevant to the given target conditions.
/// </summary>
/// <param name="conditions">Target conditions.</param>
/// <returns>True if the operator is relevant to the given conditions, false otherwise.</returns>
public bool IsRelevant(Planner.IConditions conditions)
{
return(Effects.IsRelevant((IConditions)conditions, Preconditions) && MutexChecker.Value.CheckPredecessorCompatibility((IConditions)conditions, this));
}
/// <summary>
/// Checks whether the operator is relevant to the given target conditions.
/// </summary>
/// <param name="conditions">Target conditions.</param>
/// <returns>True if the operator is relevant to the given conditions, false otherwise.</returns>
public bool IsRelevant(Planner.IConditions conditions)
{
return(LiftedOperator.IsRelevant((IConditions)conditions, Substitution));
}
/// <summary>
/// Applies the operator backwards to the given target conditions. The result is a new set of conditions.
/// </summary>
/// <param name="conditions">Target conditions.</param>
/// <returns>Preceding conditions.</returns>
public Planner.IConditions ApplyBackwards(Planner.IConditions conditions)
{
return(LiftedOperator.ApplyBackwards((IConditions)conditions, Substitution));
}
/// <summary>
/// Creates the goal action node for the FF evaluation, from the specified goal conditions and the previous state layer.
/// </summary>
/// <param name="conditions">Conditions.</param>
/// <param name="state">Previous state layer.</param>
/// <returns>New action node.</returns>
protected override ActionNode CreateFFGoalActionNode(Planner.IConditions conditions, Planner.IState state)
{
var precondAtoms = ((Conditions)conditions).GetSatisfyingAtoms(new Substitution(), (IState)state);
return(new ActionNode(precondAtoms.ConvertAll(x => (IProposition) new Proposition(x))));
}
