精华内容
下载资源
问答
  • 无标度BA模型matlab源码, 含生成BA模型中的最大度,最小度,平均度,度分布
  • 网络科学BA模型

    2014-05-12 23:01:44
    网络科学中BA模型的检验,输出结果中每行是两个连接的点
  • BA模型代码

    2008-06-18 15:27:06
    这是一个关于BA模型生成的matlab代码
  • 可以仿真BA模型的建立,输出网络图像,得到稀疏矩阵
  • BA模型的三种扩展

    2012-03-19 20:26:31
    很好的一份学习BA模型的资源,介绍了它三种模型的扩展
  • BA模型Matlab仿真代码

    2009-10-13 16:32:36
    BA模型是对无尺度网络的一个比较准确的描述,对于研究许多真实的复杂系统有非常的大的帮助,该资源利用M-文件编程,仿真了BA模型的一些特性,非常不错
  • BA模型拓扑复杂网络

    2011-03-22 18:32:32
    复杂网络中BA模型的网络拓扑 无标度网络
  • 用修正的Master 方程分析BA模型度分布的解析式并计算,由此得到BA模型度分布对数图。把离散性的Master方程与连续性的平均场理论进行对比分析,并在同一坐标系下分别做出用两种理论计算的BA模型度分布的对数图。
  • 用修正的Master方程分析BA模型度分布的解析式并计算,由此得出BA模型度分布对数图。把离散性的Master方程与连续性的平均场理论进行对比分析,并在同一坐标系下分别作出用2种理论计算的BA模型度分布的对数图。
  • 复杂网络实验3:BA模型(matlab)

    千次阅读 多人点赞 2019-04-04 23:45:18
    1.首先确定BA模型中最重要的4个参数 m_original:未增长前的网络节点个数 m_add:每次引入新节点时新生成的边数 m_after_growth:增长后的网络规模 pp:初始网络节点的连接选择 pp=1 节点均孤立 pp=2 节点间构成...

    一.思路

    1.首先确定BA模型中最重要的4个参数

    m_original:未增长前的网络节点个数

    m_add:每次引入新节点时 新生成的边数

    m_after_growth:增长后的网络规模

    pp:初始网络节点的连接选择

    pp=1 节点均孤立  pp=2 节点间构成完全图  pp=3 随机连接一些边(随机图)

    代码中这些参数都在最前面给出,可以通过修改代码来修改模型

    2.在100*100的空间中生成m_original个点

    3.通过pp值,初始化邻接矩阵A

    4.最后生成节点,每个节点和之前m_add个节点相连

    网络科学导论的BA模型没有考虑孤立节点,但是我感觉孤立节点也应该有几率被连接吧,总得给人家一点机会吧

    不考虑孤立节点,那么一个点的连接概率按照该点的度数/总度数可以得到,因为不是孤立节点就有连边,就有度数,就有机会能够连接

    但是考虑孤立节点,没有度数,再按上方的公式给孤立节点分配连接概率,是不妥的

    这里考虑的模型是我思考出的存在孤立节点的BA模型的一个解决方案

    这里有三个值得讨论的点

    ①.连接概率的设置

    首先考虑到稀疏图中这样的场景,一共10个点,只有一条边,也就是只有两个点度数为1,其余8个点度数都是0

    这个时候,你如果用上方的公式:点度数/总度数 来分配概率,那么这8个点都没机会连接,其余两个点的连接概率是1/2

    这显然不合理,因为,这些边其实相差不大,甚至可以说基本都一样,应该都有机会能够连接。

    这里我想出的策略是

    每个点的度数:1+原度数

    总度数为:原来总度数+总点数(每个点多加一个点数)

    这样每个孤立点也有机会进行连接,度数越大连接概率也越大,不影响优先连接机制

     

    ②.连接概率存在的情况下,怎么做到随机连边

    不是说你概率越大,我就连接,这里还是使用一个随机数的方法

    如上图所示,一共ABCDE5个点,A的连接概率体现在0-A这一个区间,也就是A占据了0-A,说明A的连接概率一般

    D的连接概率体现在C-D这个区间,也就是D占据了C-D,说明D的连接概率最大

    那么我们怎么做到用上面这样的策略达到目的呢?

    概率叠加

    假设A的连接概率为0.1,B为0.1,C为0.2,D为0.4,E为0.2

    那么我们让A就是0.1,B在0.1+0.1=0.2,C在0.1+0.1+0.2=0.4,以此类推

    然后每次要选一个点进行连接的时候,取一个0-1之间的随机数,看掉落在这5个区间中的哪一个,然后取这个区间的右端端点所代表的节点进行连接,因为这个区间是他的主场(之前说过哪个区间被哪个节点占据)

    ③怎么保证每次增加一个节点就增加m_add条边?怎么保证不重复连接

    这里我在网上的模型中没找到,我使用了visit数组的概念

    当你这个节点已经连接过,那么visit数组值1,下次分配连接概率置0

    当然计算总度数的时候这个点的度数就不考虑了

    重新给每个点分配一遍概率,进行概率叠加,再进行连接

    因为连接过的点连接概率置0,所以不会重复连接,也能够起到随机连接,优先连接的目的

     

    附:模型设定

    初始状态有个节点

    增长原则:每次加入一个节点i (加入时间记为), 每个节点的加入带来m条边,2m个度的增加

              其中老节点分到的度数是m,新加入的那一个节点分到的度数为m

              那么到时间t的时候,网络的总节点数是,网络的总度数为

    优先链接原则:每一次从m条边中占有一条边的概率正比于节点的度

                  那么显然,加入的越早(越小)越容易获得更多的链接数。

                  从时间0开始,每一个时间步系统中的节点度是不断增加的。

     

    二.代码+解析

    1.第一部分,四个参数

    m_original=100;                   //未增长前网络节点个数m_original
    m_add=3;                             //每次添加一个点增加的边数m_add
    m_after_growth=1000;         //增长后的网络规模m_after_growth
    pp=1;                                   

     

    2.得到m_original个点的横纵坐标(初始网络的横纵坐标)

    x=100*rand(1,m_original);  
    y=100*rand(1,m_original);

    rand(1,n)是生成一行n列的列向量,其中每个数的值是0-1,再乘上100,相当于把点分布到100*100的二维空间中

     

    3.通过pp值得到初始网络(初始邻接矩阵A)的状态

    A=zeros(m_original);                    //初始化邻接矩阵A为全0矩阵
    switch pp                                     //通过选择pp,确定A的初始状态
        case 1                                      //节点均孤立
            A=zeros(m_original);           
        case 2                                      //完全图
            A=ones(m_original);           
        case 3                                     //随机图
            for i=1:m_original
                for j=i+1:m_original         //操纵上半角矩阵
                    p=rand(1,1);               //生成0-1随机数
                    if p>0.5                       //以1/2的概率生成边
                        A(i,j)=1;
                        A(j,i)=1;
                    end
                end
            end
    end

    4.生成增加的节点和边

    for k=m_original+1:m_after_growth     //一共生成m_after_growth-m_original+1个节点
        M=k-1;                                             //当前要生成第K个节点,那么针对的图的规模就是k-1
        p=zeros(1,M);                                  //初始化每个点的连接概率为0
        
        x_now=100*rand(1,1);                    //随机生成第K个节点的坐标
        y_now=100*rand(1,1);
        x(k)=x_now;
        y(k)=y_now;

        for i=1:M
            p(i)=(length(find(A(i,:)==1))+1)/(length(find(A==1))+M);
        end                                             //这里就是前面说的修正孤立节点连接概率为0的方法


        p                                                  //不加封号的都是为了在控制台显示出来,看看p的生成情况
        pp=cumsum(p);                           //这里就是上面说的叠加概率
        pp

    备注:对于cumsum()方法,有下方测试帮助理解


        visit=zeros(1,M);                   //初始化访问数组为全0数组(1行M列)
        for i=1:m_add                                       //开始生成m_add条边
            random_data=rand(1,1);
            random_data
            aa=find(pp>=random_data); jj=aa(1);       //通过上方介绍的叠加概率+随机数的方法,得到随机连边
     备注:find函数返回括号内“满足条件的pp的数组的下标”的数组,jj取这个数组的第一个元素,对应占领这块区域的点


            A(k,jj)=1;
            A(jj,k)=1;


            visit(jj)=1;      //标记访问
            visit               //显示访问情况


            degree=zeros(1,M);      //给出度数组来记录变化后的度值,以达到访问过度数假装变成0的目的
            total_degree=0;            //总度数
            for ii=1:M
                if visit(ii)==1
                    p(ii)=0;
                    degree(ii)=0;
                else
                    degree(ii)=length(A(i,:)==1)+1;         //如果访问过度数为0,没有就照原来的方法
                end


                total_degree=total_degree+degree(ii);   //总度数计算
            end


            for iii=1:M
                p(iii)=degree(iii)/total_degree;            //新一轮的p数组计算
            end
            p
            pp=cumsum(p);                                     //新一轮的叠加概率计算
            pp
        end
    end

    A
    plot(x,y,'ro','MarkerEdgeColor','g','MarkerFaceColor','r','MarkerSize',8);         //画出点
    hold on;
    for i=1:m_after_growth
        for j=i+1:m_after_growth                                                    //按邻接矩阵上三角矩阵画出连线
            if A(i,j)~=0                                                     //~=0是不等于0的意思,就是有边,就画出来
                plot([x(i),x(j)],[y(i),y(j)],'linewidth',1.2);
            end
        end
    end

    axis equal;                 //横纵坐标相等
    hold off;                

    三.源码

    m_original=10;
    m_add=4;
    m_after_growth=11;
    pp=1;
    
    x=100*rand(1,m_original);
    y=100*rand(1,m_original);
    
    A=zeros(m_original);
    switch pp
        case 1
            A=zeros(m_original);
        case 2
            A=ones(m_original);
        case 3
            for i=1:m_original
                for j=i+1:m_original
                    p=rand(1,1);
                    if p>0.5
                        A(i,j)=1;
                        A(j,i)=1;
                    end
                end
            end
    end
    
    for k=m_original+1:m_after_growth
        M=k-1;    
        p=zeros(1,M);
        
        x_now=100*rand(1,1);
        y_now=100*rand(1,1);
        x(k)=x_now;
        y(k)=y_now;
    
        for i=1:M
            p(i)=(length(find(A(i,:)==1))+1)/(length(find(A==1))+M);
        end
        p
        pp=cumsum(p);
        pp
        visit=zeros(1,M);
        for i=1:m_add
            random_data=rand(1,1);
            random_data
            aa=find(pp>=random_data); jj=aa(1);
            
            A(k,jj)=1;
            A(jj,k)=1;
            visit(jj)=1;
            visit
            degree=zeros(1,M);
            total_degree=0;
            for ii=1:M
                if visit(ii)==1
                    p(ii)=0;
                    degree(ii)=0;
                else
                    degree(ii)=length(A(i,:)==1)+1;
                end
                total_degree=total_degree+degree(ii);
            end
            for iii=1:M
                p(iii)=degree(iii)/total_degree;
            end
            p
            pp=cumsum(p);
            pp
        end
    end
    
    A
    plot(x,y,'ro','MarkerEdgeColor','g','MarkerFaceColor','r','MarkerSize',8);
    hold on;
    for i=1:m_after_growth
        for j=i+1:m_after_growth
            if A(i,j)~=0
                plot([x(i),x(j)],[y(i),y(j)],'linewidth',1.2);
            end
        end
    end
    
    axis equal;
    hold off;
        
           
                    
        

    四.小结

    为了有直观的体验,可以把pp设置为1,即完全孤立图
    初始点数可以设置成10,增长后的规模可以设置成11,每次连接4个点
    之后再慢慢增大网络规模进行测试,验证是否每增加一个点就能有这么多条边

    最后设置

    得到的图像如下

     

    展开全文
  • 【硕士论文代码】基于Matlab的BA无标度网络拓扑生成算法,BA模型有两个重要特性:增长特性和优先连接特性.rar
  • 介绍复杂网络的一些算法,帮助数学建模 网络图的基本概念 早期网络模型 复杂网络模型 ER模型 BA模型
  • 此文档是用matlab语言对复杂网络中BA模型,即无标度网络进行的一个编程,编程关键在于对建模过程的理解。本文档多处注释,方便读者理解。
  • 经典回顾:BA模型

    千次阅读 2020-09-04 17:15:15
    Barab´asi-Albert (BA)模型是一种生成大型网络图的方法。 动机 许多大型网络的一个共同性质是顶点的度遵循幂律分布(指数分布),又被称为无标度网络。Barab´asi-Albert (BA)模型就是用来生成这种网络。 构造方法 ...

    简介

    Barab´asi-Albert (BA)模型是一种生成大型网络图的方法。

    动机

    许多大型网络的一个共同性质是顶点的度遵循幂律分布(指数分布),又被称为无标度网络。Barab´asi-Albert (BA)模型就是用来生成这种网络。

    构造方法

    为了构造这种网络需要满足两种属性:(1)网络需要不断增加新的节点不断拓展;(2)新增的节点更有可能与原网络中度更大的节点相连。
    具体过程:初始网络有 m 0 m_0 m0个无连接的顶点,每次都会添加一个新节点,新节点会与 m m m m ≤ m 0 m \leq m_0 mm0)个原节点相连,与第i个节点连接的概率为: p i = k i / ∑ j k j p_i=k_i/∑_jk_j pi=ki/jkj,当添加t个节点后,网络中会有 m 0 + t m_0+t m0+t个节点,和个 m t mt mt个边。此时节点的度 k k k的分布满足:
    p ( k ) = k − λ p(k)=k^{-\lambda} p(k)=kλ

    参考文献

    Barabási A L, Albert R. Emergence of scaling in random networks[J]. science, 1999, 286(5439): 509-512.

    展开全文
  • 基于BA无标度网络模型,融合微博用户网络的特征,构造一种微博谣言传播网络模型。提出一种新的SIR(susceptible-infected-removed)模型,通过数值仿真探讨微博谣言的传播动力学行为。研究表明,当微博用户规模以及...
  • BA模型实现算法BA_net.m

    2010-06-10 23:21:13
    matlab版本的BA网络实现算法,对研究复杂网络很有帮助的,方便大家的研究。
  • 视觉SLAM—BA模型的理解

    千次阅读 2019-02-12 10:28:54
    BA的定义: 从视觉重建中提炼出最优的3D模型和相机参数,从每个特征点反射出来的几束光线,把相机姿态和特征点空间位置做出最优调整之后,最后收束到相机光心的过程简称BA。它在视觉SLAM中起核心作用。BA本质上就是...

    参考高翔《视觉SLAM十四讲》

    PnP是通过一组匹配好的3D点和2D点来求解两帧图像之间运动的一种算法。PNP的求解有DLT(直接线性变换)、P3P、EPNP和BA优化等方式。ICP的求解有两种方式:线性代数的求解(SVD),非线性优化方式(BA).本文主要讲解BA(Bundle Adjustment)。

    基于图的SLAM算法里面使用图优化替代了原来的滤波器,这里图优化就是指BA。
    BA的定义: 从视觉重建中提炼出最优的3D模型和相机参数,从每个特征点反射出来的几束光线,把相机姿态和特征点空间位置做出最优调整之后,最后收束到相机光心的过程简称BA。它在视觉SLAM中起核心作用。
    BA本质上就是最小化重投影残差同时优化位姿和路标点,以便从每个特征点反射出的光线通过调整最后都能通过相机光心,因此也称捆集优化或光束平差法

    a. BA的代价函数

    视觉SLAM中的观测方程误差:e=z-h(\xi ,p)                                   (1)

    代价函数为:\frac{1}{2}\sum_{i=1}^{m} \sum _{j=1}^{n}\left \| e_{ij} \right \|^2=\frac{1}{2}\sum_{i=1}^{m}\sum_{j=1}^{n}\left \| z_{ij}-h(\xi _i,p_i) \right \|^2          (2)

    其中\frac{1}{2}\sum_{i=1}^{m} \sum _{j=1}^{n}\left \| e_{ij} \right \|^2表示为第i个相机第j个特征点的重投影误差之和,\frac{1}{2}\sum_{i=1}^{m}\sum_{j=1}^{n}\left \| z_{ij}-h(\xi _i,p_i) \right \|^2中的z_{ij}表示第i个相机第j个特征点在原始图像中的实际像素位置,\xi _{i}表示第i个相机的位姿,p_{i}表示第i个特征点的世界坐标系位置。

    BA的就是获取使得公式(2)右边值最小化时,\xi _{i}的取值。其中需要用到非线性最小二乘优化,即通过最小化误差的平方和寻找数据的最佳函数匹配,其中最常用的四种数值优化方法:最速下降法、牛顿法、Gauss-Newton法和Levenberg-Marquardt法。

     

    b.BA的求解

    假定x=[\xi _1,\cdots ,\xi_m,p_1,\cdots,p_2],则公式(2)的增量变为\frac{1}{2}\left \| f(x+\bigtriangleup x) \right \|^2\approx \frac{1}{2}\sum_{i=1}^{m}\sum_{j=1}^{n}\left \|e_{ij}+F_ij\bigtriangleup \xi_i +E_{ij}\bigtriangleup p_j \right \|^2其中Fij表示整个代价函数在当前状态下对相机姿态的领导,Eij表示对路标点的偏导。此后便可用最速下降法、牛顿法、Gauss-Newton法和Levenberg-Marquardt法等求解最误差最小值时的位姿,具体解法可参考 https://blog.csdn.net/xranmail/article/details/101015295和 https://www.cnblogs.com/liuweixin/p/11901266.html

     

     

    展开全文
  • #资源达人分享计划#
  • BA网络模型

    2016-04-21 15:11:08
    模拟BA网络的建立过程,编程语言为matlab
  • 针对基本BA网络模型模拟现实网络的局限性, 采用新节点的度数增加服从泊松分布的随机函数来代替传统BA模型中的常数, 修改了节点度数的增长方式, 提出了一种基于边数随机增长的改进网络模型。从理论分析和实验验证两...
  • BA网络演化模型论文

    2009-05-28 21:41:50
    BA模型是一个随机生成算法无尺度网络使用优惠附着机制。无尺度网络中被广泛观察的自然和人为系统,包括因特网,世界引文网络,和一些社会网络。它包括两个重要的基本概念:经济增长和优惠附件。经济增长和优惠附件...
  • BA网络模型matlab程序代码

    热门讨论 2012-11-23 14:30:48
    上传是关于非常经典的BA网络模型的matlab代码程序,欢迎大家学习并下载。
  • BA无标度网络模型

    2012-12-09 21:47:50
    BA无标度网络模型的matlab实现代码,有利于数学建模
  • 经典的BA网络模型

    2015-10-11 11:15:00
    详细的描述BA网络模型的构建,此程序基于matlab软件,为初学者提供一些指导
  • BA小世界模型 BA 小世界模型 matlab 程序 BA 小世界模型 matlab 程序
  • BA无标度网络中的SIR模型
  • BA无标度网络模型构造算法

    万次阅读 多人点赞 2016-05-19 15:09:58
    BA无边度网络模型构造算法 (1)增长:从一个具有 m_0 个节点的联通网络开始,每次引入一个新的节点, 并且连到 m 个已经存在的节点上,这里 m (2)优先连接:一个新的节点与一个已经存在的节点 i 相连的概率 w ...

    BA无边度网络模型构造算法

    (1)增长:从一个具有 m_0 个节点的联通网络开始,每次引入一个新的节点, 并且连到 m 个已经存在的节点上,这里 m <= m_0。

    (2)优先连接:一个新的节点与一个已经存在的节点 i 相连的概率 w 与节点 i 的度 k_i 之间的关系为 w = k_i / ( k_1 + k_2 + k_3 + ... + k_n ),其中n为网络中的节点的总个数。


    特别的说明下代码中涉及到结构体Node的作用和思路:

    三个数据域:

                   (1) degree:表示节点的度
                   (2) weight:表示被选择的概率,即 w_i = k_i / ( k_1 + k_2 + ... + k_n )
                   (3) probabilityDistribution: 给出每一个节点的概率分布,作用是通过产生0~1之间的随机数来做出决策。
                   为什么在有了weight的情况下还需要用probabilityDistribution?
                   example: 假设在一个网络中一共有5个节点,每个节点的度如下: d_1 = 4,   d_2 = 1,   d_3 = 2,   d_4 = 2,   d_5 = 1.
                   那么可以计算出每个节点的weight如下: w_1 = 0.4, w_2 = 0.1, w_3 = 0.2, w_4 = 0.2, w_5 = 0.1
                   也就是说, 当有一个新的节点出现时候,它连接到节点1的概率为0.4,连接到节点2的概率为0.1, ...
                   可以用下图来表示:

             

                   这个时候,这个新的节点要选择已有网络中的那个节点连接是随机的,但是和这些已有节点的度是成正比的,度愈大的节点越有可能被连接,此时,由系统产生一个 0~1 之间的随机数,比如0.6,那么则选择新的节点与节点 3 相连。



    代码实

    #include<stdio.h>
    #include<stdlib.h>
    #include<time.h>
    #include<string.h>
    #include "for_plot.c"
    
    int NETWORK_SIZE, M, M_0;
    
    struct Node;
    typedef struct Node* NodePtr;
    typedef struct Node{
    	int degree;
    	double weight;
    	double probabilityDistribution;
    }Node;
    
    Node* decisionMaking;
    int** adjacentMatrix;
    int* initalNetwork;
    
    void initial();
    void initalNetwork_M0_connected();
    void updateDecisionMakingData();
    void generateFreeScaleNetwork();
    void showAdjacentMatrix();
    void writeDataToFile();
    
    int main(int argc, char** argv)
    {
    	if( 4 != argc )
    	{
    		printf("this algorithm requires 4 user-specify parameters\n");
    		printf("\t1.the size of network\n");
    		printf("\t2.the initial size of network\n");
    		printf("\t1.the size of \n");
    		printf("\texample: \"a.exe 100 3 3\"\n");
    		exit(0);
    	}
    	NETWORK_SIZE = atoi(argv[1]);
    	M_0 = atoi(argv[2]);
    	M = atoi(argv[3]);
    	srand((unsigned)time(NULL));
    	initial();
    	initalNetwork_M0_connected();
    	generateFreeScaleNetwork();
    	writeDataToFile();
    	showAdjacentMatrix();
    
    	write2file(adjacentMatrix, NETWORK_SIZE, "freeScale_edges.data");
    	return 0;
    }
    
    void initial()
    {
    	if( !(decisionMaking = (NodePtr)malloc(sizeof(Node) * (NETWORK_SIZE + 1))) )
    	{
    		printf("decisionMaking* malloc error\n");
    		exit(0);
    	}
    	if( !(adjacentMatrix = (int**)malloc(sizeof(int*) * (NETWORK_SIZE + 1))) )
    	{
    		printf("adjacentMatrix** malloc error\n");
    		exit(0);
    	}
    	int i;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    	{
    		if( !(adjacentMatrix[i] = (int*)malloc(sizeof(int) * (NETWORK_SIZE + 1))) )
    		{
    			printf("adjacentMatrix[%d]* malloc error\n", i);
    			exit(0);
    		}
    	}
    	if( !(initalNetwork = (int*)malloc(sizeof(int) * (M_0 + 1))) )
    	{
    		printf("initalNetwork* malloc error\n");
    		exit(0);
    	}
    }
    
    /*
     * 初始化:在NETWORK_SIZE中随机选择M_0个节点构成连通的网络。
     * */
    void initalNetwork_M0_connected(){
    	int i, j, randomFirst, randomSecond;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		for( j = 1; j <= NETWORK_SIZE; j++ )
    			adjacentMatrix[i][j] = 0;
    	// 随机产生M_0个节点
    	for( i = 1; i <= M_0; i++ )
    	{
    		initalNetwork[i] = rand() % NETWORK_SIZE + 1;
    		for( j = 1; j < i; j++ )
    			if( initalNetwork[i] == initalNetwork[j] )
    			{
    				i--;
    				break;
    			}
    	}
    	for( i = 1; i < M_0; i++ )
    		adjacentMatrix[initalNetwork[i]][initalNetwork[i+1]] = adjacentMatrix[initalNetwork[i+1]][initalNetwork[i]] = 1;
    	adjacentMatrix[initalNetwork[M_0]][initalNetwork[1]] = adjacentMatrix[initalNetwork[1]][initalNetwork[M_0]] = 1;
    
    	//showAdjacentMatrix();
    	updateDecisionMakingData();
    }
    
    /*
     * 通过adjacentMatrix更新decisionMaking数组
     * */
    void updateDecisionMakingData(){
    	int i, j, totalDegree = 0;
    
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		decisionMaking[i].degree = 0;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		for( j = 1; j <= NETWORK_SIZE; j++ )
    			decisionMaking[i].degree += adjacentMatrix[i][j];
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		totalDegree += decisionMaking[i].degree;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		decisionMaking[i].weight = decisionMaking[i].degree/(double)totalDegree;
    	decisionMaking[1].probabilityDistribution = decisionMaking[1].weight;
    	for( i = 2; i <= NETWORK_SIZE; i++ )
    		decisionMaking[i].probabilityDistribution = decisionMaking[i - 1].probabilityDistribution + decisionMaking[i].weight;
    }
    
    /*
     * 构造BA无标度网络模型
     * */
    void generateFreeScaleNetwork(){
    	int i, k, j = 1, length = 0;
    	int random_auxiliary_old[NETWORK_SIZE + 1];
    	int random_auxiliary[NETWORK_SIZE + 1 - M_0];
    
    	/*
    	 * 要保证每次引入一个<新的>的节点,所以要随机选择不重复的节点加入,并且把初始网络中的M_0个节点先删除
    	 * */
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		random_auxiliary_old[i] = i;
    	
    	for( i = 1; i <= M_0; i++ )
    		random_auxiliary_old[initalNetwork[i]] = 0;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		if( random_auxiliary_old[i] != 0 )
    			random_auxiliary[j++] = random_auxiliary_old[i];
    	
    	/*
    	 * 添加新的节点构造无标度网络
    	 * */
    	int new_node_index, new_node_value;
    	double random_decision = 0.0;
    	int targetNode;					//表示找到的已经在网络中的将要连接的节点
    	length = NETWORK_SIZE - M_0;
    	int flag;
    	for( i = 1; i <= NETWORK_SIZE - M_0; i++ )
    	{
    		new_node_index = rand() % length + 1;
    		new_node_value = random_auxiliary[new_node_index];
    		random_auxiliary[new_node_index] = random_auxiliary[length--];
    		for( j = 1; j <= M; j++ )		//根据概率连接到已存在网络中的M个节点,不可以重边,不可以自连。
    		{
    			flag = 0;
    			random_decision = (rand()%1000)/(double)1000;
    			for( k = 1; k <= NETWORK_SIZE; k++ )
    			{
    				// 从第一个节点到最后一个节点比较probabilityDistribution和random_desction的大小,
    				// 由于probabilityDistribution是有序的,所以可以使用一些高级的算法来提高查找的效率.
    				if( decisionMaking[k].probabilityDistribution >= random_decision && decisionMaking[k].degree != 0 && adjacentMatrix[new_node_value][k] != 1 )
    				{	
    					/*
    					 *
    					 *  如何按照可能性大小来选择要连哪一个点:
    					 *         选择的已经在网络中的点是:随机产生的0-1之间的概率p,找这样的点:
    					 *         它的累加概率(probabilityDistribution)是大于p的最小的值所对应的点。
    					 *
    					 */
    					targetNode = k;	
    					flag = 1;
    					break;
    				}
    			}
    			if( flag == 0 )	
    					/*
    					 * 之前少考虑了这种情况,因为总要选择一个网络中的点接入。但是当产生了比较大的随机概率p,可能
    					 * 在他后面(按probabilityDistribution来说)没有可选的点(要么选择过了,要么不在网络中),则重新开始
    					 */
    			{
    				for( k = 1; k <= NETWORK_SIZE; k++ )
    				{
    					if( decisionMaking[k].degree != 0 && adjacentMatrix[new_node_value][k] != 1 )
    					{
    						targetNode = k;
    						break;
    					}
    				}
    			}
    			//printf(" target node is %d\n", targetNode);
    			adjacentMatrix[new_node_value][targetNode] = adjacentMatrix[targetNode][new_node_value] = 1;
    		}
    		updateDecisionMakingData();		//else新选的加入节点和已有网络中的M个边都链接后再更新
    	}
    }
    
    void showAdjacentMatrix(){
    	int i, j;
    	int numberOfEage = 0;
    	printf("\tshow adjacentMatrix\n");
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    	{
    		for( j = 1; j <= NETWORK_SIZE; j++ )
    		{
    			printf("%d", adjacentMatrix[i][j]);
    			if( adjacentMatrix[i][j] == 1 )
    				numberOfEage++;
    		}
    		printf("\n");
    	}
    	printf("the number of eage is %d\n", numberOfEage/2);
    }
    
    void writeDataToFile(){
    	FILE* fout;
    	if( NULL == (fout = fopen("freeScaleNetwork.data", "w")))
    	{
    		printf("open file(freeScaleNetwork) error!\n");
    		exit(0);
    	}
    	int i;
    	int j;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    	{
    		for( j = 1; j <= NETWORK_SIZE; j++ )
    			fprintf(fout, "%d ", adjacentMatrix[i][j]);
    		fprintf(fout, "\n");
    	}
    }

    以下分别是该算法产生的BA网络的可视化图以及度分布。





    for_plot.c文件

    /*
     * 将给定的网络@adjacentMatrix(节点的个数为@size)中的所有的连边以有序对的
     * 形式输出到文件@out_filename中,每一对使用','隔开,方便python处理。
     * 该函数被所有产生网络结构的函数(generateRandomNetwork.c,
     * generateSmallNetwork.c和generateFreeScale.c)调用
     * */
    void write2file(int** adjacentMatrix, int size, char* out_filename)
    {
    	int i, j;
    	FILE* fout;
    	if( NULL == (fout = fopen(out_filename,"w")) )
    	{
    		printf("%s cann't open!\n", out_filename);
    		exit(0);
    	}
    	for( i = 1; i <= size; i++ )
    	{
    		for( j = i + 1; j <= size; j++ )
    		{
    			if( adjacentMatrix[i][j] )
    			{
    				fprintf(fout, "%d %d\n", i, j);	
    			}
    		}
    	}
    	fclose(fout);
    }

    计算网络中节点的度分布的代码(网络大小即宏NETWORK_SIZE要按照实际网络的大小修改)

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    
    #define NETWORK_SIZE	20000
    
    char targetfilename[200];
    char distribution[200];
    int adjacentMatrix[NETWORK_SIZE + 1][NETWORK_SIZE + 1];
    int degree[NETWORK_SIZE + 1];		//统计每一个节点的度
    double statistic[NETWORK_SIZE];		//用来统计,statistic[2] = 4,表示度为2的点有4个,有度为0的,
    					//不可能有度为NETWORK_SIZE的点
    
    void readDataFromFile();
    void calculateDegreeDistribution();
    void writeDataToFile();
    
    int main(int argc, char* argv[]){
    	if( argc != 2 )
    	{
    		printf("need a parameter to indicate the network data name\n");
    		printf("for example: smallworldnetwork.data\n");
    		exit(0);
    	}
    	strcat(targetfilename, argv[1]);
    	printf("%s\n", targetfilename);
    
    	readDataFromFile();
    	calculateDegreeDistribution();
    	writeDataToFile();
    	return 0;
    }
    
    /*
     * 读入网络的结构
     * */
    void readDataFromFile(){
    	FILE* fread;
    	if( NULL == (fread = fopen(targetfilename, "r")))
    	{
    		printf("open file(%s) error!\n");
    		exit(0);
    	}
    	int i;
    	int j;
    	for( i = 1; i <= NETWORK_SIZE; i++ ){
    		for( j = 1; j <= NETWORK_SIZE; j++ )
    		{
    			if( 1 != fscanf(fread, "%d ", &adjacentMatrix[i][j]))
    			{
    				printf("fscanf error: file: %s\t(%d, %d)\n", targetfilename, i, j);
    				exit(0);
    			}
    		}
    	}
    	fclose(fread);
    }
    
    void calculateDegreeDistribution(){
    	int i;
    	int j;
    	double averageDegree = 0.0;
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		for( j = 1; j <= NETWORK_SIZE; j++ )
    			degree[i] = degree[i] + adjacentMatrix[i][j];
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		averageDegree += degree[i];
    	printf("%f----<k> = %f\n", averageDegree,averageDegree/NETWORK_SIZE);
    
    	for( i = 1; i <= NETWORK_SIZE; i++ )
    		statistic[degree[i]]++;
    
    	double indentify = 0.0;
    	for( i = 0; i < NETWORK_SIZE; i++ )
    	{
    		statistic[i] = statistic[i]/(double)(NETWORK_SIZE);
    		indentify += statistic[i];
    	}
    	printf("\nindentify: %f\n", indentify);
    }
    
    /*
     * 将网络的度分布写入文件 distributionOf@targetfilename
     * */
    void writeDataToFile(){
    	FILE* fwrite;
    	strcat(distribution, "distributionOf");
    	strcat(distribution, targetfilename);
    	printf("%s\n", distribution);
    	if( NULL == (fwrite = fopen(distribution, "w")))
    	{
    		printf("open file(%s) error!\n", distribution);
    		exit(0);
    	}
    	int i;
    	for( i = 0; i < NETWORK_SIZE; i++ )
    	{
    		fprintf(fwrite, "%d %f\n",i, statistic[i]);
    	}
    	fclose(fwrite);
    }

    可视化网络(即绘制如上的网络图的代码)的代码(需要安装igraph)

    # -*- coding:UTF8 -*-
    
    from igraph import *
    
    edges = []
    
    # 从文件@filename中读入网络的边
    def read_edges(filename):
    	fin = open(filename, "r")
    	for line in fin:
    		line = line.strip()
    		line = line.split(" ")
    		edges.append((int(line[0]) - 1, int(line[1]) - 1))
    
    def plot_network(size):
    	g = Graph()
    	g.add_vertices(size)
    	g.add_edges(edges)
    	layout = g.layout('kk')
    	visual_style = {}
    	visual_style['layout'] = layout
    	visual_style['bbox'] = (500,500)
    	visual_style['vertex_label'] = [(label + 1) for label in range(size)]
    	visual_style['vertex_color'] = 'white'
    	visual_style['vertex_size'] = g.degree()  # 节点的大小与度成正比
    	# visual_style['vertex_size'] = 20	  # 所有节点的大小都是相同的:20
    	plot(g, **visual_style)
    
    def main(size):
    	read_edges("random_edge.data")	#包含网络的连边的信息的文件的名称
    	plot_network(size)
    
    main(10)	# 这里的10需要更改为网络中的节点的个数



    展开全文
  • 根据BA无标度网络模型提出了一种具有无标度特性的有向网络演化模型,并设计程序进行了仿真实验,对有向网络的度分布进行了分析,结果表明,利用文中提出的有向网络演化模型生成的复杂有向网络的度分布符合幂律分布,...
  • 实现了小世界网络模型BA网络模型,并对节点都进行了研究。
  • BA(Barabasi-A1bert)无标度网络模型的基础上,考虑网络节点增长的同时,网络已有节点连线也在增加。在这个BA网络改进模型中,引入了两个主要参数q1,q2通过理论分析,导出了这个内部演化的增长网络的度分布,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,399
精华内容 13,759
关键字:

BA模型