//公用调用接口,计算聚类相关三个参数
 public void Calculate(pNet curNetwork)
 {
     CalCluster(curNetwork);
     CalLoop(curNetwork);
     CalClose(curNetwork);
     CalAverage(curNetwork);
 }
Esempio n. 2
0
        //K-Shell核心算法
        void CalKShell(pNet curNetwork)
        {
            int intCount, intLevel;
            List<int> intTarget;

            intCount = InitState(ref curNetwork);
            intLevel = 1;
            intTarget = new List<int>();
            while (intCount < curNetwork.intNumber)
            {
                intTarget.Clear();
                foreach (pNode curNode in curNetwork.Network)
                {
                    if(curNode.State == -1 && curNode.Degree == intLevel)
                    {//选中度和当前级别相等的,并没有赋值的节点
                        curNode.State = intLevel;
                        intCount += 1;
                        intTarget.Add(curNode.Number);
                    }
                }
                if (intTarget.Count == 0)
                {//当前循环没有节点则增加一级
                    intLevel += 1;
                }
                else
                {//选中的节点,删除所有连边
                    DeleteEdges(intTarget, ref curNetwork);
                    intLevel = 0;
                }
            }
            foreach (pNode curNode in curNetwork.Network)
            {
                intKShell[curNode.Number] = curNode.State;
            }
        }
Esempio n. 3
0
 //PageRank核心算法
 void CalPageRank(pNet curNetwork)
 {
     int i;
     double dubPiece;
     //遍历网络节点
     foreach (pNode curNode in curNetwork.Network)
     {
         if (curNode.Degree == 0)
         {
             newPageRank[curNode.Number] = dubPageRank[curNode.Number];
         }
         else
         {//将值分给朋友
             dubPiece = dubPageRank[curNode.Number] / curNode.Degree;
             foreach (Edge edge in curNode)
             {
                 newPageRank[edge.Target] += dubPiece;
             }
         }
     }
     for (i = 0; i < curNetwork.intNumber; i++)
     {
         dubPageRank[i] = newPageRank[i];
         newPageRank[i] = 0.0;
     }
 }
Esempio n. 4
0
 //公开接口函数
 public void Calculate(pNet curNetwork, int iTime)
 {
     int i;
     for (i = 0; i < iTime; i++)
     {
         CalPageRank(curNetwork);
     }
 }
Esempio n. 5
0
 public DiaParameter(FrmMain owner)
 {
     InitializeComponent();
     //设置FrmMain为父窗体,可以读取父窗体数据
     father = owner;
     XmlDocument doc = father.ComplexNet.ToXML();
     curNetwork = new pNet(doc);
 }
Esempio n. 6
0
 //计算最短路径
 void CalSmallPaths(pNet curNetwork)
 {
     int i, j;
     for (i = 0; i < curNetwork.intNumber; i++)
     {
         CalPath(i, ref curNetwork);         //以每个节点为起点,向其他点传播信息,获得距离
         for (j = 0; j < curNetwork.intNumber; j++)
         {
             intDistance[i, j] = curNetwork.Network[j].State;
             curNetwork.Network[j].State = 0;
         }
     }
 }
        //计算聚类系数
        void CalCluster(pNet curNetwork)
        {
            int intLeft, intRight;
            int intTotal, intSum, intUnit, intRes;
            double sngCluster;

            foreach (pNode curNode in curNetwork.Network)//遍历每个节点
            {
                intSum = 0;
                intTotal = 0;
                foreach (Edge edge1 in curNode)//遍历当前节点的所有邻居
                {
                    intLeft = edge1.Target;
                    intUnit = (int)Math.Ceiling(edge1.Value);
                    foreach (Edge edge2 in curNode)//遍历当前节点的所有邻居
                    {
                        intRight = edge2.Target;
                        intUnit += (int)Math.Ceiling(edge2.Value);
                        if (intRight == intLeft)//相等跳过
                        {
                            continue;
                        }
                        intRes = (int)Math.Ceiling(IsFriend(intLeft, intRight, curNetwork.Network));
                        if (intRes == -1)//不相邻则加上当前边的权重
                        {
                            intTotal += intUnit;
                        }
                        else//相邻则加上当前边的权重和返回权重
                        {
                            intUnit += intRes;
                            intTotal += intUnit;
                            intSum += intUnit;
                        }
                    }
                }
                if (intTotal == 0)//防止除零
                {
                    sngCluster = 0.0;
                }
                else
                {
                    sngCluster = intSum * 1.0 / intTotal;
                }
                dubCluster[curNode.Number] = sngCluster;
            }
        }
