public void DagWithEdgeLabels() { DAG dag = new DAG(0, 4); DAG.Node root = dag.GetRoot(); DAG.Node child = dag.MakeNodeInLayer(1, 1); dag.AddRelation(root, child); child.AddEdgeColor(0, 2); root.AddEdgeColor(1, 2); child = dag.MakeNodeInLayer(2, 1); dag.AddRelation(root, child); child.AddEdgeColor(0, 1); root.AddEdgeColor(2, 1); child = dag.MakeNodeInLayer(3, 1); dag.AddRelation(root, child); child.AddEdgeColor(0, 1); root.AddEdgeColor(3, 1); dag.InitializeWithStringLabels(new string[] { "C", "C", "C", "H" }); dag.UpdateVertexInvariants(); Console.Out.WriteLine(dag.CopyInvariants()); }
//[TestMethod()] public void TestColoringForUnlabelledThreeCycle() { DAG dag = new DAG(0, 3); DAG.Node root = dag.GetRoot(); DAG.Node childA = dag.MakeNodeInLayer(1, 1); dag.AddRelation(childA, root); DAG.Node childB = dag.MakeNodeInLayer(2, 1); dag.AddRelation(childB, root); DAG.Node childC = dag.MakeNodeInLayer(2, 2); dag.AddRelation(childC, childA); DAG.Node childD = dag.MakeNodeInLayer(1, 2); dag.AddRelation(childD, childB); Console.Out.WriteLine(dag); dag.InitializeWithStringLabels(new string[] { "C", "C" }); dag.UpdateVertexInvariants(); Console.Out.WriteLine(dag.CopyInvariants()); dag.SetColor(1, 1); dag.UpdateVertexInvariants(); Console.Out.WriteLine(dag.CopyInvariants()); }
//[TestMethod()] public void TestSimpleUnlabelledDAG() { // Sets up a simple test case with a graph that looks like this: // 0 - Node (vertexIndex - label) // / \ // 1 - Node 2 - Node DAG simpleDAG = new DAG(0, 3); // First do all the initializations related to the nodes of the graph. // Create the nodes. DAG.Node parentNode = simpleDAG.GetRoot(); DAG.Node childNode; // Add the first child. childNode = simpleDAG.MakeNodeInLayer(1, 1); simpleDAG.AddRelation(childNode, parentNode); // Add the second child. childNode = simpleDAG.MakeNodeInLayer(2, 1); simpleDAG.AddRelation(childNode, parentNode); // Initialize the all invariants. simpleDAG.InitializeWithStringLabels(new string[] { "Node", "Node", "Node" }); // Canonize DAG by a simple Hopcroft-Tarjan sweep. int[] nodeInvariants = { 0, 0, 0 }; int[] vertexInvariants = { 1, 2, 2 }; TestInvariants( nodeInvariants, vertexInvariants, simpleDAG.CopyInvariants()); simpleDAG.UpdateNodeInvariants(DAG.Direction.Down); int[] nodeInvariantsAfterDown = { 1, 0, 0 }; int[] vertexInvariantsAfterDown = { 1, 2, 2 }; TestInvariants(nodeInvariantsAfterDown, vertexInvariantsAfterDown, simpleDAG.CopyInvariants()); simpleDAG.ComputeVertexInvariants(); int[] nodeInvariantsAfterComputeVertexInv = { 1, 0, 0 }; int[] vertexInvariantsAfterComputeVertexInv = { 2, 1, 1 }; TestInvariants(nodeInvariantsAfterComputeVertexInv, vertexInvariantsAfterComputeVertexInv, simpleDAG.CopyInvariants()); simpleDAG.UpdateNodeInvariants(DAG.Direction.Up); int[] nodeInvariantsAfterUp = { 1, 1, 1 }; int[] vertexInvariantsAfterUp = { 2, 1, 1 }; TestInvariants(nodeInvariantsAfterUp, vertexInvariantsAfterUp, simpleDAG.CopyInvariants()); string simpleDAGString = simpleDAG.ToString(); string expected = "[0 Node ([], [1,2])]\n[1 Node ([0], []), " + "2 Node ([0], [])]\n"; Assert.AreEqual(expected, simpleDAGString); }
private void AddNode(int layer, DAG.Node parentNode, int vertexIndex, List <DAG.Arc> layerArcs, List <DAG.Arc> usedArcs, List <DAG.Node> nextLayer) { // look up the mapping or create a new mapping for the vertex index int mappedVertexIndex; if (vertexMapping.ContainsKey(vertexIndex)) { mappedVertexIndex = vertexMapping[vertexIndex]; } else { vertexMapping[vertexIndex] = vertexCount; mappedVertexIndex = vertexCount; vertexCount++; } // find an existing node if there is one var arc = new DAG.Arc(parentNode.vertexIndex, mappedVertexIndex); if (usedArcs.Contains(arc)) { return; } DAG.Node existingNode = null; foreach (var otherNode in nextLayer) { if (otherNode.vertexIndex == mappedVertexIndex) { existingNode = otherNode; break; } } // if there isn't, make a new node and add it to the layer if (existingNode == null) { existingNode = dag.MakeNode(mappedVertexIndex, layer); nextLayer.Add(existingNode); } // add the edge label to the node's edge label list int originalParentIndex = GetOriginalVertexIndex(parentNode.vertexIndex); string edgeLabel = GetEdgeLabel(originalParentIndex, vertexIndex); int edgeColor = ConvertEdgeLabelToColor(edgeLabel); existingNode.AddEdgeColor(parentNode.vertexIndex, edgeColor); parentNode.AddEdgeColor(mappedVertexIndex, edgeColor); dag.AddRelation(existingNode, parentNode); layerArcs.Add(arc); }
//[TestMethod()] public void TestSimpleLabelledDAG() { // { // Sets up a simple test case with a graph that looks like this: // 0 - Node0 (vertexIndex - label) // / \ // 1 - Node2 2 - Node1 DAG simpleDAG = new DAG(0, 3); // First do all the initializations related to the nodes of the graph. // Create the nodes. DAG.Node parentNode = simpleDAG.GetRoot(); // Add the first child. DAG.Node childNode = simpleDAG.MakeNodeInLayer(1, 1); simpleDAG.AddRelation(childNode, parentNode); // Add the second child. childNode = simpleDAG.MakeNodeInLayer(2, 1); simpleDAG.AddRelation(childNode, parentNode); // Initialize the all invariants. simpleDAG.InitializeWithStringLabels(new string[] { "Node0", "Node2", "Node1" }); //Console.Out.WriteLine(simpleDAG.ToString()); // Canonize DAG by a simple Hopcroft-Tarjan sweep. int[] nodeInvariants = { 0, 0, 0 }; int[] vertexInvariants = { 1, 3, 2 }; TestInvariants( nodeInvariants, vertexInvariants, simpleDAG.CopyInvariants()); simpleDAG.UpdateNodeInvariants(DAG.Direction.Down); int[] nodeInvariantsAfterDown = { 1, 0, 0 }; int[] vertexInvariantsAfterDown = { 1, 3, 2 }; TestInvariants(nodeInvariantsAfterDown, vertexInvariantsAfterDown, simpleDAG.CopyInvariants()); simpleDAG.ComputeVertexInvariants(); int[] nodeInvariantsAfterComputeVertexInv = { 1, 0, 0 }; int[] vertexInvariantsAfterComputeVertexInv = { 2, 1, 1 }; TestInvariants(nodeInvariantsAfterComputeVertexInv, vertexInvariantsAfterComputeVertexInv, simpleDAG.CopyInvariants()); simpleDAG.UpdateNodeInvariants(DAG.Direction.Up); int[] nodeInvariantsAfterUp = { 1, 1, 1 }; int[] vertexInvariantsAfterUp = { 2, 1, 1 }; TestInvariants(nodeInvariantsAfterUp, vertexInvariantsAfterUp, simpleDAG.CopyInvariants()); }
/// <summary> /// Recursively print the signature into the buffer. /// </summary> /// <param name="buffer">the string buffer to print into</param> /// <param name="node">the current node of the signature</param> /// <param name="parent">the parent node, or null</param> /// <param name="arcs">the list of already visited arcs</param> private void Print(StringBuilder buffer, DAG.Node node, DAG.Node parent, List <DAG.Arc> arcs) { int vertexIndex = GetOriginalVertexIndex(node.vertexIndex); // print out any symbol for the edge in the input graph if (parent != null) { int parentVertexIndex = GetOriginalVertexIndex(parent.vertexIndex); buffer.Append(GetEdgeLabel(vertexIndex, parentVertexIndex)); } // print out the text that represents the node itself buffer.Append(AbstractVertexSignature.StartNodeSymbolChar); buffer.Append(GetVertexSymbol(vertexIndex)); int color = dag.ColorFor(node.vertexIndex); if (color != -1) { buffer.Append(',').Append(color); } buffer.Append(AbstractVertexSignature.EndNodeSymbolChar); // Need to sort the children here, so that they are printed in an order // according to their invariants. node.children.Sort(dag.nodeComparator); // now print the sorted children, surrounded by branch symbols bool addedBranchSymbol = false; foreach (var child in node.children) { DAG.Arc arc = new DAG.Arc(node.vertexIndex, child.vertexIndex); if (arcs.Contains(arc)) { continue; } else { if (!addedBranchSymbol) { buffer.Append(AbstractVertexSignature.StartBranchSymbolChar); addedBranchSymbol = true; } arcs.Add(arc); Print(buffer, child, node, arcs); } } if (addedBranchSymbol) { buffer.Append(AbstractVertexSignature.EndBranchSymbolChar); } }
//[TestMethod()] public void TestColoring() { // C12CC1C1 DAG ring = new DAG(0, 4); DAG.Node root = ring.GetRoot(); DAG.Node child1 = ring.MakeNodeInLayer(1, 1); ring.AddRelation(child1, root); DAG.Node child2 = ring.MakeNodeInLayer(2, 1); ring.AddRelation(child2, root); DAG.Node child3 = ring.MakeNodeInLayer(3, 1); ring.AddRelation(child3, root); DAG.Node child4 = ring.MakeNodeInLayer(3, 2); ring.AddRelation(child4, child1); ring.AddRelation(child4, child2); DAG.Node child5 = ring.MakeNodeInLayer(1, 2); ring.AddRelation(child5, child3); DAG.Node child6 = ring.MakeNodeInLayer(2, 2); ring.AddRelation(child6, child3); Console.Out.WriteLine(ring); string[] labels = new string[] { "C", "C", "C" }; ring.InitializeWithStringLabels(labels); ring.UpdateNodeInvariants(DAG.Direction.Up); Console.Out.WriteLine(ring.CopyInvariants()); ring.ComputeVertexInvariants(); Console.Out.WriteLine(ring.CopyInvariants()); ring.UpdateNodeInvariants(DAG.Direction.Down); Console.Out.WriteLine(ring.CopyInvariants()); ring.ComputeVertexInvariants(); Console.Out.WriteLine(ring.CopyInvariants()); ring.UpdateVertexInvariants(); Console.Out.WriteLine(ring.CopyInvariants()); // List<Integer> orbit = ring.CreateOrbit(); // Console.Out.WriteLine(orbit); // // ring.SetColor(orbit[0], 1); // ring.UpdateVertexInvariants(); // Console.Out.WriteLine(ring.CopyInvariants()); // // orbit = ring.CreateOrbit(); // Console.Out.WriteLine(orbit); // // ring.SetColor(orbit[0], 2); // ring.UpdateVertexInvariants(); // Console.Out.WriteLine(ring.CopyInvariants()); // // orbit = ring.CreateOrbit(); // Console.Out.WriteLine(orbit); // ring.SetColor(orbit[0], 3); // Console.Out.WriteLine(ring.CopyInvariants()); }