Esempio n. 1
0
  def rand(self):
    er = nx.dense_gnm_random_graph(24, 27)
    for e in er.edges() :
      f,t=e
      self.add_edge(f,t)
    er = nx.dense_gnm_random_graph(24, 7)
    for e in er.edges() :
      f,t=e
      self.add_edge(t,f)

    return self
Esempio n. 2
0
def generate_input(n, m):
    randinput = open('rinput', 'w')
    randinput.truncate(0)

    randinput.write("{0} {1}\n".format(n, m))
    G = nx.dense_gnm_random_graph(n, m)
    while nx.is_connected(G) == False:
        G = nx.dense_gnm_random_graph(n, m)
    for (u, v) in G.edges():
        G.edge[u][v]['weight'] = random.randint(1, 100)
        w = G.edge[u][v]['weight']
        randinput.write("{0} {1} {2}\n".format(u + 1, v + 1, w))

    randinput.write("0 \n")
    randinput.close()
def generate_random_edge_graph(num_nodes, num_edges):
    """
    Generates a networkx graph and removes any isolated nodes in the graph
    :param num_nodes: number of nodes in the generated graph
    :param num_edges: number of edges in the generated graph
    :return: Graph
    """
    graph = nx.dense_gnm_random_graph(num_nodes, num_edges)
    graph.remove_nodes_from(list(nx.isolates(graph)))

    while not nx.is_connected(graph):
        graph = nx.dense_gnm_random_graph(num_nodes, num_edges)
        graph.remove_nodes_from(list(nx.isolates(graph)))

    return graph
Esempio n. 4
0
 def __init__(self, N, m, seed=None, nodetype=SimpleNode, L=5.):
     
     positions = np.random.uniform(-L, L, size=(N,2))
     graph = nx.dense_gnm_random_graph(N, m, seed=seed)
     adj = nx.adjacency_matrix(graph).todense()
     
     super().__init__(adj, positions, node_type=nodetype)
Esempio n. 5
0
def GenerateGraphs(size, base):  
    dic=GenerateDic(size,base)
    for i in range(1,5):       
        for j in range(10):        
            G=AddEdges(nx.wheel_graph(size))       
            for k in range (5):
                nodes=RandNodes(size-1)              
                for l in range(5):
                    dic["Edmond"+str(size)+"wheel"].append(Edmond(G,nodes[0],nodes[1]))                    
                    dic["Din"+str(size)+"wheel"].append(Din(G,nodes[0],nodes[1]))    
                    dic["Boyk"+str(size)+"wheel"].append(Boyk(G,nodes[0],nodes[1]))
            G=AddEdges(nx.circular_ladder_graph(size))
            for k in range (5):
                nodes=RandNodes(size-1)
                for l in range(5):
                    dic["Edmond"+str(size)+"circ"].append(Edmond(G,nodes[0],nodes[1]))
                    dic["Din"+str(size)+"circ"].append(Din(G,nodes[0],nodes[1]))    
                    dic["Boyk"+str(size)+"circ"].append(Boyk(G,nodes[0],nodes[1]))   
            G=AddEdges(nx.dense_gnm_random_graph(size,int(size*size*0.2 )))  
            for k in range (5):
                nodes=RandNodes(size-1)
                for l in range(5):
                    dic["Edmond"+str(size)+"comp"].append(Edmond(G,nodes[0],nodes[1]))
                    dic["Din"+str(size)+"comp"].append(Din(G,nodes[0],nodes[1]))    
                    dic["Boyk"+str(size)+"comp"].append(Boyk(G,nodes[0],nodes[1]))            
        size*=base;
    df=pd.DataFrame(dic)
    df.to_csv("matrix.csv")
 def test035_dense_gnm_random_graph(self):
     """ Larger random graph picked from set of all graphs 
     with n nodes and m edges. """
     g = nx.dense_gnm_random_graph(300, 10000)
     mate1 = mv.max_cardinality_matching(g)
     mate2 = nx.max_weight_matching(g, True)
     self.assertEqual(len(mate1), len(mate2))
Esempio n. 7
0
def get_qubit_op(num_qubits, seed=23412341234):
    G = nx.Graph()

    # """ HAVE DATA -- VIGO
    n = num_qubits
    SEED = seed
    np.random.seed(SEED % (2 ** 31 - 1))
    G = nx.dense_gnm_random_graph(n, n ** 2, seed=SEED)
    for (u, v, w) in G.edges(data=True):
        w['weight'] = np.random.rand() * 0.5 # 0.1

    np.random.seed(int(time.time()))

    w = np.zeros([n, n])
    for i in range(n):
        for j in range(n):
            temp = G.get_edge_data(i, j, default=0)
            if temp != 0:
                w[i, j] = temp['weight']
    # print(w)

    qubitOp, offset = max_cut.get_max_cut_qubitops(w)
    algo_input = EnergyInput(qubitOp)

    pos = nx.spring_layout(G)
    exact = ExactEigensolver(qubitOp).run()
    exact_energy = exact['energy']
    return qubitOp, exact_energy
def computeBasicIndex(graph):
    print '---------------------------------------------------'
    print 'Graph name =', graph.name
    nodes = len(graph.nodes())
    edges = len(graph.edges())
    print '|V|=', len(graph.nodes())
    print '|E|=', len(graph.edges())
    print '<k>=', len(graph.edges()) * 1.0 / len(graph.nodes())

    randomGraph = nx.dense_gnm_random_graph(nodes, edges)
    print 'average_shortest_path_length', nx.average_shortest_path_length(
        graph)
    print '随机网络average_shortest_path_length of random graph with same node number and edge number', nx.average_shortest_path_length(
        randomGraph)

    #print 'average clustering:', nx.average_clustering(graph)
    #print '随机网络average clustering of random graph with same node number and edge number :', nx.average_clustering(randomGraph)
    if nx.is_directed(graph):
        un_digraph = graph.to_undirected()
        print 'average clustering:', nx.average_clustering(un_digraph)
        un_randomdiGraph = randomGraph.to_undirected()
        print '随机网络average clustering of random graph with same node number and edge number :', nx.average_clustering(
            randomGraph)
    else:
        print 'average clustering:', nx.average_clustering(graph)
        print '随机网络average clustering of random graph with same node number and edge number :', nx.average_clustering(
            randomGraph)
    print 'degree_assortativity_coefficient:', nx.degree_assortativity_coefficient(
        graph)
    # print 'average_neighbor_degree:', nx.average_neighbor_degree(graph)
    print '---------------------------------------------------'
