public void ClearRootVertex()
        {
            var graph     = new AdjacencyGraph <int, Edge <int> >();
            var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);

            ClearRootVertex_Test(algorithm);
        }
        public void SetRootVertex_Throws()
        {
            var graph     = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
            var algorithm = new EulerianTrailAlgorithm <TestVertex, Edge <TestVertex> >(graph);

            SetRootVertex_Throws_Test(algorithm);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Tests all actions for adjacencygraph and filtered graph.
        /// </summary>
        public void Test()
        {
            // The all action algorithms
            AdjacencyGraph g = GraphProvider.Fsm();

            Console.WriteLine("Graph: {0} vertices, {1} edges, {2} eulerian trails",
                              g.VerticesCount,
                              g.EdgesCount,
                              EulerianTrailAlgorithm.ComputeEulerianPathCount(g)
                              );

            // do layout
            EulerianTrailAlgorithm euler = CreateEulerianTrail(g);
            EdgeCollection         temps = euler.AddTemporaryEdges(g);

            Console.WriteLine("Added {0} temporary edges", temps.Count);
            foreach (NamedEdge ne in temps)
            {
                ne.Name = "temporary";
            }
            euler.Compute();
            euler.RemoveTemporaryEdges(g);

            Console.WriteLine("Circuit: {0} edges",
                              euler.Circuit.Count);
            foreach (NamedEdge e in euler.Circuit)
            {
                Console.WriteLine("{0}->{1} ({2})",
                                  (NamedVertex)e.Source,
                                  (NamedVertex)e.Target,
                                  e.Name
                                  );
            }


            Console.WriteLine("Trails:");
            foreach (EdgeCollection ec in euler.Trails(
                         Traversal.FirstVertexIf(g.Vertices, new NameEqualPredicate("S0")))
                     )
            {
                foreach (IEdge edge in ec)
                {
                    Console.WriteLine("{0}->{1}, {2}",
                                      ((NamedVertex)edge.Source).Name,
                                      ((NamedVertex)edge.Target).Name,
                                      ((NamedEdge)edge).Name
                                      );
                }
                Console.WriteLine();
            }


            Console.WriteLine("Testing AdjacencyGraph");
            TestAllActions(GraphProvider.Fsm(), @"../EdgeDfs");

            // testing on filtered graph
            Console.WriteLine("Testing FilteredVertexAndEdgeListGraph");
            TestAllActions(GraphProvider.FilteredFsm(), @"../FilteredEdgeDfs");
        }
        public void AddTemporaryEdges_Throws()
        {
            var graph     = new AdjacencyGraph <int, Edge <int> >();
            var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);

            // ReSharper disable once AssignNullToNotNullAttribute
            Assert.Throws <ArgumentNullException>(() => algorithm.AddTemporaryEdges(null));
        }
        public void ComputeWithRoot()
        {
            var graph = new AdjacencyGraph <int, Edge <int> >();

            graph.AddVertex(0);
            var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);

            ComputeWithRoot_Test(algorithm);
        }
        public void RemoveTemporaryEdges(AdjacencyGraph <int, EquatableEdge <int> > graph)
        {
            var algorithm = new EulerianTrailAlgorithm <int, EquatableEdge <int> >(graph);
            int edgeCount = graph.EdgeCount;

            EquatableEdge <int>[] tmpEdges = algorithm.AddTemporaryEdges(
                (source, target) => new EquatableEdge <int>(source, target));
            Assert.AreEqual(edgeCount + tmpEdges.Length, graph.EdgeCount);

            algorithm.RemoveTemporaryEdges();
            Assert.AreEqual(edgeCount, graph.EdgeCount);
        }
        private static void ComputeTrails <TVertex, TEdge>(
            IMutableVertexAndEdgeListGraph <TVertex, TEdge> graph,
            TVertex root,
            Func <TVertex, TVertex, TEdge> edgeFactory,
            out ICollection <TEdge>[] trails,
            out TEdge[] circuit)
            where TEdge : IEdge <TVertex>
        {
            trails  = new ICollection <TEdge> [0];
            circuit = new TEdge[0];

            int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(graph);

            if (circuitCount == 0)
            {
                return;
            }

            TEdge[] graphEdges = graph.Edges.ToArray();

            var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(graph);

            algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
            TEdge[] augmentedGraphEdges = graph.Edges.ToArray();
            Assert.GreaterOrEqual(augmentedGraphEdges.Length, graphEdges.Length);
            TEdge[] temporaryEdges = augmentedGraphEdges.Except(graphEdges).ToArray();
            Assert.AreEqual(augmentedGraphEdges.Length - graphEdges.Length, temporaryEdges.Length);

            algorithm.Compute();
            trails = algorithm.Trails(root).ToArray();
            algorithm.RemoveTemporaryEdges();
            Assert.IsNotNull(algorithm.Circuit);
            circuit = algorithm.Circuit;

            // Lets make sure all the edges are in the trail
            var edges = new HashSet <TEdge>();

            foreach (TEdge edge in graph.Edges)
            {
                Assert.IsTrue(edges.Add(edge));
            }

            foreach (ICollection <TEdge> trail in trails)
            {
                Assert.AreEqual(graph.EdgeCount, edges.Count);
                QuikGraphAssert.TrueForAll(
                    trail,
                    // Edge in graph or part of temporary ones but is a root
                    edge => edges.Contains(edge) ||
                    (temporaryEdges.Contains(edge) && Equals(edge.Source, root)));
            }
        }
        public void AddTemporaryEdges(
            AdjacencyGraph <int, EquatableEdge <int> > graph,
            EquatableEdge <int>[] expectedTemporaryEdges)
        {
            var algorithm = new EulerianTrailAlgorithm <int, EquatableEdge <int> >(graph);
            int edgeCount = graph.EdgeCount;

            EquatableEdge <int>[] tmpEdges = algorithm.AddTemporaryEdges(
                (source, target) => new EquatableEdge <int>(source, target));
            CollectionAssert.AreEquivalent(expectedTemporaryEdges, tmpEdges);

            Assert.AreEqual(edgeCount + tmpEdges.Length, graph.EdgeCount);
            EquatableEdge <int>[] graphEdges = graph.Edges.ToArray();
            foreach (EquatableEdge <int> edge in tmpEdges)
            {
                Assert.Contains(edge, graphEdges);
            }
        }
        private static void ComputeTrails <TVertex, TEdge>(
            IMutableVertexAndEdgeListGraph <TVertex, TEdge> graph,
            Func <TVertex, TVertex, TEdge> edgeFactory,
            out ICollection <TEdge>[] trails,
            out TEdge[] circuit)
            where TEdge : IEdge <TVertex>
        {
            trails  = new ICollection <TEdge> [0];
            circuit = new TEdge[0];

            int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(graph);

            if (circuitCount == 0)
            {
                return;
            }

            var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(graph);

            algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
            algorithm.Compute();
            trails = algorithm.Trails().ToArray();
            algorithm.RemoveTemporaryEdges();
            Assert.IsNotNull(algorithm.Circuit);
            circuit = algorithm.Circuit;

            // Lets make sure all the edges are in the trail
            var edges = new HashSet <TEdge>();

            foreach (TEdge edge in graph.Edges)
            {
                Assert.IsTrue(edges.Add(edge));
            }

            foreach (ICollection <TEdge> trail in trails)
            {
                Assert.AreEqual(graph.EdgeCount, edges.Count);
                QuikGraphAssert.TrueForAll(
                    trail,
                    edge => edges.Contains(edge));
            }
        }
        private static void ComputeTrail <TVertex, TEdge>(
            [NotNull] IMutableVertexAndEdgeListGraph <TVertex, TEdge> graph,
            [NotNull, InstantHandle] Func <TVertex, TVertex, TEdge> edgeFactory)
            where TEdge : IEdge <TVertex>
        {
            if (graph.VertexCount == 0)
            {
                return;
            }

            int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(graph);

            if (circuitCount == 0)
            {
                return;
            }

            var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(graph);

            algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));
            algorithm.Compute();
            var trails = algorithm.Trails();

            algorithm.RemoveTemporaryEdges();

            // Lets make sure all the edges are in the trail
            var edgeColors = new Dictionary <TEdge, GraphColor>(graph.EdgeCount);

            foreach (TEdge edge in graph.Edges)
            {
                edgeColors.Add(edge, GraphColor.White);
            }

            foreach (ICollection <TEdge> trail in trails)
            {
                foreach (TEdge edge in trail)
                {
                    Assert.IsTrue(edgeColors.ContainsKey(edge));
                }
            }
        }
        public void ComputeTrail(IMutableVertexAndEdgeListGraph<string,Edge<string>> g)
        {
            if (g.VertexCount == 0)
                return;

            GraphConsoleSerializer.DisplayGraph(g);

            int oddCount = 0;
            foreach (string v in g.Vertices)
                if (g.OutDegree(v) % 2 == 0)
                    oddCount++;

            int circuitCount = EulerianTrailAlgorithm<string,Edge<string>>.ComputeEulerianPathCount(g);
            if (circuitCount == 0)
                return;

            EulerianTrailAlgorithm<string, Edge<string>> trail = new EulerianTrailAlgorithm<string, Edge<string>>(g);
            trail.AddTemporaryEdges(new EdgeFactory<string>());
            trail.Compute();
            ICollection<ICollection<Edge<string>>> trails = trail.Trails();
            trail.RemoveTemporaryEdges();

            Console.WriteLine("trails: {0}", trails.Count);
            int index = 0;
            foreach (ICollection<Edge<string>> t in trails)
            {
                Console.WriteLine("trail {0}", index++);
                foreach (Edge<string> edge in t)
                    Console.WriteLine("\t{0}", t);
            }

            // lets make sure all the edges are in the trail
            Dictionary<Edge<string>, GraphColor> edgeColors = new Dictionary<Edge<string>, GraphColor>(g.EdgeCount);
            foreach (Edge<string> edge in g.Edges)
                edgeColors.Add(edge, GraphColor.White);
            foreach (ICollection<Edge<string>> t in trails)
                foreach (Edge<string> edge in t)
                    CollectionAssert.ContainsKey(edgeColors, edge);

        }
        public void Constructor()
        {
            var graph = new AdjacencyGraph <int, Edge <int> >();

            var algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(graph);

            AssertAlgorithmProperties(algorithm, graph);

            algorithm = new EulerianTrailAlgorithm <int, Edge <int> >(null, graph);
            AssertAlgorithmProperties(algorithm, graph);

            #region Local function

            void AssertAlgorithmProperties <TVertex, TEdge>(
                EulerianTrailAlgorithm <TVertex, TEdge> algo,
                IMutableVertexAndEdgeListGraph <TVertex, TEdge> g)
                where TEdge : IEdge <TVertex>
            {
                AssertAlgorithmState(algo, g);
                CollectionAssert.IsEmpty(algo.Circuit);
            }

            #endregion
        }
