public void PutStructure() { AbstractMachineState state = SetupMachine(); PutStructureInstruction i = new PutStructureInstruction(); Assert.AreEqual("put_structure", i.Name()); Assert.AreEqual(2, i.NumberOfArguments()); object[] args = { "s/2", "X0" }; i.Process(args); i.Execute(state); AbstractTerm H = (AbstractTerm)state["H"]; Assert.IsTrue(H.IsStructure); Assert.AreEqual(2, H.Arity); Assert.AreEqual("s", H.Name); AbstractTerm X0 = (AbstractTerm)state["X0"]; Assert.AreSame(H.Dereference(), X0.Dereference()); Assert.IsTrue(X0.IsStructure); Assert.AreEqual(2, X0.Arity); Assert.AreEqual("s", X0.Name); }
public void Assign() { AbstractTerm term = new AbstractTerm(); ConstantTerm con = new ConstantTerm("ali"); term.Assign(con); Assert.AreSame(term.Dereference(), con); Assert.AreSame(term.Dereference(), con.Dereference()); Assert.AreEqual(term.Data(), con.Data()); Assert.AreSame(term.Reference(), con.Reference()); Assert.IsFalse(term.IsList); Assert.IsFalse(term.IsObject); Assert.IsFalse(term.IsReference); Assert.IsFalse(term.IsStructure); Assert.IsTrue(term.IsConstant); }
public void Unify_ref_ref() { AbstractTerm term = new AbstractTerm(); AbstractTerm another = new AbstractTerm(); bool result = term.Unify(another); Assert.AreSame(term.Dereference(), another); Assert.IsTrue(result); }
public void Dereference() { AbstractTerm term1 = new AbstractTerm(); AbstractTerm term2 = new AbstractTerm(); AbstractTerm term3 = new AbstractTerm(); term2.Bind(term3); term1.Bind(term2); Assert.AreSame(term3, term1.Dereference()); }
public override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AMHeap heap = (AMHeap)state.DataArea; AbstractTerm Vn = new AbstractTerm(); AbstractTerm reg = (AbstractTerm)state[_vn]; Vn.Assign(reg.Dereference()); heap.Push(Vn); program.Next(); }
public void SetValue() { AbstractMachineState state = SetupMachine(); SetValueInstruction i = new SetValueInstruction(); object[] args = { "X0" }; i.Process(args); AbstractTerm X0 = (AbstractTerm)state["X0"]; i.Execute(state); Assert.AreEqual("set_value", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); Assert.AreSame(X0.Dereference(), ((AbstractTerm)state["H"]).Dereference()); }
public override void Execute(AbstractMachineState state) { AMProgram program = (AMProgram)state.Program; AMHeap heap = (AMHeap)state.DataArea; AbstractTerm Vn = (AbstractTerm)state[_vn]; if (state.IsReadMode) { state.Fail = !Vn.Unify((AbstractTerm)state.S); } else { AbstractTerm addr = Vn.Dereference(); if (IsEnvironmentVariable(addr, state)) { // Push a new variable on the heap AbstractTerm newVariable = new AbstractTerm(); heap.Push(newVariable); addr.Bind((AbstractTerm)heap.Top()); } else { AbstractTerm newHeapItem = new AbstractTerm(); newHeapItem.Assign(addr); heap.Push(newHeapItem); } } if (state.S != null) { state.S = state.S.Next; } if (state.Fail) { state.Backtrack(); } else { program.Next(); } }
public void UnifyLocalValue() { AbstractMachineState state = SetupMachine(); UnifyLocalValueInstruction i = new UnifyLocalValueInstruction(); ConstantTerm con = new ConstantTerm("ali"); state.S = con; object[] args = { "X0" }; i.Process(args); i.Execute(state); Assert.AreEqual("unify_local_value", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); AbstractTerm X0 = (AbstractTerm)state["X0"]; Assert.AreEqual("ali", X0.Dereference().Data()); }
public void SetLocalValue() { AbstractMachineState state = SetupMachine(); EnvironmentFrame env = new EnvironmentFrame(null, null, 3); state.E = env; SetLocalValueInstruction i = new SetLocalValueInstruction(); object[] args = { "X0" }; i.Process(args); AbstractTerm X0 = (AbstractTerm)state["X0"]; i.Execute(state); Assert.AreEqual("set_local_value", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); Assert.AreSame(X0.Dereference(), ((AbstractTerm)state["H"]).Dereference()); }
public void UnifyVariable() { AbstractMachineState state = SetupMachine(); state.IsReadMode = true; AbstractTerm sVar = new AbstractTerm(); state.S = sVar; UnifyVariableInstruction i = new UnifyVariableInstruction(); object[] args = { "X0" }; i.Process(args); i.Execute(state); Assert.AreEqual("unify_variable", i.Name()); Assert.AreEqual(1, i.NumberOfArguments()); AbstractTerm X0 = ((AbstractTerm)state["X0"]).Dereference(); Assert.AreSame(X0.Dereference(), sVar); Assert.IsNull(state.S); }
public static double Evaluate(AbstractTerm t) { double result = 0; AbstractTerm term = t.Dereference(); if (term.IsConstant) { int r; double d; if (Int32.TryParse((string)term.Data(), out r)) { return(r); } else if (Double.TryParse((string)term.Data(), out d)) { return(d); } else { switch ((string)term.Data()) { case "pi": result = Math.PI; break; case "e": result = Math.E; break; case "cputime": Process p = Process.GetCurrentProcess(); result = (p.TotalProcessorTime.TotalMilliseconds / 1000); break; default: throw new Exception("TermEvaluator: cannot evaluate string " + term.Data()); } } } else if (term.IsReference) { throw new Exception("TermEvaluator: cannot evaluate a reference term."); } else if (term.IsStructure) { AbstractTerm op1 = (AbstractTerm)term.Next; AbstractTerm op2 = (AbstractTerm)term.Next.Next; switch (term.Name) { case "+": result = Evaluate(op1) + Evaluate(op2); break; case "-": result = Evaluate(op1) - Evaluate(op2); break; case "*": result = Evaluate(op1) * Evaluate(op2); break; case "/": if (Evaluate(op2) == 0) { throw new Exception("TermEvaluator: Division by zero error."); } result = Evaluate(op1) / Evaluate(op2); break; case "^": result = Math.Pow(Evaluate(op1), Evaluate(op2)); break; case "cos": result = Math.Cos(Evaluate(op1)); break; case "sin": result = Math.Sin(Evaluate(op1)); break; case "tan": result = Math.Tan(Evaluate(op1)); break; case "log": result = Math.Log(Evaluate(op1)); break; } } return(result); }