def test_directed(self):
"""Tests for creating a directed triangular lattice."""
G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
H = nx.triangular_lattice_graph(3, 4, create_using=nx.DiGraph())
assert_true(H.is_directed())
for u, v in H.edges():
assert_true(v[1] >= u[1])
if v[1] == u[1]:
assert_true(v[0] > u[0])
def test_directed(self):
"""Tests for creating a directed triangular lattice."""
G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
H = nx.triangular_lattice_graph(3, 4, create_using=nx.DiGraph())
assert H.is_directed()
for u, v in H.edges():
assert v[1] >= u[1]
if v[1] == u[1]:
assert v[0] > u[0]
def test_periodic(self):
G = nx.triangular_lattice_graph(4, 6, periodic=True)
assert_equal(len(G), 12)
assert_equal(G.size(), 36)
# all degrees are 6
assert_equal(len([n for n, d in G.degree() if d != 6]), 0)
G = nx.triangular_lattice_graph(5, 7, periodic=True)
TLG = nx.triangular_lattice_graph
assert_raises(nx.NetworkXError, TLG, 2, 4, periodic=True)
assert_raises(nx.NetworkXError, TLG, 4, 4, periodic=True)
assert_raises(nx.NetworkXError, TLG, 2, 6, periodic=True)
def test_periodic(self):
G = nx.triangular_lattice_graph(4, 6, periodic=True)
assert_equal(len(G), 12)
assert_equal(G.size(), 36)
# all degrees are 6
assert_equal(len([n for n, d in G.degree() if d != 6]), 0)
G = nx.triangular_lattice_graph(5, 7, periodic=True)
TLG = nx.triangular_lattice_graph
assert_raises(nx.NetworkXError, TLG, 2, 4, periodic=True)
assert_raises(nx.NetworkXError, TLG, 4, 4, periodic=True)
assert_raises(nx.NetworkXError, TLG, 2, 6, periodic=True)
def test_periodic(self):
G = nx.triangular_lattice_graph(4, 6, periodic=True)
assert len(G) == 12
assert G.size() == 36
# all degrees are 6
assert len([n for n, d in G.degree() if d != 6]) == 0
G = nx.triangular_lattice_graph(5, 7, periodic=True)
TLG = nx.triangular_lattice_graph
pytest.raises(nx.NetworkXError, TLG, 2, 4, periodic=True)
pytest.raises(nx.NetworkXError, TLG, 4, 4, periodic=True)
pytest.raises(nx.NetworkXError, TLG, 2, 6, periodic=True)
def triangular_lattice(m,
n,
with_boundaries=False,
with_lattice_components=False,
**kwargs) -> nx.Graph:
''' Sanitize networkx properties for Bokeh consumption '''
if 'periodic' in kwargs:
kwargs['with_positions'] = False
G = nx.triangular_lattice_graph(m, n, **kwargs)
nx.set_node_attributes(G, None, 'contraction')
return G
else:
G = nx.triangular_lattice_graph(m, n, **kwargs)
if with_lattice_components:
horiz = nx.Graph()
for i in range(m + 1):
sub = G.subgraph([(j, i) for j in range(n)])
horiz = nx.compose(horiz, sub.copy())
diag_l = G.copy()
for i in range(m + 1):
remove_edges(diag_l, [((j, i), (j + 1, i)) for j in range(n)])
diag_r = diag_l.copy()
for i in range(m + 1):
if i % 2 == 0:
remove_edges(diag_l,
[((j, i), (j, i + 1)) for j in range(n)])
remove_edges(diag_r,
[((j, i), (j - 1, i + 1)) for j in range(n)])
else:
remove_edges(diag_l,
[((j, i), (j + 1, i + 1)) for j in range(n)])
remove_edges(diag_r,
[((j, i), (j, i + 1)) for j in range(n)])
G.lattice_components = {
'diag_l': diag_l,
'diag_r': diag_r,
'horiz': horiz
}
if with_boundaries:
l = G.subgraph([(0, i) for i in range(m + 1)])
r_nodes = [(n // 2, 2 * i + 1) for i in range(m // 2 + 1)]
if n % 2 == 1:
r_nodes += [(n // 2 + 1, i) for i in range(m + 1)]
else:
r_nodes += [(n // 2, 2 * i) for i in range(m // 2 + 1)]
r = G.subgraph([x for x in r_nodes if x in G.nodes])
t = G.subgraph([(j, m) for j in range(n)])
b = G.subgraph([(j, 0) for j in range(n)])
return G, (l.copy(), r.copy(), t.copy(), b.copy())
else:
return G
def create_graphs(graphtype="grid"):
if graphtype == "grid":
graphs = []
for i in range(4, 6):
for j in range(4, 6):
graphs.append(nx.grid_2d_graph(i, j))
if graphtype == "tri-grid":
graphs = []
for i in range(4, 6):
for j in range(4, 5):
graphs.append(nx.triangular_lattice_graph(i, j))
if graphtype == "b-a":
graphs = []
for i in range(80, 81):
for j in range(
2, 3
): # j should be lower tahn i ( j = # of edges , i = # of nodes )
graphs.append(nx.barabasi_albert_graph(i, j))
if graphtype == "Karate":
graphs = []
graphs.append(nx.karate_club_graph())
return graphs
def triangular(size, periodic=False):
"""
Construct a triangular lattice, a lattice whose nodes and edges
are the triangular tiling of the plane.
Parameters
----------
size : int, or tuple (m, n) of ints
size of the lattice (mxn)
periodic : bool
Whether boundaries are periodic.
Returns
-------
G : networkx.Graph
The lattice represented as a networkx.Graph
The graph has the node attribute 'pos' with the given point
coordinates, and the edge attribute 'length', which is the
Euclidean distance between nodes.
"""
if np.ndim(size) == 0:
m = size
n = size
elif np.ndim(size) == 1:
m, n = size
G = nx.triangular_lattice_graph(m, n, periodic=periodic)
# pos = nx.get_node_attributes(G, 'pos')
# factor = np.sqrt(2/np.sqrt(3))
# pos_scaled = {k: factor*np.array(v) for k, v in pos.items()}
# nx.set_node_attributes(G, pos_scaled, 'pos')
distances = {(e1, e2): 1 for e1, e2 in G.edges()}
nx.set_edge_attributes(G, distances, 'length')
return nx.convert_node_labels_to_integers(G)
def __init__(self, xdim=10, ydim=10, grid_type='2d', colorize=True):
self.xdim = xdim
self.ydim = ydim
self.grid_type = grid_type
if grid_type == '2d':
self.space = nx.grid_2d_graph(xdim, ydim)
elif grid_type == 'hex':
self.space = nx.hexagonal_lattice_graph(xdim, ydim)
elif grid_type == 'tri':
self.space = nx.triangular_lattice_graph(xdim, ydim)
else:
# TODO: raise exception? default to 2d?
self.space = nx.grid_2d_graph(xdim, ydim)
for node in self.space.nodes:
self.space.node[node]['locale'] = Locale()
self.conversion_rates = {
0: 0.2,
1: 0.1,
2: 0.15,
3: 0.05,
4: 0.1,
5: 0
}
self.time = 0
self.colorize = colorize
def __init__(self, xdim=10, ydim=10, grid_type='2d', flora_system=1, colorize=True, edges=True, slow_burn=False):
self.xdim = xdim
self.ydim = ydim
self.grid_type = grid_type
if grid_type == '2d':
self.space = nx.grid_2d_graph(self.xdim, ydim)
elif grid_type == 'hex':
self.space = nx.hexagonal_lattice_graph(self.xdim, ydim)
elif grid_type == 'tri':
self.space = nx.triangular_lattice_graph(self.xdim, ydim)
else:
# TODO: raise exception? default to 2d?
self.space = nx.grid_2d_graph(self.xdim, ydim)
for node in self.space.nodes:
self.space.node[node]['locale'] = Locale(flora_system=flora_system, location=node, region=self)
self.nodes = set([node for node in self.space.nodes])
if edges:
self._add_border_nodes()
self.conversion_rates = {0: 0.2, 1: 0.1, 2: 0.15, 3: 0.05, 4: 0.1, 5: 0}
self.time = 0
self.colorize = colorize
self.slow_burn = slow_burn
self.constants = STATE_CONSTANTS
self.verbose = False
self.basins_current=False
def test_is_berge(pool : Pool, alt=False):
if alt:
from alternate import is_berge_alt as is_berge
else:
from berge import is_berge
# Note that graphs are perfect iff they are Berge
for i in range(5):
# Bipartite graphs are always Berge
n1, n2 = random.randint(1, 12), random.randint(1, 12)
graph = random_bipartite(n1=n1, n2=n2, p=.4)
assert(is_berge(graph, pool=pool))
for i in range(5):
graph = nx.line_graph(random_bipartite(n1=10, n2=10, p=.15))
# Line graphs of bipartite graphs are perfect by Konig's theorem
assert(is_berge(graph, pool=pool))
for i in range(10, 15):
assert(is_berge(nx.complete_graph(i), pool=pool))
for i in range(5):
# Make sure we work properly on disconnected graphs
graph = nx.disjoint_union_all([
random_bipartite(
random.randint(1, 6),
random.randint(1, 6), .2)
for i in range(3)])
assert(is_berge(graph, pool=pool))
for i in range(5):
m = random.randint(2, 12)
graph = nx.triangular_lattice_graph(m, 2)
assert(is_berge(graph, pool=pool))
for i in range(5):
n = random.randint(4, 20)
graph = random_chordal(n, .2)
assert(is_berge(graph, pool=pool))
for i in range(10):
n = random.randint(4, 20)
graph = nx.cycle_graph(n)
assert(is_berge(graph, pool=pool) == (n % 2 == 0))
def set_graph(self, graphtype, graphparams):
if graphtype == 'hexagonal':
self.G = nx.triangular_lattice_graph(**graphparams)
elif graphtype == 'watts strogatz':
self.G = nx.watts_strogatz_graph(**graphparams)
elif graphtype == 'newman watts strogatz':
self.G = nx.newman_watts_strogatz_graph(**graphparams)
elif graphtype == 'square':
self.G = nx.grid_2d_graph(**graphparams)
elif graphtype == 'random blocks':
self.G = nx.stochastic_block_model(**graphparams)
elif graphtype == 'powerlaw cluster':
self.G = nx.powerlaw_cluster_graph(**graphparams)
elif graphtype == 'scale-free small world':
self.G = clustered_scalefree(**graphparams)
elif graphtype == 'barabasi-albert':
self.G = nx.barabasi_albert_graph(**graphparams)
else:
print('Using complete graph')
self.G = nx.complete_graph(**graphparams)
def generate_graph(m, n):
G = nx.triangular_lattice_graph(m, n)
A = nx.to_numpy_matrix(G)
G = nx.from_numpy_matrix(A)
data = json_graph.node_link_data(G)
with open('./Working/graph.json', 'w') as f:
json.dump(data, f)
with open('./Working/graph_flag', mode='w', encoding='utf-8') as fh:
fh.write("i look at you")
def __init__(self, network_type, size, **kwargs):
if network_type == '2D_lattice':
tiling = kwargs['tiling']
per = kwargs['periodic']
if tiling == 3:
self.graph = nx.triangular_lattice_graph(size, size, periodic = per, with_positions = True)
self.pos = nx.get_node_attributes(self.graph,'pos')
self.M = len(self.graph.edges())
self.N = len(self.graph.nodes())
elif tiling == 4:
self.graph = nx.grid_2d_graph(size, size, periodic = per)
self.pos = dict( (n, n) for n in self.graph.nodes() )
self.labels = dict( ((i, j), i * size + j) for i, j in self.graph.nodes() )
self.M = len(self.graph.edges())
self.N = len(self.graph.nodes())
elif tiling == 6:
self.graph = nx.hexagonal_lattice_graph(size, size, periodic = per, with_positions = True)
self.pos = nx.get_node_attributes(self.graph,'pos')
self.M = len(self.graph.edges())
self.N = len(self.graph.nodes())
elif network_type == 'ring_lattice':# TODO: banding for every node
self.graph = nx.cycle_graph(size)
theta = (2*np.pi)/size
self.pos = dict((i,(np.sin(theta*i),np.cos(theta*i))) for i in range(size))
self.M = len(self.graph.edges())
self.N = len(self.graph.nodes())
self.text = 'Ring Lattice'
if kwargs['banded']:
if kwargs['band_length'] >= int(self.N/2)-1:
raise ValueError('Band length cannot exceed the half of the size of the network')
if kwargs['band_length'] <2:
raise ValueError('Band length should be a positive integer greater 1 since the closest neighbors are already connected')
for u in range(self.N):
for i in range(2,kwargs['band_length']+1):
# ranges from 2 to k+2 to avoid the closest node and start
## banding from the second closest node
if u + i >= self.N: v = u + i - self.N
else: v = u + i
self.graph.add_edge(u, v)
if u - i < 0: v = self.N + u - i
else: v = u - i
self.graph.add_edge(u, v)
self.text = self.text + ' w/ bandlength %d'%kwargs['band_length']
else:self.text = self.text + ' w/ bandlength 0'
else: raise ValueError('network type can be a lattice or a ring')
self.A = nx.adjacency_matrix(self.graph)
def triangular_lattice(m, n, periodic, directed, weighted):
#Generate Network:
triangular_lattice = nx.triangular_lattice_graph(m, n, periodic=periodic)
#Give the nodes an initial position:
node_position = position_nodes(triangular_lattice)
#If the network is weighted, add edge weights:
#if weighted:
# weight_edges(triangular_lattice)
return triangular_lattice, node_position
def Create_Minimum_Data(n, num):
k = 0.5
if num == 1:
G = nx.grid_2d_graph(n, n)
if num == 2:
G = nx.triangular_lattice_graph(n, n)
if num == 3:
G = nx.path_graph(n)
if num == 4:
G = Create_Triangular_Graph(n)
if num == 5:
G = Create_Kagome_Graph(n, n, plot=False)
N = len(G.nodes())
m = int(round(k * N))
n = int(round((1 - k) * N))
a = np.ones(N)
a[:m] = -1
np.random.shuffle(a)
node_colors = []
for i in a:
if i == 1:
node_colors.append("Silver")
else:
node_colors.append("Black")
attr = {}
for (node, value), color in zip(G.nodes.data(), node_colors):
attr[node] = color
nx.set_node_attributes(G, attr, 'color')
G = Add_Weights(G, 1.0)
matrix = nx.to_numpy_matrix(G)
g, weights, signed_matrix = Prepare_Data([matrix])
fi, vr = Optimization_Model(weights, signed_matrix)
#frustrations.append(fi)
G = color_nodes(G, vr)
#pos = nx.spring_layout(G, weight=None)
#nx.set_node_attributes(G,pos,'pos')
return G
def test_lattice_points(self):
"""Tests that the graph is really a triangular lattice."""
for m, n in [(2, 3), (2, 2), (2, 1), (3, 3), (3, 2), (3, 4)]:
G = nx.triangular_lattice_graph(m, n)
N = (n + 1) // 2
assert_equal(len(G), (m + 1) * (1 + N) - (n % 2) * ((m + 1) // 2))
for (i, j) in G.nodes():
nbrs = G[(i, j)]
if i < N:
assert_true((i + 1, j) in nbrs)
if j < m:
assert_true((i, j + 1) in nbrs)
if j < m and (i > 0 or j % 2) and (i < N or (j + 1) % 2):
assert_true((i + 1, j + 1) in nbrs or (i - 1, j + 1) in nbrs)
def test_lattice_points(self):
"""Tests that the graph is really a triangular lattice."""
for m, n in [(2, 3), (2, 2), (2, 1), (3, 3), (3, 2), (3, 4)]:
G = nx.triangular_lattice_graph(m, n)
N = (n + 1) // 2
assert len(G) == (m + 1) * (1 + N) - (n % 2) * ((m + 1) // 2)
for (i, j) in G.nodes():
nbrs = G[(i, j)]
if i < N:
assert (i + 1, j) in nbrs
if j < m:
assert (i, j + 1) in nbrs
if j < m and (i > 0 or j % 2) and (i < N or (j + 1) % 2):
assert (i + 1, j + 1) in nbrs or (i - 1, j + 1) in nbrs
def generate_graph(m, n):
G = nx.triangular_lattice_graph(m, n)
A = nx.to_numpy_matrix(G)
G = nx.from_numpy_matrix(A)
node_data = []
for i in nx.nodes(G):
node_data.append(i)
node_data = pd.DataFrame(node_data)
node_data.to_csv("./Resources/Output/Working/node.csv")
print('[Python]' + 'Generate Node')
edge_data = nx.to_pandas_edgelist(G)
edge_data.to_csv("./Resources/Output/Working/edge.csv")
print('[Python]' + 'Generate Edge')
with open('./Resources/Output/Working/flag', mode='w',
encoding='utf-8') as fh:
fh.write("i look at you")
def Create_Random_Data(n, choice, k=False):
if choice == 1:
G = nx.grid_2d_graph(n, n)
if choice == 2:
G = nx.triangular_lattice_graph(n, n)
if choice == 3:
G = nx.path_graph(n)
if choice == 4:
G = Create_Triangular_Graph(n)
if choice == 5:
G = Create_Kagome_Graph(n, n, plot=False)
N = len(G.nodes())
if type(k) == bool:
m = random.randrange(0, N)
n = N - m
else:
m = int(round(k * N))
n = int(round((1 - k) * N))
a = np.ones(N)
a[:m] = -1
np.random.shuffle(a)
node_colors = []
for i in a:
if i == 1:
node_colors.append("Silver")
else:
node_colors.append("Black")
attr = {}
for (node, value), color in zip(G.nodes.data(), node_colors):
attr[node] = color
nx.set_node_attributes(G, attr, 'color')
G = Add_Weights(G, 1.0)
#pos = nx.spring_layout(G, weight=None)
#nx.set_node_attributes(G,pos,'pos')
return G
def create_graph(type, width, height):
if type == SQUARE:
graph = nx.grid_2d_graph(width, height)
faces = create_square_faces(width, height)
elif type == TRIANGLE_LEFT:
graph = nx.triangular_lattice_graph(width, height, with_positions=True)
faces = []
else:
raise ValueError("No valid graph type passed.")
set_node_attributes(graph,
{n: {
"cx": n[0],
"cy": n[1]
}
for n in graph.nodes})
return graph, faces
def triangular_cylinder(m, n) -> nx.Graph:
'''
Y-periodic triangular lattice
'''
G = nx.triangular_lattice_graph(m, n)
N = (n + 1) // 2 # number of nodes in row
cols = range(N + 1)
for i in cols:
G = nx.contracted_nodes(G, (i, 0), (i, m))
nx.set_node_attributes(G, None, 'contraction')
G.l_boundary = G.subgraph([(0, i) for i in range(m)])
r_nodes = [(n // 2, 2 * i + 1) for i in range(m // 2 + 1)]
if n % 2 == 1:
r_nodes += [(n // 2 + 1, i) for i in range(m + 1)]
else:
r_nodes += [(n // 2, 2 * i) for i in range(m // 2 + 1)]
G.r_boundary = G.subgraph([x for x in r_nodes if x in G.nodes])
G.faces = find_k_cliques(G, 3)
return G
def getGraphData(u, v, k):
center, space = _center(k), _space(k)
actual, dis = {}, {}
G = nx.triangular_lattice_graph(space, space, periodic=False,
with_positions=True,
create_using=None)
pos = nx.get_node_attributes(G, 'pos')
# node locations and distances from 0,0
for n in G.nodes:
x = n[0] - center - v[0]
x2 = n[0] - center
x = round(float(np.dot(x if (n[1] % 2 == 0) else x2, u[0])), DP)
y = round(float(np.dot(n[1] - center, v[1])), DP)
actual[n] = (x, y)
dis[n] = np.sqrt(np.power(actual[n][0], SQ) + np.power(actual[n][1], SQ))
dis = dict(sorted(dis.items(), key=lambda item: item[1]))
dis_items = list(dis.items())
firstK = dis_items[:k]
var = {d: G.remove_node(d[0]) for d in dis_items[k:]}
firstK = [round(column[1], 2) for column in firstK]
return G, pos, actual, firstK
def triangular_lattice_graph(m, n):
G = nx.triangular_lattice_graph(m, n, with_positions=True)
F = nx.Graph(name='triangular')
F.add_edges_from(G.edges)
F.graph['pos'] = nx.get_node_attributes(G, 'pos')
return F
def test_multigraph(self):
"""Tests for creating a triangular lattice multigraph."""
G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
H = nx.triangular_lattice_graph(3, 4, create_using=nx.MultiGraph())
assert list(H.edges()) == list(G.edges())
import matplotlib.pyplot as plt
import networkx as nx
# Decentralized graphs
G = nx.random_lobster(0.8, 0.9, 0.8, seed=5)
# Centralized graphs
G2 = nx.Graph()
G2.add_nodes_from(G.nodes())
center = 0
for node in G2.nodes():
if node != center:
G2.add_edge(center, node)
# Distributed graph
G3 = nx.triangular_lattice_graph(10, 20, with_positions=True)
pos = nx.get_node_attributes(G3, 'pos')
# Uncomment to draw graph
# nx.draw(G, node_size=90, linewidths=.8)
# nx.draw(G2, node_size=90, linewidths=.8)
nx.draw_kamada_kawai(G3, node_size=90, linewidths=.8)
plt.show()
plt.xticks([])
plt.yticks([])
#m×n的六角形格子图。
G = nx.hexagonal_lattice_graph(3, 3)
plt.subplot(2, 3, 3)
nx.draw(G, with_labels=True)
plt.title('hexagonal_lattice_graph')
plt.axis('on')
plt.xticks([])
plt.yticks([])
#n维超立方体图形。
G = nx.hypercube_graph(3)
plt.subplot(2, 3, 4)
nx.draw(G, with_labels=True)
plt.title('hypercube_graph')
plt.axis('on')
plt.xticks([])
plt.yticks([])
#三角格子图
G = nx.triangular_lattice_graph(11, 3)
plt.subplot(2, 3, 5)
nx.draw(G, with_labels=True)
plt.title('hypercube_graph')
plt.axis('on')
plt.xticks([])
plt.yticks([])
plt.show()
def test_multigraph(self):
"""Tests for creating a triangular lattice multigraph."""
G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
H = nx.triangular_lattice_graph(3, 4, create_using=nx.MultiGraph())
assert_equal(list(H.edges()), list(G.edges()))
def triangular(m, n, periodic=False, dist_function=None):
G = nx.triangular_lattice_graph(m, n, periodic=periodic)
return G
bound = 1
if partition.parent is not None:
bound = (partition["base"]**(-len(partition["cut_edges"]) +
len(partition.parent["cut_edges"]))
) #*(len(boundaries1)/len(boundaries2))
return random.random() < bound
for pop1 in pops:
for base in bases:
for alignment in [2, 1, 0]:
m = 50
G = nx.grid_graph([m, m])
H = nx.triangular_lattice_graph(m, 2 * m - 2)
relabel = {}
for x in G.nodes():
relabel[x] = (x[0], x[1] - m + 1)
G = nx.relabel_nodes(G, relabel)
####Here is the FRANK2engraph
F = nx.compose(G, H)
'''
for i in range(-m,m):
value = 0
for x in F.nodes():
if x[1] == i:
value += 1
print(i,value)
'''
class TestSpatialGraph(unittest.TestCase):
"""Tests for the feems SpatialGraph
"""
# generate a simple networkx graph with 4 nodes and 4 samples observed on
# only 2 of the 4 nodes
graph = nx.triangular_lattice_graph(1, 2, with_positions=True)
graph = nx.convert_node_labels_to_integers(graph)
pos = nx.get_node_attributes(graph, "pos")
node_pos = np.array(list(pos.values()))
sample_pos = np.empty((4, 2))
sample_pos[0, :] = node_pos[0, ]
sample_pos[1, :] = node_pos[0, ]
sample_pos[2, :] = node_pos[2, ]
sample_pos[3, :] = node_pos[2, ]
edges = np.array(list(graph.edges)) + 1
n_snps = 100
genotypes = np.random.binomial(n=2,
p=.5,
size=(sample_pos.shape[0], n_snps))
# setup the spatial graph
sp_graph = SpatialGraph(genotypes, sample_pos, node_pos, edges)
def test_idx(self):
"""Tests original node indicies
"""
idx = query_node_attributes(self.sp_graph, "idx")
self.assertEqual(idx.tolist(), [0, 1, 2, 3])
def test_node_pos(self):
"""Tests for the correct node positions
"""
pos = query_node_attributes(self.sp_graph, "pos")
self.assertEqual(pos.tolist(), self.node_pos.tolist())
def test_sample_idx(self):
"""Tests assignment of samples to nodes
"""
sample_idx_dict = nx.get_node_attributes(self.sp_graph, "sample_idx")
self.assertEqual(sample_idx_dict[0], [0, 1])
self.assertEqual(sample_idx_dict[1], [])
self.assertEqual(sample_idx_dict[2], [2, 3])
self.assertEqual(sample_idx_dict[3], [])
def test_permuted_idx(self):
"""Tests permutation of nodes
"""
permuted_idx = query_node_attributes(self.sp_graph, "permuted_idx")
self.assertEqual(permuted_idx.tolist(), [0, 2, 1, 3])
def test_n_samples_per_obs_node_permuted(self):
"""Tests permutation of n samples
"""
ns = self.sp_graph.n_samples_per_obs_node_permuted
self.assertEqual(ns.tolist(), [2, 2])
def test_n_observed_nodes(self):
"""Tests the right number of observed nodes
"""
self.assertEqual(self.sp_graph.n_observed_nodes, 2)
def test_estimate_allele_frequencies(self):
"""Tests allele frequency estimation on the observed nodes of the
graph
"""
node_0_freqs = np.mean(self.genotypes[[0, 1], :], axis=0) # / 4.0
node_2_freqs = np.mean(self.genotypes[[2, 3], :], axis=0) # / 4.0
exp_freqs = np.vstack([node_0_freqs, node_2_freqs])
self.assertEqual(self.sp_graph.frequencies.tolist(),
exp_freqs.tolist())
__author__ = 'fhca'
import networkx as nx
import matplotlib.pyplot as plt
import matplotlib
matplotlib.use('TkAgg')
G = nx.triangular_lattice_graph(20, 20)
plt.figure(figsize=(8, 8))
pos = nx.spring_layout(G, iterations=200)
nx.draw_networkx_nodes(G, pos, node_size=1)
nx.draw_networkx_edges(G, pos, alpha=.5)
plt.show()
"""
from networkx.drawing.nx_pydot import write_dot
G = nx.triangular_lattice_graph(20,20)
pos = nx.nx_agraph.graphviz_layout(G)
nx.draw(G, pos=pos)
write_dot(G, 'file.gv')
"""
def generate_graph(parameters, type='random'):
#n, type='random', d=0, m=0, k=5, p=.5, periodic=False, with_positions=True, create_using=None
'''
INPUTS:
type Type of graph
parameters List of parameters specific to the type of graph
OUTPUTS:
Graph satisfying the specified parameters and of the specified type
'''
try:
if type == 'triangular_lattice':
n_dim = parameters[0]
m_dim = parameters[1]
graph = nx.triangular_lattice_graph(n_dim, m_dim)
return graph
if type == 'hypercube':
num_nodes = parameters[0]
graph = nx.hypercube_graph(num_nodes)
return graph
elif type == 'random':
num_nodes = parameters[0]
av_deg = parameters[1]
graph = nx.random_regular_graph(av_deg, num_nodes)
return graph
elif type == 'erdos_renyi':
num_nodes = parameters[0]
edges = parameters[1]
graph = nx.erdos_renyi_graph(num_nodes, edges)
elif type == 'complete':
num_nodes = parameters[0]
graph = nx.complete_graph(num_nodes)
elif type == 'dumbell':
n = parameters[0]
graph = nx.barbell_graph(n // 2 - 1, n - 2 * (n // 2 - 1))
elif type == 'complete_bipartite':
m = parameters[0]
n = parameters[1]
graph = nx.complete_bipartite_graph(m, n)
elif type == 'dumbell_multiple':
size_dumbell = parameters[0]
num_dumbell = parameters[1]
size_path = parameters[2]
graph = generate_dumbell_multiple_cliques(size_dumbell,
num_dumbell, size_path)
elif type == 'rich_club':
size_club = parameters[0]
size_periphery = parameters[1]
#prob_rp = parameters[2]
#prob_rr = parameters[3]
#prob_pp = parameters[4]
num_peripheries = parameters[2]
a = parameters[3]
b = parameters[4]
c = parameters[5]
graph = generate_rich_club_adapted_version(size_club,
size_periphery,
num_peripheries, a, b,
c)
elif type == 'dumbell_multiple_sized':
size_list = parameters[0]
path_length = parameters[1]
graph = generate_dumbell_multiple_sizes(size_list, path_length)
elif type == 'dumbell_string':
sizes = parameters[0]
lengths = parameters[1]
graph = generate_dumbell_string(sizes, lengths)
elif type == 'with_indicator':
indicator = parameters[0]
graph = generate_dumbell_indicator_connectionstrength(indicator)
return graph
except ValueError:
print("The specified graph type was invalid.")
