public void BinarySerialization_CompressedGraph([NotNull] CompressedSparseRowGraph <int> graph)
{
CompressedSparseRowGraph <int> deserializedGraph =
SerializeDeserialize <int, SEquatableEdge <int>, CompressedSparseRowGraph <int> >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
}
public static int[] SpectralSequence(CompressedSparseRowGraph graph)
{
Debug.WriteLine("Converting graph");
var nodes = graph.Convert();
var edgesPairs = nodes.SelectMany(x => x.Neighbors.OrderBy(y => y.Key)).ToArray();
var adjacency = new int[nodes.Count + 1];
var count = 0;
for (var i = 0; i < nodes.Count; i++)
{
count += nodes[i].Neighbors.Count;
adjacency[i + 1] = count;
}
var edges = new int[edgesPairs.Length + 1];
var edgeWeights = new float[edgesPairs.Length + 1];
Debug.WriteLine("edgePairs.Length: " + edgesPairs.Length);
for (var i = 0; i < edgesPairs.Length; i++)
{
var pair = edgesPairs[i];
edges[i] = pair.Key;
edgeWeights[i] = Math.Max(pair.Value, 1.0f);
}
edges[^ 1] = -1;
public void GraphMLSerialization_CompressedGraph([NotNull] CompressedSparseRowGraph <int> graph)
{
AdjacencyGraph <int, SEquatableEdge <int> > deserializedGraph =
SerializeDeserialize_SEdge <CompressedSparseRowGraph <int>, AdjacencyGraph <int, SEquatableEdge <int> > >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
}
public void ContainsVertex_Throws()
{
var wrappedGraph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var graph = CompressedSparseRowGraph <TestVertex> .FromGraph(wrappedGraph);
ContainsVertex_Throws_Test(graph);
}
public void TryGetOutEdges_Throws()
{
var wrappedGraph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var graph = CompressedSparseRowGraph <TestVertex> .FromGraph(wrappedGraph);
TryGetOutEdges_Throws_Test(graph);
}
private static NewNode[] ConvertToNewNodes(CompressedSparseRowGraph graph)
{
var nodes = new NewNode[graph.FirstChildEdgeIndex.Length - 1];
for (var i = 0; i < nodes.Length; i++)
{
nodes[i] = new NewNode(i);
}
for (var i = 1; i <= nodes.Length; i++)
{
var first = graph.FirstChildEdgeIndex[i - 1];
var last = graph.FirstChildEdgeIndex[i];
var parent = nodes[i - 1];
for (var j = first; j < last; j++)
{
var index = graph.EdgeToNodeIndex[j];
var child = nodes[Math.Abs(index)];
/*if (index < 0)
* {
* child.Terminal = true;
* }*/
parent.Children.Add(child);
child.Parents.Add(parent);
}
}
return(nodes);
}
public void BinarySerialization_CompressedGraph_Complex([NotNull] CompressedSparseRowGraph <EquatableTestVertex> graph)
{
CompressedSparseRowGraph <EquatableTestVertex> deserializedGraph =
SerializeDeserialize <EquatableTestVertex, SEquatableEdge <EquatableTestVertex>, CompressedSparseRowGraph <EquatableTestVertex> >(graph);
Assert.IsTrue(EquateGraphs.Equate(graph, deserializedGraph));
}
public static void WriteD3JsonFormat(this CompressedSparseRowGraph graph, string filename)
{
using var file = new StreamWriter(File.OpenWrite(filename));
file.Write(@"
{
""nodes"":
[ ");
file.Write(
@"
{
""x"":0,
""y"":0
}");
for (var i = 1; i < graph.FirstChildEdgeIndex.Length - 1; i++)
{
file.Write(
@",
{
""x"":" + i + @",
""y"":" + i + @"
}");
}
file.Write(
@"
],
""links"":[ ");
var useComma = false;
for (var i = 1; i < graph.FirstChildEdgeIndex.Length - 1; i++)
{
var node = i - 1;
var first = graph.FirstChildEdgeIndex[node];
var last = graph.FirstChildEdgeIndex[i];
for (var j = first; j < last; j++)
{
var target = Math.Abs(graph.EdgeToNodeIndex[j]);
if (useComma)
{
file.Write(",");
}
else
{
useComma = true;
}
file.Write(
@"
{
""source"":" + node + @",
""target"":" + target + @"
}");
}
}
file.Write(
@"
]
}");
}
public void ContainsEdge_Throws()
{
var wrappedGraph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var graph = CompressedSparseRowGraph <TestVertex> .FromGraph(wrappedGraph);
ContainsEdge_DefaultNullThrows_Test(graph);
ContainsEdge_SourceTarget_Throws_Test(graph);
}
public void ContainsEdge_SourceTarget()
{
var wrappedGraph = new AdjacencyGraph <int, Edge <int> >();
ContainsEdge_SourceTarget_ImmutableGraph_Test(
wrappedGraph,
() => CompressedSparseRowGraph <int> .FromGraph(wrappedGraph));
}
public void ContainsVertex()
{
var wrappedGraph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
ContainsVertex_ImmutableGraph_Test(
wrappedGraph,
() => CompressedSparseRowGraph <TestVertex> .FromGraph(wrappedGraph));
}
public void TryGetOutEdges()
{
var wrappedGraph = new AdjacencyGraph <int, Edge <int> >();
TryGetOutEdges_ImmutableGraph_Test(
wrappedGraph,
() => CompressedSparseRowGraph <int> .FromGraph(wrappedGraph));
}
public void Clone()
{
var wrappedGraph = new AdjacencyGraph <int, Edge <int> >();
var graph = CompressedSparseRowGraph <int> .FromGraph(wrappedGraph);
AssertEmptyGraph(graph);
var clonedGraph = graph.Clone();
Assert.IsNotNull(clonedGraph);
AssertEmptyGraph(clonedGraph);
clonedGraph = (CompressedSparseRowGraph <int>)((ICloneable)graph).Clone();
Assert.IsNotNull(clonedGraph);
AssertEmptyGraph(clonedGraph);
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
var edge3 = new Edge <int>(2, 3);
wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3 });
graph = CompressedSparseRowGraph <int> .FromGraph(wrappedGraph);
AssertHasVertices(graph, new[] { 1, 2, 3 });
AssertHasEdges(
graph,
new[]
{
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 3),
new SEquatableEdge <int>(2, 3)
});
clonedGraph = graph.Clone();
Assert.IsNotNull(clonedGraph);
AssertHasVertices(clonedGraph, new[] { 1, 2, 3 });
AssertHasEdges(
clonedGraph,
new[]
{
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 3),
new SEquatableEdge <int>(2, 3)
});
clonedGraph = (CompressedSparseRowGraph <int>)((ICloneable)graph).Clone();
Assert.IsNotNull(clonedGraph);
AssertHasVertices(clonedGraph, new[] { 1, 2, 3 });
AssertHasEdges(
clonedGraph,
new[]
{
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 3),
new SEquatableEdge <int>(2, 3)
});
}
public void OutEdges_Throws()
{
var wrappedGraph1 = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var graph1 = CompressedSparseRowGraph <TestVertex> .FromGraph(wrappedGraph1);
OutEdges_NullThrows_Test(graph1);
var wrappedGraph2 = new AdjacencyGraph <EquatableTestVertex, Edge <EquatableTestVertex> >();
var graph2 = CompressedSparseRowGraph <EquatableTestVertex> .FromGraph(wrappedGraph2);
OutEdges_Throws_Test(graph2);
}
public void OutEdge_Throws()
{
var wrappedGraph1 = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var graph1 = CompressedSparseRowGraph <TestVertex> .FromGraph(wrappedGraph1);
OutEdge_NullThrows_Test(graph1);
var wrappedGraph2 = new AdjacencyGraph <int, Edge <int> >();
OutEdge_Throws_ImmutableGraph_Test(
wrappedGraph2,
() => CompressedSparseRowGraph <int> .FromGraph(wrappedGraph2));
}
public OrderingInstance(CompressedSparseRowGraph graph)
{
_graph = graph;
_convertedGraph = graph.Convert();
_arrangementToDawgPointer = new int[_convertedGraph.Count];
_dawgToArrangementPointer = new int[_convertedGraph.Count];
for (var i = 0; i < _convertedGraph.Count; i++)
{
_arrangementToDawgPointer[i] = i;
_dawgToArrangementPointer[i] = i;
}
CalculateFullCost();
}
public static CompressedSparseRowGraph Arrange(this CompressedSparseRowGraph graph, int[] arrangement)
{
var nodeCount = graph.FirstChildEdgeIndex.Length - 1;
if (nodeCount != arrangement.Length)
{
throw new ArgumentOutOfRangeException(nameof(arrangement));
}
//#if DEBUG
var set = new HashSet <int>();
for (var i = 0; i < arrangement.Length; i++)
{
Debug.Assert(0 <= arrangement[i], "0 <= arrangement[i]");
if (!set.Add(arrangement[i]))
{
var errorMessage = "Duplicate in arrangement at index " + i + " with value " + arrangement[i];
throw new InvalidOperationException(errorMessage);
}
}
//#endif
var reverse = new int[arrangement.Length];
for (var i = 0; i < arrangement.Length; i++)
{
reverse[arrangement[i]] = i;
}
//#if DEBUG
set.Clear();
for (var i = 0; i < reverse.Length; i++)
{
Debug.Assert(0 <= reverse[i], "0 <= reverse[i]");
if (!set.Add(reverse[i]))
{
var errorMessage = "Duplicate in reverse at index " + i + " with value " + reverse[i];
throw new InvalidOperationException(errorMessage);
}
}
//#endif
// We skip node index 0 if it is terminal in the new graph.
// It would be indistinguishable because there's no negative 0.
var zeroIndexOffset = reverse[0] < 0 ? 1 : 0;
var newFirstChildEdgeIndex = new uint[nodeCount + 1 + zeroIndexOffset];
var newReachableTerminalCounts = new ushort[nodeCount + zeroIndexOffset];
var newEdgeToNodeIndex = new int[graph.EdgeToNodeIndex.Length];
var newEdgeCharacters = new char[graph.EdgeCharacters.Length];
var edgeCount = 0u;
for (var i = 0; i < nodeCount; i++)
{
var oldNode = arrangement[i];
newFirstChildEdgeIndex[i + zeroIndexOffset] = edgeCount;
newReachableTerminalCounts[i + zeroIndexOffset] = graph.ReachableTerminalNodes[oldNode];
var first = graph.FirstChildEdgeIndex[oldNode];
var last = graph.FirstChildEdgeIndex[oldNode + 1];
var edges = graph.EdgeToNodeIndex.Skip((int)first).Take((int)(last - first)).Select((x, index) => new { x = x, index = index });//.OrderBy(x => x.x);
foreach (var edge in edges)
{
var targetNodeOldGraph = graph.EdgeToNodeIndex[first + edge.index];
Debug.Assert(targetNodeOldGraph == edge.x);
if (targetNodeOldGraph != edge.x)
{
throw new InvalidOperationException("");
}
var terminal = targetNodeOldGraph < 0;
newEdgeToNodeIndex[edgeCount] = (reverse[Math.Abs(targetNodeOldGraph)] + zeroIndexOffset) * (terminal ? -1 : 1);
newEdgeCharacters[edgeCount] = graph.EdgeCharacters[first + edge.index];
edgeCount++;
}
/*
* for (var j = graph.FirstChildEdgeIndex[oldNode]; j < graph.FirstChildEdgeIndex[oldNode + 1]; j++)
* {
* var targetNodeOldGraph = graph.EdgeToNodeIndex[j];
* var terminal = targetNodeOldGraph < 0;
* newEdgeToNodeIndex[edgeCount] = (reverse[Math.Abs(targetNodeOldGraph)] + zeroIndexOffset) * (terminal ? -1 : 1);
* newEdgeCharacters[edgeCount] = graph.EdgeCharacters[j];
* edgeCount++;
* }*/
}
newFirstChildEdgeIndex[^ 1] = (uint)newEdgeToNodeIndex.Length;
public void Construction_Throws()
{
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => CompressedSparseRowGraph <int> .FromGraph <Edge <int> >(null));
}
public static void AssertEmptyGraph <TVertex>(
CompressedSparseRowGraph <TVertex> graph)
{
AssertNoVertex(graph);
AssertNoEdge(graph);
}
public void Construction()
{
var wrappedGraph = new AdjacencyGraph <int, Edge <int> >();
var graph = CompressedSparseRowGraph <int> .FromGraph(wrappedGraph);
AssertGraphProperties(graph);
AssertEmptyGraph(graph);
wrappedGraph.AddVertexRange(new[] { 1, 2, 3 });
graph = CompressedSparseRowGraph <int> .FromGraph(wrappedGraph);
AssertGraphProperties(graph);
AssertHasVertices(graph, new[] { 1, 2, 3 });
AssertNoEdge(graph);
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 3);
var edge3 = new Edge <int>(2, 1);
var edge4 = new Edge <int>(2, 2);
var edge5 = new Edge <int>(2, 3);
wrappedGraph.AddEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5 });
graph = CompressedSparseRowGraph <int> .FromGraph(wrappedGraph);
AssertGraphProperties(graph);
AssertHasVertices(graph, new[] { 1, 2, 3 });
AssertHasEdges(
graph,
new[]
{
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 3),
new SEquatableEdge <int>(2, 1),
new SEquatableEdge <int>(2, 2),
new SEquatableEdge <int>(2, 3)
});
var edge6 = new Edge <int>(3, 1);
var edge7 = new Edge <int>(3, 2);
wrappedGraph.Clear();
wrappedGraph.AddVertexRange(new[] { 1, 2, 3, 4 });
wrappedGraph.AddEdgeRange(new[] { edge1, edge2, edge6, edge7 });
graph = CompressedSparseRowGraph <int> .FromGraph(wrappedGraph);
AssertGraphProperties(graph);
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(
graph,
new[]
{
new SEquatableEdge <int>(1, 2),
new SEquatableEdge <int>(1, 3),
new SEquatableEdge <int>(3, 1),
new SEquatableEdge <int>(3, 2)
});
#region Local function
void AssertGraphProperties <TVertex>(
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
CompressedSparseRowGraph <TVertex> g)
{
Assert.IsTrue(g.IsDirected);
Assert.IsFalse(g.AllowParallelEdges);
}
#endregion
}
