// public static Func
/*!
* Calculate the total city-block distance for the
* state
*/
public static int ManhattanDistance(SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node)
// public static int ManhattanDistance(SearchTreeNode.Node<S,A,C>
{
int md = 0;
int[] state = node.state.State;
int dim = (int)Math.Sqrt(state.Length);
for (int i = 0; i < state.Length; i++)
{
if (state[i] != state.Length)
{
//! need to determine how far away, in city-block distance, this element
//! is from it's place in the
//! goal state. It's index in the goal state is one less then the value.
//! so we need to calculate the city block distance between the current
//! index (i) and state[i] - 1
//! To do this,
md += Math.Abs((i - state[i] + 1) / dim);
md += Math.Abs((i - state[i] + 1) % dim);
}
}
node.hv = md;
return(md);
}
private Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > GetPriorityQueue()
{
// Heuristics.HeuristicFunction<NPuzzleState<int[]>,int,int> handler = Heuristics.NPuzzleHeuristics.ManhattanDistance;
Heuristics.Heurfun <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > handler = Heuristics.NPuzzleHeuristics.ManhattanDistance;
Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > frontier = new Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> >(handler);
//SortedList<int, List<SearchTreeNode.NPuzzleNode<int[],int,int> > > frontier = new SortedList<int, List<SearchTreeNode.NPuzzleNode<int[],int,int> > >();
List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > nodes = TestNode.CreateNodesForTesting();
//! md = 12
int[] s7 = { 6, 4, 3, 1, 9, 5, 8, 7, 2 };
NPuzzleState <int[]> s7State = new NPuzzleState <int[]>(s7);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node7 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int> (s7State);
nodes.Add(node7);
//! 2 + 2 + 1 + 1 + 2 = 8
int[] s8 = { 1, 6, 3, 8, 4, 5, 7, 2, 9 };
NPuzzleState <int[]> s8State = new NPuzzleState <int[]>(s8);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node8 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int> (s8State);
nodes.Add(node8);
foreach (var node in nodes)
{
//int md = handler(node);
frontier.Append(node);
}
return(frontier);
}
public static List <SearchTreeNode.Node <Problem.NPuzzleState <int[]>, int, int> > CreateNodesForTesting()
{
//! md = 0
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//! -1 (from goal), md = 1
int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
//! md = 1
int[] s7 = { 1, 2, 3, 4, 5, 9, 7, 8, 6 };
//! 2, md = 2
int[] s2 = { 1, 2, 3, 4, 9, 6, 7, 5, 8 };
//! 1, md 3
int[] s3 = { 1, 2, 3, 4, 6, 9, 7, 5, 8 };
//! 2 md = 4
int[] s4 = { 1, 2, 9, 4, 6, 3, 7, 5, 8 };
//! -1 md = 5
int[] s5 = { 1, 9, 2, 4, 6, 3, 7, 5, 8 };
//! -1 md = 6
int[] s6 = { 9, 1, 2, 4, 6, 3, 7, 5, 8 };
//! TODO: Could refactor this. Create dictionaries with state, action, md value, and use a loop
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> rootNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(goal));
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node1 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s1), rootNode, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node2 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s2), node1, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node3 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s3), node2, 1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node4 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s4), node3, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node5 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s5), node4, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node6 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s6), node5, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node7 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s7), rootNode, 2, 1);
List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > nodes = new List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> >();
nodes.Add(rootNode);
nodes.Add(node1);
nodes.Add(node2);
nodes.Add(node3);
nodes.Add(node4);
nodes.Add(node5);
nodes.Add(node6);
nodes.Add(node7);
return(nodes);
}
public void TestSolution()
{
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
//! -1
int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);
//! 2
int[] s2 = { 1, 2, 3, 4, 9, 6, 7, 5, 8 };
NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);
//! 1
int[] s3 = { 1, 2, 3, 4, 6, 9, 7, 5, 8 };
NPuzzleState <int[]> s3State = new NPuzzleState <int[]>(s3);
//! 2
int[] s4 = { 1, 2, 9, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> s4State = new NPuzzleState <int[]>(s4);
//! -1
int[] s5 = { 1, 9, 2, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> s5State = new NPuzzleState <int[]>(s5);
//! -1
int[] s6 = { 9, 1, 2, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> s6State = new NPuzzleState <int[]>(s6);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> rootNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(goalState);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node1 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s1), rootNode, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node2 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s2), node1, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node3 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s3), node2, 1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node4 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s4), node3, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node5 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s5), node4, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node6 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s6), node5, -1, 1);
List <int> solution = node6.Solution();
Assert.AreEqual(solution[0], -1);
Assert.AreEqual(solution[1], -1);
Assert.AreEqual(solution[2], 2);
}
public void TestNodeCreation()
{
int size = 9;
//TODO: change NPuzzleUtils.GenerateInitState
NPuzzleState <int[]> state = NPuzzleUtils.GenerateInitState(size);
System.Diagnostics.Debug.WriteLine("State: ");
System.Diagnostics.Debug.WriteLine(state.State.ToString());
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(state);
}
public void TestExpand()
{
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> rootNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(goalState);
List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > expandedNodes;
Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = NPuzzleUtils.CreateProblem(9);
expandedNodes = rootNode.Expand(problem);
List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > testNodes = new List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> >();
//! actions for goal are -1 and 2
//! state resulting from action 2
int[] s1 = { 1, 2, 3, 4, 5, 9, 7, 8, 6 };
NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);
//! state resulting from -1
int[] s2 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node2 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s1State, rootNode, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node3 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s2State, rootNode, -1, 1);
testNodes.Add(node3);
testNodes.Add(node2);
Assert.AreEqual(testNodes.Count, expandedNodes.Count);
Assert.AreEqual(expandedNodes[0].state, node3.state);
// Assert.True(expandedNodes[0].state.Equals( node3.state));
Assert.AreEqual(expandedNodes[0].parent, node3.parent);
Assert.True(expandedNodes[0].parent.Equals(node3.parent));
Assert.AreEqual(expandedNodes[0].action, node3.action);
Assert.True(expandedNodes[0].action.Equals(node3.action));
Assert.AreEqual(expandedNodes[0].depth, node3.depth);
Assert.True(expandedNodes[0].depth.Equals(node3.depth));
Assert.AreEqual(expandedNodes[0].pathCost, node3.pathCost);
Assert.True(expandedNodes[0].pathCost.Equals(node3.pathCost));
// Assert.True(expandedNodes[0].Equals(node3));
// Assert.AreEqual(expandedNodes[0], node3);
// Assert.AreEqual(expandedNodes[1], node2);
// CollectionAssert.AreEqual(testNodes, expandedNodes);
// Assert.That(testNodes, Is.EquivalentTo(expandedNodes));
}
public void TestPath()
{
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
//! -1
int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
//! 2
int[] s2 = { 1, 2, 3, 4, 9, 6, 7, 5, 8 };
//! 1
int[] s3 = { 1, 2, 3, 4, 6, 9, 7, 5, 8 };
//! 2
int[] s4 = { 1, 2, 9, 4, 6, 3, 7, 5, 8 };
//! -1
int[] s5 = { 1, 9, 2, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);
NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);
NPuzzleState <int[]> s3State = new NPuzzleState <int[]>(s3);
NPuzzleState <int[]> s4State = new NPuzzleState <int[]>(s4);
NPuzzleState <int[]> s5State = new NPuzzleState <int[]>(s5);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> rootNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(goalState);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node1 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s1State, rootNode, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node2 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s2State, node1, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node3 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s3State, node2, 1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node4 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s4State, node3, 2, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node5 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s5State, node4, -1, 1);
List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > path = node5.Path();
Assert.AreEqual(s5State, path[0].state);
Assert.AreEqual(path[0].action, -1);
Assert.AreEqual(s4State, path[1].state);
Assert.AreEqual(path[1].action, 2);
Assert.AreEqual(s3State, path[2].state);
Assert.AreEqual(s2State, path[3].state);
}
public void TestSomething()
{
int size = 9;
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
NPuzzleState <int[]> initial = NPuzzleUtils.GenerateInitState(size);
Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> npuzzle = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(goalState, initial);
HashSet <NPuzzleState <int[]> > explored = new HashSet <NPuzzleState <int[]> >();
//! first node in the frontier is the initialState
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(npuzzle.InitialState);
}
public void TestAStarGraphSearch()
{
int size = 9;
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
NPuzzleState <int[]> initial = NPuzzleUtils.GenerateInitState(size);
Assert.True(NPuzzleUtils.AcceptableState(initial.State));
Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> npuzzle = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(goalState, initial);
Assert.AreEqual(npuzzle.InitialState, initial);
Assert.AreEqual(npuzzle.GoalState, goal);
//Heuristics.HeuristicFunction<NPuzzleState<int[]>,int, int> handler = Heuristics.NPuzzleHeuristics.ManhattanDistance;
Heuristics.Heurfun <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > handler = Heuristics.NPuzzleHeuristics.AStarManhattanDistance;
try
{
Assert.AreEqual(npuzzle.InitialState, initial);
// Search.BestFirstGraphSearch<int[],int,int> bfgs = new Search.BestFirstGraphSearch<int[],int,int>(npuzzle, handler);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> initialNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(npuzzle.InitialState);
// Search.PriorityQueue<int, SearchTreeNode.Node<NPuzzleState<int[]>,int,int>> frontier = new Search.PriorityQueue<int, SearchTreeNode.Node<NPuzzleState<int[]>,int,int>>();
Search.AStarGraphSearch <NPuzzleState <int[]>, int, int> asgs = new Search.AStarGraphSearch <NPuzzleState <int[]>, int, int>(npuzzle, handler);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node = asgs.Search();
List <int> solution = node.Solution();
Console.WriteLine("Printing solution to AStar:");
solution.ForEach(delegate(int a) {
Console.Write("{0} ", a);
});
Console.WriteLine("");
} catch (NPuzzleUtils.InvalidProblemException ex)
{
System.Console.WriteLine("There is an InvalidProblemException here doode");
System.Console.WriteLine(ex.Message);
throw ex;
} catch (NPuzzleUtils.InvalidProblemPropertyException ex)
{
throw ex;
} catch (System.NullReferenceException ex)
{
Console.WriteLine(ex);
}
}
private Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > GetPriorityQueueToo()
{
Heuristics.Heurfun <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > handler = Heuristics.NPuzzleHeuristics.ManhattanDistance;
Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > frontier = new Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> >(handler);
int size = 9;
SearchTreeNode.Node <NPuzzleState <int[]>, int, int>[] nodeArray = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int> [100];
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node;
for (int i = 0; i < 100; i++)
{
NPuzzleState <int[]> istate = NPuzzleUtils.GenerateInitState(size);
node = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(istate);
nodeArray[i] = node;
//int heur = NPuzzleHeuristics.ManhattanDistance(node);
frontier.Append(node);
}
return(frontier);
}
/*! Test removing elements from the frontier
*/
public void TestCount()
{
Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > f = GetPriorityQueue();
SortedList <int, List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > > frontier = f.GetPriorityQueue();
Assert.AreEqual(f.Count(), 10);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node = f.Pop();
int[] s = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Assert.AreEqual(node.state, s);
Assert.AreEqual(f.Count(), 9);
int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
//! md = 1
int[] s7 = { 1, 2, 3, 4, 5, 9, 7, 8, 6 };
//! 2, md = 2
int[] s2 = { 1, 2, 3, 4, 9, 6, 7, 5, 8 };
node = f.Pop();
Assert.AreEqual(node.state, s1);
Assert.AreEqual(f.Count(), 8);
node = f.Pop();
Assert.AreEqual(node.state, s7);
Assert.AreEqual(f.Count(), 7);
node = f.Pop();
Assert.AreEqual(node.state, s2);
Assert.AreEqual(f.Count(), 6);
node = f.Pop();
Assert.AreEqual(f.Count(), 5);
node = f.Pop();
Assert.AreEqual(f.Count(), 4);
node = f.Pop();
Assert.AreEqual(f.Count(), 3);
node = f.Pop();
Assert.AreEqual(f.Count(), 2);
node = f.Pop();
Assert.AreEqual(f.Count(), 1);
node = f.Pop();
Assert.AreEqual(f.Count(), 0);
}
public void TestGetIncumbent()
{
Heuristics.Heurfun <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > handler = Heuristics.NPuzzleHeuristics.ManhattanDistance;
Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > frontier = new Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> >(handler);
int size = 9;
SearchTreeNode.Node <NPuzzleState <int[]>, int, int>[] nodeArray = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int> [100];
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node;
for (int i = 0; i < 100; i++)
{
NPuzzleState <int[]> istate = NPuzzleUtils.GenerateInitState(size);
node = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(istate);
nodeArray[i] = node;
int heur = NPuzzleHeuristics.ManhattanDistance(node);
frontier.Append(node);
}
for (int i = 0; i < 100; i++)
{
Assert.AreEqual(nodeArray[i], frontier.GetIncumbent(nodeArray[i]));
}
}
public void TestChildNode()
{
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
//! action -1
int[] s1 = { 1, 2, 3, 4, 5, 9, 7, 8, 6 };
NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);
int[] s2 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(goalState);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> childNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s2State, node, -1, 1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> childNode2 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s1State, node, 2, 1);
Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = NPuzzleUtils.CreateProblem(9);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> expectedNode = node.ChildNode(problem, -1);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> expectedNode2 = node.ChildNode(problem, 2);
//! Tests
Assert.AreEqual(node.depth, 0);
Assert.AreEqual(expectedNode.parent, childNode.parent);
Assert.AreEqual(expectedNode.pathCost, childNode.pathCost);
Assert.AreEqual(expectedNode.state, childNode.state);
Assert.AreEqual(expectedNode.action, -1);
Assert.AreEqual(expectedNode.depth, 1);
Assert.AreEqual(expectedNode2.parent, childNode2.parent);
Assert.AreEqual(expectedNode2.pathCost, childNode2.pathCost);
Assert.AreEqual(expectedNode2.state, childNode2.state);
Assert.AreEqual(expectedNode2.action, 2);
Assert.AreEqual(expectedNode2.depth, 1);
}
public void TestAppendToo()
{
Heuristics.Heurfun <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > handler = Heuristics.NPuzzleHeuristics.ManhattanDistance;
Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > frontier = new Search.PriorityQueue <int, SearchTreeNode.Node <NPuzzleState <int[]>, int, int> >(handler);
int size = 9;
SearchTreeNode.Node <NPuzzleState <int[]>, int, int>[] nodeArray = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int> [100];
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node;
for (int i = 0; i < 100; i++)
{
NPuzzleState <int[]> istate = NPuzzleUtils.GenerateInitState(size);
node = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(istate);
nodeArray[i] = node;
//int heur = NPuzzleHeuristics.ManhattanDistance(node);
frontier.Append(node);
}
for (int i = 0; i < 100; i++)
{
int heur = NPuzzleHeuristics.ManhattanDistance(nodeArray[i]);
Assert.True(frontier.InPriorityQueue(nodeArray[i]));
}
int j = 0;
int[] heurArray = new int[100];
while (frontier.Count() > 0)
{
node = frontier.Pop();
heurArray[j] = NPuzzleHeuristics.ManhattanDistance(node);
j++;
}
for (j = 0; j < 99; j++)
{
Assert.True(heurArray[j] <= heurArray[j + 1]);
}
}
public void TestManhattanDistance()
{
//! md = 0
int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);
//! -1, md = 1
int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);
//! 2, md = 2
int[] s2 = { 1, 2, 3, 4, 9, 6, 7, 5, 8 };
NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);
//! 1, md 3
int[] s3 = { 1, 2, 3, 4, 6, 9, 7, 5, 8 };
NPuzzleState <int[]> s3State = new NPuzzleState <int[]>(s3);
//! 2 md = 4
int[] s4 = { 1, 2, 9, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> s4State = new NPuzzleState <int[]>(s4);
//! -1 md = 5
int[] s5 = { 1, 9, 2, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> s5State = new NPuzzleState <int[]>(s5);
//! -1 md = 6
int[] s6 = { 9, 1, 2, 4, 6, 3, 7, 5, 8 };
NPuzzleState <int[]> s6State = new NPuzzleState <int[]>(s6);
//! 3 + 2 + 1 + 1 + 1 + 1 + 3
int[] s7 = { 6, 4, 3, 1, 9, 5, 8, 7, 2 };
NPuzzleState <int[]> s7State = new NPuzzleState <int[]>(s7);
//! 2 + 2 + 1 + 1 + 2 = 8
int[] s8 = { 1, 6, 3, 8, 4, 5, 7, 2, 9 };
NPuzzleState <int[]> s8State = new NPuzzleState <int[]>(s8);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node8 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s8State);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(node8), 8);
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node7 = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(s7State);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(node7), 12);
List <SearchTreeNode.Node <NPuzzleState <int[]>, int, int> > nodes = TestNode.CreateNodesForTesting();
Assert.AreEqual(nodes[0].state.State, goal);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(nodes[0]), 0);
Assert.AreEqual(nodes[1].state.State, s1);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(nodes[1]), 1);
Assert.AreEqual(nodes[2].state.State, s2);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(nodes[2]), 2);
Assert.AreEqual(nodes[3].state.State, s3);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(nodes[3]), 3);
Assert.AreEqual(nodes[4].state.State, s4);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(nodes[4]), 4);
Assert.AreEqual(nodes[5].state.State, s5);
Assert.AreEqual(NPuzzleHeuristics.ManhattanDistance(nodes[5]), 5);
}
public static int AStarManhattanDistance(SearchTreeNode.Node <NPuzzleState <int[]>, int, int> node)
{
return(node.pathCost + ManhattanDistance(node));
}
public void TestNodeTypeCasting()
{
int[] s6 = { 9, 1, 2, 4, 6, 3, 7, 5, 8 };
SearchTreeNode.Node <NPuzzleState <int[]>, int, int> rootNode = new SearchTreeNode.Node <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(s6));
}
