public override Formula RemoveUniversalQuantifiers(HashSet <Constant> lConstants, List <Predicate> lConstantPredicates, Domain d)
{
ProbabilisticFormula pf = new ProbabilisticFormula();
for (int i = 0; i < Options.Count; i++)
{
pf.AddOption(Options[i].RemoveUniversalQuantifiers(lConstants, lConstantPredicates, d), Probabilities[i]);
}
return(pf);
}
public List <string> Plan(string agent, bool bUseFF, bool bUseFD, Domain d, Problem p, State curentState, Formula goal, List <Action> privateActions, int cMaxMilliseconds, out bool bUnsolvable)
{
//Program.KillPlanners();
List <string> lPlan = null;
if (privateActions != null)
{
d.Actions = privateActions;
}
if (goal != null)
{
p.Goal = goal;
}
string sFDPath = @"C:\cygwin\home\shlomi\FastDownward\src\";
Process pFF = null, pFD = null;
if (bUseFF)
{
pFF = RunFF(d.WriteSimpleDomain(), p.WriteSimpleProblem(curentState));
}
if (bUseFD)
{
pFD = RunFD(agent, sFDPath, d.WriteSimpleDomain(), p.WriteSimpleProblem(curentState));
}
bUnsolvable = false;
bool bFFDone = false, bFDDone = false;
Process[] process;
if (bUseFF && !bUseFD)
{
process = new Process[] { pFF }
}
;
else
if (!bUseFF && bUseFD)
{
process = new Process[] { pFD }
}
;
else
{
process = new Process[] { pFF, pFD }
};
if (WaitForProcesses(process, cMaxMilliseconds, out bFFDone, out bFDDone))
{
if (bFFDone)
{
// Console.WriteLine("Plan found by FF");
Thread.Sleep(200);
lPlan = ReadFFPlan(process[0].Id, out bUnsolvable);
KillAll(process.ToList());
}
else if (bFDDone)
{
Console.WriteLine("Plan found by FD");
Thread.Sleep(100);
lPlan = ReadPlan(@"C:\cygwin\home\shlomi\");
KillAll(process.ToList());
}
return(lPlan);
}
return(null);
}
public static int MaxMakespanCalculation(List <Agent> agents, List <string> lActionsName, Domain dJoint)
{
List <KeyValuePair <string, Action> > sPlan = Runner.GetActions(lActionsName, dJoint, agents);
State fullInitialState = new State(agents[0].startState);
Dictionary <string, int> agentsTimeSteps = new Dictionary <string, int>();
agentsTimeSteps.Add(agents[0].name, 0);
for (int i = 1; i < agents.Count; i++)
{
foreach (var fact in agents[i].startState.m_lPredicates)
{
fullInitialState.AddPredicate(fact);
}
agentsTimeSteps.Add(agents[i].name, 0);
}
Dictionary <GroundedPredicate, int> gpCost = new Dictionary <GroundedPredicate, int>();
foreach (GroundedPredicate gp in fullInitialState.m_lPredicates)
{
gpCost.Add(gp, 0);
}
int timeSteps = 0;
bool stop = false;
foreach (var action in sPlan)
{
int cost = MaxCost(gpCost, action.Value.Preconditions.GetAllPredicates().ToList());
if (cost < agentsTimeSteps[action.Key])
{
cost = agentsTimeSteps[action.Key];
}
HashSet <Predicate> lDeleteList = new HashSet <Predicate>(), lAddList = new HashSet <Predicate>();
fullInitialState.GetApplicableEffects(action.Value.Effects, lAddList, lDeleteList);
foreach (GroundedPredicate dellp in lDeleteList)
{
gpCost.Remove((GroundedPredicate)dellp.Negate());
}
foreach (GroundedPredicate addp in lAddList)
{
if (!gpCost.ContainsKey(addp))
{
gpCost.Add(addp, cost + 1);
}
}
foreach (GroundedPredicate addp in lDeleteList)
{
if (!gpCost.ContainsKey(addp))
{
gpCost.Add(addp, cost + 1);
}
}
agentsTimeSteps[action.Key] = cost + 1;
fullInitialState = fullInitialState.Apply(action.Value);
}
int maxSpan = 0;
foreach (Agent agent in agents)
{
if (agentsTimeSteps[agent.name] > maxSpan)
{
maxSpan = agentsTimeSteps[agent.name];
}
}
return(maxSpan);
}
/*
* public void WriteTaggedProblemNoState(string sProblemFile, Dictionary<string, List<Predicate>> dTags, IEnumerable<Predicate> lObserved,
* Dictionary<string, double> dFunctionValues)
* {
* StreamWriter sw = new StreamWriter(sProblemFile);
* sw.WriteLine("(define (problem K" + Name + ")");
* sw.WriteLine("(:domain K" + Domain.Name + ")");
* sw.WriteLine("(:init"); //ff doesn't like the and (and");
*
* string sKP = "";
* if (Domain.TIME_STEPS > 0)
* sw.WriteLine("(time0)");
* foreach (KeyValuePair<string, double> f in dFunctionValues)
* {
* sw.WriteLine("(= " + f.Key + " " + f.Value + ")");
* }
* foreach (GroundedPredicate gp in lObserved)
* {
* //if (gp.Negation)
* // continue;
* if (gp.Name == "Choice" || gp.Name == Domain.OPTION_PREDICATE)
* continue;
* if (Domain.AlwaysKnown(gp) && Domain.AlwaysConstant(gp))
* {
* sKP = "(K" + gp.Name;
* foreach (Constant c in gp.Constants)
* {
* sKP += " " + c.Name;
* }
* if (gp.Negation)
* sKP += " " + Domain.FALSE_VALUE;
* else
* sKP += " " + Domain.TRUE_VALUE;
*
* sw.WriteLine(sKP + ")");
* }
* else
* {
* foreach (string sTag in dTags.Keys)
* {
* if (!gp.Negation)
* sw.WriteLine(gp.GenerateGiven(sTag));
* if (!Domain.AlwaysKnown(gp))
* sw.WriteLine(gp.GenerateKnowGiven(sTag, true));
* }
* }
* }
* foreach (KeyValuePair<string, List<Predicate>> p in dTags)
* {
*
* foreach (GroundedPredicate gp in p.Value)
* {
* if (gp.Negation)
* continue;
* if (gp.Name == "Choice")
* continue;
* if (!gp.Negation)
* {
* sKP = GenerateKnowGivenLine(gp, p.Key, false);
* sw.WriteLine(sKP);
* }
* //sKP = GenerateKnowGivenLine(gp, p.Key, true);
* //sw.WriteLine(sKP);
* }
*
* if (SDRPlanner.AddAllKnownToGiven)
* {
* foreach (GroundedPredicate gp in lObserved)
* {
* //if (gp.Negation)
* // continue;
* if (gp.Name == "Choice")
* continue;
* if (!(Domain.AlwaysKnown(gp) && Domain.AlwaysConstant(gp)))
* {
* if (!gp.Negation)
* {
* sKP = GenerateKnowGivenLine(gp, p.Key, false);
* sw.WriteLine(sKP);
* }
* }
* if (!(Domain.AlwaysKnown(gp)) && gp.Name != Domain.OPTION_PREDICATE)
* {
* sKP = GenerateKnowGivenLine(gp, p.Key, true);
* sw.WriteLine(sKP);
* }
* }
* }
*
* }
*
* //if (Problem.Domain.HasNonDeterministicActions())
* // sw.WriteLine("(option opt0)");
*
* if (SDRPlanner.SplitConditionalEffects)
* sw.WriteLine("(NotInAction)");
*
* sw.WriteLine(")");
*
* CompoundFormula cfGoal = new CompoundFormula("and");
*
* List<Predicate> lGoalPredicates = new List<Predicate>();
* Goal.GetAllPredicates(lGoalPredicates);
*
*
* for (int iTag = 0; iTag < dTags.Count; iTag++)
* {
* if (SDRPlanner.ConsiderStateNegations && iTag == dTags.Count - 1)
* break;
* string sTag = dTags.Keys.ElementAt(iTag);
* foreach (Predicate p in lGoalPredicates)
* {
* if (!Domain.AlwaysKnown(p) || !Domain.AlwaysConstant(p))
* {
* cfGoal.AddOperand(p.GenerateGiven(sTag));
* if (!Domain.AlwaysKnown(p))
* cfGoal.AddOperand(p.GenerateKnowGiven(sTag, true));
* }
* }
* }
*
*
* sw.WriteLine("(:goal " + cfGoal + ")");
* //sw.WriteLine("))");
* if (MetricStatement != null)
* {
* sw.WriteLine(MetricStatement);
* }
* sw.WriteLine(")");
* sw.Close();
* }
*/
public void WriteTaggedProblemNoState(string sProblemFile, Dictionary <string, List <Predicate> > dTags, IEnumerable <Predicate> lObserved,
Dictionary <string, double> dFunctionValues)
{
StreamWriter sw = new StreamWriter(sProblemFile);
sw.WriteLine("(define (problem K" + Name + ")");
sw.WriteLine("(:domain K" + Domain.Name + ")");
sw.WriteLine("(:init"); //ff doesn't like the and (and");
string sKP = "";
if (Domain.TIME_STEPS > 0)
{
sw.WriteLine("(time0)");
}
foreach (KeyValuePair <string, double> f in dFunctionValues)
{
sw.WriteLine("(= " + f.Key + " " + f.Value + ")");
}
foreach (GroundedPredicate gp in lObserved)
{
//if (gp.Negation)
// continue;
if (gp.Name == "Choice" || gp.Name == Domain.OPTION_PREDICATE)
{
continue;
}
if (Domain.AlwaysKnown(gp) && Domain.AlwaysConstant(gp))
{
sKP = "(" + gp.Name;
foreach (Constant c in gp.Constants)
{
sKP += " " + c.Name;
}
sw.WriteLine(sKP + ")");
}
else
{
foreach (string sTag in dTags.Keys)
{
if (!gp.Negation)
{
Predicate pGiven = gp.GenerateGiven(sTag);
sw.WriteLine(pGiven);
}
}
}
}
foreach (KeyValuePair <string, List <Predicate> > p in dTags)
{
foreach (GroundedPredicate gp in p.Value)
{
if (gp.Negation)
{
continue;
}
if (gp.Name == "Choice")
{
continue;
}
if (!gp.Negation)
{
sw.WriteLine(gp.GenerateGiven(p.Key));
}
//sKP = GenerateKnowGivenLine(gp, p.Key, true);
//sw.WriteLine(sKP);
}
}
//if (Problem.Domain.HasNonDeterministicActions())
// sw.WriteLine("(option opt0)");
//if (SDRPlanner.SplitConditionalEffects)
sw.WriteLine("(NotInAction)");
sw.WriteLine(")");
CompoundFormula cfGoal = new CompoundFormula("and");
HashSet <Predicate> lGoalPredicates = new HashSet <Predicate>();
Goal.GetAllPredicates(lGoalPredicates);
for (int iTag = 0; iTag < dTags.Count; iTag++)
{
if (SDRPlanner.ConsiderStateNegations && iTag == dTags.Count - 1)
{
break;//What is that?
}
string sTag = dTags.Keys.ElementAt(iTag);
foreach (Predicate p in lGoalPredicates)
{
if (!Domain.AlwaysKnown(p) || !Domain.AlwaysConstant(p))
{
cfGoal.AddOperand(p.GenerateGiven(sTag));
}
}
}
if (SDRPlanner.ForceTagObservations)
{
foreach (string sTag1 in dTags.Keys)
{
foreach (string sTag2 in dTags.Keys)
{
if (sTag1 != sTag2)
{
GroundedPredicate gpNot = new GroundedPredicate("Knot");
gpNot.AddConstant(new Constant(Domain.TAG, sTag1));
gpNot.AddConstant(new Constant(Domain.TAG, sTag2));
cfGoal.AddOperand(gpNot);
}
}
}
}
sw.WriteLine("(:goal " + cfGoal + ")");
//sw.WriteLine("))");
if (MetricStatement != null)
{
sw.WriteLine(MetricStatement);
}
sw.WriteLine(")");
sw.Close();
}
public List <string> PdbFFPlan(Domain d, Problem p, State curentState, Formula goal, List <Action> privateActions, int cMaxMilliseconds, out bool bUnsolvable)
{
RunUtils.KillPlanners();
List <string> ffLplan = new List <string>();
List <string> lPlan = new List <string>();
if (privateActions != null)
{
d.Actions = privateActions;
}
if (goal != null)
{
p.Goal = goal;
}
MemoryStream msDomain = d.WriteSimpleDomain();
MemoryStream problem_M_S = p.WriteSimpleProblem(curentState);
//StreamWriter swDomainFile = new StreamWriter(@"C:\Dropbox-users\shlomi\Dropbox\Dropbox\privacyPreserving\Competition\all\factored\testd.pddl");
// StreamReader srDomain = new StreamReader(msDomain);
// swDomainFile.Write(srDomain.ReadToEnd());
// swDomainFile.Close();
// StreamWriter swProblemFile = new StreamWriter(@"C:\Dropbox-users\shlomi\Dropbox\Dropbox\privacyPreserving\Competition\all\factored\testp.pddl");
// StreamReader srProblem = new StreamReader(problem_M_S);
// swProblemFile.Write(srProblem.ReadToEnd());
// swProblemFile.Close();
problem_M_S.Position = 0;
msDomain.Position = 0;
Process planer = new Process();
//planer.StartInfo.WorkingDirectory = @"C:\project\Planning 2 new\PDDLTEST\temp";
planer.StartInfo.FileName = "ff.exe";
//planer.StartInfo.Arguments += "-o dT.pddl -f pT.pddl";
FFOutput[planer.Id] = "";
planer.StartInfo.UseShellExecute = false;
planer.StartInfo.RedirectStandardInput = true;
planer.StartInfo.RedirectStandardOutput = true;
planer.OutputDataReceived += new DataReceivedEventHandler(FFOutputHandler);
planer.Start();
planer.BeginOutputReadLine();
StreamReader srOps = new StreamReader(msDomain);
string domain = srOps.ReadToEnd();
planer.StandardInput.Write(domain);
srOps.Close();
BinaryWriter b = new BinaryWriter(planer.StandardInput.BaseStream);
b.Write('\0');
StreamReader srFct = new StreamReader(problem_M_S);
string problem = srFct.ReadToEnd();
planer.StandardInput.Write(problem);
srFct.Close();
b.Write('\0');
//planer.StandardInput.Flush();
planer.StandardInput.Close();
if (cMaxMilliseconds != -1)
{
if (!planer.WaitForExit(cMaxMilliseconds))//2 minutes max
{
planer.Kill();
bUnsolvable = false;
return(null);
}
}
else
{
planer.WaitForExit();
}
planer.Close();
//string sOutput = planer.StandardOutput.ReadToEnd();
// planer.WaitForExit();
string sOutput = FFOutput[planer.Id];
//throw new NotImplementedException();
//Console.WriteLine(sOutput);
MemoryStream planMs = new MemoryStream();
if (sOutput.Contains("found legal plan as follows"))
{
string sPlan = sOutput.Substring(sOutput.IndexOf("found legal plan as follows"));
sPlan = sPlan.Replace("found legal plan as follows", "").Trim();
string[] asPlan = sPlan.Split('\n');
string sFinalPlan = "";
for (int i = 0; i < asPlan.Length; i++)
{
if (!asPlan[i].Contains(":"))
{
break;
}
if (asPlan[i].Contains("time spent:"))
{
break;
}
sFinalPlan += asPlan[i].Substring(asPlan[i].IndexOf(':') + 2).Trim() + "\n";
}
StreamWriter sw = new StreamWriter(planMs);
sw.WriteLine(sFinalPlan);
sw.Close();
bUnsolvable = false;
}
else
{
if (sOutput.Contains("goal can be simplified to TRUE"))
{
ffLplan = new List <string>();
bUnsolvable = false;
return(ffLplan);
}
else if (sOutput.Contains("goal can be simplified to FALSE"))
{
ffLplan = null;
bUnsolvable = true;
return(null);
}
else
{
ffLplan = null;
bUnsolvable = false;
return(null);
}
}
lPlan = ReadPlan(new MemoryStream(planMs.ToArray()));
ffLplan = lPlan;
return(lPlan);
}
private Argument ReadFunctionArgument(Expression exp, Dictionary <string, string> dParameterNameToType, Domain d)
{
string sName = exp.ToString();
double dValue = 0.0;
if (double.TryParse(sName, out dValue))
{
Constant c = new Constant("Number", sName);
return(c);
}
if (exp is CompoundExpression)
{
CompoundExpression ce = (CompoundExpression)exp;
if (!d.Functions.Contains(ce.Type))
{
throw new ArgumentException("Function arguments can only be numbers, parameters, or functions");
}
ParameterizedFunctionPredicate fp = new ParameterizedFunctionPredicate(ce.Type);
foreach (Expression e in ce.SubExpressions)
{
string sParam = e.ToString();
if (dParameterNameToType != null && dParameterNameToType.ContainsKey(sParam))
{
fp.AddParameter(new Parameter(dParameterNameToType[sParam], sParam));
}
else if (d.ConstantNameToType.ContainsKey(sParam))
{
fp.AddParameter(new Constant(d.ConstantNameToType[sParam], sParam));
}
else
{
throw new ArgumentException("Unknown function parameter");
}
}
FunctionParameter fa = new FunctionParameter(fp);
return(fa);
}
if (dParameterNameToType.ContainsKey(sName))
{
return(new Parameter(dParameterNameToType[sName], sName));
}
throw new ArgumentException("Unknown function parameter");
}
public void WriteTaggedProblem(string sProblemFile, Dictionary <string, List <Predicate> > dTags, IEnumerable <Predicate> lObserved,
List <Predicate> lTrueState, Dictionary <string, double> dFunctionValues, bool bOnlyIdentifyStates)
{
StreamWriter sw = new StreamWriter(sProblemFile);
sw.WriteLine("(define (problem K" + Name + ")");
sw.WriteLine("(:domain K" + Domain.Name + ")");
sw.WriteLine("(:init"); //ff doesn't like the and (and");
string sKP = "", sP = "";
if (Domain.TIME_STEPS > 0)
{
sw.WriteLine("(time0)");
}
if (SDRPlanner.SplitConditionalEffects)
{
sw.WriteLine("(NotInAction)\n");
}
foreach (KeyValuePair <string, double> f in dFunctionValues)
{
sw.WriteLine("(= " + f.Key + " " + f.Value + ")");
}
foreach (GroundedPredicate gp in lObserved)
{
if (gp.Name == "Choice")
{
continue;
}
sKP = "(K" + gp.Name;
sP = "(" + gp.Name;
foreach (Constant c in gp.Constants)
{
sKP += " " + c.Name;
sP += " " + c.Name;
}
if (gp.Negation)
{
sKP += " " + Domain.FALSE_VALUE;
}
else
{
sKP += " " + Domain.TRUE_VALUE;
}
if (!Domain.AlwaysKnown(gp))
{
sw.WriteLine(sKP + ")");
}
if (!gp.Negation)
{
sw.WriteLine(sP + ")");
}
}
foreach (GroundedPredicate gp in lTrueState)
{
if (gp.Name == "Choice")
{
continue;
}
if (!gp.Negation)
{
sP = "(" + gp.Name;
foreach (Constant c in gp.Constants)
{
sP += " " + c.Name;
}
sw.WriteLine(sP + ")");
}
}
foreach (KeyValuePair <string, List <Predicate> > p in dTags)
{
foreach (GroundedPredicate gp in p.Value)
{
if (gp.Name == "Choice")
{
continue;
}
sKP = GenerateKnowGivenLine(gp, p.Key, false);
sw.WriteLine(sKP);
}
if (SDRPlanner.AddAllKnownToGiven)
{
foreach (GroundedPredicate gp in lObserved)
{
if (gp.Name == "Choice")
{
continue;
}
if (!Domain.AlwaysKnown(gp))
{
sKP = GenerateKnowGivenLine(gp, p.Key, false);
sw.WriteLine(sKP);
}
}
}
}
//if (Problem.Domain.HasNonDeterministicActions())
// sw.WriteLine("(option opt0)");
sw.WriteLine(")");
CompoundFormula cfGoal = new CompoundFormula("and");
if (!bOnlyIdentifyStates)
{
cfGoal.AddOperand(Goal);
HashSet <Predicate> lGoalPredicates = new HashSet <Predicate>();
Goal.GetAllPredicates(lGoalPredicates);
//string sGoal = Problem.Goal.ToString();
//sw.WriteLine("(:goal " + sGoal + ")");
//sw.Write("(:goal (and ");
//sw.Write( sGoal );
foreach (Predicate p in lGoalPredicates)
{
//Problem.Domain.WriteKnowledgePredicate(sw, p);
if (!Domain.AlwaysKnown(p))
{
cfGoal.AddOperand(new KnowPredicate(p));
}
}
}
if (bOnlyIdentifyStates || SDRPlanner.AddTagRefutationToGoal)
{
for (int iTag = 1; iTag < dTags.Count; iTag++)
{
GroundedPredicate gp = new GroundedPredicate("KNot");
gp.AddConstant(new Constant("TAG_TYPE", "tag" + iTag));
cfGoal.AddOperand(gp);
//sw.Write(" (KNot t" + iTag + ")");
}
}
if (SDRPlanner.ForceTagObservations)
{
foreach (Predicate p in lTrueState)
{
if (Domain.Observable(p))
{
cfGoal.AddOperand(new KnowPredicate(p));
}
}
}
sw.WriteLine("(:goal " + cfGoal + ")");
//sw.WriteLine("))");
if (MetricStatement != null)
{
sw.WriteLine(MetricStatement);
}
sw.WriteLine(")");
sw.Close();
}
private void ReadMetric(Problem p, Domain d, CompoundExpression eSub)
{
p.AddMetric(eSub.ToString());
}
private void ReadGoal(Problem p, Domain d, Expression eGoal)
{
Formula fGoal = ReadGroundedFormula((CompoundExpression)eGoal, d);
p.Goal = fGoal;
}
public Problem ParseProblem(string sProblemFile, Domain d)
{
StreamReader sr = new StreamReader(sProblemFile);
CompoundExpression exp = (CompoundExpression)ToExpression(sr);
sr.Close();
Problem p = null;
CompoundExpression eSub = null;
foreach (Expression e in exp.SubExpressions)
{
eSub = (CompoundExpression)e;
if (eSub.Type == "problem")
{
p = new Problem(eSub.SubExpressions.First().ToString(), d);
}
if (eSub.Type == ":domain")
{
if (eSub.SubExpressions.First().ToString() != d.Name)
{
throw new InvalidDataException("Domain and problem files don't match!");
}
}
if (eSub.Type == ":objects")
{
ReadConstants(eSub, d);
}
if (eSub.Type == ":init")
{
CompoundExpression eAnd = (CompoundExpression)eSub.SubExpressions.First();
if (eAnd.Type == "and")
{
ReadInitState(p, d, eAnd);
}
else
{
ReadInitState(p, d, eSub);
}
//throw new InvalidDataException("Expecting 'and', got " + eAnd.Type);
}
if (eSub.Type == ":goal")
{
ReadGoal(p, d, eSub.SubExpressions[0]);
}
if (eSub.Type == ":metric")
{
ReadMetric(p, d, eSub);
}
}
//p.AddReasoningActions(); not needed as long as we use FF to do the planning for us
d.ComputeAlwaysKnown();
p.CompleteKnownState();
List <Predicate> lConstantPredicates = new List <Predicate>();
foreach (Predicate pKnown in p.Known)
{
if (d.AlwaysConstant(pKnown))
{
lConstantPredicates.Add(pKnown);
}
}
//Problem here - sometimes ~p and p are both effects (remove p and immediately add it), and the current code forbids that - not sure what to do...
//d.RemoveUniversalQuantifiers(lConstantPredicates);
//p.RemoveUniversalQuantifiers();
d.ComputePrivateActions();
return(p);
}
private Formula ReadPredicate(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, bool bParametrized, Domain d)
{
Predicate p = null;
int iExpression = 0;
string sName = "";
if (bParametrized)
{
p = new ParametrizedPredicate(exp.Type);
}
else
{
p = new GroundedPredicate(exp.Type);
}
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
sName = exp.SubExpressions[iExpression].ToString();
if (bParametrized)
{
Argument a = null;
if (sName.StartsWith("?"))
{
a = new Parameter(dParameterNameToType[sName], sName);
}
else
{
a = new Constant(d.ConstantNameToType[sName], sName);
}
((ParametrizedPredicate)p).AddParameter(a);
}
else
{
Constant c = new Constant(d.ConstantNameToType[sName], sName);
((GroundedPredicate)p).AddConstant(c);
}
}
if (bParametrized)
{
if (!MatchParametersToPredicateDeclaration((ParametrizedPredicate)p, d))
{
throw new NotImplementedException();
}
}
PredicateFormula vf = new PredicateFormula(p);
return(vf);
}
private Formula ReadFormula(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, bool bParamterized, Domain d)
{
bool bPredicate = true;
//Debug.WriteLine(exp);
if (d != null && d.IsFunctionExpression(exp.Type))
{
Predicate p = ReadFunctionExpression(exp, dParameterNameToType, d);
return(new PredicateFormula(p));
}
else if (IsUniversalQuantifier(exp))
{
CompoundExpression eParameter = (CompoundExpression)exp.SubExpressions[0];
CompoundExpression eBody = (CompoundExpression)exp.SubExpressions[1];
string sParameter = eParameter.Type;
string sType = eParameter.SubExpressions[1].ToString();
dParameterNameToType[sParameter] = sType;
ParametrizedFormula cfQuantified = new ParametrizedFormula(exp.Type);
cfQuantified.Parameters[sParameter] = sType;
Formula fBody = ReadFormula(eBody, dParameterNameToType, true, d);
cfQuantified.AddOperand(fBody);
return(cfQuantified);
}
else
{
foreach (Expression eSub in exp.SubExpressions)
{
if (eSub is CompoundExpression)
{
bPredicate = false;
break;
}
}
if (bPredicate)
{
return(ReadPredicate(exp, dParameterNameToType, bParamterized, d));
}
else
{
CompoundFormula cf = new CompoundFormula(exp.Type);
int iExpression = 0;
for (iExpression = 0; iExpression < exp.SubExpressions.Count; iExpression++)
{
if (exp.SubExpressions[iExpression] is StringExpression)
{
throw new InvalidDataException();
}
Formula f = ReadFormula((CompoundExpression)exp.SubExpressions[iExpression], dParameterNameToType, bParamterized, d);
cf.SimpleAddOperand(f);
}
if (cf.Operator == "not" && cf.Operands[0] is PredicateFormula)
{
PredicateFormula fNegate = new PredicateFormula(((PredicateFormula)cf.Operands[0]).Predicate.Negate());
return(fNegate);
}
return(cf);
}
}
}
public Domain ParseDomain(string sDomainFile)
{
string sPath = sDomainFile.Substring(0, sDomainFile.LastIndexOf(@"\") + 1);
StreamReader sr = new StreamReader(sDomainFile);
/*
* Stack<string> s = ToStack(new StreamReader(sDomainFile));
* Stack<string> s2 = ToStackII(new StreamReader(sDomainFile));
*
* for (int i = 0; i < s.Count; i++)
* if (s.ElementAt(i) != s2.ElementAt(i))
* Debug.WriteLine(s.ElementAt(i) + " =/= " + s2.ElementAt(i));
*/
CompoundExpression exp = (CompoundExpression)ToExpression(sr);
sr.Close();
Domain d = null;
foreach (Expression e in exp.SubExpressions)
{
if (e is CompoundExpression)
{
CompoundExpression eSub = (CompoundExpression)e;
if (eSub.Type == "domain")
{
d = new Domain(eSub.SubExpressions.First().ToString(), sPath);
}
else if (eSub.Type == ":requirements")
{
}
else if (eSub.Type == ":types")
{
d.Types.Add("object");
List <string> lTypes = new List <string>();
CompoundExpression eTypes = ((CompoundExpression)eSub);
for (int i = 0; i < eTypes.SubExpressions.Count; i++)
{
Expression eType = eTypes.SubExpressions[i];
string sType = eType.ToString().Trim();
if (sType == "-")
{
Expression eParentType = eTypes.SubExpressions[i + 1];
i++;
string sParentType = eParentType.ToString();
foreach (string sSubType in lTypes)
{
d.TypeHierarchy[sSubType] = sParentType;
}
lTypes = new List <string>();
}
else
{
d.Types.Add(sType);
lTypes.Add(sType);
}
}
}
else if (eSub.Type == ":constants")
{
ReadConstants(eSub, d);
}
else if (eSub.Type == ":functions")
{
ReadFunctions(eSub, d);
}
else if (eSub.Type == ":predicates")
{
ReadPredicates(eSub, d);
}
else if (eSub.Type == ":action")
{
d.AddAction(ReadAction(eSub, d));
}
}
}
return(d);
}
public ParameterizedFunctionPredicate ReadFunctionExpression(CompoundExpression exp, Dictionary <string, string> dParameterNameToType, Domain d)
{
ParameterizedFunctionPredicate pp = new ParameterizedFunctionPredicate(exp.Type);
foreach (Expression e in exp.SubExpressions)
{
pp.AddParameter(ReadFunctionArgument(e, dParameterNameToType, d));
}
return(pp);
}
