private void Testing(SmallestLastSequenceEnum smallestLastSequence)
{
try
{
testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[smallestLastSequence]);
reader = new ReaderWriter.ReaderGraph(testPath, false);
graph = reader.ReadFile();
SmallestLastSequence smallestLastSequenceAlgorithm = new SmallestLastSequence(graph);
smallestLastSequenceAlgorithm.Color();
stringBuilder.AppendLine(smallestLastSequence.ToString());
stringBuilder.AppendLine("Graph colored.");
stringBuilder.AppendLine(graph.GetColoredGraph().ToString());
}
catch (KeyNotFoundException)
{
throw new MyException.TestsException.TestsMissingTestException(smallestLastSequence.ToString());
}
catch (MyException.ReaderWriterException.ReaderWriterException e)
{
stringBuilder.AppendLine(e.Message);
}
}
private void Testing(GreedyIndependentSetEnum greedyIndependentSet)
{
try
{
testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[greedyIndependentSet]);
reader = new ReaderWriter.ReaderGraph(testPath, false);
graph = reader.ReadFile();
GreedyIndependentSet greedyIndependentSetAlgorithm = new GreedyIndependentSet(graph);
greedyIndependentSetAlgorithm.Color();
stringBuilder.AppendLine(greedyIndependentSetAlgorithm.ToString());
stringBuilder.AppendLine("Graph colored.");
stringBuilder.AppendLine(graph.GetColoredGraph().ToString());
}
catch (KeyNotFoundException)
{
throw new MyException.TestsException.TestsMissingTestException(greedyIndependentSet.ToString());
}
catch (MyException.ReaderWriterException.ReaderWriterException e)
{
stringBuilder.AppendLine(e.Message);
}
}
private void Testing(ConnectedSequentialEnum connectedSequential)
{
try
{
testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[connectedSequential]);
reader = new ReaderWriter.ReaderGraph(testPath, false);
graph = reader.ReadFile();
ConnectedSequential optimalAlgorithm = new ConnectedSequential(graph);
optimalAlgorithm.Color();
stringBuilder.AppendLine(connectedSequential.ToString());
stringBuilder.AppendLine("Graph colored.");
stringBuilder.AppendLine(graph.GetColoredGraph().ToString());
}
catch (KeyNotFoundException)
{
throw new MyException.TestsException.TestsMissingTestException(connectedSequential.ToString());
}
catch (MyException.ReaderWriterException.ReaderWriterException e)
{
stringBuilder.AppendLine(e.Message);
}
}
public LargestFirstSequence(Graph.IGraphInterface graph, GraphColoringAlgorithInterchangeEnum interchangeEnum = GraphColoringAlgorithInterchangeEnum.none) : base(graph)
{
// Interchange
this.interchangeEnum = interchangeEnum;
switch (interchangeEnum)
{
case GraphColoringAlgorithInterchangeEnum.none:
name = "Largest first sequence algorithm";
timeComplexity = TimeComplexityEnum.quadratic;
break;
case GraphColoringAlgorithInterchangeEnum.interchange:
name = "Largest first sequence interchange algorithm";
timeComplexity = TimeComplexityEnum.cubic;
break;
case GraphColoringAlgorithInterchangeEnum.interchangeExtended:
name = "Largest first sequence interchange extended algorithm";
timeComplexity = TimeComplexityEnum.quartic;
break;
case GraphColoringAlgorithInterchangeEnum.interchangeExtendedK3:
name = "Largest first sequence interchange extended with K3 algorithm";
timeComplexity = TimeComplexityEnum.quintic;
break;
}
}
public GraphColoringAlgorithm(Graph.IGraphInterface graph)
{
this.graph = graph;
countInterchangeCalls = 0;
coloredGraph = graph.GetColoredGraph();
countVertices = graph.GetRealCountVertices();
}
/// <summary>
/// Constructor
/// Default value for fileNameExtensionEnum is .jpg
/// </summary>
/// <param name="graph">The graph</param>
public GraphVisualization(Graph.IGraphInterface graph,
bool isSchedule, bool showSpanningTree, bool showSimplicialVertex, bool showCutVerticesAndBridges, bool showMaximumAndMinimumDegreeVertices,
FileNameExtensionEnum fileNameExtensionEnum = FileNameExtensionEnum.jpg)
{
graphList = new List <Graph.IGraphInterface>();
graphList.Add(graph);
this.fileNameExtensionEnum = fileNameExtensionEnum;
this.isSchedule = isSchedule;
this.showSpanningTree = showSpanningTree;
this.showSimplicialVertex = showSimplicialVertex;
this.showCutVerticesAndBridges = showCutVerticesAndBridges;
this.showMaximumAndMinimumDegreeVertices = showMaximumAndMinimumDegreeVertices;
}
/// <summary>
/// If count of vertices is less than 1 throws GraphInvalidCountVerticesException
/// </summary>
/// <param name="countVertices">count of vertices</param>
/// <param name="erdosRenyiModelProbabilityEnum">probability attribute - deafult = notAssigned</param>
public ErdosRenyiModel(int countVertices, ErdosRenyiModelProbabilityEnum erdosRenyiModelProbabilityEnum = ErdosRenyiModelProbabilityEnum.notAssigned)
{
SetCountVertices(countVertices);
this.erdosRenyiModelProbabilityEnum = erdosRenyiModelProbabilityEnum;
usedVerticesHashSet = new HashSet <Graph.IVertexInterface>();
// Create graph
graph = new Graph.GraphEdgeList(countVertices);
graph.SetName(GRAPHNAME);
graph.FullGenerateVertices();
graph.InitializeGraph();
// Set random
SetRandom();
}
/// <summary>
/// Write a colored graph to a file
/// If the colored graph is not initialized throws ColoredGraphNotInitializationException
/// </summary>
/// <param name="graph">Colored graph</param>
/// <param name="graphColoringAlgorithm">Algorithm which was used for coloring the graph</param>
/// <param name="isOptimal">Is the algorithm optimal for the graph</param>
public bool WriteFileColor(Graph.IGraphInterface graph, GraphColoringAlgorithm.GraphColoringAlgorithm.GraphColoringAlgorithmEnum graphColoringAlgorithm, bool isOptimal)
{
// Variable
Graph.IColoredGraphInterface coloredGraph;
coloredGraph = graph.GetColoredGraph();
if (!coloredGraph.GetIsInitializedColoredGraph())
{
throw new MyException.GraphException.ColoredGraphNotInitializationException();
}
if (CheckIfRecordExists(graphColoringAlgorithm))
{
return(false);
}
using (StreamWriter streamWriter = File.AppendText(GetPath()))
{
streamWriter.WriteLine();
// Number of colors
if (isOptimal)
{
streamWriter.WriteLine(READERWRITERCHROMATICNUMBER + coloredGraph.GetCountUsedColors());
}
else
{
streamWriter.WriteLine(READERWRITERNUMBEROFCOLORS + coloredGraph.GetCountUsedColors());
}
// Used algorithm
streamWriter.WriteLine(READERWRITERUSEDALGORITHM + graphColoringAlgorithm);
// Colored graph
List <int> colorList = coloredGraph.UsedColors();
foreach (int color in colorList)
{
List <Graph.IVertexInterface> vertexList = coloredGraph.ColoredVertices(color);
streamWriter.WriteLine("- " + color);
vertexList.ForEach(vertex => { streamWriter.WriteLine("-- " + vertex.GetUserName()); });
}
}
return(true);
}
/// <summary>
/// Read a file with a graph and construct it
/// </summary>
private void Testing()
{
try
{
stringBuilder.AppendLine("Reading file: " + reader.GetPath());
graph = reader.ReadFile();
stringBuilder.AppendLine("Graph created.");
stringBuilder.AppendLine(graph.ToString());
}
catch (Exception e)
{
stringBuilder.AppendLine(e.Message);
}
}
private void Testing(ConverterGraphToDotEnum converterGraphToDotEnum)
{
try
{
// Variable
ConvertGraphToDot convertGraphToDot;
testPath = ReaderWriter.ReaderWriter.CreateTestFile(testsDictionary[converterGraphToDotEnum]);
reader = new ReaderWriter.ReaderGraph(testPath, false);
graph = reader.ReadFile();
List <Graph.IGraphInterface> graphList = graph.GetGraphProperty().GetComponents();
stringBuilder.AppendLine(converterGraphToDotEnum.ToString());
stringBuilder.AppendLine(graph.ToString());
stringBuilder.AppendLine("Standard graph");
convertGraphToDot = new ConvertGraphToDot(graphList, false, true, true, true, true);
stringBuilder.AppendLine(convertGraphToDot.Convert());
stringBuilder.AppendLine("Uncolored schedule");
convertGraphToDot = new ConvertGraphToDot(graphList, true, true, true, true, true);
stringBuilder.AppendLine(convertGraphToDot.Convert());
GraphColoringAlgorithm.SequenceAlgorithm.LargestFirstSequence.LargestFirstSequence largestFirstSequence;
foreach (Graph.IGraphInterface graph in graphList)
{
largestFirstSequence = new GraphColoringAlgorithm.SequenceAlgorithm.LargestFirstSequence.LargestFirstSequence(graph, GraphColoringAlgorithm.GraphColoringAlgorithm.GraphColoringAlgorithInterchangeEnum.none);
largestFirstSequence.Color();
}
stringBuilder.AppendLine("Colored schedule");
convertGraphToDot = new ConvertGraphToDot(graphList, true, true, true, true, true);
stringBuilder.AppendLine(convertGraphToDot.Convert());
}
catch (KeyNotFoundException)
{
throw new MyException.TestsException.TestsMissingTestException(converterGraphToDotEnum.ToString());
}
catch (MyException.ReaderWriterException.ReaderWriterException e)
{
stringBuilder.AppendLine(e.Message);
}
}
/// <summary>
/// Write a graph to a file
/// If the graph is not initialized throws GraphInitializationException
/// </summary>
/// <param name="graph">graph</param>
/// <returns>Is everything OK</returns>
public bool WriteFile(Graph.IGraphInterface graph)
{
if (!graph.GetIsInitialized())
{
throw new MyException.GraphException.GraphInitializationException();
}
if (ExistsFile())
{
DeleteFile();
}
CreateFile();
using (StreamWriter streamWriter = new StreamWriter(GetPath()))
{
// Header
streamWriter.WriteLine(READERWRITERHEADER + Graph.Graph.GraphRepresentationEnum.adjacencyList);
streamWriter.WriteLine(READERWRITERBALLAST);
streamWriter.WriteLine(READERWRITERNAME + graph.GetName());
streamWriter.WriteLine(READERWRITERCOUNTVERTICES + graph.GetRealCountVertices());
streamWriter.WriteLine(READERWRITERBALLAST);
// Graph
streamWriter.WriteLine(READERWRITERGRAPH);
foreach (Graph.Vertex vertex in graph.AllVertices())
{
streamWriter.WriteLine(vertex.GetUserName());
foreach (Graph.Vertex neighbour in graph.Neighbours(vertex))
{
streamWriter.WriteLine(LEFTSEPARATORADJACENCYLIST + neighbour.GetUserName() + RIGHTSEPARATORADJACENCYLIST);
}
}
// Colored graph
streamWriter.WriteLine(READERWRITERBALLAST);
streamWriter.Write(READERWRITERCOLOREDGRAPH);
}
return(true);
}
public void Color()
{
// Variable
Graph.IVertexInterface vertex;
List <Graph.IVertexInterface> neighboursVertexList;
if (coloredGraph.GetIsInitializedColoredGraph())
{
throw new MyException.GraphException.ColoredGraphAlreadyInitializedException();
}
coloredGraph.ResetColors();
while (!graph.GetColoredGraph().AreAllVerticesColored())
{
copyGraph = Graph.GraphOperation.GraphOperation.SubGraph(graph, graph.GetColoredGraph().GetUnColoredVertexList());
while (copyGraph.GetRealCountVertices() != 0)
{
vertex = copyGraph.GetGraphProperty().GetVertexWithDegree(copyGraph.GetGraphProperty().GetMinimumVertexDegree());
neighboursVertexList = copyGraph.Neighbours(vertex);
copyGraph.VertexDelete(vertex);
foreach (Graph.IVertexInterface neighbour in neighboursVertexList)
{
copyGraph.VertexDelete(neighbour);
}
graph.GetColoredGraph().ColorVertex(graph.GetVertexByUserName(vertex.GetUserName()), color);
}
color++;
}
bool isColored = coloredGraph.InitializeColoredGraph();
if (!isColored)
{
throw new MyException.GraphColoringAlgorithmException.AlgorithmGraphIsNotColored();
}
}
/// <summary>
/// If the populationSize is less than 1, throw exception AlgorithmGraphGeneticAlgorithmInvalidPopulationCount
/// If the exponentCountOfIteration is less than 1 or greater than 10 throws AlgorithmGraphGeneticAlgorithmInvalidExponentCountOfIteration
/// </summary>
/// <param name="graph">Graph</param>
/// <param name="populationSize">Size of population</param>
/// <param name="exponentCountOfIteration">Exponent of count of iteration = (populationSize)^(exponentCountOfIteration)</param>
public GeneticAlgorithm(Graph.IGraphInterface graph, int exponentCountOfIteration, int populationSize = 10) : base(graph)
{
if (populationSize < 1)
{
throw new MyException.GraphColoringAlgorithmException.AlgorithmGraphGeneticAlgorithmInvalidPopulationCount();
}
if (exponentCountOfIteration < 1 || exponentCountOfIteration > 10)
{
throw new MyException.GraphColoringAlgorithmException.AlgorithmGraphGeneticAlgorithmInvalidExponentCountOfIteration(exponentCountOfIteration.ToString());
}
random = new Random();
// Even property
if (populationSize % 2 == 1)
{
populationSize++;
}
this.populationSize = populationSize;
this.exponentCountOfIteration = exponentCountOfIteration;
name = "Genetic algorithm (exponent: " + exponentCountOfIteration + ")";
timeComplexity = TimeComplexityEnum.undefined;
if (populationSize == 10)
{
switch (exponentCountOfIteration)
{
case 1:
timeComplexity = TimeComplexityEnum.quadraticPlusMultiply;
break;
case 2:
timeComplexity = TimeComplexityEnum.cubicPlusQuadratic;
break;
}
}
}
private void Testing(GeneticAlgorithmEnum geneticAlgorithm)
{
try
{
erdosRenyiModel = new GenerateGraph.ErdosRenyiModel.ErdosRenyiModel(random.Next(15, 25));
graph = erdosRenyiModel.GenerateGraph();
GeneticAlgorithm algorithm = new GeneticAlgorithm(graph, 2, random.Next(250, 300));
algorithm.Color();
stringBuilder.AppendLine(algorithm.ToString());
stringBuilder.AppendLine("Graph colored.");
stringBuilder.AppendLine("Is valid colored: " + graph.GetColoredGraph().IsValidColored().ToString());
}
catch (KeyNotFoundException)
{
throw new MyException.TestsException.TestsMissingTestException(geneticAlgorithm.ToString());
}
catch (MyException.ReaderWriterException.ReaderWriterException e)
{
stringBuilder.AppendLine(e.Message);
}
}
public SaturationLargestFirstSequence(Graph.IGraphInterface graph) : base(graph)
{
name = "Saturation largest first sequence algorithm";
timeComplexity = TimeComplexityEnum.cubic;
}
/// <summary>
/// Return true if a graph has been colored in polynomal time, otherwise false
/// </summary>
/// <param name="graph">graph</param>
/// <returns>true if graph has been colored in polynomal time, otherwise false</returns>
public static bool TryOptimalColorInPolynomalTime(Graph.IGraphInterface graph)
{
bool isColored;
IGraphColoringAlgorithmInterface algorithm;
List <Graph.IVertexInterface> optimalVertexList;
Graph.IColoredGraphInterface coloredGraph = graph.GetColoredGraph();
coloredGraph.ResetColors();
// If the graph is chordal => use PEO for coloring
if (graph.GetGraphProperty().GetIsChordal())
{
optimalVertexList = graph.GetGraphProperty().GetPerfectEliminationOrdering();
coloredGraph.GreedyColoring(optimalVertexList);
isColored = coloredGraph.InitializeColoredGraph();
if (!isColored)
{
throw new MyException.GraphColoringAlgorithmException.AlgorithmGraphIsNotColored();
}
return(true);
}
switch (graph.GetGraphProperty().GetGraphClass())
{
case Graph.GraphClass.GraphClass.GraphClassEnum.bipartiteGraph:
Tuple <List <Graph.IVertexInterface>, List <Graph.IVertexInterface> > partites = graph.GetGraphProperty().GetPartites();
coloredGraph.GreedyColoring(partites.Item1.Concat(partites.Item2).ToList());
isColored = coloredGraph.InitializeColoredGraph();
if (!isColored)
{
throw new MyException.GraphColoringAlgorithmException.AlgorithmGraphIsNotColored();
}
return(true);
case Graph.GraphClass.GraphClass.GraphClassEnum.completeBipartiteGraph:
algorithm = new SequenceAlgorithm.SmallestLastSequence.SmallestLastSequence(graph);
algorithm.Color();
return(true);
case Graph.GraphClass.GraphClass.GraphClassEnum.completeGraph:
coloredGraph.GreedyColoring(graph.AllVertices());
isColored = coloredGraph.InitializeColoredGraph();
if (!isColored)
{
throw new MyException.GraphColoringAlgorithmException.AlgorithmGraphIsNotColored();
}
return(true);
case Graph.GraphClass.GraphClass.GraphClassEnum.cycleGraph:
case Graph.GraphClass.GraphClass.GraphClassEnum.treeGraph:
algorithm = new SequenceAlgorithm.ConnectedSequential.ConnectedSequential(graph);
algorithm.Color();
return(true);
}
return(false);
}
public Optimal(Graph.IGraphInterface graph) : base(graph)
{
name = "Optimal algorithm";
timeComplexity = TimeComplexityEnum.factorial;
}
public CombinationAlgorithm(Graph.IGraphInterface graph) : base(graph)
{
algorithmList = new List <IGraphColoringAlgorithmStepInterface>();
name = "Combination algorithm";
timeComplexity = TimeComplexityEnum.cubic;
}
public GreedyIndependentSet(Graph.IGraphInterface graph) : base(graph)
{
name = "Greedy independent set algorithm";
timeComplexity = TimeComplexityEnum.cubic;
}
public GraphColoringSequenceAlgorithm(Graph.IGraphInterface graph) : base(graph)
{
}
private void Testing(ErdosRenyiModelEnum erdosRenyiModelEnum)
{
try
{
switch (erdosRenyiModelEnum)
{
case ErdosRenyiModelEnum.erdosRenyiModelCDividedByNLessThanOne:
stringBuilder.AppendLine(erdosRenyiModelEnum.ToString());
erdosRenyiModel = new ErdosRenyiModel(COUNTVERTICES, ErdosRenyiModel.ErdosRenyiModelProbabilityEnum.cDividedByNLessThanOne);
graph = erdosRenyiModel.GenerateGraph();
if (graph.GetRealCountVertices() != COUNTVERTICES)
{
throw new MyException.GraphException.GraphInvalidCountVerticesException("The number of vertices of generated graph is wrong!");
}
stringBuilder.AppendLine("OK");
break;
case ErdosRenyiModelEnum.erdosRenyiModelCDividedByNMoreThanOne:
stringBuilder.AppendLine(erdosRenyiModelEnum.ToString());
erdosRenyiModel = new ErdosRenyiModel(COUNTVERTICES, ErdosRenyiModel.ErdosRenyiModelProbabilityEnum.cDividedByNMoreThanOne);
graph = erdosRenyiModel.GenerateGraph();
if (graph.GetRealCountVertices() != COUNTVERTICES)
{
throw new MyException.GraphException.GraphInvalidCountVerticesException("The number of vertices of generated graph is wrong!");
}
stringBuilder.AppendLine("OK");
break;
case ErdosRenyiModelEnum.erdosRenyiModelCLogNDividedByN:
stringBuilder.AppendLine(erdosRenyiModelEnum.ToString());
erdosRenyiModel = new ErdosRenyiModel(COUNTVERTICES, ErdosRenyiModel.ErdosRenyiModelProbabilityEnum.cLogNDividedByN);
graph = erdosRenyiModel.GenerateGraph();
if (graph.GetRealCountVertices() != COUNTVERTICES)
{
throw new MyException.GraphException.GraphInvalidCountVerticesException("The number of vertices of generated graph is wrong!");
}
stringBuilder.AppendLine("OK");
break;
case ErdosRenyiModelEnum.erdosRenyiModelNotAssigned:
stringBuilder.AppendLine(erdosRenyiModelEnum.ToString());
erdosRenyiModel = new ErdosRenyiModel(COUNTVERTICES, ErdosRenyiModel.ErdosRenyiModelProbabilityEnum.notAssigned);
graph = erdosRenyiModel.GenerateGraph();
if (erdosRenyiModel.GetErdosRenyiModelProbabilityEnum() == ErdosRenyiModel.ErdosRenyiModelProbabilityEnum.notAssigned)
{
throw new MyException.GenerateGraphException.ErdosReneiModelChoosePNotAssigned();
}
if (graph.GetRealCountVertices() != COUNTVERTICES)
{
throw new MyException.GraphException.GraphInvalidCountVerticesException("The number of vertices of generated graph is wrong!");
}
stringBuilder.AppendLine("OK");
break;
case ErdosRenyiModelEnum.invalidVerticesCount:
stringBuilder.AppendLine(erdosRenyiModelEnum.ToString());
erdosRenyiModel = new ErdosRenyiModel(0, ErdosRenyiModel.ErdosRenyiModelProbabilityEnum.notAssigned);
graph = erdosRenyiModel.GenerateGraph();
break;
default:
throw new MyException.TestsException.TestsMissingTestException();
}
}
catch (Exception e)
{
stringBuilder.AppendLine(e.Message);
}
}
public AI(Graph.IGraphInterface graph) : base(graph)
{
name = "AI";
timeComplexity = TimeComplexityEnum.undefined;
}
/// <summary>
/// Read a file and create a graph
/// </summary>
/// <returns>the graph from the file</returns>
public Graph.IGraphInterface ReadFile()
{
// Variable
Graph.IGraphInterface graph = null;
Graph.IGraphEdgeListInterface graphEdgeList;
Graph.IGraphAdjacencyMatrixInterface graphAdjacencyMatrix;
string header = "";
int countVertices, numberColors;
string line, graphName, numberColorsString;
ReaderWriterHeaderEnum graphRepresentationEnum;
using (FileStream fileStream = File.OpenRead(GetPath()))
using (StreamReader streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
try
{
// Header
header = streamReader.ReadLine();
/// Invalid header
if (!header.StartsWith(READERWRITERHEADER))
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidHeaderException("Invalid header");
}
graphRepresentationEnum = (ReaderWriterHeaderEnum)Enum.Parse(typeof(ReaderWriterHeaderEnum), header.Split(SEPARATOR).Last());
// Ballast
line = streamReader.ReadLine();
if (line != READERWRITERBALLAST)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Missing empty line");
}
// Graph name
line = streamReader.ReadLine();
if (!line.StartsWith(READERWRITERNAME))
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid name of graph (header)");
}
graphName = line.Substring(READERWRITERNAME.Length);
// Count of vertices
line = streamReader.ReadLine();
if (!line.StartsWith(READERWRITERCOUNTVERTICES))
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid vertex count (header)");
}
countVertices = Int32.Parse(line.Substring(READERWRITERCOUNTVERTICES.Length));
if (countVertices < 0)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid vertex count (not a number)");
}
if (countVertices == 0)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid vertex count (0)");
}
// Ballast
line = streamReader.ReadLine();
if (line != READERWRITERBALLAST)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Missing empty line");
}
// Graph
line = streamReader.ReadLine();
if (line != READERWRITERGRAPH)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid graph (header)");
}
switch (graphRepresentationEnum)
{
case ReaderWriterHeaderEnum.adjacencyList:
graphEdgeList = new Graph.GraphEdgeList(countVertices);
graphEdgeList.SetName(graphName);
ReadFileAdjacencyList(graphEdgeList, streamReader);
graph = graphEdgeList;
break;
case ReaderWriterHeaderEnum.adjacencyMatrix:
graphAdjacencyMatrix = new Graph.GraphAdjacencyMatrix(countVertices);
graphAdjacencyMatrix.SetName(graphName);
ReadFileAdjacencyMatrix(graphAdjacencyMatrix, streamReader, countVertices);
graph = graphAdjacencyMatrix;
break;
case ReaderWriterHeaderEnum.edgeList:
graphEdgeList = new Graph.GraphEdgeList(countVertices);
graphEdgeList.SetName(graphName);
ReadFileEdgeList(graphEdgeList, streamReader);
graph = graphEdgeList;
break;
default:
throw new MyException.ReaderWriterException.ReaderWriterInvalidHeaderException("Unknown header");
}
// Colored graph
line = streamReader.ReadLine();
if (line != READERWRITERCOLOREDGRAPH)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid colored graph (header)");
}
while (!streamReader.EndOfStream)
{
// Number of colors
line = streamReader.ReadLine();
if (!line.StartsWith(READERWRITERNUMBEROFCOLORS) && !line.StartsWith(READERWRITERCHROMATICNUMBER))
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid number of colors / chromatic number (header)");
}
if (line.StartsWith(READERWRITERNUMBEROFCOLORS))
{
numberColorsString = line.Substring(READERWRITERNUMBEROFCOLORS.Length);
}
else
{
numberColorsString = line.Substring(READERWRITERCHROMATICNUMBER.Length);
}
numberColors = Int32.Parse(numberColorsString);
// Used algorithm
line = streamReader.ReadLine();
if (!line.StartsWith(READERWRITERUSEDALGORITHM))
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidHeaderException("Invalid used algorithm (header)");
}
line = line.Substring(READERWRITERUSEDALGORITHM.Length);
if (!Enum.GetNames(typeof(GraphColoringAlgorithm.GraphColoringAlgorithm.GraphColoringAlgorithmEnum)).Contains(line))
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Unknown algorithm");
}
// Colored graph
line = streamReader.ReadLine();
while (line != null && line != "")
{
line = streamReader.ReadLine();
}
}
}
catch (ArgumentException)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidHeaderException("Invalid header");
}
catch (FormatException)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidFormatException("Invalid vertex count (not a number)");
// throw new MyException.ReaderWriterInvalidFormatException("Invalid chromatic number (not a number)");
}
catch (IOException)
{
throw new MyException.ReaderWriterException.ReaderWriterInvalidDataException("Something went wrong with a file");
}
}
return(graph);
}
public ConnectedSequential(Graph.IGraphInterface graph) : base(graph)
{
name = "Connected sequenctial algorithm";
timeComplexity = TimeComplexityEnum.linear;
interchangeEnum = GraphColoringAlgorithInterchangeEnum.none;
}
