Esempio n. 1
0
        public void TestNPuzzleInitialState()
        {
            int[] goal    = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] initial = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
            NPuzzleState <int[]> goalState    = new NPuzzleState <int[]>(goal);
            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(initial);


            try {
                Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(goalState, initialState);
                Assert.NotNull(problem);
                Assert.NotNull(problem.InitialState);
                Assert.AreEqual(problem.InitialState, initialState);
                Problem.AbstractProblem <NPuzzleState <int[]>, int, int> p2 = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(goalState, initialState);
                Assert.NotNull(p2);
                Assert.True(p2.GoalTest(goalState));
                Assert.AreEqual(p2.Result(initialState, 1), goalState);
                List <int> results = new List <int>();
                results.Add(1);
                results.Add(-1);
                results.Add(2);
                Assert.AreEqual(p2.Actions(initialState), results);
            } catch (NPuzzleUtils.InvalidNPuzzleStatesException ex) {
            }
        }
Esempio n. 2
0
        public void TestNPuzzleProblemAcceptableAction()
        {
            int[] state = { 5, 6, 2, 8, 9, 3, 1, 4, 7 };
            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(state);

            Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = CreateProblem(initialState);
            Assert.True(problem.AcceptableAction(initialState.State, 4, -1));
            Assert.True(problem.AcceptableAction(initialState.State, 4, 1));

            Assert.True(problem.AcceptableAction(initialState.State, 4, -2));

            Assert.True(problem.AcceptableAction(initialState.State, 4, 2));
            Assert.False(problem.AcceptableAction(initialState.State, 4, 3));

            Assert.False(problem.AcceptableAction(initialState.State, 4, 0));
            int[] state2 = { 4, 9, 8, 2, 3, 5, 6, 7, 1 };
            NPuzzleState <int[]> state2State = new NPuzzleState <int[]>(state2);

            problem = CreateProblem(state2State);

            NPuzzleState <int[]> initialState2 = new NPuzzleState <int[]>(state2);

            Assert.True(problem.AcceptableAction(initialState2.State, 1, -1));

            Assert.True(problem.AcceptableAction(initialState2.State, 1, 1));

            Assert.True(problem.AcceptableAction(initialState2.State, 1, -2));
        }
Esempio n. 3
0
        public void TestHashSet()
        {
            HashSet <NPuzzleState <int[]> > explored = new HashSet <NPuzzleState <int[]> >();
            int size = 9, num = 100;

            NPuzzleState <int[]>[] states = new NPuzzleState <int[]> [num];
            NPuzzleState <int[]>   state;

            int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);

            for (int i = 0; i < num; i++)
            {
                state     = NPuzzleUtils.GenerateInitState(size);
                states[i] = state;
                explored.Add(state);
            }
            Assert.False(explored.Contains(goalState));
            explored.Add(goalState);

            for (int i = 0; i < num; i++)
            {
                Assert.True(explored.Contains(states[i]));
            }
            Assert.True(explored.Contains(goalState));
        }
Esempio n. 4
0
        public void TestListContains()
        {
            int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);

            int[] s2 = { 1, 2, 3, 4, 5, 9, 7, 8, 6 };

            NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);

            int[] s3 = { 1, 2, 9, 4, 5, 3, 7, 8, 6 };

            NPuzzleState <int[]> s3State = new NPuzzleState <int[]>(s3);

            int[] s4 = { 1, 2, 9, 4, 5, 3, 7, 8, 6 };

            NPuzzleState <int[]>         s4State = new NPuzzleState <int[]>(s4);
            List <NPuzzleState <int[]> > list    = new List <NPuzzleState <int[]> >();

            list.Add(s1State);
            Assert.True(list.Contains(s1State));
            Assert.False(list.Contains(s2State));
            list.Add(s2State);
            Assert.True(list.Contains(s2State));
            Assert.False(list.Contains(s3State));
            list.Add(s3State);
            Assert.True(list.Contains(s3State));

            if (!list.Contains(s4State))
            {
                Console.WriteLine("Write Line: s4 not in list");
            }
        }
Esempio n. 5
0
        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);
        }
Esempio n. 6
0
        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);
        }
Esempio n. 7
0
        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);
        }
Esempio n. 8
0
        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));
        }