Esempio n. 8
0
 //节点状态初始化函数
 int InitState(ref pNet curNetwork)
 {
     int intCount = 0;
     foreach (pNode curNode in curNetwork.Network)
     {
         if (curNode.Degree == 0)
         {
             curNode.State = 0;
             intCount++;
         }
         else
         {
             curNode.State = -1;
         }
     }
     return intCount;
 }
Esempio n. 9
0
        //广度优先搜索计算路径
        void CalPath(int iSource, ref pNet curNetwork)
        {
            int intLevel = 1, intSource, intMaster, intTarget, intRound;

            foreach (pNode curNode in curNetwork.Network)
            {
                if (curNode.Number != iSource)
                {
                    curNode.State = -1;
                }
            }
            intSource = iSource;
            intMaster = intSource;
            curNetwork.Network[intSource].State = 0;
            foreach (Edge edge in curNetwork.Network[intSource])//对初始节点的第一层外围节点进行初始化
            {
                intTarget = edge.Target;
                curNetwork.Network[intTarget].State = intLevel;
            }
            while (true)//循环向周围节点(未得到信息)传播,直到不再有节点收到数据包
            {
                intRound = 0;
                foreach (pNode curNode in curNetwork.Network)
                {
                    if (curNode.State == intLevel)
                    {
                        intSource = curNode.Number;
                        foreach (Edge edge in curNode)
                        {
                            intTarget = edge.Target;
                            if (curNetwork.Network[intTarget].State == -1 && intTarget != intMaster)
                            {
                                curNetwork.Network[intTarget].State = intLevel + 1;
                                intRound++;
                            }
                        }
                    }
                }
                if (intRound == 0)
                {//本次没有一个新节点被处理,则认为传播完毕
                    break;
                }
                intLevel += 1;
            }
        }
Esempio n. 10
0
        //计算环路系数
        void CalLoop(pNet curNetwork)
        {
            double sngResult = 0.0;
            int intDeg = 0;
            int intDown = 0;
            int intDistance = 0;
            double sngUp = 0;

            foreach(pNode curNode in curNetwork.Network)
            {
                intDeg = curNode.Degree;
                sngUp = 0.0;
                sngResult = 0.0;
                intDown = 1;
                if (intDeg == 0 || intDeg == 1)
                {
                    dubLoop[curNode.Number] = 1.0;
                    continue;
                }
                foreach (Edge edge1 in curNode)
                {
                    foreach (Edge edge2 in curNode)
                    {
                        if (edge1.Target != edge2.Target)
                        {
                            intDistance = CalDistance(edge1.Target, edge2.Target, curNode.Number, curNetwork);
                            if (intDistance == 1)
                            {
                                sngUp += 1.0 / intDistance;
                            }
                            else if (intDistance != -1)
                            {
                                sngUp += 1.0 / intDistance;
                            }
                            else
                            {
                                sngUp += 0;
                            }
                        }
                    }
                }
                intDown = intDeg * (intDeg - 1);
                sngResult = sngUp / intDown;
                dubLoop[curNode.Number] = sngResult;
            }
        }
Esempio n. 11
0
        //计算平均值
        void CalAverage(pNet curNetwork)
        {
            double totalCluster = 0;               
            double totalLoop = 0;                  
            double totalClose = 0;

            if (curNetwork.intNumber == 0)
            {
                AveCluster = 0;
                AveLoop = 0;
                AveClose = 0;
            }
            for (int i = 0; i < curNetwork.intNumber; i++)
            {
                totalCluster += dubCluster[i];
                totalLoop += dubLoop[i];
                totalClose += dubClose[i];
            }
            AveCluster = totalCluster / (curNetwork.intNumber * 1.0);
            AveLoop = totalLoop / (curNetwork.intNumber * 1.0);
            AveClose = totalClose / (curNetwork.intNumber * 1.0);
        }
