예제 #1
0
        private void ExtractSpecialNodeData(SyncNode[] syncNodeBlocks)
        {
            //loops
            loopPairByStart = new Dictionary <int, LoopStart>();
            loopPairByEnd   = new Dictionary <int, LoopPair>();

            List <LoopPair> loops = new LoopDetector(dependencyGraph).FindLoops();

            foreach (LoopPair loopPair in loops)
            {
                if (!loopPairByStart.ContainsKey(loopPair.Start.NodeId))
                {
                    loopPairByStart.Add(loopPair.Start.NodeId, loopPair.Start);
                }

                loopPairByEnd.Add(loopPair.End.NodeId, loopPair);
            }

            //sync
            syncById = new Dictionary <int, SyncNode>();
            foreach (SyncNode sync in syncNodeBlocks)
            {
                syncById.Add(sync.NodeId, sync);
            }
        }
        public void SimpleExtendedLoop()
        {
            // S -> LoopStart -> LoopEnd -> Process -> End

            List <DependentNode> nodes     = new List <DependentNode>();
            DependentNode        start     = new DependentNode(0, "start"),
                                 loopStart = new DependentNode(1, LoopStart.TypeName),
                                 loopEnd   = new DependentNode(2, LoopEnd.TypeName),
                                 process   = new DependentNode(3, "pro"),
                                 end       = new DependentNode(4, "end");

            nodes.Add(start);
            nodes.Add(loopStart);
            nodes.Add(loopEnd);
            nodes.Add(process);
            nodes.Add(end);

            TestHelpers.MatchSlots(start, loopStart, 0, 0);
            TestHelpers.MatchSlots(loopStart, loopEnd, 0, 0);
            TestHelpers.MatchSlots(loopStart, loopEnd, 1, 2);
            TestHelpers.MatchSlots(loopEnd, process, 0, 0);
            TestHelpers.MatchSlots(process, end, 0, 0);

            List <LoopPair> loops = new LoopDetector(TestHelpers.ConvertToDictionary(nodes)).FindLoops();

            Assert.AreEqual(1, loops.Count, "incorrect amount of loops detected");
            Assert.AreEqual(0, loops[0].Depth);
        }
예제 #3
0
        public void KataTests()
        {
            LDNode n;

            n = LoopDetector.createChain(1, 3);
            _pobj.getLoopSize(n).ShouldBe(3);
            n = LoopDetector.createChain(3, 30);
            _pobj.getLoopSize(n).ShouldBe(30);
            n = LoopDetector.createChain(3904, 1087);
            _pobj.getLoopSize(n).ShouldBe(1087);
        }
예제 #4
0
        public void FourNodesWithLoopSize3()
        {
            var n1 = new LoopDetector.Node();
            var n2 = new LoopDetector.Node();
            var n3 = new LoopDetector.Node();
            var n4 = new LoopDetector.Node();

            n1.next = n2;
            n2.next = n3;
            n3.next = n4;
            n4.next = n2;
            Assert.AreEqual(3, LoopDetector.getLoopSize(n1));
        }
        public void MiddleExitLoops()
        {
            //                End
            //                 ᴧ
            // S -> LoopStart -> LoopEnd -> End

            List <DependentNode> nodes = new List <DependentNode>();
            { // start node
                DependentNode dep = new DependentNode(0, "start");
                dep.AddDependent(1, 0, 0);
                nodes.Add(dep);
            }
            { // loop start
                DependentNode dep = new DependentNode(1, LoopStart.TypeName);
                dep.AddDependency(0, 0, 0);
                dep.AddDependent(2, 0, 0);
                dep.AddDependent(2, 2, 1);
                dep.AddDependent(4, 1, 0);
                nodes.Add(dep);
            }
            { // condition for end loop
                DependentNode dep = new DependentNode(5, "condition");
                dep.AddDependent(2, 1, 0);
                nodes.Add(dep);
            }
            { // middle end
                DependentNode dep = new DependentNode(4, "end");
                dep.AddDependency(1, 1, 0);
                nodes.Add(dep);
            }
            { // loop end
                DependentNode dep = new DependentNode(2, LoopEnd.TypeName);
                dep.AddDependency(1, 0, 0);
                dep.AddDependency(5, 0, 1);
                dep.AddDependency(1, 1, 2);
                dep.AddDependent(3, 0, 0);
                nodes.Add(dep);
            }
            { // end node
                DependentNode dep = new DependentNode(3, "end");
                dep.AddDependency(2, 0, 0);
                nodes.Add(dep);
            }

            List <LoopPair> loops = new LoopDetector(TestHelpers.ConvertToDictionary(nodes)).FindLoops();

            Assert.AreEqual(1, loops.Count, "incorrect amount of loops detected");
            Assert.AreEqual(0, loops[0].Depth);
        }