Esempio n. 9
0
        public void TestNPuzzleStateEquals()
        {
            int[] state = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(state);

            int[] state2 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
            NPuzzleState <int[]> initialState2 = new NPuzzleState <int[]>(state2);

            Assert.False(initialState.Equals(initialState2));

            Assert.True(initialState.Equals(initialState));
        }
Esempio n. 10
0
        public void TestNPuzzleProblemCreation()
        {
            int[] goal    = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            int[] initial = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
            NPuzzleState <int[]> goalState    = new NPuzzleState <int[]>(goal);
            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(initial);

            Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(goalState, initialState);
            problem.Actions(goalState);

            Assert.Throws <NPuzzleUtils.InvalidNPuzzleStatesException>(() => new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(initialState, goalState));
        }
Esempio n. 11
0
        public void TestNPuzzleProblemResult()
        {
            int[] state = { 7, 6, 4, 9, 8, 2, 5, 3, 1 };
            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(state);

            //! acceptable actions are -2, 2, 1
            //! -2
            int[] r1 = { 7, 6, 4, 5, 8, 2, 9, 3, 1 };

            NPuzzleState <int[]> r1State = new NPuzzleState <int[]>(r1);

            int[] r2 = { 9, 6, 4, 7, 8, 2, 5, 3, 1 };

            NPuzzleState <int[]> r2State = new NPuzzleState <int[]>(r2);

            int[] r3 = { 7, 6, 4, 8, 9, 2, 5, 3, 1 };

            NPuzzleState <int[]> r3State = new NPuzzleState <int[]>(r3);

            int[] s2 = { 8, 5, 2, 9, 3, 7, 4, 6, 1 };

            NPuzzleState <int[]> s2State = new NPuzzleState <int[]>(s2);

            // 2
            int[] s2r1 = { 9, 5, 2, 8, 3, 7, 4, 6, 1 };

            NPuzzleState <int[]> s2r1State = new NPuzzleState <int[]>(s2r1);

            // -2
            int[] s2r2 = { 8, 5, 2, 4, 3, 7, 9, 6, 1 };

            NPuzzleState <int[]> s2r2State = new NPuzzleState <int[]>(s2r2);

            // 1
            int[] s2r3 = { 8, 5, 2, 3, 9, 7, 4, 6, 1 };

            NPuzzleState <int[]> s2r3State = new NPuzzleState <int[]>(s2r3);

            Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = CreateProblem(initialState);

            CollectionAssert.AreEquivalent(r1State, problem.Result(initialState, -2));

            CollectionAssert.AreEquivalent(r2State, problem.Result(initialState, 2));

            CollectionAssert.AreEquivalent(r3State, problem.Result(initialState, 2));

            CollectionAssert.AreEquivalent(s2r1State, problem.Result(s2State, 2));

            CollectionAssert.AreEquivalent(s2r2State, problem.Result(s2State, -2));

            CollectionAssert.AreEquivalent(s2r3State, problem.Result(s2State, 1));
            Assert.Throws <NPuzzleUtils.ResultAcceptableActionException>(() => problem.Result(initialState, 0));
        }
Esempio n. 12
0
 private void operatorsView_SelectionChanged(object sender, EventArgs e)
 {
     if (operatorsView.SelectedCells.Count == 1 && stateList.Count != 0)
     {
         int index = operatorsView.SelectedCells[0].RowIndex;
         if (index < stateList.Count)
         {
             NPuzzleState npState = (NPuzzleState)stateList[index];
             FillDGV(npState.Tiles, N);
         }
     }
 }
Esempio n. 13
0
        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);
        }
Esempio n. 14
0
        public void TestNPuzzleProblemGoalTest()
        {
            int[] state = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(state);

            int[] state2 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };

            NPuzzleState <int[]> initialState2 = new NPuzzleState <int[]>(state2);

            Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = CreateProblem(initialState);
            Assert.False(problem.GoalTest(initialState2));
            Assert.True(problem.GoalTest(initialState));
        }
Esempio n. 15
0
        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);
        }
Esempio n. 16
0
        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);
            }
        }
