コード例 #1
0
        /// <summary>
        /// Calculates the number of triangles of that contain the given vertex on a cluster of given level.
        /// </summary>
        /// <param name="vertexNumber">The index of vertex.</param>
        /// <param name="level">The level of cluster.</param>
        /// <returns>Number of triangles.</returns>
        private SortedDictionary <Double, Double> Count3CycleOfVertex(int vertexNumber, int level)
        {
            SortedDictionary <Double, Double> result = new SortedDictionary <Double, Double>();

            result[0] = 0;  // число циклов 3 прикрепленных к данному узлу
            result[1] = 0;  // степень узла в данном подграфе
            result[2] = 0;  // индекс узла в данном подграфе

            if (level == container.Level)
            {
                result[2] = vertexNumber;
                return(result);
            }
            else
            {
                SortedDictionary <Double, Double> previousResult = Count3CycleOfVertex(vertexNumber, level + 1);
                int      vertexIndex        = (int)previousResult[2];
                int      numberNode         = container.TreeIndexStep(vertexIndex, level);
                int      branchStart        = container.FindBranches(level, numberNode);
                int      branchSize         = container.Branches[level][numberNode];
                int      currentVertexIndex = vertexIndex - branchStart;
                BitArray node = container.TreeNode(level, numberNode);

                result[0] += previousResult[0];
                result[1] += previousResult[1];
                result[2]  = numberNode;
                double degree = previousResult[1];
                for (int i = 0; i < branchSize; ++i)
                {
                    if (container.AreConnectedTwoBlocks(node, branchSize, currentVertexIndex, i))
                    {
                        result[1] += container.CountLeaves(level + 1, i + branchStart);
                        result[0] += container.CalculateNumberOfEdges(level + 1, i + branchStart);
                        result[0] += container.CountLeaves(level + 1, i + branchStart) * degree;
                        for (int j = i + 1; j < branchSize; ++j)
                        {
                            if (container.AreConnectedTwoBlocks(node, branchSize, i, j) &&
                                container.AreConnectedTwoBlocks(node, branchSize, j, currentVertexIndex))
                            {
                                result[0] += container.CountLeaves(level + 1, i + branchStart) *
                                             container.CountLeaves(level + 1, j + branchStart);
                            }
                        }
                    }
                }

                return(result);
            }
        }
 protected override Double CalculateEdgesCountOfNetwork()
 {
     // TODO maybe non recursive calculation is available?
     return((Double)container.CalculateNumberOfEdges(0, 0));
 }