public ParameterizedPredicate(ParameterizedPredicate pp)
: base(pp.Name)
{
m_lParameters = new List <Argument>(pp.m_lParameters);
Negation = pp.Negation;
Parameterized = pp.Parameterized;
}
public override bool Equals(object obj)
{
if (obj is ParameterizedPredicate)
{
ParameterizedPredicate pp = (ParameterizedPredicate)obj;
if (pp.Name != Name)
{
return(false);
}
if (m_lParameters.Count != pp.m_lParameters.Count)
{
return(false);
}
for (int iParameter = 0; iParameter < m_lParameters.Count; iParameter++)
{
if (!m_lParameters[iParameter].Equals(pp.m_lParameters[iParameter]))
{
return(false);
}
}
return(Negation == pp.Negation);
}
return(false);
}
public override Predicate GenerateKnowGiven(string sTag, bool bKnowWhether)
{
if (bKnowWhether)
{
throw new NotImplementedException("There should no longer be any Know Whether prediate");
}
ParameterizedPredicate pKGiven = null;
if (bKnowWhether)
{
pKGiven = new ParameterizedPredicate("KWGiven" + Name);
}
else
{
pKGiven = new ParameterizedPredicate("KGiven" + Name);
}
foreach (Argument a in Parameters)
{
pKGiven.AddParameter(a);
}
pKGiven.AddParameter(new Parameter(Domain.TAG, sTag));
if (!bKnowWhether)
{
if (Negation)
{
pKGiven.AddParameter(new Parameter(Domain.VALUE, Domain.FALSE_VALUE));
}
else
{
pKGiven.AddParameter(new Parameter(Domain.VALUE, Domain.TRUE_VALUE));
}
}
return(pKGiven);
}
//for SDR
public static Predicate GenerateKNot(Argument pTag)
{
ParameterizedPredicate pp = new ParameterizedPredicate("KNot");
pp.AddParameter(pTag);
return(pp);
}
public Dictionary <string, Constant> Bind(ParameterizedPredicate p)
{
if (Name != p.Name)
{
return(null);
}
if (((List <Constant>)Constants).Count != ((List <Argument>)p.Parameters).Count)
{
return(null);
}
Dictionary <string, Constant> dBindings = new Dictionary <string, Constant>();
for (int i = 0; i < Constants.Count; i++)
{
Argument arg = p.Parameters.ElementAt(i);
if (arg is Constant)
{
if (!Constants[i].Equals(arg))
{
return(null);
}
}
if (arg is Parameter)
{
dBindings[arg.Name] = Constants[i];
}
}
return(dBindings);
}
public override Predicate Negate()
{
ParameterizedPredicate pNegate = new ParameterizedPredicate(Name);
pNegate.Negation = !Negation;
pNegate.m_lParameters = new List <Argument>(m_lParameters);
return(pNegate);
}
public override Predicate GenerateGiven(string sTag)
{
ParameterizedPredicate pGiven = new ParameterizedPredicate("Given" + Name);
foreach (Argument a in Parameters)
{
pGiven.AddParameter(a);
}
pGiven.AddParameter(new Parameter(Domain.TAG, sTag));
if (Negation)
{
return(pGiven.Negate());
}
return(pGiven);
}
public Predicate PartiallyGround(Dictionary <string, Constant> dBindings)
{
GroundedPredicate gpred = new GroundedPredicate(Name, Negation);
ParameterizedPredicate ppred = new ParameterizedPredicate(Name, Negation);
bool bAllGrounded = true;
foreach (Argument a in Parameters)
{
if (a is Parameter)
{
if (!dBindings.ContainsKey(a.Name))
{
ppred.AddParameter(a);
bAllGrounded = false;
}
else
{
ppred.AddParameter(dBindings[a.Name]);
gpred.AddConstant(dBindings[a.Name]);
}
}
else
{
gpred.AddConstant((Constant)a);
ppred.AddParameter(a);
}
}
if (bAllGrounded)
{
if (gpred.Name == "=")
{
bool bSame = gpred.Constants[0].Equals(gpred.Constants[1]);
if (bSame && !Negation || !bSame && Negation)
{
return(Domain.TRUE_PREDICATE);
}
else
{
return(Domain.FALSE_PREDICATE);
}
}
return(gpred);
}
else
{
return(ppred);
}
}
public override Predicate ToTag()
{
ParameterizedPredicate ppNew = new ParameterizedPredicate(this);
if (Negation)
{
ppNew.Name = ppNew.Name + "-Remove";
}
else
{
ppNew.Name = ppNew.Name + "-Add";
}
ppNew.Negation = false;
return(ppNew);
}