Esempio n. 17
0
        public void TestNPuzzleProblemActions()
        {
            int[] initial = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };

            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(initial);

            Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = CreateProblem(initialState);
            List <int> actions  = problem.Actions(initialState);
            List <int> expected = new List <int>();

            expected.Add(-1);
            expected.Add(1);
            expected.Add(2);
            CollectionAssert.AreEquivalent(expected, actions);
            int[] initial2 = { 9, 7, 4, 2, 6, 3, 5, 8, 1 };

            NPuzzleState <int[]> initialState2 = new NPuzzleState <int[]>(initial2);

            problem  = CreateProblem(initialState2);
            actions  = problem.Actions(initialState2);
            expected = new List <int>();
            expected.Add(-2);
            expected.Add(1);
            CollectionAssert.AreEquivalent(expected, actions);
            int[] initial3 = { 2, 4, 8, 6, 3, 9, 7, 1, 5 };

            NPuzzleState <int[]> initialState3 = new NPuzzleState <int[]>(initial3);

            problem  = CreateProblem(initialState3);
            actions  = problem.Actions(initialState3);
            expected = new List <int>();
            expected.Add(-2);
            expected.Add(2);
            expected.Add(-1);
            CollectionAssert.AreEquivalent(expected, actions);
            int[] initial4 = { 2, 4, 8, 6, 9, 3, 7, 1, 5 };
            NPuzzleState <int[]> initialState4 = new NPuzzleState <int[]>(initial4);

            problem  = CreateProblem(initialState4);
            actions  = problem.Actions(initialState4);
            expected = new List <int>();
            expected.Add(-2);
            expected.Add(2);
            expected.Add(-1);
            expected.Add(1);
            CollectionAssert.AreEquivalent(expected, actions);
        }
Esempio n. 18
0
        public void TestNPuzzleProblemGetEmptyIndex()
        {
            int[] state = { 9, 7, 3, 6, 5, 2, 8, 1, 4 };
            NPuzzleState <int[]> initialState = new NPuzzleState <int[]>(state);

            Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = CreateProblem(initialState);
            Assert.AreEqual(problem.GetEmptyIndex(initialState.State), 0);
            int[] state2 = { 1, 7, 6, 5, 4, 3, 8, 2, 9 };
            NPuzzleState <int[]> initialState2 = new NPuzzleState <int[]>(state2);

            Assert.AreEqual(problem.GetEmptyIndex(initialState2.State), 8);
            int[] state3 = { 1, 2, 3, 4, 5, 6, 7, 8, 8 };
            NPuzzleState <int[]> initialState3 = new NPuzzleState <int[]>(state3);

            // Assert.Throws<NPuzzleUtils.MissingEmptyElementException>(() =>problem.GetEmptyIndex(state3));
            Assert.AreEqual(problem.GetEmptyIndex(initialState3.State), -1);
        }
Esempio n. 19
0
        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);
        }
Esempio n. 20
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]));
            }
        }
Esempio n. 21
0
        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]);
            }
        }
Esempio n. 22
0
        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);
        }
Esempio n. 23
0
    /*!
     * Create a random instance of a problem
     */
    public static Problem.NPuzzleProblem <Problem.NPuzzleState <int[]>, int, int> CreateProblem(int size)
    {
        if (!AcceptableLength(size))
        {
            string msg = String.Format("Length given: {0}", size);
            UnacceptableLengthException ex = new UnacceptableLengthException(msg);
            throw ex;
        }

        int[] goalState = new int[size];
        NPuzzleState <int[]> initial;

        for (int i = 0; i < size; i++)
        {
            goalState[i] = i + 1;
        }

        NPuzzleState <int[]> goal = new NPuzzleState <int[]>(goalState);

        initial = GenerateInitState(size);

        Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(goal, initial);
        return(problem);
    }
Esempio n. 24
0
        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);
        }
