testlg.cpp

在复杂网络中如何 统计度、出度、入度、出权、入权、边权、点权分布

	//获取authorid文本文件的数据，即连接的起点
	i=0;
	j=0;
	fgets(line,256,fp);
	while (!feof(fp))
	{ 
      m_Temp=atoi(line);
      m_Link1[i]=m_Temp;
	  i++;
	  j++;
	  fgets(line,256,fp);
	}
     
    //获取p_authorid文本文件的数据，即连接的终点
    i=0;
	fgets(line2,256,fp1);
	while (!feof(fp1))
	{ 
      m_Temp=atoi(line2);
      m_Link2[i]=m_Temp;
	  i++;
	  fgets(line2,256,fp1);
	}
    //获取node文本文件的数据
	i=0;
	fgets(line3,256,Node);
	while (!feof(Node))
	{ 
      m_Temp=atoi(line3);
      m_Node[i]=m_Temp;
	  i++;
      m_Nodeptr++;
	  fgets(line3,256,Node);
	}
     
	 for(i=0;i<=j;i++)
	 {
        if(m_EdgeWeight[m_Link1[i]][m_Link2[i]]!=0)      //看节点Link1[i]和节点Link2[i]之间是否已经存在边
			
			{
		     m_EdgeWeight[m_Link1[i]][m_Link2[i]]++;       //如果已经存在，则只是把边的权重进行加1
             m_OutWeight[m_Link1[i]]++;                   //连接的起点的出权加1
		     m_InWeight[m_Link2[i]]++;                   //连接的终点的入权加1	 
		}
		   else
		   { 
		     m_EdgeWeight[m_Link1[i]][m_Link2[i]]=1;       //为边的权重赋值为1
		     m_OutDegree[m_Link1[i]]++;                   //连接的起点的出度加1
		     m_InDegree[m_Link2[i]]++;                    //连接的终点的入度加1
             m_OutWeight[m_Link1[i]]++;                   //连接的起点的出权加1
		     m_InWeight[m_Link2[i]]++;                    //连接的终点的入权加1
		     m_TotalDegree=m_TotalDegree+2;              //网络总度加2
		     m_Degree[m_Link1[i]]++;                     //节点的度加1
             m_Degree[m_Link2[i]]++;                      //节点的度加1
		     m_Edge[m_Edgeptr]=m_Link1[i];               //存储边
             m_Edgeptr=m_Edgeptr+1; 
		     m_Edge[m_Edgeptr]=m_Link2[i];
             m_Edgeptr=m_Edgeptr+1;                            //边的存储位置指针加1
		}
		   m_NodeWeight[m_Link1[i]]=m_InWeight[m_Link1[i]]+m_OutWeight[m_Link1[i]];     //计算点权，为点入权与点出权的和
	       m_NodeWeight[m_Link2[i]]=m_InWeight[m_Link2[i]]+m_OutWeight[m_Link2[i]];     //计算点权，为点入权与点出权的和
	 }
   //统计度、出度、入度、出权、入权、边权、点权分布

    for(i=0;i<=m_Nodeptr;i++)        //找出度最大的点
	{
	   if(m_Degree[i]>m_MaxDegree)
		   m_MaxDegree=m_Degree[i];
       if(m_InDegree[i]>m_MaxInDegree)
		   m_MaxInDegree=m_InDegree[i];
       if(m_OutDegree[i]>m_MaxOutDegree)
		   m_MaxOutDegree=m_OutDegree[i];
       if(m_InWeight[i]>m_MaxInWeight)
		   m_MaxInWeight=m_InWeight[i];
       if(m_OutWeight[i]>m_MaxOutWeight)
		   m_MaxOutWeight=m_OutWeight[i];
       if(m_EdgeWeight[i][i]>m_MaxEdgeWeight)
		   m_MaxEdgeWeight=m_EdgeWeight[i][i];	
	   if(m_NodeWeight[i]>m_MaxNodeWeight)
	       m_MaxNodeWeight=m_NodeWeight[i];
	}
	for(i=0;i<=m_Nodeptr;i++)
		for(j=0;j<=m_Nodeptr;j++)
		{
		  if(m_EdgeWeight[i][j]>m_MaxEdgeWeight)
		   m_MaxEdgeWeight=m_EdgeWeight[i][j];	
		}
	m_DegreeVsNum=(int *)calloc(1,(m_MaxDegree+1)*sizeof(int));
    m_OutDegreeVsNum=(int *)calloc(1,(m_MaxOutDegree+1)*sizeof(int));
    m_InDegreeVsNum=(int *)calloc(1,(m_MaxInDegree+1)*sizeof(int));
    m_OutWeightVsNum=(int *)calloc(1,(m_MaxOutWeight+1)*sizeof(int));
    m_InWeightVsNum=(int *)calloc(1,(m_MaxInWeight+1)*sizeof(int));
    m_EdgeWeightVsNum=(int *)calloc(1,(m_MaxEdgeWeight+1)*sizeof(int));
    m_NodeWeightVsNum=(int *)calloc(1,(m_MaxNodeWeight+1)*sizeof(int));
    for(i=0;i<=m_Nodeptr;i++)
	{
	   m_DegreeVsNum[m_Degree[i]]++;
       m_OutDegreeVsNum[m_OutDegree[i]]++;
       m_InDegreeVsNum[m_InDegree[i]]++;
       m_OutWeightVsNum[m_OutWeight[i]]++;
       m_InWeightVsNum[m_InWeight[i]]++;
       m_NodeWeightVsNum[m_NodeWeight[i]]++;
	}
    for(i=0;i<=m_Nodeptr;i++)
		for(j=0;j<=m_Nodeptr;j++)
       m_EdgeWeightVsNum[m_EdgeWeight[i][j]]++;
	//计算出对数
	FILE *fp_DF,*fp_OutDF,*fp_InDF,*fp_OutWeight,*fp_InWeight,*fp_EdgeWeight,*fp_NodeWeight;
	float m_a,m_b,m_c,m_d,m_e,m_theta;
	int m_TotalPtr=0;
	m_a=m_b=m_c=m_d=m_e=0;
	fp_DF=fopen("DrawDegreeOri.txt","w+");    //保存度log_log数据
    fp_OutDF=fopen("DrawOutDegreeOri.txt","w+");    //保存出度log_log数据
    fp_InDF=fopen("DrawInDegreeOri.txt","w+");    //保存入度log_log数据
    fp_OutWeight=fopen("DrawOutWeightOri.txt","w+");    //保存出权log_log数据
    fp_InWeight=fopen("DrawInWeightOri.txt","w+");    //保存入权log_log数据
    fp_EdgeWeight=fopen("DrawEdgeWeightOri.txt","w+");    //保存入权log_log数据
    fp_NodeWeight=fopen("DrawNodeWeightOri.txt","w+");    //保存入权log_log数据

	
	for(i=0;i<=m_MaxDegree;i++)                    //保存度log_log数据
	{
	   if(m_DegreeVsNum[i]==0) continue;
       fprintf(fp_DF,"%f      %f      %d       %d\n",log(i),log(m_DegreeVsNum[i]),i,m_DegreeVsNum[i]);
	   m_a=m_a+log(i)*m_DegreeVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_DegreeVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_DF,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxOutDegree;i++)                        //保存出度log_log数据
	{
	   if(m_OutDegreeVsNum[i]==0) continue;
       fprintf(fp_OutDF,"%f      %f      %d       %d\n",log(i),log(m_OutDegreeVsNum[i]),i,m_OutDegreeVsNum[i]);
	   m_a=m_a+log(i)*m_OutDegreeVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_OutDegreeVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_OutDF,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxInDegree;i++)                        //保存入度log_log数据
	{
	   if(m_InDegreeVsNum[i]==0) continue;
       fprintf(fp_InDF,"%f      %f      %d       %d\n",log(i),log(m_InDegreeVsNum[i]),i,m_InDegreeVsNum[i]);
	   m_a=m_a+log(i)*m_InDegreeVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_InDegreeVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_InDF,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxOutWeight;i++)                        //保存出权log_log数据
	{
	   if(m_OutWeightVsNum[i]==0) continue;
       fprintf(fp_OutWeight,"%f      %f      %d       %d\n",log(i),log(m_OutWeightVsNum[i]),i,m_OutWeightVsNum[i]);
	   m_a=m_a+log(i)*m_OutWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_OutWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_OutWeight,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxInWeight;i++)                        //保存入权log_log数据
	{
	   if(m_InWeightVsNum[i]==0) continue;
       fprintf(fp_InWeight,"%f      %f      %d       %d\n",log(i),log(m_InWeightVsNum[i]),i,m_InWeightVsNum[i]);
	   m_a=m_a+log(i)*m_InWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_InWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_InWeight,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxEdgeWeight;i++)                        //保存边权log_log数据
	{
	   if(m_EdgeWeightVsNum[i]==0) continue;
       fprintf(fp_EdgeWeight,"%f      %f      %d       %d\n",log(i),log(m_EdgeWeightVsNum[i]),i,m_EdgeWeightVsNum[i]);
	   m_a=m_a+log(i)*m_EdgeWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_EdgeWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_EdgeWeight,"m_theta=%f\n",m_theta);

    for(i=0;i<=m_MaxNodeWeight;i++)                        //保存点权log_log数据
	{
	   if(m_NodeWeightVsNum[i]==0) continue;
       fprintf(fp_NodeWeight,"%f      %f      %d       %d\n",log(i),log(m_NodeWeightVsNum[i]),i,m_NodeWeightVsNum[i]);
	   m_a=m_a+log(i)*m_NodeWeightVsNum[i];
	   m_b=m_b+log(i);
	   m_c=m_c+m_NodeWeightVsNum[i];
	   m_d=m_d+log(i)*log(i);
	   m_TotalPtr;
	}
	m_e=m_b*m_b;
	m_theta=m_a-(m_b*m_c)/float(m_TotalPtr);
	m_theta=m_theta/(m_d-m_e/float(m_TotalPtr));
	fprintf(fp_NodeWeight,"m_theta=%f\n",m_theta);
	fclose(fp_DF);
    fclose(fp_OutDF);
    fclose(fp_InDF);
    fclose(fp_OutWeight);
    fclose(fp_InWeight);
    fclose(fp_EdgeWeight);
    fclose(fp_NodeWeight);

    
	
	 MessageBox("Reading and writting finished!","Finish");
	 fclose(fp);
     fclose(fp1);
     fclose(Node);
//     fclose(fp_outmeasure);
	 /*delete(m_OutDegree);
	 delete(m_InDegree);
     delete(m_Degree);
     delete(m_Edge);*/
	 return;
}

/*float CTEST3Dlg::MeanRouteLen()
{
  
	float m_MeanLean;
    m_MeanLean=CalculateLen();   
	return m_MeanLean;
}*/