private CompressedGraph ExecuteTest(List <SimilarNode> similarNodeList, CompressParameters compressParameters)
        {
            var sortingAlgorithm     = GetMockedSortingAlgorithm().Object;
            var similarNodeProcessor = GetMockedSimilarNodeProcessor(similarNodeList).Object;

            var graphCompressor = new GraphCompressor(sortingAlgorithm, similarNodeProcessor);

            var result = graphCompressor.Compress(new Graph(), compressParameters);

            return(result);
        }
예제 #2
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
        }