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