예제 #6
0
        private void TestSingleChain(int taillength, int looplength)
        {
            LDNode n, n2;

            n = LoopDetector.createChain(taillength, looplength);
            for (int i = 0; i < taillength; i++)
            {
                //Console.WriteLine($"tail {i}: {n.ID}");
                n = n.next;
            }
            n2 = n;
            for (int i = 0; i < looplength - 1; i++)
            {
                //Console.WriteLine($"loop {i}: {n2.next.ID}");
                n2 = n2.next;
            }
            //n2.next.ID.ShouldBe(n.ID);
            n2.ShouldBe(n);
        }
        public void NoLoop()
        {
            // S -> End

            List <DependentNode> nodes = new List <DependentNode>();
            { // start node
                DependentNode dep = new DependentNode(0, "start");
                dep.AddDependent(3, 0, 0);
                nodes.Add(dep);
            }
            { // end node
                DependentNode dep = new DependentNode(3, "end");
                dep.AddDependency(0, 0, 0);
                nodes.Add(dep);
            }

            List <LoopPair> loops = new LoopDetector(TestHelpers.ConvertToDictionary(nodes)).FindLoops();

            Assert.AreEqual(0, loops.Count, "incorrect amount of loops detected");
        }
예제 #8
0
        public static long getLoopSize(LoopDetector.Node initialNode)
        {
            //Been a while since I wrote imperative code this ugly...
            ISet<LoopDetector.Node> visitedNotes = new HashSet<LoopDetector.Node>();
            var currentNode = initialNode;
            while (!visitedNotes.Contains(currentNode))
            {
                visitedNotes.Add(currentNode);
                currentNode = currentNode.next;
            }

            var endOfCycle = currentNode;
            currentNode = currentNode.next;
            var loopLength = 1;
            while (endOfCycle != currentNode)
            {
                loopLength++;
                currentNode = currentNode.next;
            }

            return loopLength;
        }
        public void NestedLoop2()
        {
            // S -> LoopStart -> LoopStart -> Process -> LoopEnd -> LoopEnd -> End

            List <DependentNode> nodes          = new List <DependentNode>();
            DependentNode        start          = new DependentNode(0, "start"),
                                 outerLoopStart = new DependentNode(1, LoopStart.TypeName),
                                 innerLoopStart = new DependentNode(2, LoopStart.TypeName),
                                 process        = new DependentNode(3, ""),
                                 innerLoopEnd   = new DependentNode(4, LoopEnd.TypeName),
                                 outerLoopEnd   = new DependentNode(5, LoopEnd.TypeName),
                                 end            = new DependentNode(6, "end");

            nodes.Add(start);
            nodes.Add(outerLoopEnd);
            nodes.Add(innerLoopEnd);
            nodes.Add(innerLoopStart);
            nodes.Add(outerLoopStart);
            nodes.Add(process);
            nodes.Add(end);

            TestHelpers.MatchSlots(start, outerLoopStart, 0, 0);
            TestHelpers.MatchSlots(outerLoopStart, outerLoopEnd, 0, 0);
            TestHelpers.MatchSlots(outerLoopStart, innerLoopStart, 2, 2);
            TestHelpers.MatchSlots(innerLoopStart, innerLoopEnd, 0, 0);
            TestHelpers.MatchSlots(innerLoopStart, process, 2, 0);
            TestHelpers.MatchSlots(process, innerLoopEnd, 0, 2);
            TestHelpers.MatchSlots(innerLoopEnd, outerLoopEnd, 0, 2);
            TestHelpers.MatchSlots(outerLoopEnd, end, 0, 0);

            List <LoopPair> loops = new LoopDetector(TestHelpers.ConvertToDictionary(nodes)).FindLoops();

            Assert.AreEqual(2, loops.Count, "incorrect amount of loops detected");
            Assert.AreEqual(1, loops[0].Depth);
            Assert.AreEqual(0, loops[1].Depth);
            Assert.AreNotSame(loops[0].Id, loops[1].Id);
            Assert.AreNotSame(loops[0].End.NodeId, loops[1].End.NodeId);
        }
