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);
}