Esempio n. 1
0
        public void TestDijkstra()
        {
            // 0 -- 1 -- 2 -- 3
            //  \        |   /
            //    \      | /
            //      4 -- 5
            bool[,] graph1 =
            {
                { false, true,  false, false, true,  false },
                { true,  false, true,  false, false, false },
                { false, true,  false, true,  false, true  },
                { false, false, true,  false, false, true  },
                { true,  false, false, false, false, true  },
                { false, false, true,  true,  true,  false },
            };

            SearchGraph searchGraph1 = SearchGraphFromData(graph1);

            Dictionary <int, GraphNode> graphNodes = GetGraphNodesIdIndex(searchGraph1);


            DistanceLookup distanceLookup = new DistanceLookup(graphNodes.Values.ToList());

            Assert.AreEqual((uint)0, distanceLookup[graphNodes[0].DistancesIndex, graphNodes[0].DistancesIndex], "Failed 0 distance test");
            Assert.AreEqual((uint)2, distanceLookup[graphNodes[0].DistancesIndex, graphNodes[5].DistancesIndex], "Wrong distance");
            Assert.AreEqual((uint)3, distanceLookup[graphNodes[0].DistancesIndex, graphNodes[3].DistancesIndex], "Wrong distance");
        }
Esempio n. 2
0
        public void DijkstraUnconnected()
        {
            // 0 -- 1    2 -- 3
            //           |   /
            //           | /
            //      4 -- 5
            bool[,] graph2 =
            {
                { false, true,  false, false, false, false },
                { true,  false, false, false, false, false },
                { false, false, false, true,  false, true  },
                { false, false, true,  false, false, true  },
                { false, false, false, false, false, true  },
                { false, false, true,  true,  true,  false },
            };
            SearchGraph searchGraph2 = SearchGraphFromData(graph2);
            Dictionary <int, GraphNode> graphNodes2 = GetGraphNodesIdIndex(searchGraph2);
            var mstNodes2 = new List <GraphNode> {
                graphNodes2[0], graphNodes2[2], graphNodes2[4], graphNodes2[3]
            };

            var distances = new DistanceLookup(graphNodes2.Values.ToArray());

            Assert.IsNull(distances.GetShortestPath(mstNodes2[0].DistancesIndex, mstNodes2[3].DistancesIndex));
        }
Esempio n. 3
0
        public void DijkstraUnconnected()
        {
            // 0 -- 1    2 -- 3
            //           |   /
            //           | /
            //      4 -- 5
            bool[,] graph2 =
            {
                { false, true,  false, false, false, false },
                { true,  false, false, false, false, false },
                { false, false, false, true,  false, true  },
                { false, false, true,  false, false, true  },
                { false, false, false, false, false, true  },
                { false, false, true,  true,  true,  false },
            };
            SearchGraph searchGraph2 = SearchGraphFromData(graph2);
            Dictionary <int, GraphNode> graphNodes2 = GetGraphNodesIdIndex(searchGraph2);
            var mstNodes2 = new List <GraphNode> {
                graphNodes2[0], graphNodes2[2], graphNodes2[4], graphNodes2[3]
            };

            var distances = new DistanceLookup();

            try
            {
                var _ = distances[mstNodes2[0], mstNodes2[3]];
            }
            catch (GraphNotConnectedException)
            {
                return;
            }
            Assert.Fail("No exception thrown for disconnected graph");
        }
Esempio n. 4
0
        public void TestDijkstra()
        {
            // TODO: Maybe make the graphs class members.
            /// 0 -- 1 -- 2 -- 3
            ///  \        |   /
            ///    \      | /
            ///      4 -- 5
            bool[,] graph1 =
            {
                { false, true,  false, false, true,  false },
                { true,  false, true,  false, false, false },
                { false, true,  false, true,  false, true  },
                { false, false, true,  false, false, true  },
                { true,  false, false, false, false, true  },
                { false, false, true,  true,  true,  false },
            };

            SearchGraph searchGraph1 = SearchGraphFromData(graph1);

            Dictionary <int, GraphNode> graphNodes = GetGraphNodesIdIndex(searchGraph1);


            DistanceLookup distanceLookup = new DistanceLookup();

            Assert.IsTrue(distanceLookup.GetDistance(graphNodes[0], graphNodes[0]) == 0, "Failed 0 distance test");
            Assert.IsTrue(distanceLookup.GetDistance(graphNodes[0], graphNodes[5]) == 2, "Wrong distance");
            Assert.IsTrue(distanceLookup.GetDistance(graphNodes[0], graphNodes[3]) == 3, "Wrong distance");
        }
