def test_algorithm(self):
for i in range(10):
graph = graph_utils.random_graph(100, 0.1)
g1 = graph_utils.graph_to_numpy(graph)
g2 = graph_utils.graph_to_numpy(graph)
cover_group1 = shaked_algo_impl_v2(g1)
cover_group2 = shaked_algo_impl(g2)
assert_equal(cover_group1, cover_group2)
def test_degree():
graph = graph_utils.graph_to_numpy(igraph.Graph.Full(5))
assert_equal(vsa.all_vertex_degree(graph), [4, 4, 4, 4, 4])
graph = graph_utils.graph_to_numpy(igraph.Graph.Ring(5))
assert_equal(vsa.all_vertex_degree(graph), [2, 2, 2, 2, 2])
graph = graph_utils.graph_to_numpy(
igraph.Graph(n=5, edges=[(1, 2), (3, 4), (4, 1)]))
assert_equal(vsa.all_vertex_degree(graph), [0, 2, 1, 1, 2])
def main():
iterations = 1000000
n = 1000
c = 1
results = []
graph: Graph = Graph.Erdos_Renyi(n, c / n)
randomize = True
for i in range(iterations):
np_graph = graph_to_numpy(graph)
cover_group = shaked_algo_impl_v2.shaked_algo_impl_v2(np_graph, randomize=randomize)
cover_group_size = len(cover_group)
if i % 100 == 0:
print(f'iteration {i}')
results.append(cover_group_size)
results = np.array(results)
print('=========')
avg = results.mean()
print(f'average: {avg}')
variance = results.var()
print(f'variance: {variance}')
np.save('theorem5.npy', results)
bins = np.max(results)-np.min(results)
results = (results - avg)/np.sqrt(variance)
plot_hist(results, bins)
return results
def test_zero_vertex(self):
graph = graph_utils.random_graph(10, 0.3)
npgraph = graph_utils.graph_to_numpy(graph)
degree_vector = all_vertex_degree(npgraph)
zero_vertex(npgraph, 4, degree_vector)
degree_vector_check = all_vertex_degree(npgraph)
assert_equal(degree_vector, degree_vector_check)
def test_algorithm(self):
graph = Graph.Erdos_Renyi(10, 0.3)
cover = most_neighbors_with_minimal_degree.most_neighbors_with_minimal_degree_algo(
None, graph)
assert_equal(
graph_utils.check_if_legal_vertex_cover(
graph_utils.graph_to_numpy(graph), cover), True)
def test_check_if_legal_vertex_cover():
graph = graph_utils.graph_to_numpy(
Graph(n=5, edges=[(1, 2), (3, 4), (4, 1)]))
assert_equal(graph_utils.check_if_legal_vertex_cover(graph, ['v1', 'v3']),
True)
assert_equal(graph_utils.check_if_legal_vertex_cover(graph, ['v1', 'v4']),
True)
assert_equal(graph_utils.check_if_legal_vertex_cover(graph, ['v3', 'v4']),
False)
assert_equal(graph_utils.check_if_legal_vertex_cover(graph, ['v1']), False)
assert_equal(graph_utils.check_if_legal_vertex_cover(graph, ['v0']), False)
def theorem4():
results = {}
for c in cs:
c_results = []
print(f'c {c}')
for i in range(iterations):
if i % 10 == 0:
print(f'iteration {i}')
graph: Graph = Graph.Erdos_Renyi(n, c / n)
np_graph = graph_to_numpy(graph)
cover_group = shaked_algo_impl_v2.shaked_algo_impl_v2(np_graph, randomize=True)
cover_group_size = len(cover_group)
c_results.append(cover_group_size)
results[c] = c_results
return results
def main():
iterations = 200
n = 1000
cs = np.arange(0.5, 0.75, 0.25) # c = [0.25..10]
results = {}
for c in cs:
c_results = []
print(f'c {c}')
for i in range(iterations):
if i % 10 == 0:
print(f'iteration {i}')
graph: Graph = Graph.Erdos_Renyi(n, c / n)
np_graph = graph_to_numpy(graph)
cover_group = degree(np_graph)
#cover_group = shaked_algo_impl_v2.shaked_algo_impl_v2(np_graph, randomize=True)
cover_group_size = len(cover_group)
c_results.append(cover_group_size)
results[c] = c_results
return results
def theorem5():
results = {}
for c in cs:
c_results = []
print(f'c {c}')
for i in range(iterations):
if i % 10 == 0:
print(f'graph iteration {i}')
graph_results = []
graph: Graph = Graph.Erdos_Renyi(n, c / n)
orig = graph_to_numpy(graph)
for j in range(iterations):
np_graph = orig.copy()
cover_group = shaked_algo_impl_v2.shaked_algo_impl_v2(np_graph, randomize=True)
cover_group_size = len(cover_group)
graph_results.append(cover_group_size)
c_results.append(np.array(graph_results))
results[c] = np.array(c_results)
return results
def test_algorithm():
graph = Graph.Erdos_Renyi(100, 0.05)
cover = first_vertex_with_degree.first_vertex_with_degree_algo(None, graph)
assert_equal(
graph_utils.check_if_legal_vertex_cover(
graph_utils.graph_to_numpy(graph), cover), True)
def test_algorithm():
graph = Graph.Erdos_Renyi(100, 0.05)
cover = neighbors_algo.neighbors_algo(None, graph)
assert_equal(
graph_utils.check_if_legal_vertex_cover(
graph_utils.graph_to_numpy(graph), cover), True)
def main():
what_graph = 'gnp' # gnp | star | ring
iterations = 1000000
n = 1000
c = 1
results = []
# if what_graph == 'gnp':
rhs_a = (n / c) * (c - 1 + np.e**(-c))
# rhs_b = (n / (2 * c)) * (np.e ** (-c) - 1) ** 2
rhs_b_1 = 1 / (2 * (c**3) * (np.exp(2 * c)))
rhs_b_2 = 2 * c * np.exp(c) * (np.exp(c) - 1 - special.expi(c) +
np.log(c) + np.euler_gamma)
rhs_b_3 = 2 * ((c * np.exp(c) - np.exp(c) + 1)**2)
rhs_b_4 = (
(c**2 - 2 * c) * np.exp(2 * c)) + 4 * c * np.exp(c) - c**2 - 2 * c
rhs_b = rhs_b_1 * (rhs_b_2 - rhs_b_3 + rhs_b_4) * n
numerator = rhs_a
denominator = np.sqrt(rhs_b)
# if what_graph == 'gnp':
graph: Graph = Graph.Erdos_Renyi(n, c / n)
randomize = True
# elif what_graph == 'ring':
# graph: Graph = Graph.Ring(n)
# randomize = True
# elif what_graph == 'star':
# graph: Graph = Graph.Star(n)
# randomize = True
# else:
# raise Exception("Bad what_graph value")
for i in range(iterations):
np_graph = graph_to_numpy(graph)
cover_group = shaked_algo_impl_v2.shaked_algo_impl_v2(
np_graph, randomize=randomize)
cover_group_size = len(cover_group)
if i % 100 == 0:
print(f'iteration {i}')
results.append(cover_group_size)
if what_graph == 'gnp':
theorem2_c = (np.array(results) - numerator) / denominator
print('=========')
avg = np.array(results).mean()
print(f'average: {avg}')
if what_graph == 'gnp':
print(f'rhs_a {rhs_a}')
variance = np.array(results).var()
print(f'variance: {variance}')
if what_graph == 'gnp':
print(f'rhs_b {rhs_b}')
np.save('theorem2_c.npy', theorem2_c)
plot_hist(theorem2_c)
if what_graph == 'star':
expectation = (n**2 + n - 2) / (2 * n)
print(f'star expectation: {expectation}')
return results
def test_vertex_support_all():
graph = graph_utils.graph_to_numpy(
igraph.Graph(n=5, edges=[(1, 2), (3, 4), (4, 1)]))
assert_equal(vsa.vertex_support_all(graph), [0, 3, 2, 2, 3])
import igraph
from numpy.testing import assert_equal, assert_array_almost_equal
from numpy import matrix
import graph_utils
from algorithms.xyz import xyz
graph = xyz.build_sparse(
graph_utils.graph_to_numpy(
igraph.Graph(n=5, edges=[(0, 2), (1, 2), (3, 4), (4, 1)])))
expected_degrees = [1, 2, 2, 1, 2]
def test_degrees():
assert_equal(xyz.all_vertex_degree(graph), expected_degrees)
def test_x_vector():
expected_x = [1 / 2, 2 / 3, 2 / 3, 1 / 2, 2 / 3]
assert_equal(xyz.get_x_vector(xyz.all_vertex_degree(graph)), expected_x)
def test_y_vector():
x = [1 / 2, 2 / 3, 2 / 3, 1 / 2, 2 / 3]
expected_y = [
x[0] + x[2], x[1] + x[2] + x[4], x[2] + x[1] + x[0], x[3] + x[4],
x[4] + x[1] + x[3]
]
degree_vector = xyz.all_vertex_degree(graph)
x_vector = xyz.get_x_vector(degree_vector)
def test_algorithm(self):
graph = graph_utils.graph_to_numpy(
Graph(n=3, edges=[(0, 1), (0, 2), (1, 2)]))
cover_group = degree_minus(graph)
assert_equal(len(cover_group), 2)
def test_random_graphs(self):
for i in range(10):
graph = graph_utils.random_graph(100, 0.1)
g = graph_utils.graph_to_numpy(graph)
cover = degree_minus(g)
assert (graph_utils.check_if_legal_vertex_cover(g, cover))