Esempio n. 12
0
 //计算接近中心度
 void CalClose(pNet curNetwork)
 {
     int[,] intDistance;
     int intCount, intSum;
     DistanceStrategy disStrategy = new DistanceStrategy(curNetwork.Number);
     disStrategy.Calculate(curNetwork);
     intDistance = disStrategy.Distance;
     foreach(pNode sourNode in curNetwork.Network)
     {
         intSum = 0;
         intCount = 0;
         foreach(pNode tarNode in curNetwork.Network)
         {
             if (intDistance[sourNode.Number,tarNode.Number] > 0)
             {
                 intCount += 1;
                 intSum += intDistance[sourNode.Number, tarNode.Number];
             }
         }
         if (intSum == 0)
         {
             dubClose[sourNode.Number] = 0;
         }
         else
         {
             dubClose[sourNode.Number] = intCount * 1.0d / intSum;
         }
     }
 }
Esempio n. 13
0
 //节点状态初始化
 void InitState(int iValue, ref pNet curNetwork)
 {
     foreach(pNode curNode in curNetwork.Network)
     {
         curNode.State = iValue;
     }
 }
Esempio n. 14
0
        //连边删除
        void DeleteEdges(List<int> Source, ref pNet curNetwork)
        {
            List<int> Target;

            foreach (int iNum in Source)
            {
                Target = new List<int>();
                //不能再foreach内部改变节点的连边,只能先记录下来
                foreach (Edge edge in curNetwork.Network[iNum])
                {
                    Target.Add(edge.Target);
                }
                //依据记录结果删除连边
                foreach (int intTarget in Target)
                {
                    curNetwork.DecEdge(iNum, intTarget);
                }
            }
        }
Esempio n. 15
0
 //公用调用接口,计算距离相关三个参数
 public void Calculate(pNet curNetwork)
 {
     CalSmallPaths(curNetwork);
     CalAveDistance(curNetwork.Number);
     CalDiameter(curNetwork.Number);
 }
Esempio n. 16
0
        //信息传播方法,计算两点间距离
        int CalDistance(int iSource, int iTarget, int iMask, pNet curNetwork)
        {
            int intLevel = 0;
            int intTarget = 0, intRound;

            if (iSource == iTarget)
            {
                return 0;
            }
            InitState(-1, ref curNetwork);
            curNetwork.Network[iSource].State = 0;
            foreach (Edge edge in curNetwork.Network[iSource])
            {
                intTarget = edge.Target;
                if (intTarget == iTarget)
                {
                    return 1;
                }
                if (intTarget == iMask)
                {
                    continue;
                }
                curNetwork.Network[intTarget].State = 1;
            }
            intLevel = 1;
            while (true)//循环向周围节点(未得到信息)传播,直到不再有节点收到数据包
            {
                intRound = 0;
                foreach (pNode curNode in curNetwork.Network)
                {
                    if (curNode.State == intLevel)
                    {
                        foreach (Edge edge in curNode)
                        {
                            intTarget = edge.Target;
                            if (curNetwork.Network[intTarget].State == -1 && intTarget != iSource)
                            {
                                curNetwork.Network[intTarget].State = intLevel + 1;
                                intRound++;
                            }
                            if (intTarget == iTarget)
                            {
                                return intLevel;
                            }
                            if (intTarget == iMask)
                            {
                                continue;
                            }
                        }
                    }
                }
                if (intRound == 0)
                {//本次没有一个新节点被处理,则认为传播完毕
                    break;
                }
                intLevel += 1;
            }
            return -1;
        }
Esempio n. 17
0
 //公开接口函数
 public void Calculate(pNet curNetwork)
 {
     CalKShell(curNetwork);
 }