def keywords(self, text, n=10): tokens = self.pos_tagging(text) tokens = [t for s in tokens for w in s[1] for t in w] nodes = [ k for t in tokens for k in t[1] if (k[1][0] in ['N', 'V']) & (len(k[0]) > 1) ] tokens = [k for t in tokens for k in t[1]] def connect(nodes, tokens): window_size = 5 # coocurrence를 판단하기 위한 window 사이즈 설정 edges = [] for window_start in range(0, (len(tokens) - window_size + 1)): window = tokens[window_start:window_start + window_size] #edges.append([(window[i], window[j]) for i in range(window_size) for j in range(window_size) if ( (i > j) & (window[i] in nodes) & (window[j] in nodes))]) for i in range(window_size): for j in range(window_size): if (i > j) & (window[i] in nodes) & (window[j] in nodes): edges.append((window[i], window[j])) return edges graph = nx.diamond_graph() graph.clear() #처음 생성시 graph에 garbage node가 남아있어 삭제 graph.add_nodes_from(list(set(nodes))) #node 등록 graph.add_edges_from(connect(nodes, tokens)) #edge 연결 scores = nx.pagerank(graph) #pagerank 계산 rank = sorted(scores.items(), key=lambda x: x[1], reverse=True) #score 역순 정렬 return rank[:n]
def __init__(self, pos_tagger_name='mecab', mecab_path='', exceptional_stop_pos=[], lang='ko', stopwords=[]): self.stop_pos = STOP_POS[lang] # print(self.stop_pos) if pos_tagger_name == 'mecab': from konlpy.tag import Mecab self.pos_tagger = Mecab(mecab_path) elif pos_tagger_name == 'komoran': from konlpy.tag import Komoran self.pos_tagger = Komoran() elif pos_tagger_name == 'nltk': self.pos_tagger = None else: from konlpy.tag import Okt self.pos_tagger = Okt() if not exceptional_stop_pos: self.stop_pos = [ x for x in self.stop_pos if x not in exceptional_stop_pos ] self.stopwords = [] if stopwords: self.stopwords = stopwords self.graph = nx.diamond_graph() self.graph.clear() # 처음 생성시 graph에 garbage node가 남아있어 삭제 self.tokens = []
def DiamondGraph(): """ Returns a diamond graph with 4 nodes. A diamond graph is a square with one pair of diagonal nodes connected. This constructor depends on NetworkX numeric labeling. PLOTTING: Upon construction, the position dictionary is filled to override the spring-layout algorithm. By convention, the diamond graph is drawn as a diamond, with the first node on top, second on the left, third on the right, and fourth on the bottom; with the second and third node connected. EXAMPLES: Construct and show a diamond graph :: sage: g = graphs.DiamondGraph() sage: g.show() # long time """ pos_dict = {0:(0,1),1:(-1,0),2:(1,0),3:(0,-1)} import networkx G = networkx.diamond_graph() return graph.Graph(G, pos=pos_dict, name="Diamond Graph")
def DiamondGraph(): """ Returns a diamond graph with 4 nodes. A diamond graph is a square with one pair of diagonal nodes connected. This constructor depends on NetworkX numeric labeling. PLOTTING: Upon construction, the position dictionary is filled to override the spring-layout algorithm. By convention, the diamond graph is drawn as a diamond, with the first node on top, second on the left, third on the right, and fourth on the bottom; with the second and third node connected. EXAMPLES: Construct and show a diamond graph :: sage: g = graphs.DiamondGraph() sage: g.show() # long time """ pos_dict = {0: (0, 1), 1: (-1, 0), 2: (1, 0), 3: (0, -1)} import networkx G = networkx.diamond_graph() return graph.Graph(G, pos=pos_dict, name="Diamond Graph")
def testLimit(self): '''Test we can limit the number of instances generated.''' g = networkx.diamond_graph() gen = FixedNetwork(g, limit=10) n = 0 for _ in gen: n += 1 self.assertEqual(n, 10)
def testFixedNetworkGenerator(self): '''Test that adding a network creates the right generator.''' g = networkx.diamond_graph() p = Process() dyn = Dynamics(p) dyn.setNetworkGenerator(g) self.assertIsInstance(dyn.networkGenerator(), FixedNetwork) self.assertGraphsEqual(g, dyn.networkGenerator().generate())
def __init__(self,STOPWORD=None, STOPPOS=pos, MECABPATH=None): from konlpy.tag import Mecab self.stopwords = STOPWORD self.stoppos = STOPPOS self.mecabpath = MECABPATH self.pos_tag = Mecab(self.mecabpath) self.graph = {} self.graph_treform =nx.diamond_graph() self.graph_treform.clear()
def testFixedNetwork(self): '''Test we always return a fixed network.''' g = networkx.diamond_graph( ) # doesn't matter what it as, as long as it's fixed gen = FixedNetwork(g) self.assertGraphsEqual(g, gen.generate()) for _ in range(5): # make sure the iterator is stable gp = gen.__next__() self.assertGraphsEqual(g, gp)
def instance4(): lst = [] for _ in range(25): lst.append(nx.diamond_graph()) L = nx.Graph() for i in lst: L = nx.disjoint_union(L, i) r = 0 while (r <= 92): L.add_edge(r + 3, r + 4) r += 4 L.add_edge(0, 99) return L
def summarize(self, text, n=3): tokens = self.pos_tagging(text) #자카드 유사도 계산 def jaccard_similarity(query, document): intersection = set(query).intersection(set(document)) union = set(query).union(set(document)) return len(intersection) / len(union) # 문장간 유사도 측정 (BoW를 활용 코사인 유사도 측정) def sentence_similarity(sentence1, sentence2): sentence1 = self.tokenizer.morphs( sentence1[0] ) #[t[0] for s in sentence1[1][0] for t in s[1] if t[1][0] in ['N','V'] ] sentence2 = self.tokenizer.morphs( sentence2[0] ) #.split()#[t[0] for s in sentence2[1][0] for t in s[1] if t[1][0] in ['N','V'] ] #print(sentence1) return jaccard_similarity(sentence1, sentence2) def sentences(doc): return [s[0].strip() for s in doc] def connect(doc): return [(start[0].strip(), end[0].strip(), sentence_similarity(start, end)) for start in doc for end in doc if start is not end] graph = nx.diamond_graph() graph.clear() #처음 생성시 graph에 garbage node가 남아있어 삭제 graph.add_nodes_from(sentences(tokens)) #node 등록 graph.add_weighted_edges_from(connect(tokens)) #edge 연결 scores = nx.pagerank(graph) #pagerank 계산 #print(scores) rank = sorted(scores.items(), key=lambda x: x[1], reverse=True) #score 역순 정렬 ssum = rank[:n] ranks = [] for s in ssum: ranks.append(s[0]) return ' '.join(ranks)
def keywords(self, text, n=10, window_size=WINDOW_SIZE): if self.pos_tagger is None: import nltk _tokens = nltk.word_tokenize(text) tokenized = nltk.pos_tag(_tokens) else: tokenized = self.pos_tagger.pos(text) # print(tokenized) nodes = [] tokens = [] for token in tokenized: if (len(token[0]) > 1) & (str(token[0]) not in self.stopwords) & ( token[1][:3] not in self.stop_pos) & ( token[0] != token[1]): # nltk는 특수문자는 품사가 태깅이 안되고 토큰이 그대로 품사에 나옴 nodes.append(token) tokens.append(token) def connect(nodes, tokens): edges = [] for window_start in range(0, (len(tokens) - window_size + 1)): window = tokens[window_start:window_start + window_size] for i in range(window_size): for j in range(window_size): if (i > j) & (window[i] in nodes) & (window[j] in nodes): edges.append((window[i], window[j])) return edges graph = nx.diamond_graph() graph.clear() # 처음 생성시 graph에 garbage node가 남아있어 삭제 graph.add_nodes_from(list(set(nodes))) # node 등록 graph.add_edges_from(connect(nodes, tokens)) # edge 연결 scores = nx.pagerank(graph) # pagerank 계산 rank = sorted(scores.items(), key=lambda x: x[1], reverse=True) # score 역순 정렬 return rank[:n]
def summarize(self, text, max=3): # 자카드 유사도 계산 def jaccard_similarity(query, document): intersection = set(query).intersection(set(document)) union = set(query).union(set(document)) return len(intersection) / len(union) # 문장간 유사도 측정 (BoW를 활용 코사인 유사도 측정) def sentence_similarity(sentence1, sentence2): sentence1 = [ t[0] for t in self.pos_tagger.pos(sentence1) if t[1][:3] not in self.stop_pos ] # 개선 필요 sentence2 = [ t[0] for t in self.pos_tagger.pos(sentence2) if t[1][:3] not in self.stop_pos ] # 개선 필요 # print(sentence1) return jaccard_similarity(sentence1, sentence2) def sentences(doc): return sent_tokenize(doc) # [s[0].strip() for s in doc] def connect(doc): return [(start, end, sentence_similarity(start, end)) for start in doc for end in doc if start is not end] # tokens = self.pos_tagger(text) sentence_li = sentences(text) graph = nx.diamond_graph() graph.clear() # 처음 생성시 graph에 garbage node가 남아있어 삭제 graph.add_nodes_from(sentence_li) # node 등록 graph.add_weighted_edges_from(connect(sentence_li)) # edge 연결 scores = nx.pagerank(graph) # pagerank 계산 rank = sorted(scores.items(), key=lambda x: x[1], reverse=True) # score 역순 정렬 return rank[:max]
def diamond(): return nx.diamond_graph()
from monosat import * from networkx.relabel import convert_node_labels_to_integers print("begin encode") seed = random.randint(1, 100000) random.seed(seed) print("RandomSeed=" + str(seed)) size = 6 #Monosat().newSolver("-decide-graph-bv -no-decide-theories -no-decide-graph-rnd -lazy-maxflow-decisions -conflict-min-cut -conflict-min-cut-maxflow -reach-underapprox-cnf ") 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),
def small_graphs(): print("Make small graph") G = nx.make_small_graph( ["adjacencylist", "C_4", 4, [[2, 4], [1, 3], [2, 4], [1, 3]]]) draw_graph(G) G = nx.make_small_graph( ["adjacencylist", "C_4", 4, [[2, 4], [3], [4], []]]) draw_graph(G) G = nx.make_small_graph( ["edgelist", "C_4", 4, [[1, 2], [3, 4], [2, 3], [4, 1]]]) draw_graph(G) print("LCF graph") G = nx.LCF_graph(6, [3, -3], 3) draw_graph(G) G = nx.LCF_graph(14, [5, -5], 7) draw_graph(G) print("Bull graph") G = nx.bull_graph() draw_graph(G) print("Chvátal graph") G = nx.chvatal_graph() draw_graph(G) print("Cubical graph") G = nx.cubical_graph() draw_graph(G) print("Desargues graph") G = nx.desargues_graph() draw_graph(G) print("Diamond graph") G = nx.diamond_graph() draw_graph(G) print("Dodechaedral graph") G = nx.dodecahedral_graph() draw_graph(G) print("Frucht graph") G = nx.frucht_graph() draw_graph(G) print("Heawood graph") G = nx.heawood_graph() draw_graph(G) print("House graph") G = nx.house_graph() draw_graph(G) print("House X graph") G = nx.house_x_graph() draw_graph(G) print("Icosahedral graph") G = nx.icosahedral_graph() draw_graph(G) print("Krackhardt kite graph") G = nx.krackhardt_kite_graph() draw_graph(G) print("Moebius kantor graph") G = nx.moebius_kantor_graph() draw_graph(G) print("Octahedral graph") G = nx.octahedral_graph() draw_graph(G) print("Pappus graph") G = nx.pappus_graph() draw_graph(G) print("Petersen graph") G = nx.petersen_graph() draw_graph(G) print("Sedgewick maze graph") G = nx.sedgewick_maze_graph() draw_graph(G) print("Tetrahedral graph") G = nx.tetrahedral_graph() draw_graph(G) print("Truncated cube graph") G = nx.truncated_cube_graph() draw_graph(G) print("Truncated tetrahedron graph") G = nx.truncated_tetrahedron_graph() draw_graph(G) print("Tutte graph") G = nx.tutte_graph() draw_graph(G)
import networkx as nx import matplotlib.pylab as plt from plot_multigraph import plot_multigraph graphs = [ ("bull", nx.bull_graph()), ("chvatal", nx.chvatal_graph()), ("cubical", nx.cubical_graph()), ("desargues", nx.desargues_graph()), ("diamond", nx.diamond_graph()), ("dodecahedral", nx.dodecahedral_graph()), ("frucht", nx.frucht_graph()), ("heawood", nx.heawood_graph()), ("house", nx.house_graph()), ("house_x", nx.house_x_graph()), ("icosahedral", nx.icosahedral_graph()), ("krackhardt_kite", nx.krackhardt_kite_graph()), ("moebius_kantor", nx.moebius_kantor_graph()), ("octahedral", nx.octahedral_graph()), ("pappus", nx.pappus_graph()), ("petersen", nx.petersen_graph()), ("sedgewick_maze", nx.sedgewick_maze_graph()), ("tetrahedral", nx.tetrahedral_graph()), ("truncated_cube", nx.truncated_cube_graph()), ("truncated_tetrahedron", nx.truncated_tetrahedron_graph()), ] plot_multigraph(graphs, 4, 5, node_size=50) plt.savefig('graphs/small.png')
seed = random.randint(1,100000) 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)
def test_get_cliques_of_size(): networkx_graph_with_cliques = nx.diamond_graph() nose.tools.assert_equal( len( networkx_graph_from_array._get_cliques_of_size( networkx_graph_with_cliques, 3)), 2)
def test_remove_clique_edges(): networkx_graph_with_cliques = nx.diamond_graph() edges_before = networkx_graph_with_cliques.number_of_edges() networkx_graph_from_array._remove_clique_edges(networkx_graph_with_cliques) nose.tools.assert_equal(networkx_graph_with_cliques.number_of_edges(), edges_before)
def test_diamond(self): expected = True actual = is_planar(nx.diamond_graph()) self.assertEqual(expected, actual)
if not os.path.exists(args.output): os.makedirs(args.output) with open(args.output + '/output.csv', 'w') as output: helper(output, nx.balanced_tree(2, 5), "balanced_tree") # branching factor, height helper(output, nx.barbell_graph(50, 50), "barbell_graph") helper(output, nx.complete_graph(50), "complete_graph") helper(output, nx.complete_bipartite_graph(50, 50), "complete_bipartite_graph") helper(output, nx.circular_ladder_graph(50), "circular_ladder_graph") helper(output, nx.cycle_graph(50), "cycle_graph") helper(output, nx.dorogovtsev_goltsev_mendes_graph(5), "dorogovtsev_goltsev_mendes_graph") helper(output, nx.empty_graph(50), "empty_graph") helper(output, nx.grid_2d_graph(5, 20), "grid_2d_graph") helper(output, nx.grid_graph([2, 3]), "grid_graph") helper(output, nx.hypercube_graph(3), "hypercube_graph") helper(output, nx.ladder_graph(50), "ladder_graph") helper(output, nx.lollipop_graph(5, 20), "lollipop_graph") helper(output, nx.path_graph(50), "path_graph") helper(output, nx.star_graph(50), "star_graph") helper(output, nx.trivial_graph(), "trivial_graph") helper(output, nx.wheel_graph(50), "wheel_graph") helper(output, nx.random_regular_graph(1, 50, 678995), "random_regular_graph_1") helper(output, nx.random_regular_graph(3, 50, 683559), "random_regular_graph_3") helper(output, nx.random_regular_graph(5, 50, 515871), "random_regular_graph_5") helper(output, nx.random_regular_graph(8, 50, 243579), "random_regular_graph_8") helper(output, nx.random_regular_graph(13, 50, 568324), "random_regular_graph_13") helper(output, nx.diamond_graph(), "diamond_graph")
def process_arguments(args): extract_id_fn = subgraph_counts2ids ###### choose the function that computes the automorphism group and the orbits ####### if args['edge_automorphism'] == 'induced': automorphism_fn = induced_edge_automorphism_orbits if args[ 'id_scope'] == 'local' else automorphism_orbits elif args['edge_automorphism'] == 'line_graph': automorphism_fn = edge_automorphism_orbits if args[ 'id_scope'] == 'local' else automorphism_orbits else: raise NotImplementedError ###### choose the function that computes the subgraph isomorphisms ####### count_fn = subgraph_isomorphism_edge_counts if args[ 'id_scope'] == 'local' else subgraph_isomorphism_vertex_counts ###### choose the substructures: usually loaded from networkx, ###### except for 'all_simple_graphs' where they need to be precomputed, ###### or when a custom edge list is provided in the input by the user if args['id_type'] in [ 'cycle_graph', 'path_graph', 'complete_graph', 'binomial_tree', 'star_graph', 'nonisomorphic_trees' ]: args['k'] = args['k'][0] k_max = args['k'] k_min = 2 if args['id_type'] == 'star_graph' else 3 args['custom_edge_list'] = get_custom_edge_list( list(range(k_min, k_max + 1)), args['id_type']) elif args['id_type'] in [ 'cycle_graph_chosen_k', 'path_graph_chosen_k', 'complete_graph_chosen_k', 'binomial_tree_chosen_k', 'star_graph_chosen_k', 'nonisomorphic_trees_chosen_k' ]: args['custom_edge_list'] = get_custom_edge_list( args['k'], args['id_type'].replace('_chosen_k', '')) elif args['id_type'] in ['all_simple_graphs']: args['k'] = args['k'][0] k_max = args['k'] k_min = 3 filename = os.path.join(args['root_folder'], 'all_simple_graphs') args['custom_edge_list'] = get_custom_edge_list(list( range(k_min, k_max + 1)), filename=filename) elif args['id_type'] in ['all_simple_graphs_chosen_k']: filename = os.path.join(args['root_folder'], 'all_simple_graphs') args['custom_edge_list'] = get_custom_edge_list(args['k'], filename=filename) elif args['id_type'] in ['diamond_graph']: args['k'] = None graph_nx = nx.diamond_graph() args['custom_edge_list'] = [list(graph_nx.edges)] elif args['id_type'] == 'custom': assert args[ 'custom_edge_list'] is not None, "Custom edge list must be provided." else: raise NotImplementedError( "Identifiers {} are not currently supported.".format( args['id_type'])) # define if degree is going to be used as a feature and when (for each layer or only at initialization) if args['inject_degrees']: args['degree_as_tag'] = [ args['degree_as_tag'] for _ in range(args['num_layers']) ] else: args['degree_as_tag'] = [args['degree_as_tag']] + [ False for _ in range(args['num_layers'] - 1) ] # define if existing features are going to be retained when the degree is used as a feature args['retain_features'] = [args['retain_features']] + [ True for _ in range(args['num_layers'] - 1) ] # replicate d_out dimensions if the rest are not defined (msg function, mlp hidden dimension, encoders, etc.) # and repeat hyperparams for every layer if args['d_msg'] == -1: args['d_msg'] = [None for _ in range(args['num_layers'])] elif args['d_msg'] is None: args['d_msg'] = [args['d_out'] for _ in range(args['num_layers'])] else: args['d_msg'] = [args['d_msg'] for _ in range(args['num_layers'])] if args['d_h'] is None: args['d_h'] = [[args['d_out']] * (args['num_mlp_layers'] - 1) for _ in range(args['num_layers'])] else: args['d_h'] = [[args['d_h']] * (args['num_mlp_layers'] - 1) for _ in range(args['num_layers'])] if args['d_out_edge_encoder'] is None: args['d_out_edge_encoder'] = [ args['d_out'] for _ in range(args['num_layers']) ] else: args['d_out_edge_encoder'] = [ args['d_out_edge_encoder'] for _ in range(args['num_layers']) ] if args['d_out_node_encoder'] is None: args['d_out_node_encoder'] = args['d_out'] else: pass if args['d_out_id_embedding'] is None: args['d_out_id_embedding'] = args['d_out'] else: pass if args['d_out_degree_embedding'] is None: args['d_out_degree_embedding'] = args['d_out'] else: pass # virtual node configuration for ogb datasets if args['vn']: if args['d_out_vn_encoder'] is None: args['d_out_vn_encoder'] = args['d_out'] else: pass if args['d_out_vn'] is None: args['d_out_vn'] = [ args['d_out'] for _ in range(args['num_layers'] - 1) ] else: args['d_out_vn'] = [ args['d_out_vn'] for _ in range(args['num_layers'] - 1) ] else: pass # repeat hyperparams for every layer args['d_out'] = [args['d_out'] for _ in range(args['num_layers'])] args['train_eps'] = [args['train_eps'] for _ in range(args['num_layers'])] if len(args['final_projection']) == 1: args['final_projection'] = [ args['final_projection'][0] for _ in range(args['num_layers']) ] + [True] args['bn'] = [args['bn'] for _ in range(args['num_layers'])] args['dropout_features'] = [ args['dropout_features'] for _ in range(args['num_layers']) ] + [args['dropout_features']] # loss function & metrics if args['loss_fn'] == 'CrossEntropyLoss': assert args[ 'regression'] is False, "Can't use Cross-Entropy loss in regression." loss_fn = nn.CrossEntropyLoss() elif args['loss_fn'] == 'BCEWithLogitsLoss': assert args[ 'regression'] is False, "Can't use binary Cross-Entropy loss in regression." loss_fn = nn.BCEWithLogitsLoss() elif args['loss_fn'] == 'MSELoss': loss_fn = nn.MSELoss() elif args['loss_fn'] == 'L1Loss': loss_fn = nn.L1Loss() else: raise NotImplementedError if args['prediction_fn'] == 'multi_class_accuracy': assert args[ 'regression'] is False, "Can't use Classification Accuracy metric in regression." prediction_fn = multi_class_accuracy elif args['prediction_fn'] == 'MSELoss': prediction_fn = nn.MSELoss(reduction='sum') elif args['prediction_fn'] == 'L1Loss': prediction_fn = nn.L1Loss(reduction='sum') elif args['prediction_fn'] == 'None': prediction_fn = None else: raise NotImplementedError if args['regression']: perf_opt = np.argmin else: perf_opt = np.argmax return args, extract_id_fn, count_fn, automorphism_fn, loss_fn, prediction_fn, perf_opt
def test_properties_named_small_graphs(self): G = nx.bull_graph() assert G.number_of_nodes() == 5 assert G.number_of_edges() == 5 assert sorted(d for n, d in G.degree()) == [1, 1, 2, 3, 3] assert nx.diameter(G) == 3 assert nx.radius(G) == 2 G = nx.chvatal_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 24 assert list(d for n, d in G.degree()) == 12 * [4] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.cubical_graph() assert G.number_of_nodes() == 8 assert G.number_of_edges() == 12 assert list(d for n, d in G.degree()) == 8 * [3] assert nx.diameter(G) == 3 assert nx.radius(G) == 3 G = nx.desargues_graph() assert G.number_of_nodes() == 20 assert G.number_of_edges() == 30 assert list(d for n, d in G.degree()) == 20 * [3] G = nx.diamond_graph() assert G.number_of_nodes() == 4 assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3] assert nx.diameter(G) == 2 assert nx.radius(G) == 1 G = nx.dodecahedral_graph() assert G.number_of_nodes() == 20 assert G.number_of_edges() == 30 assert list(d for n, d in G.degree()) == 20 * [3] assert nx.diameter(G) == 5 assert nx.radius(G) == 5 G = nx.frucht_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 18 assert list(d for n, d in G.degree()) == 12 * [3] assert nx.diameter(G) == 4 assert nx.radius(G) == 3 G = nx.heawood_graph() assert G.number_of_nodes() == 14 assert G.number_of_edges() == 21 assert list(d for n, d in G.degree()) == 14 * [3] assert nx.diameter(G) == 3 assert nx.radius(G) == 3 G = nx.hoffman_singleton_graph() assert G.number_of_nodes() == 50 assert G.number_of_edges() == 175 assert list(d for n, d in G.degree()) == 50 * [7] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.house_graph() assert G.number_of_nodes() == 5 assert G.number_of_edges() == 6 assert sorted(d for n, d in G.degree()) == [2, 2, 2, 3, 3] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.house_x_graph() assert G.number_of_nodes() == 5 assert G.number_of_edges() == 8 assert sorted(d for n, d in G.degree()) == [2, 3, 3, 4, 4] assert nx.diameter(G) == 2 assert nx.radius(G) == 1 G = nx.icosahedral_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 30 assert (list( d for n, d in G.degree()) == [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]) assert nx.diameter(G) == 3 assert nx.radius(G) == 3 G = nx.krackhardt_kite_graph() assert G.number_of_nodes() == 10 assert G.number_of_edges() == 18 assert (sorted( d for n, d in G.degree()) == [1, 2, 3, 3, 3, 4, 4, 5, 5, 6]) G = nx.moebius_kantor_graph() assert G.number_of_nodes() == 16 assert G.number_of_edges() == 24 assert list(d for n, d in G.degree()) == 16 * [3] assert nx.diameter(G) == 4 G = nx.octahedral_graph() assert G.number_of_nodes() == 6 assert G.number_of_edges() == 12 assert list(d for n, d in G.degree()) == 6 * [4] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.pappus_graph() assert G.number_of_nodes() == 18 assert G.number_of_edges() == 27 assert list(d for n, d in G.degree()) == 18 * [3] assert nx.diameter(G) == 4 G = nx.petersen_graph() assert G.number_of_nodes() == 10 assert G.number_of_edges() == 15 assert list(d for n, d in G.degree()) == 10 * [3] assert nx.diameter(G) == 2 assert nx.radius(G) == 2 G = nx.sedgewick_maze_graph() assert G.number_of_nodes() == 8 assert G.number_of_edges() == 10 assert sorted(d for n, d in G.degree()) == [1, 2, 2, 2, 3, 3, 3, 4] G = nx.tetrahedral_graph() assert G.number_of_nodes() == 4 assert G.number_of_edges() == 6 assert list(d for n, d in G.degree()) == [3, 3, 3, 3] assert nx.diameter(G) == 1 assert nx.radius(G) == 1 G = nx.truncated_cube_graph() assert G.number_of_nodes() == 24 assert G.number_of_edges() == 36 assert list(d for n, d in G.degree()) == 24 * [3] G = nx.truncated_tetrahedron_graph() assert G.number_of_nodes() == 12 assert G.number_of_edges() == 18 assert list(d for n, d in G.degree()) == 12 * [3] G = nx.tutte_graph() assert G.number_of_nodes() == 46 assert G.number_of_edges() == 69 assert list(d for n, d in G.degree()) == 46 * [3] # Test create_using with directed or multigraphs on small graphs pytest.raises(nx.NetworkXError, nx.tutte_graph, create_using=nx.DiGraph) MG = nx.tutte_graph(create_using=nx.MultiGraph) assert sorted(MG.edges()) == sorted(G.edges())
def test_diamond(self): print '\ndiamond:', self.g = nx.diamond_graph() a = programming_for_tree_decomposition(self.g, True) self.t = a.tree_decomposition() self.assertTrue(self.__test_all_conditions())
def clean_attributes(g): for v in g.nodes(): if 'visited' in g.node[v]: del g.node[v]['visited'] for u, v in g.edges(): if 'visited' in g[u][v]: del g[u][v]['visited'] if __name__ == '__main__': targets = { 'bull': nx.bull_graph(), # 1-connected planar 'chvatal': nx.chvatal_graph(), # 4-connected non-planar 'cubical': nx.cubical_graph(), # 3-connected planar 'desargues': nx.desargues_graph(), # 3-connected non-planar 'diamond': nx.diamond_graph(), # 2-connected planar 'dodecahedral': nx.dodecahedral_graph(), # 3-connected planar 'frucht': nx.frucht_graph(), # 3-connected planar 'heawood': nx.heawood_graph(), # 3-connected non-planar 'house': nx.house_graph(), # 2-connected planar 'house_x': nx.house_x_graph(), # 2-connected planar 'icosahedral': nx.icosahedral_graph(), # 5-connected planar 'krackhardt': nx.krackhardt_kite_graph(), # 1-connected planar 'moebius': nx.moebius_kantor_graph(), # non-planar 'octahedral': nx.octahedral_graph(), # 4-connected planar 'pappus': nx.pappus_graph(), # 3-connected non-planar 'petersen': nx.petersen_graph(), # 3-connected non-planar 'sedgewick': nx.sedgewick_maze_graph(), # 1-connected planar 'tetrahedral': nx.tetrahedral_graph(), # 3-connected planar 'truncated_cube': nx.truncated_cube_graph(), # 3-conn. planar 'truncated_tetrahedron': nx.truncated_tetrahedron_graph(),
def rank(nodes, edges): '''Return a dicitionary containing the scores for each vertex.''' graph = nx.diamond_graph() graph.add_nodes_from(nodes) graph.add_weighted_edges_from(edges) return nx.pagerank(graph)
print("begin encode"); seed = random.randint(1,100000) 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 ") 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)