Python Topology.graph['type']方法代码示例

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def star_topology(n):
    """
    Return a star (a.k.a hub-and-spoke) topology of :math:`n+1` nodes

    The root (hub) node has id 0 while all leaf (spoke) nodes have id
    :math:`(1, n+1)`.

    Each node has the attribute type which can either be *root* (for node 0) or
    *leaf* for all other nodes

    Parameters
    ----------
    n : int
        The number of leaf nodes

    Returns
    -------
    topology : A Topology object
    """
    if not isinstance(n, int):
        raise TypeError('n argument must be of int type')
    if n < 1:
        raise ValueError('n argument must be a positive integer')
    G = Topology(nx.star_graph(n))
    G.name = "star_topology(%d)" % (n)
    G.graph['type'] = 'star'
    G.node[0]['type'] = 'root'
    for v in range(1, n + 1):
        G.node[v]['type'] = 'leaf'
    return G

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def k_ary_tree_topology(k, h):
    """
    Return a balanced k-ary tree topology of with depth h
    
    Each node has two attributes:
     * type: which can either be *root*, *intermediate* or *leaf*
     * depth:math:`(0, h)` the height of the node in the tree, where 0 is the
       root and h are leaves.
    
    Parameters
    ----------
    k : int
        The branching factor of the tree
    h : int 
        The height or depth of the tree

    Returns
    -------
    topology : A Topology object
    """
    if not isinstance(k, int) or not isinstance(h, int):
        raise TypeError('k and h arguments must be of int type')
    if k <= 1:
        raise ValueError("Invalid k parameter. It should be > 1")
    if h < 1:
        raise ValueError("Invalid h parameter. It should be >=1")
    G = Topology(nx.balanced_tree(k, h))
    G.name = "k_ary_tree_topology(%d,%d)" % (k, h)
    G.graph['type'] = 'tree'
    G.graph['k'] = k
    G.graph['h'] = h
    G.node[0]['type'] = 'root'
    G.node[0]['depth'] = 0
    # Iterate through the tree to assign labels to nodes
    v = 1
    for depth in range(1, h + 1):
        for _ in range(k**depth):
            G.node[v]['depth'] = depth
            if depth == h:
                G.node[v]['type'] = 'leaf'
            else:
                G.node[v]['type'] = 'intermediate'
            v += 1                   
    return G

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def full_mesh_topology(n):
    """
    Return a fully connected mesh topology of n nodes

    Parameters
    ----------
    n : int
        The number of nodes

    Returns
    -------
    topology : A Topology object
    """
    if not isinstance(n, int):
        raise TypeError('n argument must be of int type')
    if n < 1:
        raise ValueError('n argument must be a positive integer')
    G = Topology(nx.complete_graph(n))
    G.name = "full_mesh_topology(%d)" % (n)
    G.graph['type'] = 'full_mesh'
    return G

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def line_topology(n):
    """
    Return a line topology of n nodes

    Parameters
    ----------
    n : int
        The number of nodes

    Returns
    -------
    topology : A Topology object

    """
    if not isinstance(n, int):
        raise TypeError('n argument must be of int type')
    if n < 1:
        raise ValueError('n argument must be a positive integer')
    G = Topology(nx.path_graph(n))
    G.name = "line_topology(%d)" % (n)
    G.graph['type'] = 'line'
    return G

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def erdos_renyi_topology(n, p, seed=None, fast=False):
    r"""Return a random graph :math:`G_{n,p}` (Erdos-Renyi graph, binomial
    graph).

    Chooses each of the possible edges with probability p.

    Parameters
    ----------
    n : int
        The number of nodes.
    p : float
        Probability for edge creation.
    seed : int, optional
        Seed for random number generator (default=None).
    fast : boolean, optional
        Uses the algorithm proposed by [3]_, which is faster for small p

    References
    ----------
    .. [1] P. Erdos and A. Renyi, On Random Graphs, Publ. Math. 6, 290 (1959).
    .. [2] E. N. Gilbert, Random Graphs, Ann. Math. Stat., 30, 1141 (1959).
    .. [3] Vladimir Batagelj and Ulrik Brandes,
       "Efficient generation of large random networks",
       Phys. Rev. E, 71, 036113, 2005.
    """
    # validate input parameters
    if not isinstance(n, int) or n < 0:
        raise ValueError('n must be a positive integer')
    if p > 1 or p < 0:
        raise ValueError('p must be a value in (0,1)')
    if fast:
        G = Topology(nx.fast_gnp_random_graph(n, p, seed=seed))
    else:
        G = Topology(nx.gnp_random_graph(n, p, seed=seed))
    G.name = "erdos_renyi_topology(%s, %s)" % (n, p)
    G.graph['type'] = 'er'
    return G

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def glp_topology(n, m, m0, p, beta, seed=None):
    r"""
    Return a random topology using the Generalized Linear Preference (GLP)
    preferential attachment model.

    It differs from the extended Barabasi-Albert model in that there is link
    rewiring and a beta parameter is introduced to fine-tune preferential
    attachment.

    More precisely, the GLP topology is built as follows. First, a
    line topology with *m0* nodes is created. Then, at each step:
    with probability *p*, add *m* new links between existing nodes, selected
    with probability:

    .. math::
        \Pi(i) = \frac{deg(i) - \beta 1}{\sum_{v \in V} (deg(v) - \beta)}

    with probability :math:`1-p`, add a new node and attach it to m nodes of
    the existing topology selected with probability :math:`\Pi(i)`

    Repeat the previous step until the topology comprises n nodes in total.

    Parameters
    ----------
    n : int
        Number of nodes
    m : int
        Number of edges to attach from a new node to existing nodes
    m0 : int
        Number of edges initially attached to the network
    p : float
        The probability that new links are added
    beta : float
        Parameter to fine-tune preferntial attachment: beta < 1
    seed : int, optional
        Seed for random number generator (default=None).

    Returns
    -------
    G : Topology

    References
    ----------
    .. [1] T. Bu and D. Towsey "On distinguishing between Internet power law
       topology generators", Proceeding od the 21st IEEE INFOCOM conference.
       IEEE, volume 2, pages 638-647, 2002.
    """
    def calc_pi(G, beta):
        """Calculate GLP Pi function for all nodes of the graph"""
        # validate input parameter
        if beta >= 1:
            raise ValueError('beta must be < 1')
        degree = dict(G.degree())
        den = float(sum(degree.values()) - (G.number_of_nodes() * beta))
        return {node: (degree[node] - beta) / den for node in G.nodes()}

    def add_m_links(G, pi):
        """Add m links between existing nodes to the graph"""
        n_nodes = G.number_of_nodes()
        n_edges = G.number_of_edges()
        max_n_edges = (n_nodes * (n_nodes - 1)) / 2
        if n_edges + m > max_n_edges:  # cannot add m links
            add_node(G, pi)  # add a new node instead
            # return in any case because before doing another operation
            # (add node or links) we need to recalculate pi
            return
        new_links = 0
        while new_links < m:
            u = random_from_pdf(pi)
            v = random_from_pdf(pi)
            if u != v and not G.has_edge(u, v):
                G.add_edge(u, v)
                new_links += 1

    def add_node(G, pi):
        """Add one node to the graph and connect it to m existing nodes"""
        new_node = G.number_of_nodes()
        G.add_node(new_node)
        new_links = 0
        while new_links < m:
            existing_node = random_from_pdf(pi)
            if not G.has_edge(new_node, existing_node):
                G.add_edge(new_node, existing_node)
                new_links += 1

    # validate input parameters
    if n < 1 or m < 1 or m0 < 1:
        raise ValueError('n, m and m0 must be a positive integers')
    if beta >= 1:
        raise ValueError('beta must be < 1')
    if m >= m0:
        raise ValueError('m must be <= m0')
    if p > 1 or p < 0:
        raise ValueError('p must be included between 0 and 1')
    if seed is not None:
        random.seed(seed)
    # step 1: create a graph of m0 nodes connected by n-1 edges
    G = Topology(nx.path_graph(m0))
    G.graph['type'] = 'glp'
    G.name = "glp_topology(%d, %d, %d, %f, %f)" % (n, m, m0, p, beta)