Exemplo n.º 13
0
        private static string ComputeTrails <TVertex, TEdge>(
            IMutableVertexAndEdgeListGraph <TVertex, TEdge> g,
            TVertex root,
            Func <TVertex, TVertex, TEdge> edgeFactory,
            out ICollection <TEdge>[] trails,
            out TEdge[] circuit)
            where TEdge : IEdge <TVertex>
        {
            trails  = new ICollection <TEdge> [0];
            circuit = new TEdge[0];

            int circuitCount = EulerianTrailAlgorithm <TVertex, TEdge> .ComputeEulerianPathCount(g);

            if (circuitCount == 0)
            {
                return("No Eulerian path found.");
            }

            var algorithm = new EulerianTrailAlgorithm <TVertex, TEdge>(g);

            algorithm.AddTemporaryEdges((s, t) => edgeFactory(s, t));

            algorithm.Compute();
            try
            {
                trails = algorithm.Trails(root).ToArray();
            }
            catch (System.Exception ex)
            {
                return(ex.Message);
            }

            algorithm.RemoveTemporaryEdges();
            circuit = algorithm.Circuit;
            return(null);
        }
 public void ComputeEulerianPathCount_Throws()
 {
     // ReSharper disable once AssignNullToNotNullAttribute
     Assert.Throws <ArgumentNullException>(
         () => EulerianTrailAlgorithm <int, Edge <int> > .ComputeEulerianPathCount(null));
 }
 public int ComputeEulerianPathCount(AdjacencyGraph <int, Edge <int> > graph)
 {
     return(EulerianTrailAlgorithm <int, Edge <int> > .ComputeEulerianPathCount(graph));
 }