Esempio n. 5
0
        public void TestMST()
        {
            // 0 -- 1 -- 2 -- 3
            //  \        |   /
            //    \      | /
            //      4 -- 5 -- 6 -- 7
            bool[,] graph1 =
            {
                { false, true,  false, false, true,  false, false, false },
                { true,  false, true,  false, false, false, false, false },
                { false, true,  false, true,  false, true,  false, false },
                { false, false, true,  false, false, true,  false, false },
                { true,  false, false, false, false, true,  false, false },
                { false, false, true,  true,  true,  false, true,  false },
                { false, false, false, false, false, true,  false, true  },
                { false, false, false, false, false, false, true,  false },
            };

            SearchGraph searchGraph1 = SearchGraphFromData(graph1);

            Dictionary <int, GraphNode> graphNodes1 = GetGraphNodesIdIndex(searchGraph1);
            var distances = new DistanceLookup();

            var mstNodes1 = new List <GraphNode>
            {
                graphNodes1[3], graphNodes1[5], graphNodes1[7], graphNodes1[0]
            };

            distances.CalculateFully(mstNodes1);
            MinimalSpanningTree mst1 = new MinimalSpanningTree(mstNodes1, distances);

            mst1.Span(graphNodes1[0]);

            Assert.AreEqual(3, mst1.SpanningEdges.Count, "Wrong amount of spanning edges");
            var goalEdges = new []
            {
                new [] { 0, 5 }, new [] { 5, 3 }, new [] { 5, 7 }
            };

            foreach (var edge in goalEdges)
            {
                Assert.AreEqual(1,
                                mst1.SpanningEdges.Count(
                                    e =>
                                    (e.Inside.Id == edge[0] && e.Outside.Id == edge[1]) ||
                                    (e.Inside.Id == edge[1] && e.Outside.Id == edge[0])),
                                "Edge " + edge + " not contained exactly once.");
            }
            Assert.AreEqual(6, mst1.GetUsedNodes().Count, "Wrong MST length");
        }
Esempio n. 6
0
        public void TestMST()
        {
            // 0 -- 1 -- 2 -- 3
            //  \        |   /
            //    \      | /
            //      4 -- 5 -- 6 -- 7
            bool[,] graph1 =
            {
                { false, true,  false, false, true,  false, false, false },
                { true,  false, true,  false, false, false, false, false },
                { false, true,  false, true,  false, true,  false, false },
                { false, false, true,  false, false, true,  false, false },
                { true,  false, false, false, false, true,  false, false },
                { false, false, true,  true,  true,  false, true,  false },
                { false, false, false, false, false, true,  false, true  },
                { false, false, false, false, false, false, true,  false },
            };

            SearchGraph searchGraph1 = SearchGraphFromData(graph1);

            Dictionary <int, GraphNode> graphNodes1 = GetGraphNodesIdIndex(searchGraph1);

            var mstNodes1 = new List <GraphNode>
            {
                graphNodes1[3], graphNodes1[5], graphNodes1[7], graphNodes1[0]
            };
            var distances = new DistanceLookup(mstNodes1);
            var mst1      = new MinimalSpanningTree(mstNodes1.Select(n => n.DistancesIndex).ToList(), distances);

            mst1.Span(graphNodes1[0].DistancesIndex);

            Assert.AreEqual(3, mst1.SpanningEdges.Count, "Wrong amount of spanning edges");
            var goalEdges = new[]
            {
                new [] { 0, 5 }, new [] { 5, 3 }, new [] { 5, 7 }
            };

            foreach (var edge in goalEdges)
            {
                Assert.AreEqual(1,
                                mst1.SpanningEdges.Select(e => new Tuple <ushort, ushort>(distances.IndexToNode(e.Inside).Id, distances.IndexToNode(e.Outside).Id)).Count(
                                    t =>
                                    (t.Item1 == edge[0] && t.Item2 == edge[1]) ||
                                    (t.Item1 == edge[1] && t.Item2 == edge[0])),
                                "Edge " + edge + " not contained exactly once.");
            }
        }
