/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public Tuple <bool, bool> Visit(EqualsLiteralCNF expression)
{
bool positiveCondition = false;
bool negativeCondition = true;
Action <ITerm, ITerm> checkObjectFunctionArgument = (argument, secondaryArgument) =>
{
ObjectFunctionTerm objectFunction = argument as ObjectFunctionTerm;
if (objectFunction != null)
{
ITerm assignValue;
if (Effects.GroundedObjectFunctionAssignmentEffects.TryGetValue(GroundingManager.GroundAtom(objectFunction.FunctionAtom, ExpressionSubstitution), out assignValue))
{
positiveCondition = true;
if (!(secondaryArgument is ObjectFunctionTerm) && !(assignValue is ObjectFunctionTerm))
{
bool valueDiffersValueAssign = !GroundingManager.GroundTerm(secondaryArgument, ExpressionSubstitution).Equals(GroundingManager.GroundTerm(assignValue, OperatorSubstitution));
if (valueDiffersValueAssign && !expression.IsNegated || !valueDiffersValueAssign && expression.IsNegated)
{
// surely assigning different value (or assigning exact value with negated equals) -> not relevant
negativeCondition = false;
}
}
}
}
};
checkObjectFunctionArgument(expression.LeftArgument, expression.RightArgument);
checkObjectFunctionArgument(expression.RightArgument, expression.LeftArgument);
return(Tuple.Create(positiveCondition, negativeCondition));
}
/// <summary>
/// Transforms the term.
/// </summary>
/// <param name="term">Term.</param>
/// <returns>Transformed term.</returns>
public ITerm Visit(ObjectFunctionTerm term)
{
if (ReferenceState != null)
{
IAtom groundedFunctionAtom = GroundAtomDeep(term.FunctionAtom, Substitution, ReferenceState);
return(new ConstantTerm(ReferenceState.GetObjectFunctionValue(groundedFunctionAtom), IdManager));
}
return(new ObjectFunctionTerm(GroundAtom(term.FunctionAtom, Substitution), IdManager));
}
/// <summary>
/// Checks whether the literal is in the form of a simple object function assignment, e.g. (= (objFunc) constA),
/// and in such case returns the pair of object function and its assigned value. Otherwise returns null.
/// </summary>
/// <returns>Object function assignment with its value, if the literal is in such form. Null otherwise.</returns>
public Tuple <ObjectFunctionTerm, ConstantTerm> TryGetObjectFunctionAssignment()
{
ObjectFunctionTerm objFunc = LeftArgument as ObjectFunctionTerm;
ConstantTerm constTerm = RightArgument as ConstantTerm;
if (objFunc == null || constTerm == null)
{
objFunc = RightArgument as ObjectFunctionTerm;
constTerm = LeftArgument as ConstantTerm;
}
return((objFunc == null || constTerm == null) ? null : Tuple.Create(objFunc, constTerm));
}
/// <summary>
/// Visits expression term.
/// </summary>
/// <param name="term">Expression term.</param>
public void PostVisit(ObjectFunctionTerm term)
{
List <int> argumentsList = new List <int>();
for (int i = 0; i < term.Terms.Count; ++i)
{
argumentsList.Add(TermStack.Pop());
}
argumentsList.Reverse();
IGroundedAtom groundedFunctionAtom = new GroundedAtom(term.NameID, argumentsList);
int groundedConstantValue = ReferenceState.GetObjectFunctionValue(groundedFunctionAtom);
TermStack.Push(groundedConstantValue);
}
/// <summary>
/// Extracts the parameters from the given term.
/// </summary>
/// <param name="term">Term.</param>
private void ExtractParameters(ITerm term)
{
VariableTerm variableTerm = term as VariableTerm;
if (variableTerm != null)
{
CollectedParameters.Add(variableTerm.NameId);
return;
}
ObjectFunctionTerm objectFunctionTerm = term as ObjectFunctionTerm;
if (objectFunctionTerm != null)
{
ExtractParameters(objectFunctionTerm.FunctionAtom);
}
}
/// <summary>
/// Checks whether the term needs a rename and performs the rename.
/// </summary>
/// <param name="term">Predicate or function term.</param>
private void CheckAndRenameTerm(ITerm term)
{
VariableTerm variableTerm = term as VariableTerm;
if (variableTerm != null)
{
int newParameterId;
if (ParametersRemapping.TryGetValue(variableTerm.NameId, out newParameterId))
{
variableTerm.NameId = newParameterId;
}
return;
}
ObjectFunctionTerm objectFunctionTerm = term as ObjectFunctionTerm;
if (objectFunctionTerm != null)
{
CheckAndRenameAtom(objectFunctionTerm.FunctionAtom);
}
}
/// <summary>
/// Visits the expression.
/// </summary>
/// <param name="expression">Expression.</param>
public IElementCNF Visit(EqualsLiteralCNF expression)
{
var objectAssignEffects = Effects.GroundedObjectFunctionAssignmentEffects;
if (objectAssignEffects.Count == 0)
{
return(expression.Clone());
}
Func <ITerm, ITerm> transformArgument = null;
transformArgument = (term) =>
{
ObjectFunctionTerm objectFunction = term as ObjectFunctionTerm;
if (objectFunction != null)
{
ITerm assignmentValue;
if (objectAssignEffects.TryGetValue(GroundAtom(objectFunction.FunctionAtom), out assignmentValue))
{
UsedGroundedFunctions.Add(objectFunction.FunctionAtom);
return(transformArgument(assignmentValue));
}
}
return(term.Clone());
};
ITerm transformedLeftTerm = transformArgument(expression.LeftArgument);
ITerm transformedRightTerm = transformArgument(expression.RightArgument);
bool termsEqual = transformedLeftTerm.Equals(transformedRightTerm);
if ((termsEqual && !expression.IsNegated) || (!termsEqual && expression.IsNegated))
{
// exact constant assignment (or unassignment with negated equals) -> positively contributing, i.e. remove
return(null);
}
return(new EqualsLiteralCNF(transformedLeftTerm, transformedRightTerm, expression.IsNegated));
}
/// <summary>
/// Visits expression term.
/// </summary>
/// <param name="term">Expression term.</param>
public void Visit(ObjectFunctionTerm term)
{
}
/// <summary>
/// Processes a single CNF literal of operator preconditions.
/// </summary>
/// <param name="literal">CNF literal.</param>
/// <param name="state">Relative state to be applied to.</param>
private static void ProcessPreconditionLiteral(LiteralCNF literal, IRelativeState state)
{
PredicateLiteralCNF predicateLiteral = literal as PredicateLiteralCNF;
if (predicateLiteral != null)
{
if (predicateLiteral.IsNegated)
{
state.AddNegatedPredicate(predicateLiteral.PredicateAtom);
}
else
{
state.AddPredicate(predicateLiteral.PredicateAtom);
}
return;
}
EqualsLiteralCNF equalsLiteral = literal as EqualsLiteralCNF;
if (equalsLiteral != null)
{
ObjectFunctionTerm objFunc = equalsLiteral.LeftArgument as ObjectFunctionTerm;
ConstantTerm constTerm = equalsLiteral.RightArgument as ConstantTerm;
if (objFunc == null || constTerm == null)
{
objFunc = equalsLiteral.RightArgument as ObjectFunctionTerm;
constTerm = equalsLiteral.LeftArgument as ConstantTerm;
}
if (objFunc != null && constTerm != null)
{
if (equalsLiteral.IsNegated)
{
if (state.GetObjectFunctionValue(objFunc.FunctionAtom) == constTerm.NameId)
{
state.AssignObjectFunction(objFunc.FunctionAtom, IdManager.InvalidId);
}
}
else
{
state.AssignObjectFunction(objFunc.FunctionAtom, constTerm.NameId);
}
}
return;
}
NumericCompareLiteralCNF compareLiteral = literal as NumericCompareLiteralCNF;
if (compareLiteral != null)
{
if (compareLiteral.Operator != NumericCompareExpression.RelationalOperator.EQ)
{
return;
}
NumericFunction numFunc = compareLiteral.LeftArgument as NumericFunction;
Number number = compareLiteral.RightArgument as Number;
if (numFunc == null || number == null)
{
numFunc = compareLiteral.RightArgument as NumericFunction;
number = compareLiteral.LeftArgument as Number;
}
if (numFunc != null && number != null)
{
if (compareLiteral.IsNegated)
{
if (state.GetNumericFunctionValue(numFunc.FunctionAtom).Equals(number.Value))
{
state.AssignNumericFunction(numFunc.FunctionAtom, NumericFunction.DefaultValue);
}
}
else
{
state.AssignNumericFunction(numFunc.FunctionAtom, number.Value);
}
}
}
}
