def get_data(filename: str):
graph = Graph()
with open(filename, 'r') as file:
lines = file.readlines()
n, m = tuple(int(x) for x in lines[0].split())
clients = tuple(int(x) for x in lines[1].split())
for line in lines[2:]:
start, end, weight = tuple(int(x) for x in line.split())
graph.create_edges_from_vertexes(start, end, weight)
return n, m, clients, graph
def get_intersection(graph1, graph2):
result = Graph()
result.vertices_count = graph1.vertices_count * graph2.vertices_count
for i in graph1.start_vertices:
for j in graph2.start_vertices:
result.start_vertices.add(i * graph1.vertices_count + j)
for i in graph1.terminal_vertices:
for j in graph2.terminal_vertices:
result.terminal_vertices.add(i * graph1.vertices_count + j)
for label in graph1.label_matrices.keys():
if label in graph2.label_matrices.keys():
result.label_matrices[label] = graph1.label_matrices[
label].kronecker(graph2.label_matrices[label])
return result
def setUp(self) -> None:
self.firstGraph = Graph()
self.firstGraph.create_edges_from_vertexes(1, 3, 10)
self.firstGraph.create_edges_from_vertexes(3, 4, 80)
self.firstGraph.create_edges_from_vertexes(4, 5, 50)
self.firstGraph.create_edges_from_vertexes(5, 6, 20)
self.firstGraph.create_edges_from_vertexes(2, 3, 40)
self.firstGraph.create_edges_from_vertexes(2, 4, 100)
self.secondGraph = Graph()
self.secondGraph.create_edges_from_vertexes(1, 2, 20)
self.secondGraph.create_edges_from_vertexes(2, 3, 20)
self.secondGraph.create_edges_from_vertexes(3, 6, 20)
self.secondGraph.create_edges_from_vertexes(6, 9, 20)
self.secondGraph.create_edges_from_vertexes(9, 8, 20)
self.secondGraph.create_edges_from_vertexes(8, 7, 20)
self.secondGraph.create_edges_from_vertexes(7, 4, 20)
self.secondGraph.create_edges_from_vertexes(4, 1, 20)
self.secondGraph.create_edges_from_vertexes(5, 2, 10)
self.secondGraph.create_edges_from_vertexes(5, 4, 10)
self.secondGraph.create_edges_from_vertexes(5, 6, 10)
self.secondGraph.create_edges_from_vertexes(5, 8, 10)
self.thirdGraph = Graph()
self.thirdGraph.create_edges_from_vertexes(1, 2, 50)
self.thirdGraph.create_edges_from_vertexes(2, 3, 1000000000)
from classes.Node import Node
from classes.Cell import Cell
from classes.Graph import Graph
boardName = 'Square'
nodes = [Node() for i in range(4)]
cells = [
Cell([nodes[0], nodes[1], nodes[2], nodes[3]]),
]
graph = Graph(cells)
cytoscapeNodes = [
{
'data': {
'id': nodes[0].id,
},
'position': {
'x': 0,
'y': 0
},
'grabbable': False
},
{
'data': {
'id': nodes[1].id,
},
'position': {
'x': 100,
'y': 0
},
class GraphTest(unittest.TestCase):
def setUp(self) -> None:
self.firstGraph = Graph()
self.firstGraph.create_edges_from_vertexes(1, 3, 10)
self.firstGraph.create_edges_from_vertexes(3, 4, 80)
self.firstGraph.create_edges_from_vertexes(4, 5, 50)
self.firstGraph.create_edges_from_vertexes(5, 6, 20)
self.firstGraph.create_edges_from_vertexes(2, 3, 40)
self.firstGraph.create_edges_from_vertexes(2, 4, 100)
self.secondGraph = Graph()
self.secondGraph.create_edges_from_vertexes(1, 2, 20)
self.secondGraph.create_edges_from_vertexes(2, 3, 20)
self.secondGraph.create_edges_from_vertexes(3, 6, 20)
self.secondGraph.create_edges_from_vertexes(6, 9, 20)
self.secondGraph.create_edges_from_vertexes(9, 8, 20)
self.secondGraph.create_edges_from_vertexes(8, 7, 20)
self.secondGraph.create_edges_from_vertexes(7, 4, 20)
self.secondGraph.create_edges_from_vertexes(4, 1, 20)
self.secondGraph.create_edges_from_vertexes(5, 2, 10)
self.secondGraph.create_edges_from_vertexes(5, 4, 10)
self.secondGraph.create_edges_from_vertexes(5, 6, 10)
self.secondGraph.create_edges_from_vertexes(5, 8, 10)
self.thirdGraph = Graph()
self.thirdGraph.create_edges_from_vertexes(1, 2, 50)
self.thirdGraph.create_edges_from_vertexes(2, 3, 1000000000)
def test_graphs_vertexes(self):
self.assertEqual([1, 3, 4, 5, 6, 2],
list(self.firstGraph.connections.keys()))
self.assertEqual([1, 2, 3, 6, 9, 8, 7, 4, 5],
list(self.secondGraph.connections.keys()))
def test_graphs_connections(self):
self.assertEqual(
{
1: [(3, 10)],
3: [(1, 10), (4, 80), (2, 40)],
4: [(3, 80), (5, 50), (2, 100)],
5: [(4, 50), (6, 20)],
6: [(5, 20)],
2: [(3, 40), (4, 100)]
}, self.firstGraph.connections)
self.assertEqual(
{
1: [(2, 20), (4, 20)],
2: [(1, 20), (3, 20), (5, 10)],
3: [(2, 20), (6, 20)],
6: [(3, 20), (9, 20), (5, 10)],
9: [(6, 20), (8, 20)],
8: [(9, 20), (7, 20), (5, 10)],
7: [(8, 20), (4, 20)],
4: [(7, 20), (1, 20), (5, 10)],
5: [(2, 10), (4, 10), (6, 10), (8, 10)]
}, self.secondGraph.connections)
self.assertEqual(
{
1: [(2, 50)],
2: [(1, 50), (3, 1000000000)],
3: [(2, 1000000000)]
}, self.thirdGraph.connections)
def test_graph_wrong_inputs(self):
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, '1', 2,
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, '2',
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, 2,
'3')
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1.5, 2,
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, 2.5,
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, 2,
3.5)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, {1}, 2,
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, {2},
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, 2,
{3})
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, [1], 2,
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, [2],
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, 2,
[3])
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, (1, ), 2,
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, (2, ),
3)
self.assertRaises(TypeError,
self.firstGraph.create_edges_from_vertexes, 1, 2,
(3, ))
self.assertRaises(ValueError,
self.firstGraph.create_edges_from_vertexes, 1, 2, -3)
def cfpq_tensor_product(graph: Graph, grammar: CFG):
if graph.vertices_count == 0:
return False
result = graph.get_copy()
rfa = Graph()
rfa_heads = dict()
rfa.vertices_count = sum(
[len(production.body) + 1 for production in grammar.productions])
index = 0
for production in grammar.productions:
start_state = index
terminal_state = index + len(production.body)
rfa.start_vertices.add(start_state)
rfa.terminal_vertices.add(terminal_state)
rfa_heads[(start_state, terminal_state)] = production.head.value
for variable in production.body:
matrix = rfa.label_matrices.get(
variable.value,
Matrix.sparse(BOOL, rfa.vertices_count,
rfa.vertices_count))
matrix[index, index + 1] = True
rfa.label_matrices[variable.value] = matrix
index += 1
index += 1
for production in grammar.productions:
if len(production.body) == 0:
matrix = Matrix.sparse(BOOL, graph.vertices_count,
graph.vertices_count)
matrix += Matrix.identity(BOOL, graph.vertices_count)
result.label_matrices[production.head] = matrix
changed = True
while changed:
changed = False
intersection = Utils.get_intersection(rfa, result)
closure = Utils.get_transitive_closure_squaring(intersection)
for i, j, _ in zip(*closure.to_lists()):
rfa_from, rfa_to = i // result.vertices_count, j // result.vertices_count
graph_from, graph_to = i % result.vertices_count, j % result.vertices_count
if (rfa_from, rfa_to) not in rfa_heads:
continue
variable = rfa_heads[(rfa_from, rfa_to)]
matrix = result.label_matrices.get(
variable,
Matrix.sparse(BOOL, graph.vertices_count,
graph.vertices_count))
if matrix.get(graph_from, graph_to) is None:
changed = True
matrix[graph_from, graph_to] = True
result.label_matrices[variable] = matrix
return result.label_matrices.get(
grammar.start_symbol,
Matrix.sparse(BOOL, graph.vertices_count, graph.vertices_count))
def Main():
global lMemory
global wrMemory
global lNetwork
global wrNetwork
global lCPU
global wrCPU
global lDisk
global wrDisk
global lDisplayThread
global Path
global Files
global Infected
global currentDate
global dGraph
global nGraph
global mGraph
global cGraph
global LoopCount
global LoopsAllowed
try:
currentDate = '{0:%Y-%m-%d-%H-%M-%S}'.format(datetime.datetime.now())
# Setting up Memory and Memory Writer
lMemory = Memory()
infected = "Infected" if Infected is True else "Not-Infected"
wrMemory = Writer(Path + "\\CSV\\Memory\\" + infected + "\\", "Memory",
None, currentDate)
# Setting up CPU and CPUs Writer
lCPU = CPU()
wrCPU = Writer(Path + "\\CSV\\CPU\\" + infected + "\\", "CPU", None,
currentDate)
# Setting up Disks and Disks Writer
lDisk = Disks()
wrDisk = Writer(Path + "\\CSV\\Disks\\" + infected + "\\", "Disk",
None, currentDate)
# Setting up Network and Networks Writer
lNetwork = Network()
wrNetwork = Writer(Path + "\\CSV\\Network\\" + infected + "\\",
"Network", None, currentDate)
LoopsAllowed = options.opt_loops
LoopCount = 0
# Setting up graph objects
if options.opt_graph is True:
dGraph = Graph(Disks, "Time", "Value", "Disk Performance", True)
nGraph = Graph(Network, "Time", "Value", "Network Performance",
True)
mGraph = Graph(Memory, "Time", "Value", "Memory Performance", True)
cGraph = Graph(CPU, "Time", "Value", "CPU Performance", True)
# Setting up the display thread
lDisplayThread = RepeatedTimer(1, Display)
except Exception as ex:
print(ex)
while True:
time.sleep(1000)
return
elif folder == 'memory':
fType = Memory
elif folder == 'network':
fType = Network
comparer = Recollect(fType, ("\CSV\%s\\Not-Infected\%s" %
(folderKept, files[0])),
False)
comparer.Read()
comparer.Change_File(
("\CSV\%s\\Infected\%s" % (folderKept, files[1])))
comparer.Change_Infected(True)
comparer.Read()
if fType is Disks:
dGraph = Graph(fType, "Time", "Value",
"Disk Performance", True)
dGraph.Plot_Graph_2D(comparer.Graph_X(),
comparer.Get_Graph())
elif fType is Network:
nGraph = Graph(fType, "Time", "Value",
"Network Performance", True)
nGraph.Plot_Graph_2D(comparer.Graph_X(),
comparer.Get_Graph())
elif fType is Memory:
mGraph = Graph(fType, "Time", "Value",
"Memory Performance", True)
mGraph.Plot_Graph_3D(comparer.Graph_X(),
comparer.Get_Graph())
elif fType is CPU:
nGraph = Graph(fType, "Time", "Value",
"CPU Performance", True)
class DejkstraTest(unittest.TestCase):
def setUp(self) -> None:
self.firstGraph = Graph()
self.firstGraph.create_edges_from_vertexes(1, 3, 10)
self.firstGraph.create_edges_from_vertexes(3, 4, 80)
self.firstGraph.create_edges_from_vertexes(4, 5, 50)
self.firstGraph.create_edges_from_vertexes(5, 6, 20)
self.firstGraph.create_edges_from_vertexes(2, 3, 40)
self.firstGraph.create_edges_from_vertexes(2, 4, 100)
self.secondGraph = Graph()
self.secondGraph.create_edges_from_vertexes(1, 2, 20)
self.secondGraph.create_edges_from_vertexes(2, 3, 20)
self.secondGraph.create_edges_from_vertexes(3, 6, 20)
self.secondGraph.create_edges_from_vertexes(6, 9, 20)
self.secondGraph.create_edges_from_vertexes(9, 8, 20)
self.secondGraph.create_edges_from_vertexes(8, 7, 20)
self.secondGraph.create_edges_from_vertexes(7, 4, 20)
self.secondGraph.create_edges_from_vertexes(4, 1, 20)
self.secondGraph.create_edges_from_vertexes(5, 2, 10)
self.secondGraph.create_edges_from_vertexes(5, 4, 10)
self.secondGraph.create_edges_from_vertexes(5, 6, 10)
self.secondGraph.create_edges_from_vertexes(5, 8, 10)
self.thirdGraph = Graph()
self.thirdGraph.create_edges_from_vertexes(1, 2, 50)
self.thirdGraph.create_edges_from_vertexes(2, 3, 1000000000)
def test_dejkstra(self):
self.assertRaises(ValueError, dejkstra_algorithm, self.firstGraph, 0)
self.assertEqual({
1: 0,
3: 10,
4: 90,
5: 140,
6: 160,
2: 50
}, dejkstra_algorithm(self.firstGraph, 1))
self.assertEqual({
1: 50,
3: 40,
4: 100,
5: 150,
6: 170,
2: 0
}, dejkstra_algorithm(self.firstGraph, 2))
self.assertEqual({
1: 10,
3: 0,
4: 80,
5: 130,
6: 150,
2: 40
}, dejkstra_algorithm(self.firstGraph, 3))
self.assertEqual({
1: 90,
3: 80,
4: 0,
5: 50,
6: 70,
2: 100
}, dejkstra_algorithm(self.firstGraph, 4))
self.assertEqual({
1: 140,
3: 130,
4: 50,
5: 0,
6: 20,
2: 150
}, dejkstra_algorithm(self.firstGraph, 5))
self.assertEqual({
1: 160,
3: 150,
4: 70,
5: 20,
6: 0,
2: 170
}, dejkstra_algorithm(self.firstGraph, 6))
def main():
graph = Graph("Power evolution of Android libraries")
"""
graph.addExperiment(Experiment("Firebase", "results/firebase-release-0.csv", "firebrick"))
graph.addExperiment(Experiment("Flurry", "results/flurry-release-0.csv", "blue"))
graph.addExperiment(Experiment("Google", "results/google-release-0.csv", "green"))
"""
graph.addExperiment(
Experiment("Acra", "results/acra-release-0.csv", "firebrick"))
graph.addExperiment(
Experiment("Newrelic", "results/newrelic-release-0.csv", "blue"))
graph.addExperiment(
Experiment("Crashlytics", "results/crashlytics-release-0.csv",
"green"))
# graph.plotExperiments()
graph.plotSmoothedExperiments()
graph.show()