/// <summary>
/// String representation.
/// </summary>
/// <returns>String representation.</returns>
public override string ToString()
{
List <string> itemsList = new List <string>();
if (Predicates != null)
{
foreach (var predicateAtom in Predicates)
{
itemsList.Add(predicateAtom.ToString(IdManager.Predicates));
}
}
if (NumericFunctions != null)
{
foreach (var numericFunction in NumericFunctions)
{
string functionAtom = numericFunction.Key.ToString(IdManager.Functions);
string numericValue = (NumericFunction.IsValueUndefined(numericFunction.Value)) ? "undefined" : numericFunction.Value.ToString(CultureInfo.InvariantCulture);
itemsList.Add($"(= {functionAtom} {numericValue})");
}
}
if (ObjectFunctions != null)
{
foreach (var objectFunction in ObjectFunctions)
{
string functionAtom = objectFunction.Key.ToString(IdManager.Functions);
string constValue = IdManager.Constants.GetNameFromId(objectFunction.Value);
itemsList.Add($"(= {functionAtom} {constValue})");
}
}
return(string.Join(", ", itemsList));
}
/// <summary>
/// Defines a new value for the requested function in the state.
/// </summary>
/// <param name="function">Requested function.</param>
/// <param name="assignment">Value to be assigned.</param>
public void AssignNumericFunction(IAtom function, double assignment)
{
if (NumericFunction.IsValueUndefined(assignment))
{
if (NumericFunctions != null && NumericFunctions.ContainsKey(function))
{
NumericFunctions.Remove(function);
}
}
else
{
CheckNumericFunctionsInitialized();
NumericFunctions[function] = assignment;
}
}
/// <summary>
/// Checks whether the literal is in the form of a simple numeric function assignment, e.g. (= (numFunc) 8.5),
/// and in such case returns the pair of numeric function and its assigned value. Otherwise returns null.
/// </summary>
/// <returns>Numeric function assignment with its value, if the literal is in such form. Null otherwise.</returns>
public Tuple <NumericFunction, Number> TryGetNumericFunctionAssignment()
{
if (Operator != NumericCompareExpression.RelationalOperator.EQ)
{
return(null);
}
NumericFunction numFunc = LeftArgument as NumericFunction;
Number number = RightArgument as Number;
if (numFunc == null || number == null)
{
numFunc = RightArgument as NumericFunction;
number = LeftArgument as Number;
}
return((numFunc == null || number == null) ? null : Tuple.Create(numFunc, number));
}
/// <summary>
/// Transforms the numeric expression.
/// </summary>
/// <param name="expression">Numeric expression.</param>
/// <returns>Transformed numeric expression.</returns>
public INumericExpression Visit(NumericFunction expression)
{
IAtom functionAtom = GroundingManager.GroundAtom(expression.FunctionAtom, ExpressionSubstitution);
if (!ReplacedFunctionAtomsInSubExpression.Contains(functionAtom))
{
INumericExpression substitutedValue;
if (NumericFunctionAssignments.TryGetValue(functionAtom, out substitutedValue))
{
ReplacedFunctionAtomsInSubExpression.Add(functionAtom);
ExpressionSubstitution.AddLocalSubstitution(OperatorSubstitution);
INumericExpression transformedValue = substitutedValue.Accept(this);
ExpressionSubstitution.RemoveLocalSubstitution(OperatorSubstitution);
ReplacedFunctionAtomsInSubExpression.Remove(functionAtom);
return(transformedValue);
}
}
return(expression.Clone());
}
/// <summary>
/// Evaluates the numeric expression.
/// </summary>
/// <param name="expression">Numeric expression.</param>
public override void Visit(NumericFunction expression)
{
ExtractParameters(expression.FunctionAtom);
}
/// <summary>
/// Evaluates the numeric expression.
/// </summary>
/// <param name="expression">Numeric expression.</param>
public override void Visit(NumericFunction expression)
{
CheckAndRenameAtom(expression.FunctionAtom);
}
/// <summary>
/// Visits numeric expression.
/// </summary>
/// <param name="expression">Numeric expression.</param>
public override void Visit(NumericFunction expression)
{
NumericFunctions.Add(expression);
}
/// <summary>
/// Transforms the numeric expression.
/// </summary>
/// <param name="expression">Numeric expression.</param>
/// <returns>Transformed numeric expression.</returns>
public INumericExpression Visit(NumericFunction expression)
{
return(new NumericFunction(TermsGrounder.Value.GroundAtom(expression.FunctionAtom, Substitution), IdManager));
}
/// <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);
}
}
}
}