between-newnetworks.txt

这个文件是复杂网络的介数介绍的一些细节。

/**  
 * Created on 2007-4-9  
 *  
 * @status   
 */   
package net.analysis;   
   
import java.util.*;   
import net.utility.*;   
   
/**  
 * @author 袁韶谦  
 *   
 * 计算最小距离和介数  
 *   
 * 只能处理数组形式的网络  
 *   
 *  
 */   
public class Betweenness {   
       
    public static int MAX_INT=999999999;   
       
    /**  
     * 得到网络任意两个节点间的最短路径  
     * @param net 网络的邻接矩阵  
     * @return 最短路径矩阵  
     */   
    public static int[][] get_minimum_distance(int[][] net){   
        int[][] md=new int[net.length][net[0].length];   
           
        for(int i=0;i<NET.LENGTH;I++) if(md[i][j] j="0;j<net.length;j++){" for(int i="0;i<net.length;i++)" k="0;k<net.length;k++)" Floyed算法 初始化 } if(i="=j)md[i][j]=0;" md[i][j]="MAX_INT;" else if(net[i][j]="=0)">(md[i][k]+md[k][j])){   
                        md[i][j]=md[i][k]+md[k][j];   
                    }   
        return md;   
    }   
       
    //并行支持的最大线程个数    
    private final static int MAX_THREAD_NUMBER=2;   
       
    /**  
     * 计算介数，多线程版本  
     * @param n  
     * @return  
     */   
    public static double[] ub_betweenness_parallel(Network n){   
        double CB[]=new double[n.getNetworkSize()];   
        for(int i=0;i<CB.LENGTH;I++)CB[I]=0; for(int i="0;i<pb.length-1;i++){" if(cidx cidx++; cidx+="istep;" ParallelBetweenness(n,cidx,cidx+istep); pb[i]="new" istep="n.getNetworkSize()/MAX_THREAD_NUMBER;" int 节点序号 cidx="0;" ParallelBetweenness[MAX_THREAD_NUMBER]; pb="new" ParallelBetweenness[] 创建并行对象数组 sleepcount="(n.getNetworkSize()/MAX_THREAD_NUMBER);" long>=n.getNetworkSize()){   
                Debug.outn("-_-!!");   
            }   
        }   
        pb[MAX_THREAD_NUMBER-1]=new ParallelBetweenness(n,cidx,n.getNetworkSize()-1);   //最后一个并行对象    
           
        int cpbx=0;     //当前的并行对象    
        int stopcount=0;   
        while(true){   
            if(pb[cpbx]==null){     //这个对象还是空的，则直接创建新的运行对象    
            }else if(pb[cpbx].be_done()){       //这个对象是停止着的    
                double[] dtao=pb[cpbx].get_result();   
                   
                if(dtao!=null)  //如果包含有效的结果，则累加到最终结果上    
                    for(int i=0;i<CB.LENGTH;I++)CB[I]+=DTAO[I]; } if(stopcount 停止计数加一 stopcount++; pb[cpbx]="null;" pb[cpbx].stop(); Debug.out(?见鬼了吗？?); else{>=pb.length)break;    //已经计算完成，返回    
            }else{  //这个对象正在进行计算    
                try{   
                    Thread.sleep(sleepcount);   //休眠一会    
                }catch(InterruptedException ie){}   
            }   
               
            cpbx++; //转到下一个对象    
            if(cpbx==pb.length)cpbx=0;   
        }///while true    
           
        return CB;   
    }   
       
    /**  
     * 计算介数  
     * 采用Ulrik Brandes的快速介数算法  
     * @param ne  
     * @return  
     */   
    public static double[] ub_betweenness(Network n){   
        double CB[]=new double[n.getNetworkSize()];   
        for(int i=0;i<CB.LENGTH;I++)CB[I]=0; for(int i="0;i<CB.length;i++)CB[i]+=dtao[i];" } if(sidx sidx){ n,int ub_dependencies(Network double[] static public * @return sidx @param n Brandes的快速介数算法 采用Ulrik 计算单一节点的单点介数，实际介数等于所有节点的单点数之和 ** CB; return dtao="ub_dependencies(n,idx);" idx="0;idx<n.getNetworkSize();idx++){">=n.getNetworkSize())return null;   //错误的节点序号    
           
        Stack<INTEGER> S=new Stack<INTEGER>();  //Stack    
        Set<INTEGER>[] P=new Set[n.getNetworkSize()];   
        int[] count=new int[n.getNetworkSize()];   
        double[] d=new double[n.getNetworkSize()];   
        Queue<INTEGER> Q=new LinkedList<INTEGER>(); //Queue    
        double[] dtao=new double[n.getNetworkSize()];   
           
        //初始化    
        for(int i=0;i<P.LENGTH;I++)P[I]=NEW HashSet<Integer>();   
        for(int i=0;i<COUNT.LENGTH;I++)COUNT[I]=0; for(int i="0;i<d.length;i++)d[i]=-1;" while(Q.size() Q.add(sidx); d[sidx]="0;" count[sidx]="1;">0){   
            int v=Q.remove();   
            S.push(v);   
               
            int[]nbrs=n.n_neighbors(v);   
            for(int i=0;i<NBRS.LENGTH;I++){ class="" j="0;j<v_dep_result.length;j++)" for(int i="0;i<dtao.length;i++)dtao[i]/=2;" } int double[] public * @return ** return pre < v_dep_result; private v_sync; Object v_idx_end; v_idx_start; v_net; Network 标志当前的运行状态 v_running; boolean v_running="true;" 累加临时结果 v_dep_result[j]+="dtao[j];" i); double[]dtao="Betweenness.ub_dependencies(v_net," 最大优先级 setPriority(Thread.MAX_PRIORITY); run(){ void 还未计算完毕，返回null null; if(v_running)return get_result(){ !v_running; be_done(){ 用来判断运算是否已经完成 be_running(){ this.start(); double[net.getNetworkSize()]; v_dep_result="new" v_idx_end="ixE;" v_idx_start="ixS;" v_net="net;" ixE){ ixS,int net,int ParallelBetweenness(Network v_sync="sync;" this(net,ixS,ixE); sync){ ixE,Object Thread{ extends ParallelBetweenness 当然调用者需要多次创建对象，花费一定额外的系统资源 这样做的目的是想省去烦人的、又容易出现各种错误的同步过程 运算之后就可以销毁了 一次性对象，创建一次只能执行一个运算 袁韶谦 @author dtao; if(!((n.getNetworkType()&Network.NTYPE_DIRECTED)="=Network.NTYPE_DIRECTED)){" S empty not while dtao[v]="dtao[v]+(count[v]/count[w])*(1+dtao[w]);" v while(it.hasNext()){ it="P[w].iterator();" Iterator w="nbrs[i];" while(!S.empty()){ Q of neighbor each for P[w].add(v); count[w]="count[w]+count[v];" if(d[w]="=(d[v]+1)){" d[w]="d[v]+1;" Q.add(w); if(d[w]<0){>  
<SCRIPT src="/inc/gg_read2.js"></SCRIPT>