private Prove ( Structure goal ) : IEnumerable |
||
goal | Structure | |
return | IEnumerable |
IEnumerable <CutState> Prover(Structure goal) { if (goal == null) { return(CutStateSequencer.Succeed()); } return(context.Prove(goal)); }
private static IEnumerable<CutState> IfThenImplementation(object[] args, PrologContext context) { if (args.Length != 2) throw new ArgumentCountException("->", args, "if_condition", "then_result"); #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(args[0], "Arguments to -> must be valid subgoals.")) // ReSharper restore UnusedVariable { // ReSharper disable UnusedVariable foreach (var ignore2 in context.Prove(args[1], "Arguments to -> must be valid subgoals.")) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { yield return CutState.Continue; } yield break; } }
private static IEnumerable<CutState> IfThenElseImplementation(object test, object consequent, object alternative, PrologContext context) { #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(test, "Arguments to -> must be valid subgoals.")) // ReSharper restore UnusedVariable { // ReSharper disable UnusedVariable foreach (var ignore2 in context.Prove(consequent, "Arguments to -> must be valid subgoals.")) // ReSharper restore UnusedVariable { yield return CutState.Continue; } yield break; } // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(alternative, "Arguments to -> must be valid subgoals.")) // ReSharper restore UnusedVariable { yield return CutState.Continue; } #pragma warning restore 414, 168, 219 }
private static IEnumerable<CutState> RealOrImplementation(object[] args, PrologContext context) { foreach (var status1 in context.Prove(args[0], "Arguments to ; (or) must be valid subgoals.")) { if (status1 == CutState.ForceFail) { //yield return status1; yield break; } yield return CutState.Continue; } foreach (var status2 in context.Prove(args[1], "Arguments to ; (or) must be valid subgoals.")) { if (status2 == CutState.ForceFail) { //yield return status2; yield break; } yield return CutState.Continue; } }
private static IEnumerable<CutState> AndImplementation(object[] args, PrologContext context) { if (args.Length != 2) throw new ArgumentCountException(", (and)", args, "goal1", "goal2"); foreach (var status1 in context.Prove(args[0], "Arguments to , (and) must be valid subgoals.")) { if (status1==CutState.ForceFail) { yield return status1; yield break; } foreach (var status2 in context.Prove(args[1], "Arguments to , (and) must be a valid subgoals.")) { if (status2 == CutState.ForceFail) { yield return status2; yield break; } yield return CutState.Continue; } } }
private static IEnumerable<CutState> FreezeImplementation(object[] args, PrologContext context) { if (args.Length != 2) throw new ArgumentCountException("freeze", args, "variable", "goal"); Structure goal = Term.Structurify(args[1], "Goal argument to freeze must be a valid Prolog goal."); var v = args[0] as LogicVariable; if (v == null) throw new ArgumentTypeException("freeze", "variable", args[0], typeof (LogicVariable)); object canon = Term.Deref(v); var canonv = canon as LogicVariable; if (canonv == null) // Variable is already instantiated - run the goal return context.Prove(goal); // Variable is uninstantiated; tag it with a suspension of goal. return canonv.MetaUnify(new Suspension(null, goal, context)); }
private static IEnumerable<CutState> ForAllImplementation(object[] args, PrologContext context) { if (args.Length != 2) throw new ArgumentCountException("forall", args, ":generator", ":goal"); #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(args[0], "goal argument to findall must be a valid Prolog goal.")) { var gotOne = false; foreach (var ignore2 in context.Prove(args[1], "Arguments for forall/2 must be valid goals.")) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 gotOne = true; if (!gotOne) yield break; } yield return CutState.Continue; }
private static IEnumerable<CutState> OnceImplementation(object[] args, PrologContext context) { if (args.Length != 1) throw new ArgumentCountException("once", args, "goal"); #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(args[0], "Argument to once/1 must be a valid subgoal.")) #pragma warning restore 414, 168, 219 { // ReSharper restore UnusedVariable yield return CutState.Continue; yield break; } }
private static IEnumerable<CutState> CallWithStepLimitImplementation(object[] args, PrologContext context) { if (args.Length != 2) throw new ArgumentCountException("call_with_step_limit", args, "max_steps", ":goal"); object arg = Term.Deref(args[0]); var v = arg as LogicVariable; if (v != null) throw new InstantiationException(v, "first argument to call_with_step_limit/2 must be instantiated to an integer."); int newStepLimit = Convert.ToInt32(arg); int previousLimit = context.StepLimit; int previousRemaining = context.StepsRemaining; context.StepLimit = newStepLimit; context.StepsRemaining = newStepLimit; #pragma warning disable 0168 // ReSharper disable once UnusedVariable foreach (var ignore in context.Prove(args[1], "Argument to step_limit/2 must be a valid goal")) #pragma warning restore 0168 { yield return CutState.Continue; } context.StepLimit = previousLimit; context.StepsRemaining = previousRemaining; }
private static IEnumerable<CutState> CheckImplementation(object[] args, PrologContext context) { if (args.Length != 1) throw new ArgumentCountException("check", args, "goal"); using (var e = context.Prove(args[0], "Goal to check is not a valid Prolog goal.").GetEnumerator()) { if (e.MoveNext()) yield return CutState.Continue; else throw new InvalidOperationException("Check failed: " + ISOPrologWriter.WriteToString(args[0])); } }
private static IEnumerable<CutState> ArgMinImplementation(object[] args, PrologContext context) { if (args.Length != 3) throw new ArgumentCountException("arg_min", args, "template", "score", "goal"); object template = Term.Deref(args[0]); object score = Term.Deref(args[1]); float bestScore = 0; object bestObj = null; bool gotOne = false; #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(args[2], "Goal argument to arg_min must be a valid Prolog goal.")) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { float newScore = Convert.ToSingle(Term.Deref(score)); if (!gotOne || newScore < bestScore) { gotOne = true; bestScore = newScore; bestObj = Term.CopyInstantiation(template); } } if (gotOne) { #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in Term.Unify(score, bestScore)) foreach (var ignore2 in Term.Unify(template, bestObj)) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 yield return CutState.Continue; } }
private static IEnumerable<CutState> SumallImplementation(object[] args, PrologContext context) { if (args.Length != 3) throw new ArgumentCountException("sumall", args, "numberVar", "generator", "sum"); var numberVar = Term.Deref(args[0]) as LogicVariable; if (numberVar == null) throw new ArgumentTypeException("sumall", "numberVar", args[0], typeof(LogicVariable)); //object bag = null; double sum = 0; #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(args[1], "goal argument to findall must be a valid Prolog goal.")) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { sum += Convert.ToDouble(numberVar.Value); } return Term.UnifyAndReturnCutState(args[2], sum); }
private static List<object> SolutionList(PrologContext context, object template, object goal, int maxSolutions, bool deleteDuplicates) { var bag = new List<object>(); #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in context.Prove(goal, "goal argument to findall must be a valid Prolog goal.")) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 { object instance = Term.CopyInstantiation(template); bag.Add(instance); if (--maxSolutions <= 0) break; } if (deleteDuplicates) Term.Sort(bag, true); return bag; }
private static IEnumerable<CutState> ForAllUniqueImplementation(object[] args, PrologContext context) { if (args.Length != 3) throw new ArgumentCountException("for_all_unique", args, "-Template", ":generator", ":goal"); var template = Term.Deref(args[0]); foreach (var templateValue in SolutionList(context, template, Term.Deref(args[1]), int.MaxValue, true)) #pragma warning disable 414, 168, 219 // ReSharper disable UnusedVariable foreach (var ignore in Term.Unify(template, templateValue)) { var gotOne = false; foreach (var ignore2 in context.Prove(args[2], "Arguments for forall/2 must be valid goals.")) // ReSharper restore UnusedVariable #pragma warning restore 414, 168, 219 gotOne = true; if (!gotOne) yield break; } yield return CutState.Continue; }
private static IEnumerable<CutState> NotImplementation(object[] args, PrologContext context) { if (args.Length != 1) throw new ArgumentCountException("not", args, "goal"); LogicVariable v = Term.FindUninstantiatedVariable(args[0]); if (v != null) throw new InstantiationException(v, "Argument to not must be a ground literal (i.e. contain no unbound variables)."); using (var e = context.Prove(args[0], "Argument to not must be a valid term to prove.").GetEnumerator()) { if (!e.MoveNext() || e.Current == CutState.ForceFail) yield return CutState.Continue; } }
private static IEnumerable<CutState> NotPlusImplementation(object[] args, PrologContext context) { if (args.Length != 1) throw new ArgumentCountException("\\+", args, "goal"); using (var e = context.Prove(args[0], "Argument to \\+ must be a valid term to prove.").GetEnumerator()) { if (!e.MoveNext() || e.Current == CutState.ForceFail) yield return CutState.Continue; } }
private static IEnumerable<CutState> BeginImplementation(object[] args, PrologContext context) { var enumerators = new IEnumerator<CutState>[args.Length]; int i=0; try { for (; i<args.Length; i++) { var goal = args[i]; var goalStructure = Term.Structurify(goal, "Argument to begin is not a valid goal."); if (goalStructure.IsFunctor(Symbol.Dot, 2)) FunctionalExpression.Eval(goalStructure, context); else { var enumerator = context.Prove(goalStructure).GetEnumerator(); enumerators[i] = enumerator; if (!enumerator.MoveNext() || enumerator.Current == CutState.ForceFail) throw new GoalException(goal, "Goal failed"); } } yield return CutState.Continue; } finally { while ((--i)>=0) enumerators[i].Dispose(); } }
private static IEnumerable<CutState> IgnoreImplementation(object[] args, PrologContext context) { if (args.Length != 1) throw new ArgumentCountException("ignore", args, "goal"); using (var e = context.Prove(args[0], "Argument to ignore/n must be a valid subgoal.").GetEnumerator()) { e.MoveNext(); // Ignore whether it succeeded. yield return CutState.Continue; } }
private static IEnumerable<CutState> CallImplementation(object[] args, PrologContext context) { switch (args.Length) { case 0: throw new ArgumentCountException("call", args, "goal", "optionalAdditionalArguments", "..."); case 1: return IgnoreCuts(context.Prove(args[0], "Argument to call must be a valid subgoal.")); default: // More than 1 argument - add other arguments to the end of the predicate { object goal = Term.Deref(args[0]); var t = goal as Structure; if (t != null) { var goalArgs = new object[t.Arguments.Length + args.Length - 1]; t.Arguments.CopyTo(goalArgs, 0); Array.Copy(args, 1, goalArgs, t.Arguments.Length, args.Length - 1); return IgnoreCuts(context.KnowledgeBase.Prove(t.Functor, goalArgs, context, context.CurrentFrame)); } var s = goal as Symbol; if (s != null) { var goalArgs = new object[args.Length - 1]; Array.Copy(args, 1, goalArgs, 0, args.Length - 1); return IgnoreCuts(context.KnowledgeBase.Prove(s, goalArgs, context, context.CurrentFrame)); } throw new ArgumentException("Argument to call must be a valid subgoal."); } } }