Esempio n. 9
0
def generate_graph(size, graph_type):
    if graph_type == 'random':
        G = nx.dense_gnm_random_graph(size, size * 5, seed=SEED)
    elif graph_type == 'small_world':
        G = nx.watts_strogatz_graph(size, 8, 0.25, seed=SEED)
    elif graph_type == 'small_world_sparse':
        G = nx.watts_strogatz_graph(size, size / 8, 0.25, seed=SEED)
    elif graph_type == 'scale_free':
        # regular expts
        G = nx.barabasi_albert_graph(size, 8, seed=SEED)

        # implementation, celer expts - 10 node graph
        # G = nx.barabasi_albert_graph(size, 5, seed=12)
    elif graph_type == 'scale_free_sparse':
        G = nx.barabasi_albert_graph(size, size / 8, seed=SEED)
    elif graph_type == 'tree':
        G = nx.random_tree(size, seed=SEED)

    # remove self loops and parallel edges
    G.remove_edges_from(G.selfloop_edges())
    G = nx.Graph(G)

    print('Generated a ', graph_type, ' graph')
    print('number of nodes: ', G.number_of_nodes())
    print('Number of Edges: ', G.number_of_edges())
    print('Number of connected components: ',
          nx.number_connected_components(G))
    return G
 def random_graph(n=100, m=2500):
     """ランダムグラフ
     :param n: node num
     :param m: edge num
     :return: dense_gnm_random_graph instance
     """
     return nx.dense_gnm_random_graph(n, m)
Esempio n. 11
0
def substrate_gen(snet_type='random', rand_topo_info = (10, 16)):
    ''' generate substrate network '''
    # create 10 nodes, with 14 edges, a fixed topology
    if snet_type == 'random':
        num_nodes, num_edges = rand_topo_info
        G = nx.dense_gnm_random_graph(num_nodes, num_edges, 3)
        G.remove_edge(0,7)
        G.remove_edge(6,9)
#    if snet_type == 'I2':
#        G = nx.Graph()
#        G.add_edges_from(topo_type.I2_topo.keys())
#    if snet_type == 'GEANT':
#        geant_ip = topo_type.geant_ip
#        geant_mapping, geant_geo = \
#            topo_type.relabel_nodeinfo(topo_type.geant_node_mapping, 
#                                       topo_type.geant_node_geoinfo, 
#                                       geant_ip)                                       
#        geant_link = topo_type.relabel_linkinfo(geant_ip, geant_mapping)
#        G = nx.Graph()
#        G.add_edges_from(geant_link.keys())
    if snet_type != 'random':
        
        xml_file = TOPO_PATH + snet_type + ".xml"
        print xml_file
        node_dict, link_dict, node_dict_new = topo_xml.run(xml_file)
        G = nx.Graph()
        G.add_edges_from(link_dict.values())
        
    return G