예제 #10
0
        public void GetLoopSizeTest(int n, int m)
        {
            var startNode = LoopDetector.GenerateLinkedNodes(n, m);

            Assert.AreEqual(m, LoopDetector.GetLoopSizeClever(startNode));
        }
예제 #11
0
        static void Main(string[] args)
        {
            var path = @"..\..\..\Data\web-baidu-baike-related.edges";

            var graphLoader = new AdjacencyListGraphLoader();

            var(graph, map) = graphLoader.Load(path);

            var similarNodeProcessor = new SimilarNodeProcessor();
            var loopDetector         = new LoopDetector();
            var graphCompressor      = new GraphCompressor(similarNodeProcessor, loopDetector);

            var compressedGraph = graphCompressor.Compress(graph);

            #region Compress ration test

            var originalGraph = (UndirectedGraph)graph;

            var originalGraphSize   = originalGraph.RawGraphStructure.Count + Enumerable.Sum(originalGraph.RawGraphStructure.Select(x => x.Value.Count)) * 64;
            var compressedGraphSize = 0.0;
            foreach (var x in compressedGraph.GraphStructure)
            {
                compressedGraphSize += 64; //ReferenceToObject
                compressedGraphSize += 64; //Id

                if (x.ReferenceId != null)
                {
                    compressedGraphSize += 64; //ReferenceId
                }

                if (x.ReferenceList != null)
                {
                    compressedGraphSize += 64; //Reference to ReferenceList
                    compressedGraphSize += x.ReferenceList.Count;
                }

                if (x.ExtraNodes != null)
                {
                    compressedGraphSize += 64; //Reference to ExtraNodeList
                    compressedGraphSize += x.ExtraNodes.Count * 64;
                }
            }

            var kkk = (compressedGraphSize / originalGraphSize) * 100; //43.76 = MAX, 43.68 = 200, 43.57 = 10, 43.55 = 1 | 94 vs 84


            var pp = compressedGraph.GraphStructure.Where(x => x.ReferenceId != null).ToList();

            #endregion

            #region Test same nodes

            var randomGenerator = new Random();
            var visitedNodes    = new HashSet <int>();
            while (true)
            {
                var nodeId = randomGenerator.Next(0, compressedGraph.GraphStructure.Count - 1);
                while (visitedNodes.Contains(nodeId))
                {
                    nodeId = randomGenerator.Next(0, compressedGraph.GraphStructure.Count - 1);
                }

                visitedNodes.Add(nodeId);

                var node = compressedGraph.GetNodeById(nodeId);
                var originalGraphNeighbors = originalGraph.RawGraphStructure[nodeId];

                if (originalGraphNeighbors.Count != node.Neighbors.Count)
                {
                    //BAD
                    Console.WriteLine();
                }


                foreach (var neighbor in originalGraph.RawGraphStructure[nodeId])
                {
                    if (!node.Neighbors.Contains(neighbor))
                    {
                        //BAD
                        Console.WriteLine();
                    }
                }
            }

            #endregion
        }
예제 #12
0
        public void RandomLongChainNodesWithLoopSize103387()
        {
            var n1 = LoopDetector.createChain(3903004, 2103387);

            Assert.AreEqual(2103387, Kata.getLoopSize(n1));
        }
예제 #13
0
        public void RandomChainNodesWithLoopSize30()
        {
            var n1 = LoopDetector.createChain(3, 30);

            Assert.AreEqual(30, Kata.getLoopSize(n1));
        }