コード例 #1
0
        private void Testing(SpanningTreeEnum spanningTreeEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[spanningTreeEnum]);
                reader   = new ReaderWriter.ReaderGraph(testPath, false);
                graph    = reader.ReadFile();

                stringBuilder.AppendLine(spanningTreeEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                stringBuilder.AppendLine("SpanningTree: ");

                List <IEdgeInterface> spanningTreeList = graph.GetGraphProperty().GetSpanningTree();

                foreach (IEdgeInterface edge in spanningTreeList)
                {
                    stringBuilder.AppendLine(edge.ToString());
                }
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(spanningTreeEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #2
0
        /// <summary>
        /// Return a subgraph
        /// If the graph is not initialized throws GraphInitializationException
        /// Time complexity: O(V + E)
        /// Space complexity: O(V + E)
        /// </summary>
        /// <param name="graph">graph</param>
        /// <param name="vertexList">list of vertices which will be in the subgraph</param>
        /// <returns>subgraph</returns>
        public static IGraphInterface SubGraph(IGraphInterface graph, List <IVertexInterface> vertexList)
        {
            // Variable
            IGraphEdgeListInterface subGraph;
            List <IVertexInterface> neighboursList;

            if (!graph.GetIsInitialized())
            {
                throw new MyException.GraphException.GraphInitializationException();
            }

            subGraph = new GraphEdgeList(vertexList.Count);
            subGraph.SetName("Subgraph - " + graph.GetName());

            foreach (IVertexInterface vertex in vertexList)
            {
                neighboursList = graph.Neighbours(vertex).Intersect(vertexList).ToList();

                if (neighboursList.Count == 0)
                {
                    subGraph.AddVertex(vertex.GetUserName());
                    continue;
                }

                foreach (IVertexInterface neighbour in neighboursList)
                {
                    subGraph.AddEdge(vertex.GetUserName(), neighbour.GetUserName());
                }
            }

            subGraph.InitializeGraph();

            return(subGraph);
        }
コード例 #3
0
ファイル: GraphClass.cs プロジェクト: Illner/GraphColoring
        public static GraphClassEnum GetGraphClass(IGraphInterface graph)
        {
            if (IsCompleteGraph(graph))
            {
                return(GraphClassEnum.completeGraph);
            }

            if (IsTreeGraph(graph))
            {
                return(GraphClassEnum.treeGraph);
            }

            if (IsCycleGraph(graph))
            {
                return(GraphClassEnum.cycleGraph);
            }

            Tuple <bool, bool> bipartiteResult = IsBipartiteGraph(graph);

            if (bipartiteResult.Item1)
            {
                if (bipartiteResult.Item2)
                {
                    return(GraphClassEnum.completeBipartiteGraph);
                }

                return(GraphClassEnum.bipartiteGraph);
            }

            return(GraphClassEnum.none);
        }
コード例 #4
0
ファイル: SubGraphTest.cs プロジェクト: Illner/GraphColoring
        private void Testing(SubGraphEnum subGraphEnum)
        {
            try
            {
                testPath      = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[subGraphEnum].Item1);
                countVertices = testsDictionary[subGraphEnum].Item2;

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(subGraphEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                IGraphInterface subGraph = GraphOperation.SubGraph(graph, graph.AllVertices().Take(countVertices).ToList());

                stringBuilder.AppendLine("Subgraph created.");
                stringBuilder.AppendLine(subGraph.ToString());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(subGraphEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #5
0
        private void Testing(ChordalTestEnum chordalEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[chordalEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(chordalEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                stringBuilder.AppendLine("isChordal " + graph.GetGraphProperty().GetIsChordal());

                foreach (IVertexInterface vertex in graph.GetGraphProperty().GetPerfectEliminationOrdering())
                {
                    stringBuilder.AppendLine("- " + vertex.GetIdentifier());
                }
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(chordalEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
            catch (MyException.GraphException.GraphIsNotConnected e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #6
0
        private void Testing(ClassEnum classEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[classEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(classEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                GraphClass.GraphClassEnum graphClassEnum = GraphClass.GetGraphClass(graph);

                stringBuilder.AppendLine("Graph class: " + graphClassEnum.ToString());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(classEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #7
0
ファイル: CycleTest.cs プロジェクト: Illner/GraphColoring
        private void Testing(CycleEnum cycleEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[cycleEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(cycleEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                stringBuilder.AppendLine("Is graph cyclic: " + graph.GetGraphProperty().GetIsCyclic());
                stringBuilder.AppendLine("Gridth: " + graph.GetGraphProperty().GetGirth());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(cycleEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #8
0
        private void Testing(ComplementEnum complementEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[complementEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(complementEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                IGraphInterface graphComplement = GraphOperation.ComplementGraph(graph);

                stringBuilder.AppendLine("Complement graph.");
                stringBuilder.AppendLine(graphComplement.ToString());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(complementEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #9
0
        private void Testing(ModificationEnum modificationEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[modificationEnum]);
                reader   = new ReaderWriter.ReaderGraph(testPath, false);
                graph    = reader.ReadFile();

                stringBuilder.AppendLine(modificationEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                switch (modificationEnum)
                {
                case ModificationEnum.valid:
                    Valid(graph);
                    break;

                case ModificationEnum.invalid:
                    Invalid(graph);
                    break;

                default:
                    throw new MyException.TestsException.TestsMissingTestException(modificationEnum.ToString());
                }

                stringBuilder.AppendLine("Graph modified.");
                stringBuilder.AppendLine(graph.ToString());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(modificationEnum.ToString());
            }
        }
コード例 #10
0
ファイル: ComponentTest.cs プロジェクト: Illner/GraphColoring
        private void Testing(ComponentEnum componentEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[componentEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(componentEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                stringBuilder.AppendLine("Number of components: " + graph.GetGraphProperty().GetCountComponents());
                stringBuilder.AppendLine("Is graph connected: " + graph.GetGraphProperty().GetIsConnected());
                stringBuilder.AppendLine("Circuit rank: " + graph.GetGraphProperty().GetCircuitRank());

                graphComponentList = graph.GetGraphProperty().GetComponents();

                foreach (Graph graphComponent in graphComponentList)
                {
                    stringBuilder.AppendLine("Graph component.");
                    stringBuilder.AppendLine(graphComponent.ToString());
                }
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(componentEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #11
0
ファイル: GraphClass.cs プロジェクト: Illner/GraphColoring
        /// <summary>
        /// Return true if the graph is complete graph
        /// Time complexity: O(1)
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>true if the graph is complete graph, otherwise false</returns>
        public static bool IsCompleteGraph(IGraphInterface graph)
        {
            // |E| = (|V|)C(2)
            if (graph.GetGraphProperty().GetCountEdges() == MyMath.MyMath.nCr(graph.GetGraphProperty().GetCountVertices(), 2))
            {
                return(true);
            }

            return(false);
        }
コード例 #12
0
ファイル: GraphClass.cs プロジェクト: Illner/GraphColoring
        /// <summary>
        /// Return true if the graph is tree
        /// Time complexity: O(V + E)
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>true if the graph is tree, otherwise false</returns>
        public static bool IsTreeGraph(IGraphInterface graph)
        {
            // Graph is connected and |E| = |V| - 1 // Euler's formula
            if ((graph.GetGraphProperty().GetIsConnected()) &&
                (graph.GetGraphProperty().GetCountEdges() == graph.GetGraphProperty().GetCountVertices() - 1))
            {
                return(true);
            }

            return(false);
        }
コード例 #13
0
        private void Testing(DegreeSequenceEnum degreeSequenceEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[degreeSequenceEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(degreeSequenceEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                // Sorted
                List <int> degreeSequenceList = graph.GetGraphProperty().GetDegreeSequenceInt(true);

                stringBuilder.AppendLine("Degree sequence");
                foreach (int degree in degreeSequenceList)
                {
                    stringBuilder.Append(degree + " ");
                }

                stringBuilder.AppendLine("");
                stringBuilder.AppendLine("Minimum vertex degree: " + graph.GetGraphProperty().GetMinimumVertexDegree());
                stringBuilder.AppendLine("Maximum vertex degree: " + graph.GetGraphProperty().GetMaximumVertexDegree());
                stringBuilder.AppendLine("Average vertex degree: " + graph.GetGraphProperty().GetAverageVertexDegree());
                stringBuilder.AppendLine("Is graph regular: " + graph.GetGraphProperty().GetIsRegular());

                graph.GetGraphProperty().Reset();

                // Unsorted
                degreeSequenceList = graph.GetGraphProperty().GetDegreeSequenceInt(false);

                stringBuilder.AppendLine("Degree sequence");
                foreach (int degree in degreeSequenceList)
                {
                    stringBuilder.Append(degree + " ");
                }

                stringBuilder.AppendLine("");
                stringBuilder.AppendLine("Minimum vertex degree: " + graph.GetGraphProperty().GetMinimumVertexDegree());
                stringBuilder.AppendLine("Maximum vertex degree: " + graph.GetGraphProperty().GetMaximumVertexDegree());
                stringBuilder.AppendLine("Average vertex degree: " + graph.GetGraphProperty().GetAverageVertexDegree());
                stringBuilder.AppendLine("Is graph regular: " + graph.GetGraphProperty().GetIsRegular());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(degreeSequenceEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #14
0
ファイル: GraphClass.cs プロジェクト: Illner/GraphColoring
        /// <summary>
        /// Return true if the graph is cycle
        /// Time complexity: O(V + E)
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>true if the graph is cycle, otherwise false</returns>
        public static bool IsCycleGraph(IGraphInterface graph)
        {
            // Graph is connected and 2-regular
            if ((graph.GetGraphProperty().GetIsConnected()) &&
                (graph.GetGraphProperty().GetIsRegular()) &&
                (graph.GetGraphProperty().GetMaximumVertexDegree() == 2))
            {
                return(true);
            }

            return(false);
        }
コード例 #15
0
        private void Testing(ColoredGraphEnum coloredGraphEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[coloredGraphEnum]);
                reader   = new ReaderWriter.ReaderGraph(testPath, false);
                graph    = reader.ReadFile();

                stringBuilder.AppendLine(coloredGraphEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                switch (coloredGraphEnum)
                {
                case ColoredGraphEnum.valid:
                    Valid(graph);
                    stringBuilder.AppendLine("Graph modified.");
                    break;

                case ColoredGraphEnum.invalid:
                    Invalid(graph);
                    stringBuilder.AppendLine("Graph modified.");
                    break;

                case ColoredGraphEnum.interchange1:
                case ColoredGraphEnum.interchange2:
                case ColoredGraphEnum.interchange3:
                case ColoredGraphEnum.interchange4:
                case ColoredGraphEnum.interchange5:
                    graph.GetColoredGraph().GreedyColoring(graph.AllVertices(), GraphColoringAlgorithm.GraphColoringAlgorithm.GraphColoringAlgorithInterchangeEnum.interchange);
                    stringBuilder.AppendLine("Graph colored.");
                    break;

                default:
                    throw new MyException.TestsException.TestsMissingTestException(coloredGraphEnum.ToString());
                }

                stringBuilder.AppendLine(graph.GetColoredGraph().ToString());
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(coloredGraphEnum.ToString());
            }
            catch (MyException.GraphException.GraphException e)
            {
                stringBuilder.AppendLine(e.ToString());
            }
        }
コード例 #16
0
        /// <summary>
        /// Return a complement graph
        /// If the graph is not initialized throws GraphInitializationException
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>complement graph</returns>
        public static IGraphInterface ComplementGraph(IGraphInterface graph)
        {
            // Variable
            IGraphEdgeListInterface complementGraph;
            List <IVertexInterface> vertexList;
            List <IVertexInterface> neighboursList;
            List <IVertexInterface> intersectionVertexAndNeighboursList;

            if (!graph.GetIsInitialized())
            {
                throw new MyException.GraphException.GraphInitializationException();
            }

            complementGraph = new GraphEdgeList(graph.GetRealCountVertices());
            complementGraph.SetName("Complement graph - " + graph.GetName());
            vertexList = graph.AllVertices();

            // Add edges
            foreach (IVertexInterface vertex in vertexList)
            {
                neighboursList = graph.Neighbours(vertex);
                neighboursList.Add(vertex);

                intersectionVertexAndNeighboursList = vertexList.FindAll(v => !neighboursList.Contains(v)).ToList();

                if (intersectionVertexAndNeighboursList.Count == 0)
                {
                    complementGraph.AddVertex(vertex.GetUserName());
                    continue;
                }

                foreach (IVertexInterface neighbour in intersectionVertexAndNeighboursList)
                {
                    complementGraph.AddEdge(vertex.GetUserName(), neighbour.GetUserName());
                }
            }

            complementGraph.InitializeGraph();

            return(complementGraph);
        }
コード例 #17
0
        private void Testing(BridgesCutVerticesEnum bridgesCutVerticesEnum)
        {
            try
            {
                testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[bridgesCutVerticesEnum]);

                reader = new ReaderWriter.ReaderGraph(testPath, false);
                graph  = reader.ReadFile();

                stringBuilder.AppendLine(bridgesCutVerticesEnum.ToString());
                stringBuilder.AppendLine("Graph created.");
                stringBuilder.AppendLine(graph.ToString());

                stringBuilder.AppendLine("Number of cut vertices: " + graph.GetGraphProperty().GetCutVertices().Count);
                stringBuilder.AppendLine("Cut vertices: ");
                graph.GetGraphProperty().GetCutVertices().ForEach(x => { stringBuilder.AppendLine(x.GetUserName()); });
                stringBuilder.AppendLine("Number of bridges: " + graph.GetGraphProperty().GetBridges().Count);
                stringBuilder.AppendLine("Bridges: ");
                graph.GetGraphProperty().GetBridges().ForEach(x => { stringBuilder.AppendLine(x.GetVertex1().GetUserName() + " " + x.GetVertex2().GetUserName()); });

                graph.GetGraphProperty().Reset();
                stringBuilder.AppendLine("Number of cut vertices: " + graph.GetGraphProperty().GetCutVertices().Count);
                stringBuilder.AppendLine("Number of bridges: " + graph.GetGraphProperty().GetBridges().Count);
            }
            catch (KeyNotFoundException)
            {
                throw new MyException.TestsException.TestsMissingTestException(bridgesCutVerticesEnum.ToString());
            }
            catch (MyException.ReaderWriterException.ReaderWriterException e)
            {
                stringBuilder.AppendLine(e.Message);
            }
            catch (MyException.GraphException.GraphIsNotConnected e)
            {
                stringBuilder.AppendLine(e.Message);
            }
        }
コード例 #18
0
        /// <summary>
        /// Copy a graph
        /// If the graph is not initialized throws GraphInitializationException
        /// Time complexity: O(V + E)
        /// Space complexity: O(V + E)
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>graph copy</returns>
        public static IGraphInterface CopyGraph(IGraphInterface graph)
        {
            if (!graph.GetIsInitialized())
            {
                throw new MyException.GraphException.GraphInitializationException();
            }

            // Variable
            IGraphEdgeListInterface graphCopy;
            List <IVertexInterface> neighboursVertexList;
            List <IVertexInterface> allVerticesList = graph.AllVertices();

            graphCopy = new GraphEdgeList(graph.GetGraphProperty().GetCountVertices());

            graphCopy.SetName(graph.GetName());

            foreach (IVertexInterface vertex1 in allVerticesList)
            {
                neighboursVertexList = graph.Neighbours(vertex1);

                if (neighboursVertexList.Count == 0)
                {
                    graphCopy.AddVertex(vertex1.GetUserName());
                    continue;
                }

                foreach (IVertexInterface vertex2 in neighboursVertexList)
                {
                    graphCopy.AddEdge(vertex1.GetUserName(), vertex2.GetUserName());
                }
            }

            graphCopy.InitializeGraph();

            return(graphCopy);
        }
コード例 #19
0
ファイル: GraphProperty.cs プロジェクト: Illner/GraphColoring
        public void VertexExpansion(IVertexInterface vertex)
        {
            // Component
            if (componentsList != null)
            {
                // Need change => copies of component
                if (countComponents > 1)
                {
                    // Get component which contains the vertex
                    IVertexInterface myVertexComponent = null;
                    IGraphInterface  myComponentGraph  = null;
                    foreach (IGraphInterface componentGraph in componentsList)
                    {
                        if (componentGraph.ExistsUserName(vertex.GetUserName()))
                        {
                            myComponentGraph  = componentGraph;
                            myVertexComponent = myComponentGraph.GetVertexByUserName(vertex.GetUserName());
                            break;
                        }
                    }

                    myComponentGraph.VertexExpansion(myVertexComponent);
                }

                //componentsList = componentsList;
                //countComponents = countComponents;
                //isConnected = isConnected;
            }

            // Properties
            isCyclic   = null;
            isEulerian = EulerianGraphEnum.undefined;

            // IntegralInvariants
            circuitRank    = null;
            girth          = null;
            cayleysFormula = null;

            // SequencesAndPolynomialsOthers
            if (isConnected != null && !(bool)isConnected)
            {
                spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>();
            }
            else
            {
                spanningTreeBFS = null;
            }
            matching    = null;
            cutVertices = null;
            bridges     = null;

            // DegreeSequence
            degreeSequence         = null;
            maximumVertexDegree    = null;
            minimumVertexDegree    = null;
            averageVertexDegree    = null;
            medianVertexDegree     = null;
            isDegreeSequenceSorted = false;
            isRegular = null;

            // Chordal
            if (isChordal.HasValue && (bool)isChordal)
            {
                isChordal = null;
                perfectEliminationOrderingList = null;
                righNeighborhoodDictionary     = null;
            }

            // GraphClass
            graphClass = GraphClass.GraphClass.GraphClassEnum.undefined;
        }
コード例 #20
0
ファイル: GraphProperty.cs プロジェクト: Illner/GraphColoring
        public void VertexDelete(IVertexInterface vertex)
        {
            // Component
            if (componentsList != null)
            {
                // More components => copies of components
                if (countComponents > 1)
                {
                    // Get component which contains the vertex
                    IVertexInterface myVertexComponent = null;
                    IGraphInterface  myComponentGraph  = null;
                    foreach (IGraphInterface componentGraph in componentsList)
                    {
                        if (componentGraph.ExistsUserName(vertex.GetUserName()))
                        {
                            myComponentGraph  = componentGraph;
                            myVertexComponent = myComponentGraph.GetVertexByUserName(vertex.GetUserName());
                            break;
                        }
                    }

                    // The vertex is component
                    if (myComponentGraph.CountNeighbours(myVertexComponent) == 0)
                    {
                        componentsList.Remove(myComponentGraph);
                        countComponents--;
                        isConnected = countComponents == 1 ? true : false;
                    }
                    // The vertex is in a component with another vertices
                    else
                    {
                        componentsList  = null;
                        countComponents = null;
                        isConnected     = null;
                    }
                }
                else
                {
                    if (cutVertices != null && !cutVertices.Contains(vertex))
                    {
                        //componentsList = componentsList;
                        //countComponents = countComponents;
                        //isConnected = isConnected;
                    }
                    else
                    {
                        componentsList  = null;
                        countComponents = null;
                        isConnected     = null;
                    }
                }
            }

            // Properties
            if (isCyclic != null && (bool)isCyclic)
            {
                isCyclic = null;
            }
            if (isConnected != null && !(bool)isConnected)
            {
                isEulerian = EulerianGraphEnum.notEulerian;
            }
            else
            {
                isEulerian = EulerianGraphEnum.undefined;
            }

            // IntegralInvariants
            circuitRank    = null;
            girth          = null;
            cayleysFormula = null;

            // SequencesAndPolynomialsOthers
            if (isConnected != null && !(bool)isConnected)
            {
                spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>();
            }
            else
            {
                spanningTreeBFS = null;
            }
            matching    = null;
            cutVertices = null;
            bridges     = null;

            // DegreeSequence
            degreeSequence         = null;
            maximumVertexDegree    = null;
            minimumVertexDegree    = null;
            averageVertexDegree    = null;
            medianVertexDegree     = null;
            isDegreeSequenceSorted = false;
            isRegular = null;

            // Chordal
            isChordal = null;
            perfectEliminationOrderingList = null;
            righNeighborhoodDictionary     = null;

            // GraphClass
            graphClass = GraphClass.GraphClass.GraphClassEnum.undefined;
        }
コード例 #21
0
 public Graph(IGraphInterface graph)
 {
     InitializeComponent();
     InternalGraph = graph;
 }
コード例 #22
0
        private void Valid(IGraphInterface graph)
        {
            // Variable
            List <IVertexInterface> vertexList   = graph.AllVertices();
            IColoredGraphInterface  coloredGraph = graph.GetColoredGraph();

            if (coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.First(), coloredGraph.GreedyColoring(vertexList.First()));

            if (coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ResetColorVertex(vertexList.First());

            coloredGraph.GreedyColoring(vertexList);

            if (!coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.DeinitializationColoredGraph();
            if (!coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }
            coloredGraph.DeinitializationColoredGraph();

            coloredGraph.ResetColors();
            coloredGraph.ResetColors();

            if (coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.First(), 1);
            coloredGraph.ColorVertex(vertexList.ElementAt(1), 1);

            if (coloredGraph.CheckValidColor().Count == 0)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.First(), 2);

            if (!coloredGraph.IsVertexColored(vertexList.First()))
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.IsVertexColored(vertexList.ElementAt(2)))
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ResetColorVertex(vertexList.First());

            if (coloredGraph.IsVertexColored(vertexList.First()))
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ResetColorVertex(vertexList.ElementAt(2));

            if (coloredGraph.IsVertexColored(vertexList.ElementAt(2)))
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.First(), 1);

            if (coloredGraph.CheckValidColor(vertexList.First()))
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (!coloredGraph.CheckValidColor(vertexList.ElementAt(2)))
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GreedyColoring(vertexList.First()) != 2)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GetUnColoredVertexList().Count != 4)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GetColoredVertexList().Count != 2)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GetCountUsedColors() != 1)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.GreedyColoring(vertexList);

            if (coloredGraph.GetCountUsedColors() != 2)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.First(), VertexExtended.GetDefaultColor());

            if (coloredGraph.CheckValidColor().Count != 0)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.GreedyColoring(vertexList);
            coloredGraph.InitializeColoredGraph();

            if (!coloredGraph.GetIsInitializedColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            graph.VertexAdd(new Vertex());

            if (coloredGraph.GetIsInitializedColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            vertexList = graph.AllVertices();

            if (vertexList.Last().GetColor() != VertexExtended.GetDefaultColor())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.Last(), 2);
            coloredGraph.ColorVertex(vertexList.First(), 2);

            if (coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.GreedyColoring(vertexList);

            if (!coloredGraph.InitializeColoredGraph())
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            graph.VertexDelete(vertexList.Last());
            graph.VertexAdd(new Vertex());
            vertexList = graph.AllVertices();

            if (coloredGraph.GetColoredVertexList().Count != 6)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GetUnColoredVertexList().Count != 1)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            coloredGraph.ColorVertex(vertexList.Last(), 3);

            if (coloredGraph.GetCountUsedColors() != 3)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            graph.VertexDelete(vertexList.Last());

            if (coloredGraph.GetColoredVertexList().Count != 6)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GetUnColoredVertexList().Count != 0)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }

            if (coloredGraph.GetCountUsedColors() != 2)
            {
                throw new MyException.TestsException.SomethingWrongTestException();
            }
        }
コード例 #23
0
        /// <summary>
        /// Return a line graph
        /// If the graph is not initialized throws GraphInitializationException
        /// If teh graph has 0 edges throws GraphLineGraphInvalidCountOfEdges
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>line graf</returns>
        public static IGraphInterface LineGraph(IGraphInterface graph)
        {
            // Variable
            int    idVertex1, idVertex2;
            string idNewVertex, userNameNewVertex;
            string userNameVertex1, userNameVertex2;
            IGraphEdgeListInterface lineGraph;
            List <IVertexInterface> vertexList;
            List <IVertexInterface> neighboursList;
            Dictionary <string, IVertexInterface> vertexMap;
            List <IVertexInterface> neighboursNewList;

            if (!graph.GetIsInitialized())
            {
                throw new MyException.GraphException.GraphInitializationException();
            }

            if (graph.GetGraphProperty().GetCountEdges() == 0)
            {
                throw new MyException.GraphException.GraphLineGraphInvalidCountOfEdges(graph.GetGraphProperty().GetCountEdges().ToString());
            }

            lineGraph = new GraphEdgeList(graph.GetGraphProperty().GetCountEdges());
            lineGraph.SetName("Line graph - " + graph.GetName());

            vertexMap  = new Dictionary <string, IVertexInterface>();
            vertexList = graph.AllVertices();

            foreach (IVertexInterface vertex in vertexList)
            {
                idVertex1       = vertex.GetIdentifier();
                userNameVertex1 = vertex.GetUserName();
                neighboursList  = graph.Neighbours(vertex);

                neighboursNewList = new List <IVertexInterface>();

                foreach (IVertexInterface neighbour in neighboursList)
                {
                    idVertex2       = neighbour.GetIdentifier();
                    userNameVertex2 = neighbour.GetUserName();

                    if (idVertex1 < idVertex2)
                    {
                        idNewVertex       = idVertex1.ToString() + idVertex2.ToString();
                        userNameNewVertex = userNameVertex1 + userNameVertex2;
                    }
                    else
                    {
                        idNewVertex       = idVertex2.ToString() + idVertex1.ToString();
                        userNameNewVertex = userNameVertex2 + userNameVertex1;
                    }

                    if (!vertexMap.TryGetValue(idNewVertex, out IVertexInterface newVertex))
                    {
                        newVertex = new Vertex(userNameNewVertex);
                        vertexMap.Add(idNewVertex, newVertex);
                    }

                    neighboursNewList.Add(newVertex);
                }

                if (neighboursList.Count == 1)
                {
                    lineGraph.AddVertex(neighboursNewList.First().GetUserName());
                    continue;
                }

                for (int i = 0; i < neighboursNewList.Count - 1; i++)
                {
                    for (int j = i + 1; j < neighboursNewList.Count; j++)
                    {
                        lineGraph.AddEdge(neighboursNewList[i].GetUserName(), neighboursNewList[j].GetUserName());
                    }
                }
            }

            lineGraph.InitializeGraph();

            return(lineGraph);
        }
コード例 #24
0
        private void Invalid(IGraphInterface graph)
        {
            // Variable
            List <IVertexInterface> vertexList   = graph.AllVertices();
            IColoredGraphInterface  coloredGraph = graph.GetColoredGraph();

            coloredGraph.GreedyColoring(vertexList);
            coloredGraph.InitializeColoredGraph();

            // VertexColor - initialization
            stringBuilder.AppendLine("VertexColor - initialization");
            try { coloredGraph.ColorVertex(vertexList.First(), 2); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // GreedingColoring - initialization
            stringBuilder.AppendLine("GreedyColoring - initialization");
            try { coloredGraph.GreedyColoring(vertexList); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // ResetColorVertex - initialization
            stringBuilder.AppendLine("Reset - initialization");
            try { coloredGraph.ResetColorVertex(vertexList.First()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Reset - initialization
            stringBuilder.AppendLine("Reset - initialization");
            try { coloredGraph.ResetColors(); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Initialization - initialization
            stringBuilder.AppendLine("Initialization - initialization");
            try { coloredGraph.InitializeColoredGraph(); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            coloredGraph.DeinitializationColoredGraph();

            // Deinitialization - initialization
            stringBuilder.AppendLine("Deinitialization - initialization");
            try { coloredGraph.DeinitializationColoredGraph(); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // ColorVertex - Doesn't exist
            stringBuilder.AppendLine("VertexColor - Doesn't exist");
            try { coloredGraph.ColorVertex(new Vertex(), 3); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // GreedyColoring - Doesn't exist
            stringBuilder.AppendLine("GreedyColoring - Doesn't exist");
            try { coloredGraph.GreedyColoring(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // CheckValidColor - Doesn't exist
            stringBuilder.AppendLine("CheckValidColor - Doesn't exist");
            try { coloredGraph.CheckValidColor(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // IsVertexColored - Doesn't exist
            stringBuilder.AppendLine("IsVertexColored - Doesn't exist");
            try { coloredGraph.IsVertexColored(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // GetColorVertex - Doesn't exist
            stringBuilder.AppendLine("GetColorVertex - Doesn't exist");
            try { coloredGraph.GetColorVertex(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }
        }
コード例 #25
0
        private void Valid(IGraphInterface graph)
        {
            // Variable
            List <IVertexInterface> vertexList = graph.AllVertices();

            graph.VertexContraction(vertexList.First());
            vertexList = graph.AllVertices();

            graph.VertexSuppression(vertexList.First());
            vertexList = graph.AllVertices();

            graph.VertexExpansion(vertexList.First());
            vertexList = graph.AllVertices();

            graph.VertexSuppression(vertexList.Last());
            vertexList = graph.AllVertices();

            graph.VertexDelete(vertexList.First());
            vertexList = graph.AllVertices();

            graph.VertexSuppression(vertexList.Last());
            vertexList = graph.AllVertices();

            IVertexInterface v1 = new Vertex("V1");

            graph.VertexAdd(v1);
            vertexList = graph.AllVertices();

            graph.EdgeAdd(new Edge(vertexList.First(), v1));
            vertexList = graph.AllVertices();

            graph.VertexContraction(v1);
            vertexList = graph.AllVertices();

            graph.EdgeSubdivision(new Edge(vertexList.First(), vertexList.Skip(1).First()));
            vertexList = graph.AllVertices();

            graph.EdgeAdd(new Edge(vertexList.First(), vertexList.Skip(1).First()));
            vertexList = graph.AllVertices();

            graph.EdgeContraction(new Edge(vertexList.First(), vertexList.Skip(1).First()));
            vertexList = graph.AllVertices();

            graph.EdgeDelete(new Edge(vertexList.First(), vertexList.Skip(1).First()));
            vertexList = graph.AllVertices();

            graph.VertexDelete(vertexList.Skip(1).First());
            vertexList = graph.AllVertices();

            graph.VertexSuppression(vertexList.First());
            vertexList = graph.AllVertices();

            graph.VertexDelete(vertexList.First());
            vertexList = graph.AllVertices();

            graph.VertexExpansion(vertexList.First());
            vertexList = graph.AllVertices();

            graph.EdgeContraction(new Edge(vertexList.First(), vertexList.Skip(1).First()));
            vertexList = graph.AllVertices();

            IVertexInterface v2 = new Vertex("V2");

            graph.VertexAdd(v2);
            vertexList = graph.AllVertices();

            graph.VertexDelete(vertexList.Skip(1).First());

            graph.VertexAdd(new Vertex("V3"));
        }
コード例 #26
0
ファイル: GraphProperty.cs プロジェクト: Illner/GraphColoring
        public void EdgeDelete(IEdgeInterface edge)
        {
            // Variable
            IVertexInterface vertex1 = graph.GetVertexByUserName(edge.GetVertex1().GetUserName());
            IVertexInterface vertex2 = graph.GetVertexByUserName(edge.GetVertex2().GetUserName());

            // Component
            if (componentsList != null)
            {
                if (countComponents > 1)
                {
                    // Get component which contains the vertex
                    IGraphInterface myComponentGraph = null;
                    foreach (IGraphInterface componentGraph in componentsList)
                    {
                        if (componentGraph.ExistsUserName(vertex1.GetUserName()))
                        {
                            myComponentGraph = componentGraph;
                            break;
                        }
                    }

                    myComponentGraph.EdgeDelete(new Edge(myComponentGraph.GetVertexByUserName(vertex1.GetUserName()), myComponentGraph.GetVertexByUserName(vertex2.GetUserName())));

                    componentsList  = null;
                    countComponents = null;
                    isConnected     = null;
                }
                else
                {
                    if (bridges != null)
                    {
                        // The edge is a bridge
                        if (bridges.Any(e => ((e.GetVertex1().Equals(vertex1) && e.GetVertex2().Equals(vertex2)) ||
                                              (e.GetVertex1().Equals(vertex2) && e.GetVertex2().Equals(vertex1)))))
                        {
                            componentsList  = null;
                            countComponents = null;
                            isConnected     = null;
                        }
                        // The edge isn't a bridge
                        else
                        {
                            //componentsList = componentsList;
                            //countComponents = countComponents;
                            //isConnected = isConnected;
                        }
                    }
                }
            }

            // Properties
            if (isCyclic != null && !(bool)isCyclic)
            {
                isCyclic = false;
            }
            else
            {
                isCyclic = null;
            }
            if (isEulerian == EulerianGraphEnum.eulerian)
            {
                isEulerian = EulerianGraphEnum.semiEulerian;
            }
            else
            {
                isEulerian = EulerianGraphEnum.undefined;
            }

            // IntegralInvariants
            circuitRank = null;
            if (girth != null && girth > 2)
            {
                girth = null;
            }
            //cayleysFormula = cayleysFormula;

            // SequencesAndPolynomialsOthers
            if (isConnected != null && !(bool)isConnected)
            {
                spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>();
            }
            else
            {
                spanningTreeBFS = null;
            }
            matching    = null;
            cutVertices = null;
            bridges     = null;

            // DegreeSequence
            if (degreeSequence != null)
            {
                int countNeighbourVertex1 = graph.CountNeighbours(vertex1);
                int countNeighbourVertex2 = graph.CountNeighbours(vertex2);
                if (!isDegreeSequenceSorted)
                {
                    // Variable
                    int index1, index2;

                    index1 = degreeSequenceInt.FindIndex(i => i == (countNeighbourVertex1 + 1));
                    degreeSequenceInt[index1] = countNeighbourVertex1;
                    index2 = degreeSequenceInt.FindIndex(i => i == (countNeighbourVertex2 + 1));
                    degreeSequenceInt[index2] = countNeighbourVertex2;

                    index1 = degreeSequence.FindIndex(p => p.Key == vertex1);
                    index2 = degreeSequence.FindIndex(p => p.Key == vertex2);
                    degreeSequence[index1] = new KeyValuePair <IVertexInterface, int>(vertex1, countNeighbourVertex1);
                    degreeSequence[index2] = new KeyValuePair <IVertexInterface, int>(vertex2, countNeighbourVertex2);
                }
                else
                {
                    degreeSequence         = null;
                    degreeSequenceVertex   = null;
                    degreeSequenceInt      = null;
                    isDegreeSequenceSorted = false;
                }

                if (minimumVertexDegree.HasValue)
                {
                    if (countNeighbourVertex1 < minimumVertexDegree)
                    {
                        minimumVertexDegree = countNeighbourVertex1;
                    }
                    if (countNeighbourVertex2 < minimumVertexDegree)
                    {
                        minimumVertexDegree = countNeighbourVertex2;
                    }
                }

                if (maximumVertexDegree.HasValue)
                {
                    if (((countNeighbourVertex1 + 1) == maximumVertexDegree) ||
                        ((countNeighbourVertex2 + 1) == maximumVertexDegree))
                    {
                        maximumVertexDegree = null;
                    }
                }

                averageVertexDegree = null;
                medianVertexDegree  = null;
                isRegular           = null;
            }

            // Chordal
            isChordal = null;
            perfectEliminationOrderingList = null;
            righNeighborhoodDictionary     = null;

            // GraphClass
            graphClass = GraphClass.GraphClass.GraphClassEnum.undefined;
        }
コード例 #27
0
ファイル: GraphClass.cs プロジェクト: Illner/GraphColoring
        /// <summary>
        /// Return true if the graph is (complete) bipartite
        /// Time complexity: O(V + E)
        /// </summary>
        /// <param name="graph">graph</param>
        /// <returns>(bool, bool) - the first item stands for bipartite and the second item stands for complete
        /// (true, true) - complete bipartite graph
        /// (true, false) - bipartite graph
        /// (false, - ) - the graph is not (complete) bipartite</returns>
        public static Tuple <bool, bool> IsBipartiteGraph(IGraphInterface graph)
        {
            // Variable
            IVertexInterface        vertex;
            List <IVertexInterface> neighboursVertexList;
            bool isFirstPartite, isBipartite = true;

            HashSet <IVertexInterface> firstPartite  = new HashSet <IVertexInterface>();
            HashSet <IVertexInterface> secondPartite = new HashSet <IVertexInterface>();
            Queue <IVertexInterface>   vertexQueue   = new Queue <IVertexInterface>();

            vertex = graph.GetFirstVertex();
            vertexQueue.Enqueue(vertex);
            firstPartite.Add(vertex);

            while (vertexQueue.Count != 0)
            {
                vertex = vertexQueue.Dequeue();
                neighboursVertexList = graph.Neighbours(vertex);

                if (firstPartite.Contains(vertex))
                {
                    isFirstPartite = true;
                }
                else
                {
                    isFirstPartite = false;
                }

                foreach (IVertexInterface neighbourVertex in neighboursVertexList)
                {
                    if (!firstPartite.Contains(neighbourVertex) && !secondPartite.Contains(neighbourVertex))
                    {
                        if (isFirstPartite)
                        {
                            secondPartite.Add(neighbourVertex);
                        }
                        else
                        {
                            firstPartite.Add(neighbourVertex);
                        }

                        vertexQueue.Enqueue(neighbourVertex);
                    }
                    else
                    {
                        if ((firstPartite.Contains(neighbourVertex) && isFirstPartite) || (secondPartite.Contains(neighbourVertex) && !isFirstPartite))
                        {
                            isBipartite = false;
                        }
                    }
                }
            }

            if (!isBipartite)
            {
                return(new Tuple <bool, bool>(false, false));
            }

            // Set bipartites
            graph.GetGraphProperty().SetPartites(firstPartite.ToList(), secondPartite.ToList());

            // Variable
            int countFirstPartiteVertex  = firstPartite.Count;
            int countSecondPartiteVertex = secondPartite.Count;

            // Is the graph a complete bipartite graph
            foreach (Vertex firstPartiteVertex in firstPartite)
            {
                if (graph.CountNeighbours(firstPartiteVertex) != countSecondPartiteVertex)
                {
                    return(new Tuple <bool, bool>(true, false));
                }
            }
            foreach (Vertex secondPartiteVertex in secondPartite)
            {
                if (graph.CountNeighbours(secondPartiteVertex) != countFirstPartiteVertex)
                {
                    return(new Tuple <bool, bool>(true, false));
                }
            }

            return(new Tuple <bool, bool>(true, true));
        }
コード例 #28
0
 public Graph(IGraphInterface graph)
 {
     InitializeComponent();
     this.graph = graph;
 }
コード例 #29
0
ファイル: GraphProperty.cs プロジェクト: Illner/GraphColoring
        public void EdgeSubdivision(IEdgeInterface edge)
        {
            // Variable
            IVertexInterface vertex1 = graph.GetVertexByUserName(edge.GetVertex1().GetUserName());
            IVertexInterface vertex2 = graph.GetVertexByUserName(edge.GetVertex2().GetUserName());

            // Component
            if (componentsList != null)
            {
                if (countComponents > 1)
                {
                    // Get component which contains the vertex
                    IGraphInterface myComponentGraph = null;
                    foreach (IGraphInterface componentGraph in componentsList)
                    {
                        if (componentGraph.ExistsUserName(vertex1.GetUserName()))
                        {
                            myComponentGraph = componentGraph;
                            break;
                        }
                    }

                    myComponentGraph.EdgeSubdivision(new Edge(myComponentGraph.GetVertexByUserName(vertex1.GetUserName()), myComponentGraph.GetVertexByUserName(vertex2.GetUserName())));
                }
                else
                {
                    //componentsList = componentsList;
                    //countComponents = countComponents;
                    //isConnected = isConnected;
                }
            }

            // Properties
            //isCyclic = isCyclic;
            //isEulerian = isEulerian;

            // IntegralInvariants
            //circuitRank = circuitRank;
            if (girth.HasValue && girth > 2)
            {
                girth = null;
            }
            cayleysFormula = null;

            // SequencesAndPolynomialsOthers
            if (isConnected != null && !(bool)isConnected)
            {
                spanningTreeBFS = spanningTreeBFS = new List <IEdgeInterface>();
            }
            else
            {
                spanningTreeBFS = null;
            }
            matching    = null;
            cutVertices = null;
            bridges     = null;

            // DegreeSequence
            degreeSequence         = null;
            maximumVertexDegree    = null;
            minimumVertexDegree    = null;
            averageVertexDegree    = null;
            medianVertexDegree     = null;
            isDegreeSequenceSorted = false;
            isRegular = null;

            // Chordal
            if (isChordal.HasValue && (bool)isChordal)
            {
                isChordal = null;
                perfectEliminationOrderingList = null;
                righNeighborhoodDictionary     = null;
            }

            // GraphClass
            graphClass = GraphClass.GraphClass.GraphClassEnum.undefined;
        }
コード例 #30
0
        private void Invalid(IGraphInterface graph)
        {
            // Variable
            List <IVertexInterface> vertexList           = graph.AllVertices();
            List <IVertexInterface> vertexNot2DegreeList = new List <IVertexInterface>();

            vertexNot2DegreeList = vertexList.Where(v => graph.CountNeighbours(v) != 2).ToList();
            IEdgeInterface edge = new Edge(vertexList.First(), graph.Neighbours(vertexList.First()).First());

            // Vertex add
            stringBuilder.AppendLine("Vertex add");
            stringBuilder.AppendLine("Vertex exists");
            try { graph.VertexAdd(vertexList.First()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Vertex delete
            stringBuilder.AppendLine("Vertex delete");
            stringBuilder.AppendLine("Vertex doesn't exist");
            try { graph.VertexDelete(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Vertex contract
            stringBuilder.AppendLine("Vertex contract");
            stringBuilder.AppendLine("Vertex doesn't exist");
            try { graph.VertexContraction(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Vertex suppression
            stringBuilder.AppendLine("Vertex suppression");
            stringBuilder.AppendLine("Vertex doesn't exist");
            try { graph.VertexSuppression(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }
            stringBuilder.AppendLine("Invalid vertex degree");
            try { graph.VertexSuppression(vertexNot2DegreeList.First()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Vertex expansion
            stringBuilder.AppendLine("Vertex expansion");
            stringBuilder.AppendLine("Vertex doesn't exist");
            try { graph.VertexExpansion(new Vertex()); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Edge add
            stringBuilder.AppendLine("Edge add");
            stringBuilder.AppendLine("Edge exists");
            try { graph.EdgeAdd(edge); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Edge delete
            stringBuilder.AppendLine("Edge delete");
            stringBuilder.AppendLine("Edge doesn't exist");
            try { graph.EdgeDelete(new Edge(new Vertex(), new Vertex())); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Edge contract
            stringBuilder.AppendLine("Edge contract");
            stringBuilder.AppendLine("Edge doesn't exist");
            try { graph.EdgeContraction(new Edge(new Vertex(), new Vertex())); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }

            // Edge subdivision
            stringBuilder.AppendLine("Edge subdivision");
            stringBuilder.AppendLine("Edge doesn't exist");
            try { graph.EdgeSubdivision(new Edge(new Vertex(), new Vertex())); }
            catch (MyException.GraphException.GraphException e) { stringBuilder.AppendLine(e.Message); }
        }