def test_is_semieulerian(self):
# Test graphs with Eulerian paths but no cycles return True.
assert nx.is_semieulerian(nx.path_graph(4))
G = nx.path_graph(6, create_using=nx.DiGraph)
assert nx.is_semieulerian(G)
# Test graphs with Eulerian cycles return False.
assert not nx.is_semieulerian(nx.complete_graph(5))
assert not nx.is_semieulerian(nx.complete_graph(7))
assert not nx.is_semieulerian(nx.hypercube_graph(4))
assert not nx.is_semieulerian(nx.hypercube_graph(6))
def test_is_eulerian(self):
assert_true(is_eulerian(nx.complete_graph(5)))
assert_true(is_eulerian(nx.complete_graph(7)))
assert_true(is_eulerian(nx.hypercube_graph(4)))
assert_true(is_eulerian(nx.hypercube_graph(6)))
assert_false(is_eulerian(nx.complete_graph(4)))
assert_false(is_eulerian(nx.complete_graph(6)))
assert_false(is_eulerian(nx.hypercube_graph(3)))
assert_false(is_eulerian(nx.hypercube_graph(5)))
assert_false(is_eulerian(nx.petersen_graph()))
assert_false(is_eulerian(nx.path_graph(4)))
def test_is_eulerian(self):
assert nx.is_eulerian(nx.complete_graph(5))
assert nx.is_eulerian(nx.complete_graph(7))
assert nx.is_eulerian(nx.hypercube_graph(4))
assert nx.is_eulerian(nx.hypercube_graph(6))
assert not nx.is_eulerian(nx.complete_graph(4))
assert not nx.is_eulerian(nx.complete_graph(6))
assert not nx.is_eulerian(nx.hypercube_graph(3))
assert not nx.is_eulerian(nx.hypercube_graph(5))
assert not nx.is_eulerian(nx.petersen_graph())
assert not nx.is_eulerian(nx.path_graph(4))
def _hypercube(n):
"""Hypercube's nodes are cube coordinates, which isn't so nice"""
G = nx.hypercube_graph(int(np.log2(n) + .1))
G = nx.relabel_nodes(
G, {n: int('0b' + ''.join(str(i) for i in n), 2)
for n in G.node})
return G
def hypercubegraph(n):
'''
n-dimensional hypercube
'''
g = BaseGraph()
g.load_from_nx(nx.hypercube_graph(n))
return g
def construct_H_cube():
G = nx.hypercube_graph(3)
# convert node labels to ints
G = nx.relabel_nodes(G, lambda v: to_int(v))
N = 2**G.order()
# H = np.zeros( (N, N) )
H = construct_Hv(G, 0)
# for v in G.nodes():
for v in range(1, G.order()):
# print(v)
Hv = construct_Hv(G, v)
# H = and_hams(H, Hv)
H = H + Hv
# nx.draw_networkx(G)
# plt.show()
# print(DataFrame(H))
# print(np.matrix(H))
# Hm = np.matrix(H)
diag = np.diagonal(H)
for idx, d in enumerate(diag):
cut = format(idx, '#010b')[2:]
print(idx, d, cut)
def generateNonGreedyGray(bits=5):
assert bits >= 3, "ngg only exists for l >= 3"
g = nx.hypercube_graph(bits)
l = bits - 3
zero = tuple([0] * l) + (0, 0, 0)
one = tuple([0] * l) + (0, 0, 1)
two = tuple([0] * l) + (0, 1, 1)
three = tuple([0] * l) + (1, 1, 1)
g.remove_node(zero)
g.remove_node(one)
g.remove_node(two)
g.remove_node(three)
cycle = [zero, one, two, three] + hamilton(g, tuple([0] * l) + (1, 0, 1))
stringifiedCycle = []
for node in cycle:
string = ''
for coord in node:
string += str(coord)
stringifiedCycle.append(string)
repfn = {stringifiedCycle[i]: i for i in range(len(stringifiedCycle))}
nongreedy = rp.Representation(repfn,
"Non Greedy Gray " + str(bits) + "-bits")
return nongreedy
def __init__(self, N): self.name = 'Hypercube graph HyperCube_%i' % N self.N = N self.G = nx.hypercube_graph(N) self.params = dict() self.state = None
def _gen_hypercube(self, n):
for _ in range(n):
num_v = np.random.randint(self.min_num_v, self.max_num_v)
g = nx.hypercube_graph(int(math.log(num_v, 2)))
g = nx.convert_node_labels_to_integers(g)
self.graphs.append(g)
self.labels.append(4)
def createHypercube(self, algorithm, dimension=10):
# type: (Union[AlgorithmCtorFactory,collections.abc.Sequence,Callable[[],pg.algorithm]], int) -> Topology
'''
Creates a hypercube topology.
'''
return self._processTopology(nx.hypercube_graph(dimension), algorithm,
Topology)
def generate_connection_graph(graph_type, params, count):
lower_type = graph_type.lower()
if lower_type == 'complete':
assert (len(params) == 0)
return networkx.complete_graph(count)
elif lower_type == 'complete-bipartite':
assert (len(params) == 2)
assert (int(params[0]) > 0.0)
assert (int(params[1]) > 0.0)
n1 = int(round(count * float(params[0]) / float(params[1])))
n2 = int(round(count * float(params[1]) / float(params[0])))
n1 = 1 if n1 < 1 else n1
n2 = 1 if n2 < 1 else n2
return networkx.complete_bipartite_graph(n1, n2)
elif lower_type == 'circular-ladder':
assert (len(params) == 0)
return networkx.circular_ladder_graph(count)
elif lower_type == 'cycle':
assert (len(params) == 0)
return networkx.cycle_graph(count)
elif lower_type == 'periodic-2grid':
assert (len(params) == 2)
assert (int(params[0]) > 0.0)
assert (int(params[1]) > 0.0)
width = int(round(math.sqrt(count * float(params[0]) / float(params[1]))))
height = int(round(math.sqrt(count * float(params[1]) / float(params[0]))))
width = 1 if width < 1 else width
height = 1 if height < 1 else height
return networkx.grid_2d_graph(width, height, True)
elif lower_type == 'nonperiodic-2grid':
assert (len(params) == 2)
assert (int(params[0]) > 0.0)
assert (int(params[1]) > 0.0)
width = int(round(math.sqrt(count * float(params[0]) / float(params[1]))))
height = int(round(math.sqrt(count * float(params[1]) / float(params[0]))))
width = 1 if width < 1 else width
height = 1 if height < 1 else height
return networkx.grid_2d_graph(width, height, False)
elif lower_type == 'hypercube':
assert (len(params) == 0)
return networkx.hypercube_graph(int(round(math.log(count, 2))))
elif lower_type == 'star':
assert (len(params) == 0)
return networkx.star_graph(count - 1)
elif lower_type == 'wheel':
assert (len(params) == 0)
return networkx.wheel_graph(count)
elif lower_type == 'erdos-reyni':
assert (len(params) == 1)
return networkx.erdos_renyi_graph(count, float(params[0]))
elif lower_type == 'watts-strogatz':
assert (len(params) == 2)
if int(params[0]) >= count / 2:
k = int(count / 2 - 1)
else:
k = int(params[0])
return networkx.connected_watts_strogatz_graph(count, k, int(params[1]))
else:
print "Unknown graph type {}".format(lower_type)
assert False
def sorted_from_NK(landscape):
df = landscape.sort_values(by="Fitness")
fitnesses = list(df.Fitness)
N = len(df.iloc[0]["Location"])
hypercube = nx.hypercube_graph(N)
chosen_peak = tuple((np.random.rand(N) > 0.5).astype(int))
node_dict = nx.shortest_path_length(hypercube, chosen_peak)
distance_dict = defaultdict(list)
max_dist = 0
for key, dist in node_dict.items():
distance_dict[dist].append(key)
if dist > max_dist:
max_dist = dist
sorted_landscape = {}
sorted_landscape["".join([str(i) for i in chosen_peak
])] = (fitnesses.pop(), chosen_peak)
for dist in range(1,
max_dist + 1): # node_dict has zero key...so weird IMHO
for location in distance_dict[dist]:
sorted_landscape["".join([str(i) for i in location
])] = (fitnesses.pop(), location)
return pd.DataFrame.from_dict(sorted_landscape,
orient="index",
columns=["Fitness", "Location"])
def landscape_as_digraph(df):
N = len(df.iloc[0].name)
hypercube = nx.hypercube_graph(N)
digraph = nx.DiGraph()
digraph.add_nodes_from(hypercube.nodes())
fitness_diff_dict = {}
fitness_dict = {}
for focal_row in df.itertuples():
source_fit = focal_row.Fitness
Neighbors = df[df['Location'].apply(lambda row: sum(
abs(np.array(row) - np.array(focal_row.Location))) == 1)]
fitness_dict[focal_row.Location] = source_fit
for neighbor in Neighbors.itertuples():
fitness_diff_dict[(
focal_row.Location,
neighbor.Location)] = 1 + source_fit - neighbor.Fitness
fitness_diff_dict[(
neighbor.Location,
focal_row.Location)] = 1 + neighbor.Fitness - source_fit
nx.set_node_attributes(digraph, fitness_dict, "fitness")
nx.set_edge_attributes(digraph, fitness_diff_dict, "fitness_difference")
return digraph
def test_loader(self):
graph = networkx.hypercube_graph(3)
nb_graph = networkx_loader.load_graph(graph)
expected = {'edges':
[{'id': 0, 'target': '(0, 1, 0)', 'source': '(0, 1, 1)'},
{'id': 1, 'target': '(0, 0, 1)', 'source': '(0, 1, 1)'},
{'id': 2, 'target': '(1, 1, 1)', 'source': '(0, 1, 1)'},
{'id': 3, 'target': '(1, 0, 0)', 'source': '(0, 0, 0)'},
{'id': 4, 'target': '(0, 1, 0)', 'source': '(0, 0, 0)'},
{'id': 5, 'target': '(0, 0, 1)', 'source': '(0, 0, 0)'},
{'id': 6, 'target': '(1, 0, 0)', 'source': '(1, 1, 0)'},
{'id': 7, 'target': '(0, 1, 0)', 'source': '(1, 1, 0)'},
{'id': 8, 'target': '(1, 1, 1)', 'source': '(1, 1, 0)'},
{'id': 9, 'target': '(1, 0, 1)', 'source': '(1, 0, 0)'},
{'id': 10, 'target': '(1, 0, 1)', 'source': '(0, 0, 1)'},
{'id': 11, 'target': '(1, 0, 1)', 'source': '(1, 1, 1)'}],
'nodes': [
{'id': '(0, 1, 1)', 'label': '(0, 1, 1)'},
{'id': '(1, 0, 0)', 'label': '(1, 0, 0)'},
{'id': '(0, 0, 1)', 'label': '(0, 0, 1)'},
{'id': '(1, 0, 1)', 'label': '(1, 0, 1)'},
{'id': '(0, 0, 0)', 'label': '(0, 0, 0)'},
{'id': '(1, 1, 1)', 'label': '(1, 1, 1)'},
{'id': '(1, 1, 0)', 'label': '(1, 1, 0)'},
{'id': '(0, 1, 0)', 'label': '(0, 1, 0)'}]}
self.assertEqual(nb_graph.as_dict(), expected)
def classic_graphs():
print("Balanced Tree")
BG = nx.balanced_tree(3, 2)
draw_graph(BG)
print("Barbell Graph")
BBG = nx.barbell_graph(3, 2)
draw_graph(BBG)
print("Complete Graph")
CG = nx.complete_graph(10)
draw_graph(CG)
print("Complete Multipartite Graph")
CMG = nx.complete_multipartite_graph(1, 2, 10)
print([CMG.node[u]['block'] for u in CMG])
print(CMG.edges(0))
print(CMG.edges(2))
print(CMG.edges(4))
draw_graph(CMG)
print("Circular Ladder Graph")
CLG = nx.circular_ladder_graph(5)
draw_graph(CLG)
print("Dorogovtsev Goltsev Mendes Graph")
DGMG = nx.dorogovtsev_goltsev_mendes_graph(3)
draw_graph(DGMG)
print("Empty Graph")
EG = nx.empty_graph(5, create_using=nx.DiGraph())
draw_graph(EG)
print("Grid 2D Graph")
G2DG = nx.grid_2d_graph(5, 6)
draw_graph(G2DG)
print("Grid Graph")
GDG = nx.grid_graph(dim=[5, 2])
draw_graph(GDG)
print("Hypercube Graph")
HG = nx.hypercube_graph(3)
draw_graph(HG)
print("Ladder Graph")
LG = nx.ladder_graph(8)
draw_graph(LG)
print("Ladder Graph")
LG = nx.ladder_graph(8)
draw_graph(LG)
print("Lollipop Graph")
LPG = nx.lollipop_graph(n=6, m=4)
draw_graph(LPG)
print("Null Graph")
NG = nx.null_graph()
draw_graph(NG)
print("Path Graph")
PG = nx.path_graph(16)
draw_graph(PG)
print("Star Graph")
SG = nx.star_graph(16)
draw_graph(SG)
print("Trivial Graph")
TG = nx.trivial_graph()
draw_graph(TG)
print("Wheel Graph")
WG = nx.wheel_graph(n=18)
draw_graph(WG)
def Graph():
# Diameter = n
# kmax = 2
# DFS = Should traverse in order until b reached
# BFS =
G = nx.hypercube_graph(3)
return G
def test_centralised_spanning_tree():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_type=CentralisedSpanningTreeProcess,
channel_type=DelayedChannel)
list(sm.node_map.keys())[1].is_initiator = True
sm.run(quit_after=4.0)
def test_token_ring():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_type=TokenRingProcess,
channel_type=DelayedChannel)
list(sm.node_map.keys())[1].is_initiator = True
sm.run(quit_after=4.0)
def test_basic_depth_first_traversal():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_types=[BasicDepthFirstTraversalProcess],
channel_type=DelayedChannel)
list(sm.node_map.keys())[1].is_initiator = True
sm.run(quit_after=12.0)
def test_synchronizer_alpha():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_types=[SynchronizerAlphaProcess],
channel_type=DelayedChannel)
list(sm.node_map.keys())[1].is_initiator = True
sm.run(quit_after=4.0)
def hypercube_graph(n=None, dim=None):
if n is None and dim is None:
return nx.empty_graph()
if dim is None:
dim = round(math.log(n, 2))
G = nx.hypercube_graph(dim)
G.name = 'hypercube'
return G
def test_echo():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_types=[EchoProcess, TerminatingEchoProcess],
channel_type=DelayedChannel)
list(sm.node_map.keys())[1].is_initiator = True
sm.run(quit_after=4.0)
def test_special_cases(self):
for n, H in [
(0, nx.null_graph()),
(1, nx.path_graph(2)),
(2, nx.cycle_graph(4)),
(3, nx.cubical_graph()),
]:
G = nx.hypercube_graph(n)
assert nx.could_be_isomorphic(G, H)
def test_echo():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_type=TerminatingEchoProcess,
channel_type=DelayedChannel)
for a in sm.node_map:
a.is_initiator = True
break
sm.run(quit_after=4.0)
def test_spanning_tree():
graph = nx.hypercube_graph(4) # 4 dimensional
sm = Simulation(embedding_graph=graph,
process_types=[SpanningTreeProcess],
channel_type=DelayedChannel)
list(sm.node_map.keys())[0].is_initiator = True
#for a in sm.node_map:
# a.is_initiator = True
# break
sm.run(quit_after=4.0)
def test_networkx_graphs(): G = nx.path_graph(10) mc_srw = mkm.nx_graph_srw(G) mc_lswr = mkm.nx_graph_lazy_srw(G) G = nx.hypercube_graph(10) print nx.number_of_nodes(G) mkm.nx_graph_lazy_srw(G) G = nx.complete_graph(50) print mkm.nx_graph_nbrw(G).get_n()
def test_networkx_graphs():
G = nx.path_graph(10)
mc_srw = mkm.nx_graph_srw(G)
mc_lswr = mkm.nx_graph_lazy_srw(G)
G = nx.hypercube_graph(10)
print nx.number_of_nodes(G)
mkm.nx_graph_lazy_srw(G)
G = nx.complete_graph(50)
print mkm.nx_graph_nbrw(G).get_n()
def test_ladder_graph(self):
for i, G in [(0, nx.empty_graph(0)), (1, nx.path_graph(2)),
(2, nx.hypercube_graph(2)), (10, nx.grid_graph([2, 10]))]:
assert is_isomorphic(nx.ladder_graph(i), G)
pytest.raises(nx.NetworkXError,
nx.ladder_graph,
2,
create_using=nx.DiGraph)
g = nx.ladder_graph(2)
mg = nx.ladder_graph(2, create_using=nx.MultiGraph)
assert_edges_equal(mg.edges(), g.edges())
def compare_times(gtype, n_max, n_min=2, chords=0):
"""
Compare computational times between the Deletion-Contraction algorithm, and its optimized version
:param gtype: <GType> graph type (enum object)
:param n_max: maximum number of nodes
:param n_min: minimum number of nodes (2 by default)
:param chords: number of chords (only in the case of random hamiltonian graphs), 0 by default
:return: dictionary with all the times where <key=nodes, value = both times (pair object)
"""
print("----------------------------------------------", gtype.name,
"------------------------------------------------")
times = dict()
for n in range(n_min, n_max + 1):
print("\n-----------> n =", n)
if gtype == GType.Hypercube:
g = nx.hypercube_graph(n)
elif gtype == GType.Grid:
g = nx.grid_graph([n, n])
elif gtype == GType.CircularLadder:
g = nx.circular_ladder_graph(n)
elif gtype == GType.Complete:
g = nx.complete_graph(n)
elif gtype == GType.RandomHamiltonian:
g = GraphTools.gen_random_hamiltonian(n, chords)
start1 = time.time()
poly = GraphRel.relpoly_binary_basic(g)
end1 = time.time()
t1 = end1 - start1
print(Utilities.polynomial2binomial(poly))
print("Basic - ", gtype.name, " ", n, ":", t1)
start2 = time.time()
poly = GraphRel.relpoly_binary_improved(g)
end2 = time.time()
t2 = end2 - start2
print(Utilities.polynomial2binomial(poly))
print("Advanced - ", gtype.name, " ", n, ":", t2)
times[n] = (t1, t2)
try:
print("SP efficientcy compared to basic: ",
round(t1 * 100 / t2, 3), "%")
except (ZeroDivisionError):
print("SP efficientcy compared to basic: ", round(t1 * 100, 3),
"%")
print(
"-------------------------------------------------------------------------------------------------------"
)
return times
def main():
#G = nx.drawing.nx_agraph.read_dot('input.dot')
#G = nx.erdos_renyi_graph(50,0.5)
G = nx.hypercube_graph(3)
P = nx.all_pairs_shortest_path_length(G)
for i in P:
print(i)
d = np.asarray(all_pairs_shortest_path(G)) / 1
print(d)
#all_three(d)
Y = MDS(d, geometry='euclidean')
Y.solve(1000)
print(Y.calc_stress())
output_euclidean(G, Y.X)
def generate_index(message_type='ba',
n=16,
sparsity=0.5,
p=0.2,
directed=False,
seed=123):
degree = n * sparsity
known_names = [
'mcwhole', 'mcwholeraw', 'mcvisual', 'mcvisualraw', 'cat', 'catraw'
]
if message_type == 'er':
graph = nx.gnm_random_graph(n=n, m=n * degree // 2, seed=seed)
elif message_type == 'random':
edge_num = int(n * n * sparsity)
edge_id = np.random.choice(n * n, edge_num, replace=False)
edge_index = np.zeros((edge_num, 2), dtype=int)
for i in range(edge_num):
edge_index[i, 0] = edge_id[i] // n
edge_index[i, 1] = edge_id[i] % n
elif message_type == 'ws':
graph = connected_ws_graph(n=n, k=degree, p=p, seed=seed)
elif message_type == 'ba':
graph = nx.barabasi_albert_graph(n=n, m=degree // 2, seed=seed)
elif message_type == 'hypercube':
graph = nx.hypercube_graph(n=int(np.log2(n)))
elif message_type == 'grid':
m = degree
n = n // degree
graph = nx.grid_2d_graph(m=m, n=n)
elif message_type == 'cycle':
graph = nx.cycle_graph(n=n)
elif message_type == 'tree':
graph = nx.random_tree(n=n, seed=seed)
elif message_type == 'regular':
graph = nx.connected_watts_strogatz_graph(n=n,
k=degree,
p=0,
seed=seed)
elif message_type in known_names:
graph = load_graph(message_type)
edge_index = nx_to_edge(graph, directed=True, seed=seed)
else:
raise NotImplementedError
if message_type != 'random' and message_type not in known_names:
edge_index = nx_to_edge(graph, directed=directed, seed=seed)
return edge_index
def large_graph_tests():
if not total_coloring_test("Complete graph on 7 vertices",
networkx.complete_graph(7), 7):
return False
if not total_coloring_test("Cycle of length 100",
networkx.cycle_graph(100), 4):
return False
if not total_coloring_test("Star graph on 200 vertices",
networkx.star_graph(200), 201):
return False
if not total_coloring_test("Complete bipartite graph on 4+4 vertices",
networkx.complete_multipartite_graph(4, 4), 6):
return False
if not total_coloring_test("Hypercube of dimension 5",
networkx.hypercube_graph(5), 6):
return False
return True
def _hypercube(n):
"""Hypercube's nodes are cube coordinates, which isn't so nice"""
G = nx.hypercube_graph(int(np.log2(n) + .1))
G = nx.relabel_nodes(G, {n: int('0b' + ''.join(str(i) for i in n), 2)
for n in G.node})
return G
def test_line_inverse_line_hypercube(self):
G = nx.hypercube_graph(5)
H = nx.line_graph(G)
J = nx.inverse_line_graph(H)
assert_true(nx.is_isomorphic(G, J))
def hypercube():
"""Generates a hypercube"""
n = int(input("Number of dimensions: "))
G = nx.hypercube_graph(n)
return G
def test092_hypercube_graph(self):
""" Larger hypercube graph. """
g = nx.hypercube_graph(13)
mate1 = mv.max_cardinality_matching( g )
mate2 = nx.max_weight_matching( g, True )
self.assertEqual( len(mate1), len(mate2) )
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")
script, filename1, filename2 = argv
print("usage: python adiabaticv2.py info_file distribution_file")
infofile = open(filename1, 'w') # writing file
infofile.truncate()
distfile = open(filename2, 'w') # writing file
distfile.truncate()
##################### Parameters
T=10
deltaT=0.01
timesteps=int(T/deltaT) # number of steps
n=10 # dimension of hypercube
if (deltaT > (1/float(3*n))): print("Warning: time-step deltaT is very large") # NOTE this condition depends on the dynamics
vertexnumber=2**n # for hypercube
initialwalkernum=4*n # initial number of walkers should be logarithmic in the number of vertices
##################### Use NetworkX to generate a hypercube; generate various dictionaries with the output
hyper=nx.hypercube_graph(n) # generate hypercube using NetworkX
vertexlist=hyper.nodes()
edgelist=hyper.edges()
adjlist=hyper.adjacency_list()
incidencedict=dict() # adjacency dictionary
hammingdist=dict() # hamming weight dictionary
layerdict=dict() # dictionary of vertices organized according to hamming weights
#eg for n=3 layerdict[2]={(1,1,0),(1,0,1),(0,1,1)}
for dist in range((2**n)+1):
layerdict[dist]=list()
for v in range(vertexnumber):
vert=vertexlist[v]
adj=adjlist[v]
incidencedict[vert]=adj
weight=0 # variable for hamming weight of v
for ind in range(n):
def test_degree_distribution(self):
for n in range(1, 10):
G = nx.hypercube_graph(n)
expected_histogram = [0] * n + [2 ** n]
assert_equal(nx.degree_histogram(G), expected_histogram)
def test_special_cases(self):
for n, H in [(0, nx.null_graph()), (1, nx.path_graph(2)),
(2, nx.cycle_graph(4)), (3, nx.cubical_graph())]:
G = nx.hypercube_graph(n)
assert_true(nx.could_be_isomorphic(G, H))
n = 6
hypercube_n = 4
m = 6
r = 2
h = 3
dim = [2, 3]
# left out dorogovtsev_goltsev_mendes_graph and null_graph
graphs = [
("balanced_tree", nx.balanced_tree(r, h)),
("barbell_graph", nx.barbell_graph(n, m)),
("complete_graph", nx.complete_graph(n)),
("complete_bipartite_graph", nx.complete_bipartite_graph(n, m)),
("circular_ladder_graph", nx.circular_ladder_graph(n)),
("cycle_graph", nx.cycle_graph(n)),
("empty_graph", nx.empty_graph(n)),
("grid_2d_graph", nx.grid_2d_graph(m, n)),
("grid_graph", nx.grid_graph(dim)),
("hypercube_graph", nx.hypercube_graph(hypercube_n)),
("ladder_graph", nx.ladder_graph(n)),
("lollipop_graph", nx.lollipop_graph(m, n)),
("path_graph", nx.path_graph(n)),
("star_graph", nx.star_graph(n)),
("trivial_graph", nx.trivial_graph()),
("wheel_graph", nx.wheel_graph(n)),
]
plot_multigraph(graphs, 4, 4, node_size=50)
plt.savefig("graphs/classic.png")