Esempio n. 12
0
def get_random_circuit(n,
                       type='general',
                       min_r=1,
                       max_r=1000,
                       min_v=1,
                       max_v=1000,
                       density=0.5):
    G = nx.Graph()
    if type == 'erdos':
        G = nx.erdos_renyi_graph(n, density)
        while not nx.is_connected(G):
            G = nx.erdos_renyi_graph(n, density)
    elif type[:7] == 'regular':
        d = int(type[7:])
        G = nx.random_regular_graph(d, n)
    elif type == 'general':
        G = nx.dense_gnm_random_graph(n, n**2 - n)
    elif type == 'bridge':
        A = nx.erdos_renyi_graph(n // 2, density)
        while not nx.is_connected(A):
            A = nx.erdos_renyi_graph(n // 2, density)
        B = nx.erdos_renyi_graph(n // 2, density)
        while not nx.is_connected(B):
            B = nx.erdos_renyi_graph(n // 2, density)
        an = A.number_of_nodes()
        A.add_nodes_from([an + i for i in B.nodes()])
        A.add_edges_from([(an + x, an + y) for x, y in B.edges()])
        A.add_edge(1, an + 1)
        G = A
    V = len(G.nodes())
    L = []
    for i in G.nodes():
        for k, v in G[i].items():
            L.append((i, k, randint(min_r, max_r)))
    return Circuit(V, L, 0, V - 1, randint(min_v, max_v))
Esempio n. 13
0
def ErdosRenyi(n, m, d, display=None, seed=None):
    """
	n: the number of nodes
	m: the number of edges
	"""
    # counter = 0
    # naive way to generate connected graph
    while True:
        if m <= 30:
            G = nx.gnm_random_graph(n, m, seed=None, directed=False)
        else:
            G = nx.dense_gnm_random_graph(n, m, seed=None)
        maxDegree = max([item for item in G.degree().values()])
        if nx.is_connected(G) and maxDegree <= d:
            break
        # if maxDegree > d:
        # counter += 1

    # avgDegree = 2 * nx.number_of_edges(G) / nx.number_of_nodes(G)
    # print avgDegree

    if display:
        nx.draw(G)
        img_name = 'erdos_renyi_%i_%i.png' % (n, m)
        plt.savefig(img_name)
        sh.open(img_name)

    adjacencyMatrix = generateAdjacencyMatrix(G)
    return adjacencyMatrix
Esempio n. 14
0
def random_connected_graph(n):
    """ Generates a Erdos-Renyi G_{n,m} random graph """
    g = nx.Graph([(0, 1), (2, 3)])
    while not nx.is_connected(g):
        edges = randint(n - 1, n * (n - 1) // 2)
        g = nx.dense_gnm_random_graph(n, edges)
    return g
Esempio n. 15
0
def test_is_bipartite():
    for i in range(1, 10):
        for j in range(1, i * i):
            x = nx.dense_gnm_random_graph(i, j)
            y = nqs.graph.CustomGraph(x.edges)
            # if len(x) == len(set((i for (i, j) in x.edges)) | set((j for (i, j) in x.edges))):
            assert y.is_bipartite == nx.is_bipartite(x)
Esempio n. 16
0
def generate_random_graphs(numberOfNodes, outputFile, graphType, degree=None):
    sparseResult = open(outputFile, "w")
    #first writing the number of nodes
    if (graphType == "degreeBased"):
        G = nx.random_regular_graph(
            degree, numberOfNodes,
            numberOfNodes * int(math.sqrt(numberOfNodes)))
    if (graphType == "completeChaos"):
        G = nx.gnm_random_graph(numberOfNodes,
                                numberOfNodes * int(math.sqrt(numberOfNodes)))
    if (graphType == "dense"):
        G = nx.dense_gnm_random_graph(
            numberOfNodes, numberOfNodes * int(math.sqrt(numberOfNodes)))

    sparseResult.write(
        str(numberOfNodes) + " " + str(nx.number_of_edges(G)) + "\n")
    semiSparseRep = nx.to_dict_of_lists(G)
    #print semiSparseRep
    for element in semiSparseRep:
        if len(semiSparseRep[element]) == 0:
            return 0
        for j in semiSparseRep[element]:
            sparseResult.write(str(j + 1) + " ")
        sparseResult.write("\n")
    return 1
Esempio n. 17
0
def random_expected_modularity_frac(num_nodes, num_edges):
    gnx = dense_gnm_random_graph(num_nodes, num_edges).to_undirected()
    partition = best_partition(gnx)
    modularity(partition, gnx)
    in_partition = len([
        1 for u, v in gnx.edges() if partition[u] == partition[v]
    ]) / len(gnx.edges)
    return in_partition - modularity(partition, gnx)
Esempio n. 18
0
    def ranDAG(self, n_nodes, n_edges):
        er = nx.dense_gnm_random_graph(n_nodes, n_nodes)
        for e in er.edges():
            f, t = e
            self.add_edge(f, t)
        if 0 not in self.nodes(): self.add_edge(0, 1)

        return self
Esempio n. 19
0
def get_graph_triangles(args):
    N_nodes, rnd = args
    N_edges = int((rnd.rand() + 1) * N_nodes)
    G = nx.dense_gnm_random_graph(N_nodes, N_edges, seed=None)
    A = nx.to_numpy_array(G)
    A_cube = A.dot(A).dot(A)
    label = int(np.trace(A_cube) / 6.)  # number of triangles
    return A.astype(np.bool), label, N_edges, G
Esempio n. 20
0
def getGraph(type="given"):
    if type == "given":
        g = nx.read_edgelist("pagerank.txt")
    elif type == "erdos_renyi":
        g = nx.dense_gnm_random_graph(40, 200)
    elif type == "poisson":
        g = poissongraph(40, 5)

    return g
Esempio n. 21
0
def random_graphs():
    print("Random graphs")
    print("fast GNP random graph")
    G = nx.fast_gnp_random_graph(n=9, p=0.4)
    draw_graph(G)
    print("GNP random graph")
    G = nx.gnp_random_graph(n=9, p=0.1)
    draw_graph(G)
    print("Dense GNM random graph")
    G = nx.dense_gnm_random_graph(n=19, m=28)
    draw_graph(G)
    print("GNM random graph")
    G = nx.gnm_random_graph(n=11, m=14)
    draw_graph(G)
    print("Erdős Rényi graph")
    G = nx.erdos_renyi_graph(n=11, p=0.4)
    draw_graph(G)
    print("Binomial graph")
    G = nx.binomial_graph(n=45, p=0.4)
    draw_graph(G)
    print("Newman Watts Strogatz")
    G = nx.newman_watts_strogatz_graph(n=9, k=5, p=0.4)
    draw_graph(G)
    print("Watts Strogatz")
    G = nx.watts_strogatz_graph(n=9, k=2, p=0.4)
    draw_graph(G)
    print("Watts Strogatz")
    G = nx.watts_strogatz_graph(n=9, k=2, p=0.4)
    draw_graph(G)
    print("Connected Watts Strogatz")
    G = nx.connected_watts_strogatz_graph(n=8, k=2, p=0.1)
    draw_graph(G)
    print("Random Regular Graph")
    G = nx.random_regular_graph(d=2, n=9)
    draw_graph(G)
    print("Barabasi Albert Graph")
    G = nx.barabasi_albert_graph(n=10, m=2)
    draw_graph(G)
    print("Powerlow Cluster Graph")
    G = nx.powerlaw_cluster_graph(n=10, m=2, p=0.2)
    draw_graph(G)
    print("Duplication Divergence Graph")
    G = nx.duplication_divergence_graph(n=10, p=0.2)
    draw_graph(G)
    print("Random lobster Graph")
    G = nx.random_lobster(n=10, p1=0.2, p2=0.8)
    draw_graph(G)
    print("Random shell Graph")
    constructor = [(10, 20, 0.8), (20, 40, 0.8)]
    G = nx.random_shell_graph(constructor)
    draw_graph(G)
    print("Random Powerlow Tree")
    G = nx.random_powerlaw_tree(n=24, gamma=3)
    draw_graph(G)
    print("Random Powerlow Tree Sequence")
    G = nx.random_powerlaw_tree(n=13, gamma=3)
    draw_graph(G)
Esempio n. 22
0
def pure_random_graph(num_nodes, num_edges, num_labels, vocab_size, num_words, attr_noise):
    G = nx.dense_gnm_random_graph(num_nodes, num_edges)
    attributes = []
    for u in list(G.nodes):
        label = rd.randint(0,num_labels-1)
        attributes.append(get_attributes(label,num_labels,vocab_size,num_words,attr_noise))
    attributes = np.array(attributes)
    attributes = sp.coo_matrix(attributes)
    return G, attributes
Esempio n. 23
0
def test_is_bipartite():
    for i in range(1, 10):
        for j in range(1, i * i):
            x = nx.dense_gnm_random_graph(i, j)
            y = Graph.from_networkx(x)
            if len(x) == len(
                set((i for (i, j) in x.edges())) | set((j for (i, j) in x.edges()))
            ):
                assert y.is_bipartite() == nx.is_bipartite(x)
Esempio n. 24
0
def test_is_bipartite():
    for i in range(1, 10):
        for j in range(1, i * i):
            x = nx.dense_gnm_random_graph(i, j)
            y = nk.graph.Graph(nodes=list(x.nodes()), edges=list(x.edges()))
            if len(x) == len(
                    set((i for (i, j) in x.edges()))
                    | set((j for (i, j) in x.edges()))):
                assert y.is_bipartite() == nx.is_bipartite(x)
Esempio n. 25
0
def RandomGNM(n, m, dense=False, seed=None):
    """
    Returns a graph randomly picked out of all graphs on n vertices
    with m edges.

    INPUT:


    -  ``n`` - number of vertices.

    -  ``m`` - number of edges.

    -  ``dense`` - whether to use NetworkX's
       dense_gnm_random_graph or gnm_random_graph


    EXAMPLES: We show the edge list of a random graph on 5 nodes with
    10 edges.

    ::

        sage: graphs.RandomGNM(5, 10).edges(labels=False)
        [(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

    We plot a random graph on 12 nodes with m = 12.

    ::

        sage: gnm = graphs.RandomGNM(12, 12)
        sage: gnm.show()  # long time

    We view many random graphs using a graphics array::

        sage: g = []
        sage: j = []
        sage: for i in range(9):
        ...    k = graphs.RandomGNM(i+3, i^2-i)
        ...    g.append(k)
        ...
        sage: for i in range(3):
        ...    n = []
        ...    for m in range(3):
        ...        n.append(g[3*i + m].plot(vertex_size=50, vertex_labels=False))
        ...    j.append(n)
        ...
        sage: G = sage.plot.graphics.GraphicsArray(j)
        sage: G.show()  # long time
    """
    if seed is None:
        seed = current_randstate().long_seed()
    import networkx

    if dense:
        return graph.Graph(networkx.dense_gnm_random_graph(n, m, seed=seed))
    else:
        return graph.Graph(networkx.gnm_random_graph(n, m, seed=seed))
Esempio n. 26
0
def RandomGNM(n, m, dense=False, seed=None):
    """
    Returns a graph randomly picked out of all graphs on n vertices
    with m edges.

    INPUT:


    -  ``n`` - number of vertices.

    -  ``m`` - number of edges.

    -  ``dense`` - whether to use NetworkX's
       dense_gnm_random_graph or gnm_random_graph


    EXAMPLES: We show the edge list of a random graph on 5 nodes with
    10 edges.

    ::

        sage: graphs.RandomGNM(5, 10).edges(labels=False)
        [(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

    We plot a random graph on 12 nodes with m = 12.

    ::

        sage: gnm = graphs.RandomGNM(12, 12)
        sage: gnm.show()  # long time

    We view many random graphs using a graphics array::

        sage: g = []
        sage: j = []
        sage: for i in range(9):
        ...    k = graphs.RandomGNM(i+3, i^2-i)
        ...    g.append(k)
        ...
        sage: for i in range(3):
        ...    n = []
        ...    for m in range(3):
        ...        n.append(g[3*i + m].plot(vertex_size=50, vertex_labels=False))
        ...    j.append(n)
        ...
        sage: G = sage.plot.graphics.GraphicsArray(j)
        sage: G.show()  # long time
    """
    if seed is None:
        seed = current_randstate().long_seed()
    import networkx
    if dense:
        return graph.Graph(networkx.dense_gnm_random_graph(n, m, seed=seed))
    else:
        return graph.Graph(networkx.gnm_random_graph(n, m, seed=seed))
Esempio n. 27
0
def main(args):
    print('--- Prediction by existing algorithm ---')
    print('Index\t|V|\t|E|\ttw(G)\ttime\tevaltw\tprunenum\tfunccallnum')
    output_file = "exist.dat"
    result = ["Index\t|V|\t|E|\ttw\ttime\tevaltw\tfunccallnum"]

    # make some graphs
    graphs = []
    for idx in range(0, args.data_num):
        n = np.random.randint(5, 10)  # [5, 10] |V|
        m = np.random.randint(n - 1, (n * (n - 1)) // 2)  # |E|
        g = nx.dense_gnm_random_graph(n, m)
        while not nx.is_connected(g):
            g = nx.dense_gnm_random_graph(n, m)

        graphs.append(g)

    for idx, eval_graph in enumerate(graphs):
        # exact computation
        tw = dnx.treewidth_branch_and_bound(eval_graph)[0]

        for calc_type in ["upper", "lower"]:
            graphstat = "{3}\t{0}\t{1}\t{2}".format(
                eval_graph.number_of_nodes(), eval_graph.number_of_edges(), tw,
                str(idx).rjust(5))
            print('{0}\t{1}\t{2}\t{3}'.format(
                str(idx).rjust(5), eval_graph.number_of_nodes(),
                eval_graph.number_of_edges(), tw),
                  end='\t')
            try:
                tm, evtw, fcn = linear_search(eval_graph, calc_type)
                res = "{0}\t{1}\t{2}".format(tm, evtw, fcn)
            except TimeoutError:
                res = "TimeOut"
            print(res)
            assert evtw == tw
            result.append(graphstat + "\t" + res)

    # write results to a file
    if args.out_to_file:
        with open("./{}/".format(args.out) + output_file, "w") as f:
            f.write('\n'.join(result))
Esempio n. 28
0
def test_is_connected():
    for i in range(5, 10):
        for j in range(i + 1, i * i):
            x = nx.dense_gnm_random_graph(i, j)
            y = nqs.graph.CustomGraph(x.edges)
            if len(x) == len(
                    set((i for (i, j) in x.edges))
                    | set((j for (i, j) in x.edges))):
                assert y.is_connected == nx.is_connected(x)
            else:
                assert not nx.is_connected(x)
Esempio n. 29
0
def generate_graph(nodes,edges):
    random_graph = nx.dense_gnm_random_graph(nodes,edges)
    possible_weight = [-1,1]
    for (u, v, w) in random_graph.edges(data=True):
        w['weight'] = random.choice(possible_weight)

    for (u, v, w) in random_graph.edges(data=True):
        print u,v,w


    return random_graph
def generate_random_graph(n, e):
    G = nx.dense_gnm_random_graph(n, e)
    for (u, v) in G.edges():
        G.edge[u][v]['weight'] = random.randint(1, 10)
    pos = nx.circular_layout(G)
    nx.draw_networkx(G, pos, node_size=700)
    labels = nx.get_edge_attributes(G, 'weight')
    nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)
    plt.savefig('graph.png')
    plt.show(G)
    return G
 def __init__(self, T, n_user, D, c, graph_density):
     self.T = T
     self.n_user = n_user
     self.D = D
     self.c = c
     self.V = nx.dense_gnm_random_graph(n_user, graph_density)
     self.m = len(list(nx.connected_component_subgraphs(self.V)))
     self.U = self.init_user()
     self.list_i = []
     self.list_m = []
     self.list_C = []
Esempio n. 32
0
def test_is_connected():
    for i in range(5, 10):
        for j in range(i + 1, i * i):
            x = nx.dense_gnm_random_graph(i, j)
            y = nk.graph.Graph(nodes=list(x.nodes()), edges=list(x.edges()))

            if len(x) == len(
                    set((i for (i, j) in x.edges))
                    | set((j for (i, j) in x.edges))):
                assert y.is_connected() == nx.is_connected(x)
            else:
                assert not nx.is_connected(x)
def generateGraph (n,m,filename='',pw=.75,maxw=5):
    G = nx.dense_gnm_random_graph(n,m)
    for e in G.edges():
        if random.random() < pw:
            G[e[0]][e[1]]['weight'] = 1
        else:
            G[e[0]][e[1]]['weight'] = random.randint(2,maxw)
    if filename:
        with open(filename, 'w+') as f:
            f.write('%s %s%s' %(len(G.nodes()), len(G.edges()), os.linesep))
            for v1,v2,edata in G.edges(data=True):
                for it in range(edata['weight']):
                    f.write('%s %s%s' %(v1, v2, os.linesep))
Esempio n. 34
0
def generateGraph(n, m, filename='', pw=.75, maxw=5):
    G = nx.dense_gnm_random_graph(n, m)
    for e in G.edges():
        if random.random() < pw:
            G[e[0]][e[1]]['weight'] = 1
        else:
            G[e[0]][e[1]]['weight'] = random.randint(2, maxw)
    if filename:
        with open(filename, 'w+') as f:
            f.write('%s %s%s' % (len(G.nodes()), len(G.edges()), os.linesep))
            for v1, v2, edata in G.edges(data=True):
                for it in range(edata['weight']):
                    f.write('%s %s%s' % (v1, v2, os.linesep))
Esempio n. 35
0
def random_weighted_graph(size):
    """Creates random graph

    :size: int: number of nodes in graph
    :returns: nx.Graph object

    """
    nodes = size
    edges = nodes* (nodes/3)
    MAX_WEIGHT = 100
    G = nx.dense_gnm_random_graph(n=nodes, m=edges)
    # give our graph some random weights
    for edge in G.edges(): G.add_edge(*edge, weight = rr(MAX_WEIGHT))
    assert nx.is_connected(G) == True # make sure its connected
    return G
def generate_random_graphs(numberOfNodes, outputFile, graphType, degree=None):
    sparseResult = open(outputFile, "w")
    # first writing the number of nodes
    if graphType == "degreeBased":
        G = nx.random_regular_graph(degree, numberOfNodes, numberOfNodes * int(math.sqrt(numberOfNodes)))
    if graphType == "completeChaos":
        G = nx.gnm_random_graph(numberOfNodes, numberOfNodes * int(math.sqrt(numberOfNodes)))
    if graphType == "dense":
        G = nx.dense_gnm_random_graph(numberOfNodes, numberOfNodes * int(math.sqrt(numberOfNodes)))

    sparseResult.write(str(numberOfNodes) + " " + str(nx.number_of_edges(G)) + "\n")
    semiSparseRep = nx.to_dict_of_lists(G)
    # print semiSparseRep
    for element in semiSparseRep:
        if len(semiSparseRep[element]) == 0:
            return 0
        for j in semiSparseRep[element]:
            sparseResult.write(str(j + 1) + " ")
        sparseResult.write("\n")
    return 1
def probability_reliability():
    from itertools import combinations
    import networkx as nx
    import random
    G=nx.dense_gnm_random_graph(5,10)
    total_Edges=G.edges()
    probability=0
    while probability<1.02:
        reliability=0
        for i in xrange(0,11):
            for subset in combinations(total_Edges,i):
                count=0
                for j in subset:
                    if len(subset)!=0:
                        count=count+1
                    G.remove_edge(j[0],j[1])
                if (len(list(nx.all_simple_paths(G,0,2))) > 0):
                    reliability+=(pow(1-probability,count))*(pow(probability,(10-count)))
                for k in subset:
                    G.add_edge(k[0],k[1])
        print probability,reliability
        probability+=0.02
Esempio n. 38
0
    def __init__(self, num_switches=None):

        
        super(DenseTopology, self).__init__()
        if not num_switches:
            num_switches = 8
        num_hosts=num_switches*4
        
        # build graphman graph
        graph = nx.dense_gnm_random_graph(num_switches, min(num_switches - 1,10)* num_switches)

        # Add switches
        for s in graph:
            log.debug("Added switch %x" % s)
            self.add_switch(s+1)

        # Add edges
        for s1, s2 in graph.edges():
            self.add_link(s1+1, s2+1)
                         
        # Add hosts
        hostoffset = num_switches+2
        for h in range(1,num_hosts+1):
            # Add host
            host = h + hostoffset
            self.add_host(host)

            # Connect to a "random" switch
            s = graph.nodes()[h % len(graph)]
            self.add_link(host,s+1)
        # Globally connected host
        # self.add_host(999)
        # for switch in graph:
        #     self.add_link(999, switch+1)


        self.finalize()
Esempio n. 39
0
random.seed(seed)
print("RandomSeed=" + str(seed))

size =6
filename="/tmp/test.gnf"
#Monosat().init("-decide-graph-bv -no-decide-theories -no-decide-graph-rnd   -lazy-maxflow-decisions -conflict-min-cut -conflict-min-cut-maxflow -reach-underapprox-cnf ")
Monosat().setOutputFile(open(filename,'w'))
print("Writing file to " + filename)




graphs = [nx.diamond_graph(), nx.complete_graph(2), nx.complete_graph(3), nx.complete_graph(4), nx.cycle_graph(5),
          nx.grid_2d_graph(4,4),nx.grid_2d_graph(4,4,True),
          nx.dense_gnm_random_graph(4,8,123),
          nx.dense_gnm_random_graph(4,8,124),
          nx.dense_gnm_random_graph(4,16,125)
          ]
            #Directed graphs:
graphs+=[nx.gnp_random_graph(4,8,123,True),nx.gnp_random_graph(4,8,124,True),nx.gnp_random_graph(4,8,125,True),nx.gnp_random_graph(4,8,126,True),
         nx.gnp_random_graph(4,16,127,True),
          nx.gnp_random_graph(4,32,128,True),
          nx.gnp_random_graph(9,16,127,True),
         
         ]
for i,nxg in enumerate(graphs):

    nxg = convert_node_labels_to_integers(nxg)
    g = Graph()
    print("Graph %d"%(i))
Esempio n. 40
0
time = []
source = []
dst = []
tt1 = np.zeros((7, 9))
paramaters = []
l1 = []
num_packets = 7

overlap = []
path = []
reduced_transmission = []
#temp = 0

path_in_order = {6: 24}
fill_num = 25
G = nx.dense_gnm_random_graph(10, 50)
pos = nx.spring_layout(G)
H = G.number_of_edges()

colors = range(H)
# nx.draw(G,pos,node_color='#A0CBE2',edge_color=colors,width=4,edge_cmap=plt.cm.Reds,with_labels=True)
nx.draw(G, pos, node_color='#A0CBE2', width=0.4, edge_cmap=plt.cm.Reds, with_labels=True)


# plt.savefig("edge_colormap.png", dpi=300) # save as png
# plt.show()

# separate the string and packets.
def copy_source_dst_time(x):
    source_c = []
    dst_c = []
Esempio n. 41
0
#!/usr/bin/env python

import networkx as nx

N = 100
E = int(round((N**2)/1.5))

dense = nx.dense_gnm_random_graph(N, E)
nx.write_edgelist(dense, 'dense.dat', data=False)

karate = nx.karate_club_graph()
nx.write_edgelist(karate, 'karate.dat', data=False)

plaw = nx.powerlaw_cluster_graph(N * 10, N/10, 0.3)
nx.write_edgelist(plaw, 'plaw.dat', data=False)
def SEN_dense_gnm_random_graph(n1,m1,n2,m2,n3,m3,pa,pb):
    """Creates a SEN model with an actor network of n1 elements, with a neighbourhood connectivity of p1, a user network of n2 elements, with a neighbourhood connectivity of p2, and a ecological network of n3 elements with a neighbourhood connectivity of p3. The probability of connections between the actor network and the user netwrok, and between the user network and the ecological network, are respectively passed through pa and pb"""

    # Actor network
    A = nx.dense_gnm_random_graph(n1, m1)
    A.graph['Network']='Actors'
    # Adding id
    for i in range(len(A)):
        A.node[i]['num'] = i+1
    # Subnetwork
    for i in range(len(A)):
        A.node[i]['subnetwork'] = 1
    # Adding random class (office dwellers/field people)
    p_class_bureau = 0.75
    for i in range(len(A)):
        if random.random() <= p_class_bureau:
            A.node[i]['group'] = 0
        else:
            A.node[i]['group'] = 0
    # Adding randow weight
#    for n,nbrs in A.adjacency_iter():
#        for nbr,eattr in nbrs.items():
#            A[n][nbr]['weight'] = int(random.random()*8)


    # User network
    U = nx.dense_gnm_random_graph(n2, m2)
    U.graph['Network']='Actors'
    # Adding id
    for i in range(len(U)):
        U.node[i]['num'] = i+1001
    # Subnetwork
    for i in range(len(U)):
        U.node[i]['subnetwork'] = 2
    # Adding random class (office dwellers/field people)
    for i in range(len(U)):
        rnd=random.random()
        if rnd <= .2:
            U.node[i]['group'] = 1
        if rnd > .2 and rnd <= .4:
            U.node[i]['group'] = 1
        if rnd > .4 and rnd <= .6:
            U.node[i]['group'] = 1
        if rnd > .6 and rnd <= .8:
            U.node[i]['group'] = 1
        if rnd > .8:
            U.node[i]['group'] = 1
    # Adding randow weight
#    for n,nbrs in U.adjacency_iter():
#        for nbr,eattr in nbrs.items():
#            U[n][nbr]['weight'] = int(random.random()*8)

    # Ecological network
    E = nx.dense_gnm_random_graph(n3, m3)
    E.graph['Network']='Actors'
    # Adding id
    for i in range(len(E)):
        E.node[i]['num'] = i+10001
    # Subnetwork
    for i in range(len(E)):
        E.node[i]['subnetwork'] = 3
    # Adding class
    for i in range(len(E)):
            E.node[i]['group'] = 2
    # Adding weight
#    for n,nbrs in E.adjacency_iter():
#        for nbr,eattr in nbrs.items():
#            E[n][nbr]['weight'] = 5

    # joint the three subnetworks
    G = nx.disjoint_union_all([A,U,E])

    # link some actors to some users
    for i in range(0, len(G)):
        for j in range(0, len(G)):
            if i != j:
                if G.node[i]['subnetwork'] == 1 and G.node[j]['subnetwork'] == 2:
                    #if G.node[i]['group'] == 1 and G.node[j]['group'] == 2:
                    if random.random() < pa:
                        G.add_edge(i,j)

    # link some users to some patches
    for i in range(0, len(G)):
        G.node[i]['degreeold'] = G.degree(i)

    for i in range(0, len(G)):
        for j in range(0, len(G)):
            if i != j:
                #print str(j) + " " + str(G.degree(j))
                if G.node[i]['subnetwork'] == 2 and G.node[j]['subnetwork'] == 3 and G.degree(j) - G.node[j]['degreeold'] < 4:
                    if G.degree(j) - G.node[j]['degreeold'] < 4:
                        if random.random() < pb:
                            G.add_edge(i,j)
                            
    #remove lone nodes
    for i in range(0, len(G)):
        if G.degree(i) == 0:
            G.remove_node(i)
        

    # write json formatted data
    d = json_graph.node_link_data(G)
    json.dump(d, open('/Users/Rodolphe/Dropbox/Public/d3/examples/force/force.json','w'))

    nx.write_graphml(G, "graph.graphml")
    
    return G
              [ic, "itertive_compression"],
              # [rn, "randomized_opt"], # disabled because too slow
              [mif, "maximum_induced_forest"]]

graph = nx.erdos_renyi_graph(9, 0.5)
test_algorithms(algorithms, graph)

graph = nx.erdos_renyi_graph(10, 0.7)
test_algorithms(algorithms, graph)

graph = nx.erdos_renyi_graph(11, 0.6)
test_algorithms(algorithms, graph)

graph = nx.erdos_renyi_graph(12, 0.3)
test_algorithms(algorithms, graph)

graph = nx.erdos_renyi_graph(13, 0.5)
test_algorithms(algorithms, graph)

graph = nx.erdos_renyi_graph(15, 0.8)
test_algorithms(algorithms, graph)

graph = nx.erdos_renyi_graph(16, 0.8)
test_algorithms(algorithms, graph)

graph = nx.dense_gnm_random_graph(10, 25)
test_algorithms(algorithms, graph)

graph = nx.newman_watts_strogatz_graph(11, 5, 0.2)
test_algorithms(algorithms, graph)
Esempio n. 44
0
#!/usr/bin/env python
import networkx as nx
import random
import graph

from annealing import Annealing
from exact import is_graph_secure

if __name__ == '__main__':
    g = nx.dense_gnm_random_graph(50, 200)
    nodes = g.nodes()

    ss = set()

    for i in range(20):
        ss.add(random.choice(nodes))

    graph = graph.GraphWithSecureSet(g, ss)

    a = Annealing(graph)
    #TODO: 3/p times
    print a.security()
    print is_graph_secure(graph)

Esempio n. 45
0
def grow_graph(reverserandom = False, outgoingrandom = False, incomingrandom = False, totalrandom = False, usenx= True, force_connected = True, sparse = True, plot = False, directed = True, randomgrowth=False, wholegrowth=False,growthfactor=100, num_measurements = 10, verbose = True, connected = True, plotx = 'nodegrowth', ploty = 'maxclique', ploty2 = 'modval',drawgraph = 'triangulated', draw= True, drawspectral = True, getgraph = True):
	
	random = False #set as false, gets made to truth later if the person passes a type of random graph they want

	#make sure user does not want to draw and plot at the same time. 
	if plot == True:
		draw = False
	if draw == True:
		plot = False
	#you cannot plot and draw at the same time

	# initialize database 
	graph_db = database()

	#get the pickled dictionary of nodes and node names (for the database) that is made while the csv file is loaded.
	try:
		nodes = open('nodes.p','r')
		nodes = pickle.load(nodes)
	except:
		print 'Your graph is empty. Please load a graph into the database.'
		1/0
	data = []
	if graph_db.size < 2:
		print 'Your graph is empty. Please load a graph into the database.'
		1/0
	# this will grow the whole graph. Takes a while for big ones! 
	if wholegrowth == True:
	    growthfactor = len(nodes)

	#make a list of all the nodes in the database to randomly choose from, but only if force connected graph option is false. 
	if force_connected == False:
		possiblenodes = nodes
		print 'Graph will not be fully connected, use "force_connected = True" if you want it to be fully connected'

	# here we figure out at what points to measure if the user wants a spare measumement or to measure every time a node is added. This speeds up big graph growths a lot! 
	if sparse == True:
	    sparsemeasurements = [10,15,growthfactor]
	    measurements = np.logspace(1, (int(len(str(growthfactor))))-1, num_measurements)
	    for x in measurements:
	        sparsemeasurements.append(int(x))
	else:
		sparsemeasurements = range(2,growthfactor)

	# this will actually only work for directed graph because we are moralizing, but I want to leave the option for later. Perhaps I can just skip moralization for undirected graphs.
	if directed:
		graph = nx.DiGraph()
	else:
		graph = nx.graph()




	# pick an initial node to start from
	initial_node = np.random.choice(nodes.keys()) #randomly get a node to add from dictionary
	if verbose:
	    print 'Starting from ' + initial_node
	initial_used = 0 #keep track of how many times the initial node was used
	nodegrowth = graph.number_of_nodes()
	edgegrowth = graph.number_of_edges()
	while nodegrowth < growthfactor: # make sure we aren't above how many nodes we want to measure in the graph    
		#start off finding a node to add to the graph.
		if force_connected == True:
			try:
				possiblenodes = graph.nodes() # get all nodes in graph.
				fromnode = Random.choice(possiblenodes) #pick random node in graph to grow from(add one of its nieghbors). This uses the random module, not np.random
				if verbose:
				    print 'Using ' + str(fromnode) + ' to find new node'
			except: #this is because you can't do random from one node at the start.
			    fromnode = initial_node
			    graph.add_node(fromnode)
			    if verbose:
			        print 'using initial node'
			        initial_used = initial_used+1
			        if initial_used > 5:
			        	1/0

			fromnode = nodes[fromnode] #get DB version of the node.
			#get all relationships in graph DB for that node so we can pick 
			new_node_rels = list(graph_db.match(end_node = fromnode, bidirectional=True))
			new_rel = Random.choice(new_node_rels) #randomly pick one of them, thus picking a node to add to graph. This uses the random module, not np.random

			# is the new node a parent or child of the node we are growing from?
			if new_rel.end_node == fromnode:
			    new_node = new_rel.start_node
			if new_rel.start_node == fromnode:
			    new_node = new_rel.end_node
			assert new_node != fromnode
		
		if force_connected == False: # if not connected, we can just pick from the pickled dictionary of nodes in the database
			new_node = np.random.choice(possiblenodes.values())
			
		print 'adding' + str(new_node)
		#add the nodes to the graph, connecting it to nodes in the graph that it is connected to.
	    # go through the list of edges that have the new node as a part of it, and only add the edge if they are between the new node and a node in the graph already.
		rels = list(graph_db.match(start_node=new_node)) #query graph for edges from that node
		for edge in rels:
			#get the string name of the node
		    newnodename = edge.start_node.get_properties()
		    newnodename = newnodename.get('name')
		    newnodename = newnodename.encode()
		    endnodename = edge.end_node.get_properties()
		    endnodename = endnodename.get('name')
		    endnodename = endnodename.encode()
		    if newnodename not in graph: #check to see if new node is in graph
		        graph.add_node(newnodename) # add if not
		        if verbose:
		            print 'added ' + str(newnodename)
		    if endnodename in graph: #check to see if end node is in graph
		        graph.add_edge(newnodename, endnodename) #add it if it is
		        if verbose:
		            print 'connected ' + newnodename +' to '+ endnodename

		rels = list(graph_db.match(end_node=new_node)) #query graph for edges to that node
		for edge in rels:
		    newnodename = edge.end_node.get_properties()
		    newnodename = newnodename.get('name')
		    newnodename = newnodename.encode()
		    startnodename = edge.start_node.get_properties()
		    startnodename = startnodename.get('name')
		    startnodename = startnodename.encode()
		    if newnodename not in graph: #check to see if new node is in graph
		        graph.add_node(newnodename) # add if not
		        if verbose:
		            print 'added ' + str(newnodename)
		    if startnodename in graph: #check to see if end node is in graph
		        graph.add_edge(startnodename, newnodename) #add it if it is
		        if verbose:
		            print 'connected ' + startnodename +' to '+ newnodename
				#measure the nodegrowth and edge growth
		nodegrowth = len(graph.nodes())
		edgegrowth = len(graph.edges())
		if verbose:
			print 'Graph has ' + str(nodegrowth) + ' nodes.'
		if verbose:
		    print 'Graph has ' + str(edgegrowth) + ' edges.'

		#here I make a few random graphs to compare the growth of the real graph. They are all the same size and same edges, but different controls.		

		# Reverse the direction of the edges. The in-degree distribution in this graph is power-law, but the out-degree is exponential tailed. So this is just a check that degree distribution is irrelevant.
		if reverserandom == True: 
			random_graph =  graph.reverse()
			random = True
		# Keep the number of outgoing links for each node the same, but randomly allocating their destinations. This should break modularity, put preserves out-degree.
		if outgoingrandom == True:
			random_graph = graph.copy()
			for edge in random_graph.edges():
				parent = edge[0]
				child = edge[1]
				random_graph.remove_edge(parent,child)
				newchild = parent
				while newchild == parent: #so that we don't get a self loop.
					newchild = np.random.choice(graph.nodes())
				random_graph.add_edge(parent,newchild)
				random = True
		# Same thing, but this time fixing the number of incoming links and randomly allocating their origins. Likewise, but preserves in-degree.
		if incomingrandom ==True:
			random_graph = graph.copy()
			for edge in random_graph.edges():
				parent = edge[0]
				child = edge[1]
				random_graph.remove_edge(parent,child)
				newparent = child
				while newparent == child:
					newparent = np.random.choice(graph.nodes())
				random_graph.add_edge(newparent,child)
				random = True
		#gives a graph picked randomly out of the set of all graphs with n nodes and m edges. This preserves overall degree, and number of nodes/edges, but is completeley random to outdegree/indegree. 
		if totalrandom == True:
			numrandomedges = graph.number_of_edges()
			numrandomnodes = graph.number_of_nodes()
			random_graph = nx.dense_gnm_random_graph(numrandomnodes, numrandomedges)
			random_graph = random_graph.to_directed()
			random = True
				
		    #here is where we measure everything about the graph 
		if nodegrowth in sparsemeasurements: #we only measure every now and then in sparse.
			start_time = time()
			if nodegrowth > 5:
				modgraph = nx.Graph(graph) #make it into a undirected networkx graph. This measures moduilarity on undirected version of graph! 
				partition = best_partition(modgraph) #find the partition with maximal modularity
				modval = modularity(partition,modgraph) #calculate modularity with that partition
				sleep(2)
				if random == True:
					random_modgraph = random_graph.to_undirected() #make it into a undirected networkx graph. This measures moduilarity on undirected version of graph! 
					random_partition = best_partition(random_modgraph) #find the partition with maximal modularity
					random_modval = modularity(random_partition,random_modgraph) #calculate modularity with that partition
			#option to use python nx to moralize and triangulate
			if usenx == True:
				moralized = moral_graph(graph)
				if random == True:
					random_moralized = moral_graph(random_graph)
			
			else: #use Octave to run Matlab Bayes Net Toolbox, NOT SET UP FOR RANDOM GRAPHS YET.
				moralized = nx.to_numpy_matrix(graph) # make nx graph into a simple matrix
				ismoral = False
				tries = 0
				while ismoral == False and tries < 5: #sometimes oct2py takes too long to return I think
				    try:
				        moralized, moral_edges = octave.moralize(moralized)
				        ismoral = True
				    except:
				        ismoral = False
				        print 'Octave Error, trying again!'
				        tries = tries + 1
			
			order = range(len(moralized)+1) # BNT needs order of nodes to triangulate
			order = order[1:]
			
			random_order = range(len(random_moralized)+1) # BNT needs order of nodes to triangulate
			random_order = random_order[1:] # I think you have to shift the space because you are going from 0 index to 1 idndex
			
			istriangulated = False
			tries = 0
			while istriangulated == False and tries < 5: #sometimes oct2py takes too long to return I think
				try:
				    moralized = nx.to_numpy_matrix(moralized)  # have to make it into matrix.
				    triangulated, cliques, fill_ins = octave.triangulate(moralized,order)
				    if random == True:
				    	random_moralized = nx.to_numpy_matrix(random_moralized) # have to make it into matrix.
				    	random_triangulated, random_cliques, random_fill_ins = octave.triangulate(random_moralized, random_order)
				    istriangulated = True
				    tries = 5
				except:
				    istriangulated = False
				    print 'Octave Error, trying again!'
				    tries = tries + 1 
			#loop through cliques and get the size of them
			cliquesizes = [] #empty array to keep clique sizes in
			for x in cliques:
			    size = len(x)
			    cliquesizes.append(size)
			maxclique = max(cliquesizes) #get the biggest clique
			avgclique = np.mean(cliquesizes) # get the mean of the clique sizes

			#do the same for random graph cliques
			if random == True:
				random_cliquesizes = [] #empty array to keep clique sizes in
				#loop through cliques and get the size of them
				for x in random_cliques:
					size = len(x)
					random_cliquesizes.append(size)
				random_maxclique = max(random_cliquesizes) #get the biggest clique
				random_avgclique = np.mean(random_cliquesizes) # get the mean of the clique sizes
		
			end_time = time() #get end time 
			run_time = end_time - start_time #time how long all the took
			
			#store the data! 

			if random == True:
				data.append([nodegrowth, edgegrowth, modval, random_modval, maxclique, random_maxclique, avgclique, random_avgclique, run_time]) #store results

			if random == False:
				data.append([nodegrowth, edgegrowth, modval, maxclique,avgclique,run_time]) #store results
			
			sparsemeasurements.remove(nodegrowth) #so we don't calculate clique size more than once!
			if verbose:
			    print 'took ' + str(run_time) + ' to run last computation'
			
			#this will always print, basic status update everytime clique size is measured.
			if random == True:
				print str(nodegrowth) + ' nodes, ', str(edgegrowth) + ' edges; ' + 'Modularity: ' + str(modval) + ', Random Modularity: ' +str(random_modval) + ', Largest Clique: ' + str(maxclique) + ', Largest Random Clique: ' + str(random_maxclique)
			if random == False:
				print str(nodegrowth) + ' nodes, ', str(edgegrowth) + ' edges; ' + 'Modularity: ' + str(modval) + ', Largest Clique: ' + str(maxclique)
			

			#this will redraw the plot everytime a computation is done.
			if plot == True:
				if random == False:
					df = pd.DataFrame(data, columns= ('nodegrowth','edgegrowth', 'modularity','maxclique','avgclique','run_time'))
					plt.close()
					fig = plt.figure(figsize=(24,16))
					ax = fig.add_subplot(1,1,1)
					ax2 = ax.twinx()
					y1 = df[ploty] #user input, default to clique size
					y2 = df[ploty2] #user input, default to modularity
					x = df[plotx] #user input, default to nodes in graph.
					ax.set_xlabel('%s in Graph' %(plotx),fontsize=20)
					line1, = ax.plot(x, y1, label = ploty)
					line2, = ax2.plot(x, y2, label = ploty2, color = 'red')
					ax.set_ylabel(ploty,fontsize=20)
					ax2.set_ylabel(ploty2, fontsize=20)
					plt.suptitle('Graph Growth', fontsize=30)
					plt.legend((line1,line2),(ploty , ploty2), loc='upper center', frameon=False, fontsize=20)
					plt.show()

				if random == True:
					df = pd.DataFrame(data, columns= ('nodegrowth', 'edgegrowth', 'modval','random_modval', 'maxclique', 'random_maxclique', 'avgclique', 'random_avgclique', 'run_time'))
					plt.close()
					fig = plt.figure(figsize=(18,10))
					ax = fig.add_subplot(1,1,1)
					ax2 = ax.twinx()
					ax3 = ax.twinx()
					y1 = df[ploty]
					y2 = df[ploty2]
					y3def = str('random_'+ploty) # i just add random to whatever the user inputs as the y stuff they want to plot
					y3 = df[y3def]
					y4def = str('random_'+ploty2)
					y4 = df[y4def]
					x = df[plotx]
					ax.set_xlabel('%s in Graph' %(plotx),fontsize=20)
					line1, = ax.plot(x, y1, label = ploty, color = 'blue')
					line2, = ax2.plot(x, y2, label = ploty2, color = 'green')
					line3, = ax.plot(x,y3, label = y3def, color = 'red')
					line4, = ax3.plot(x,y4, label = y4def, color = 'cyan')
					ax.set_ylabel(ploty,fontsize=20)
					ax2.set_ylabel(ploty2, fontsize=20)
					plt.suptitle('Graph Growth', fontsize=30)
					plt.legend((line1,line2,line3,line4), (ploty,ploty2,y3def,y4def),loc='upper center', frameon=False, fontsize=20)#
					plt.show()
			#draw the graph 
			if draw == True:
				if drawgraph == 'triangulated':
					G = nx.from_numpy_matrix(triangulated)
				elif drawgraph == 'moralized':
					G = nx.from_numpy_matrix(moralized)
				elif drawgraph == 'directed':
					G = graph
				plt.close()
				
				if drawspectral == True:
					nx.draw_random(G, prog='neato')
				else:
					pos = nx.random_layout(G)
					# find node near center (0.5,0.5)
					dmin=1
					ncenter=0
					for n in pos:
					    x,y=pos[n]
					    d=(x-0.5)**2+(y-0.5)**2
					    if d<dmin:
					        ncenter=n
					        dmin=d

					# color by path length from node near center
					p=nx.single_source_shortest_path_length(G,ncenter)
					plt.figure(figsize=(15,15))
					plt.suptitle(drawgraph + ' graph')
					nx.draw_networkx_edges(G,pos,nodelist=[ncenter],alpha=0.2)
					nx.draw_networkx_nodes(G,pos,nodelist=p.keys(),
					                       node_size=20,
					                       node_color=p.values(),
					                       cmap=plt.cm.Reds_r)

					plt.xlim(-0.05,1.05)
					plt.ylim(-0.05,1.05)
					plt.axis('off')

				plt.show()
	if random == True:
		df = pd.DataFrame(data, columns= ('nodegrowth', 'edgegrowth', 'modval','random_modval', 'maxclique', 'random_maxclique', 'avgclique', 'random_avgclique', 'run_time'))
	if random == False:
		df = pd.DataFrame(data, columns= ('nodegrowth','edgegrowth', 'modval','maxclique','avgclique','run_time'))
	if getgraph == True:
		return (graph, df)
	else:
		return(df)
from itertools import combinations
import networkx as nx
from random import choice
G=nx.dense_gnm_random_graph(5,10)
t=G.edges()
p=0.9
a=0
r=0
s='nothing'
num=[]


def main():
    for i in xrange(0,11):
        for subset in combinations(t,i):
            count=0
            for j in subset:
                if len(subset)!=0:
                    count=count+1
                G.remove_edge(j[0],j[1])
            if (len(list(nx.all_simple_paths(G,0,2))) > 0):
                s='up'
            else:
                s='down'
            r=(pow(1-p,count))*(pow(p,(10-count)))
            for k in subset:
                G.add_edge(k[0],k[1])
            num.append([r,s])
    #print num
    for i in range(2,3):
        r1=0