Esempio n. 7
0
 public BottleneckSteinerDistanceCalculator(DistanceLookup distances)
 {
     _distances = distances;
 }
Esempio n. 8
0
        public void TestMST()
        {
            /// 0 -- 1 -- 2 -- 3
            ///  \        |   /
            ///    \      | /
            ///      4 -- 5 -- 6 -- 7
            bool[,] graph1 =
            {
                { false, true,  false, false, true,  false, false, false },
                { true,  false, true,  false, false, false, false, false },
                { false, true,  false, true,  false, true,  false, false },
                { false, false, true,  false, false, true,  false, false },
                { true,  false, false, false, false, true,  false, false },
                { false, false, true,  true,  true,  false, true,  false },
                { false, false, false, false, false, true,  false, true  },
                { false, false, false, false, false, false, true,  false },
            };

            SearchGraph searchGraph1 = SearchGraphFromData(graph1);

            Dictionary <int, GraphNode> graphNodes1 = GetGraphNodesIdIndex(searchGraph1);
            DistanceLookup distanceLookup           = new DistanceLookup();

            HashSet <GraphNode> mstNodes1 = new HashSet <GraphNode>
            {
                graphNodes1[3], graphNodes1[5], graphNodes1[7]
            };
            MinimalSpanningTree mst1 = new MinimalSpanningTree(mstNodes1);

            mst1.Span(startFrom: graphNodes1[0]);

            Assert.IsTrue(mst1.SpanningEdges.Count == 3, "Wrong amount of spanning edges");
            /// This can fail even if the mst would be valid! The test only works for
            /// the current implementation of the mst algorithm, but I can't find a
            /// better way to do this with the current data structures...
            Assert.IsTrue(mst1.SpanningEdges[0].inside.Id == 0 && mst1.SpanningEdges[0].outside.Id == 5,
                          "First edge is wrong");
            Assert.IsTrue(mst1.SpanningEdges[1].inside.Id == 5 && mst1.SpanningEdges[1].outside.Id == 3,
                          "Second edge is wrong");
            Assert.IsTrue(mst1.SpanningEdges[2].inside.Id == 5 && mst1.SpanningEdges[2].outside.Id == 7,
                          "Third edge is wrong");
            Assert.IsTrue(mst1.UsedNodeCount == 5, "Wrong MST length");


            /// Test unconnected graph

            /// 0 -- 1    2 -- 3
            ///           |   /
            ///           | /
            ///      4 -- 5
            bool[,] graph2 =
            {
                { false, true,  false, false, false, false },
                { true,  false, false, false, false, false },
                { false, false, false, true,  false, true  },
                { false, false, true,  false, false, true  },
                { false, false, false, false, false, true  },
                { false, false, true,  true,  true,  false },
            };
            SearchGraph searchGraph2 = SearchGraphFromData(graph2);
            Dictionary <int, GraphNode> graphNodes2 = GetGraphNodesIdIndex(searchGraph2);
            HashSet <GraphNode>         mstNodes2   = new HashSet <GraphNode> {
                graphNodes2[0], graphNodes2[2], graphNodes2[4]
            };

            bool pass = false;

            try
            {
                MinimalSpanningTree mst = new MinimalSpanningTree(mstNodes2);
                mst.Span(graphNodes2[3]);
            }
            catch (DistanceLookup.GraphNotConnectedException)
            {
                pass = true;
            }
            Assert.IsTrue(pass, "No exception thrown for disconnected graph");
        }