#.........这里部分代码省略.........

# 需要导入模块: from fnss.topologies.topology import Topology [as 别名]
# 或者: from fnss.topologies.topology.Topology import graph['type'] [as 别名]
def barabasi_albert_topology(n, m, m0, seed=None):
    r"""
    Return a random topology using Barabasi-Albert preferential attachment
    model.

    A topology of n nodes is grown by attaching new nodes each with m links
    that are preferentially attached to existing nodes with high degree.

    More precisely, the Barabasi-Albert topology is built as follows. First, a
    line topology with m0 nodes is created. Then at each step, one node is
    added and connected to m existing nodes. These nodes are selected randomly
    with probability

    .. math::
            \Pi(i) = \frac{deg(i)}{sum_{v \in V} deg V}.

    Where i is the selected node and V is the set of nodes of the graph.

    Parameters
    ----------
    n : int
        Number of nodes
    m : int
        Number of edges to attach from a new node to existing nodes
    m0 : int
        Number of nodes initially attached to the network
    seed : int, optional
        Seed for random number generator (default=None).

    Returns
    -------
    G : Topology

    Notes
    -----
    The initialization is a graph with with m nodes connected by :math:`m -1`
    edges.
    It does not use the Barabasi-Albert method provided by NetworkX because it
    does not allow to specify *m0* parameter.
    There are no disconnected subgraphs in the topology.

    References
    ----------
    .. [1] A. L. Barabasi and R. Albert "Emergence of scaling in
       random networks", Science 286, pp 509-512, 1999.
    """
    def calc_pi(G):
        """Calculate BA Pi function for all nodes of the graph"""
        degree = dict(G.degree())
        den = float(sum(degree.values()))
        return {node: degree[node] / den for node in G.nodes()}

    # input parameters
    if n < 1 or m < 1 or m0 < 1:
        raise ValueError('n, m and m0 must be positive integers')
    if m >= m0:
        raise ValueError('m must be <= m0')
    if n < m0:
        raise ValueError('n must be > m0')
    if seed is not None:
        random.seed(seed)
    # Step 1: Add m0 nodes. These nodes are interconnected together
    # because otherwise they will end up isolated at the end
    G = Topology(nx.path_graph(m0))
    G.name = "ba_topology(%d,%d,%d)" % (n, m, m0)
    G.graph['type'] = 'ba'

    # Step 2: Add one node and connect it with m links
    while G.number_of_nodes() < n:
        pi = calc_pi(G)
        u = G.number_of_nodes()
        G.add_node(u)
        new_links = 0
        while new_links < m:
            v = random_from_pdf(pi)
            if not G.has_edge(u, v):
                G.add_edge(u, v)
                new_links += 1
    return G