Esempio n. 25
0
        public SolutionForm(ISolver A, IEnvironment env, INode start, INode goal)
        {
            InitializeComponent();

            DataGridViewTextBoxColumn col = new DataGridViewTextBoxColumn();

            col.HeaderText = "Operators";
            col.SortMode   = DataGridViewColumnSortMode.NotSortable;
            operatorsView.Columns.Add(col);
            operatorsView.RowHeadersWidth = 50;
            col.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;


            IState      currentState = start.State;
            IPolicy     policy       = A.getPolicy();
            ISearchInfo info         = A.GetSearchInfo();

            if (policy == null)
            {
                MessageBox.Show("No solution found");
            }


            //use policy to find solution

            int             i    = 0;
            int             maxi = 3000;
            double          SumQ = 0;
            DataGridViewRow row;

            while (policy != null && !currentState.Equals(goal.State) && i < maxi)
            {
                row = new DataGridViewRow();

                row.HeaderCell.Value = String.Format("{0}", i + 1);

                IOperator op = policy.action(currentState);

                operatorsView.Rows.Add(row);

                operatorsView.Rows[i].Cells[0].Value = op.Name;

                IOutcome outcome = env.act(currentState, policy.action(currentState));

                currentState = outcome.State;
                stateList.Add(outcome.State);

                SumQ += outcome.Reward;

                i += 1;
            }

            if (i >= maxi)
            {
                MessageBox.Show("No solution found");
                stateList.Clear();
            }
            operatorsView.Update();

            // print solver parameters + results
            col            = new DataGridViewTextBoxColumn();
            col.HeaderText = "Properties";
            ResultView.Columns.Add(col);
            ResultView.RowHeadersWidth = 50;

            col            = new DataGridViewTextBoxColumn();
            col.HeaderText = "Values";
            ResultView.Columns.Add(col);
            ResultView.RowHeadersWidth = 50;
            col.AutoSizeMode           = DataGridViewAutoSizeColumnMode.Fill;

            i = 0;
            foreach (KeyValuePair <string, string> pair in info.SearchResults.Union(info.SearchParameters))
            {
                row = new DataGridViewRow();

                row.HeaderCell.Value = String.Format("{0}", i + 1);

                ResultView.Rows.Add(row);

                ResultView.Rows[i].Cells[0].Value = pair.Key;
                ResultView.Rows[i].Cells[1].Value = pair.Value;
                i += 1;
            }


            //print total reward
            row = new DataGridViewRow();
            row.HeaderCell.Value = String.Format("{0}", i + 1);
            ResultView.Rows.Add(row);
            ResultView.Rows[i].Cells[0].Value = "Cummulative reward";
            ResultView.Rows[i].Cells[1].Value = SumQ.ToString();

            ResultView.Width = col.Width + ResultView.RowHeadersWidth + 20;
            ResultView.Update();

            ConfigureDGV(N);
            NPuzzleState npState = (NPuzzleState)start.State;

            FillDGV(npState.Tiles, N);
        }
Esempio n. 26
0
        public void TestHashSet()
        {
            int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            NPuzzleState <int[]> goalState = new NPuzzleState <int[]>(goal);

            //! -1 (from goal), md = 1
            int[] s1 = { 1, 2, 3, 4, 5, 6, 7, 9, 8 };
            NPuzzleState <int[]> s1State = new NPuzzleState <int[]>(s1);

            //! md = 1
            int[] s7 = { 1, 2, 3, 4, 5, 9, 7, 8, 6 };

            NPuzzleState <int[]> s7State = new NPuzzleState <int[]>(s7);

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

            int[] s8 = { 9, 1, 2, 4, 6, 3, 7, 5, 8 };
            NPuzzleState <int[]>            s8State  = new NPuzzleState <int[]>(s8);
            HashSet <NPuzzleState <int[]> > explored = new HashSet <NPuzzleState <int[]> >();

            Assert.NotNull(explored.Comparer);
            Console.WriteLine(explored.Comparer.ToString());
            explored.Add(goalState);
            explored.Add(s1State);
            explored.Add(s2State);
            explored.Add(s3State);
            //explored.Add(s4);
            //explored.Add(s5State);
            explored.Add(s6State);
            explored.Add(s7State);

            Assert.True(explored.Contains(goalState));
            Assert.True(explored.Contains(s1State));
            Assert.True(explored.Contains(s7State));
            Assert.True(explored.Contains(s2State));
            Assert.True(explored.Contains(s3State));

            Assert.True(s8State.Equals(s6State));
            Assert.AreEqual(s8State.GetHashCode(), s6State.GetHashCode());
            Assert.True(explored.Contains(s8State));
            Assert.False(explored.Contains(s4State));
            Assert.False(explored.Contains(s5State));
        }
Esempio n. 27
0
 private Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> CreateProblem(NPuzzleState <int[]> initial)
 {
     int[] goal = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
     Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int> problem = new Problem.NPuzzleProblem <NPuzzleState <int[]>, int, int>(new NPuzzleState <int[]>(goal), initial);
     return(problem);
 }