def tracage_courbe3():
"""Trace une courbe de performance en temps en fonction du nombre de
polygones utilisés."""
les_x = [i * 100 for i in [5, 10, 15, 20, 25, 30, 35, 40]]
les_poly = [
"tests/polygons/sqline-" + str(i * 100) + ".poly"
for i in [5, 10, 15, 20, 25, 30, 35, 40]
]
les_y_fct2 = [
chrono(trouve_inclusions2, vecteur_polygone(poly)) for poly in les_poly
]
les_y_fct3 = [
chrono(trouve_inclusions3, vecteur_polygone(poly)) for poly in les_poly
]
les_y_fct4 = [
chrono(trouve_inclusions4, read_instance(poly)) for poly in les_poly
]
les_y_fct5 = [
chrono(trouve_inclusions5, read_instance(poly)) for poly in les_poly
]
les_y_fct6 = [
chrono(trouve_inclusions6, read_instance(poly)) for poly in les_poly
]
plt.plot(les_x, les_y_fct2, c='g', label='Fonction trouve_inclusions2')
plt.plot(les_x, les_y_fct3, c='b', label='Fonction trouve_inclusions3')
plt.plot(les_x, les_y_fct4, c='r', label='Fonction trouve_inclusions4')
plt.plot(les_x, les_y_fct5, c='m', label='Fonction trouve_inclusions5')
plt.plot(les_x, les_y_fct6, c='c', label='Fonction trouve_inclusions6')
plt.xlabel("Nombre de polygones")
plt.ylabel("Temps d'exécution de la fonction (s)")
plt.legend()
plt.title('Temps en fonction du nombre de polygones')
plt.savefig("Performance3.png")
def tracage_courbe7():
"""Trace une courbe de performance en temps en fonction du nombre de
polygones utilisés."""
les_x = [i * 10 for i in [4, 5, 6]]
nb_poly = [x**2 for x in les_x]
les_poly = [
"tests/polygons/circgrid-" + str(i) + "-" + str(i) + "-36.poly"
for i in les_x
]
les_y_fct2 = [
chrono(trouve_inclusions2, vecteur_polygone(poly)) for poly in les_poly
]
les_y_fct3 = [
chrono(trouve_inclusions3, vecteur_polygone(poly)) for poly in les_poly
]
les_y_fct4 = [
chrono(trouve_inclusions4, read_instance(poly)) for poly in les_poly
]
les_y_fct5 = [
chrono(trouve_inclusions5, read_instance(poly)) for poly in les_poly
]
les_y_fct6 = [
chrono(trouve_inclusions6, read_instance(poly)) for poly in les_poly
]
plt.plot(nb_poly, les_y_fct2, c='g', label='Fonction trouve_inclusions2')
plt.plot(nb_poly, les_y_fct3, c='b', label='Fonction trouve_inclusions3')
plt.plot(nb_poly, les_y_fct4, c='r', label='Fonction trouve_inclusions4')
plt.plot(nb_poly, les_y_fct5, c='m', label='Fonction trouve_inclusions5')
plt.plot(nb_poly, les_y_fct6, c='c', label='Fonction trouve_inclusions6')
plt.xlabel("Nombre de polygones")
plt.ylabel("Temps d'exécution de la fonction (s)")
plt.legend()
plt.title('Temps en fonction du nombre de polygones')
plt.savefig("Performance7.png")
def tracage_courbe8():
"""Trace une courbe de performance en temps en fonction du nombre de
polygones utilisés."""
les_x = [4, 5, 6, 7]
les_poly = ["tests/polygons/sierp-" + str(i) + ".poly" for i in les_x]
les_y_fct2 = [
chrono(trouve_inclusions2, vecteur_polygone(poly)) for poly in les_poly
]
les_y_fct3 = [
chrono(trouve_inclusions3, vecteur_polygone(poly)) for poly in les_poly
]
les_y_fct4 = [
chrono(trouve_inclusions4, read_instance(poly)) for poly in les_poly
]
les_y_fct5 = [
chrono(trouve_inclusions5, read_instance(poly)) for poly in les_poly
]
les_y_fct6 = [
chrono(trouve_inclusions6, read_instance(poly)) for poly in les_poly
]
plt.plot(les_x, les_y_fct2, c='g', label='Fonction trouve_inclusions2')
plt.plot(les_x, les_y_fct3, c='b', label='Fonction trouve_inclusions3')
plt.plot(les_x, les_y_fct4, c='r', label='Fonction trouve_inclusions4')
plt.plot(les_x, les_y_fct5, c='m', label='Fonction trouve_inclusions5')
plt.plot(les_x, les_y_fct6, c='c', label='Fonction trouve_inclusions6')
plt.xlabel("Niveau de récursion")
plt.ylabel("Temps d'exécution de la fonction (s)")
plt.legend()
plt.title('Temps en fonction du niveau de récursion')
plt.savefig("Performance8.png")
def main_multiprocessing():
for fichier in sys.argv[1:]:
polygones = read_instance(fichier)
n = len(polygones)
results = multiprocessing.Array("i", [-1] * n)
# # creating new process
# p1 = multiprocessing.Process(target=trouve_inclusions_multiprocessing, args=(polygones, results))
# p1.start()
# p1.join()
processes = []
count = 2 # multiprocessing.cpu_count()
split_polygones = chunked(permutations(enumerate(polygones), 2), count)
for split_polygone in split_polygones:
_process = multiprocessing.Process(
target=trouve_inclusions_multiprocessing,
args=(split_polygone, results, polygones),
)
processes.append(_process)
_process.start()
for _process in processes:
_process.join()
print(results[:])
def main():
"""
charge chaque fichier .poly donne
trouve les inclusions
affiche l'arbre en format texte
"""
polygones1 = read_instance("lourd.poly")
inclusion1 = trouve_inclusions4(polygones1)
print(inclusion1)
def main():
"""
charge chaque fichier .poly donne
trouve les inclusions
affiche l'arbre en format texte
"""
for fichier in sys.argv[1:]:
polygones = read_instance(fichier)
inclusions = trouve_inclusions_segments(polygones)
print(inclusions)
def perf_test(a_mesurer):
# augmenter le range de number si besoin, descendre à 6 pour avoir des résultats corrects et un temps réduit d'exécution
for number in range(1, 6):
filename = f"generated_from_examples_{number}.poly"
if not os.path.exists(filename):
print("Files generation...")
generator(number=number)
preparation = read_instance(filename)
for temps in bench(preparation, a_mesurer):
print(number, temps)
def main():
"""
charge chaque fichier .poly donne
trouve les inclusions
affiche l'arbre en format texte
"""
sys.setrecursionlimit(10000)
for fichier in sys.argv[1:]:
polygones = read_instance(fichier)
inclusions = trouve_inclusions(polygones)
print(inclusions)
def main():
"""
charge chaque fichier .poly donne
trouve les inclusions
affiche l'arbre en format texte
"""
polygones = read_instance(sys.argv[1])
if sys.argv[2] == '4':
print(chrono(trouve_inclusions4, polygones))
elif sys.argv[2] == '5':
print(chrono(trouve_inclusions5, polygones))
else:
print(chrono(trouve_inclusions6, polygones))
def tracage_courbe6():
"""Trace une courbe de performance en temps en fonction du nombre de
polygones utilisés."""
les_x = [i * 10 for i in [4, 5, 6, 7, 8, 9, 10, 11]]
nb_poly = [x**2 for x in les_x]
les_poly = [
"tests/polygons/sqgrid-" + str(i) + "-" + str(i) + ".poly"
for i in les_x
]
les_y_fct4 = [
chrono(trouve_inclusions4, read_instance(poly)) for poly in les_poly
]
les_y_fct6 = [
chrono(trouve_inclusions6, read_instance(poly)) for poly in les_poly
]
plt.plot(nb_poly, les_y_fct4, c='r', label='Fonction trouve_inclusions4')
plt.plot(nb_poly, les_y_fct6, c='c', label='Fonction trouve_inclusions6')
plt.xlabel("Nombre de polygones")
plt.ylabel("Temps d'exécution de la fonction (s)")
plt.legend()
plt.title('Temps en fonction du nombre de polygones')
plt.savefig("Performance6.png")
def main():
from algos_trouve_inclusions import (
trouve_inclusions_sorted1,
trouve_inclusions_sorted2,
trouve_inclusions,
trouve_inclusions_groupy1,
trouve_inclusions_groupy2,
)
from algos_pip import (
crossing_number,
crossing_number_v2,
crossing_number_v3,
crossing_number_v3_sec,
crossing_number_v3_segments,
crossing_number_v5,
winding_number,
)
from tycat import read_instance
pip_functions = [
# crossing_number,
# crossing_number_v2,
# crossing_number_v3,
crossing_number_v3_sec,
# crossing_number_v3_segments,
# crossing_number_v5,
# winding_number,
]
functions_list = [
# trouve_inclusions,
trouve_inclusions_sorted1,
# trouve_inclusions_sorted2,
trouve_inclusions_groupy1,
# trouve_inclusions_groupy2, n'utilise pas les pip_functions
]
polygones = read_instance(sys.argv[1])
_, _ = empirical_complexity(functions_list, pip_functions, polygones)
else:
if not (crossing_number(point, new[j], quadrants[j])):
continue
else:
output[polygones.index(new[i])] = polygones.index(new[j])
break
return output
# Initier des listes
nombre_poly = [] # Liste pour varier le nombre de polygones
time_1 = [] # Liste de performances pour crossing_number
time_2 = [] # Liste de performances pour quadrant_product
time_3 = [] # Liste de performances pour cutting_triangle
for fichier in sys.argv[1:]:
polygones = read_instance(fichier)
for i in range(1, 3001, 20):
poly = polygones[:i]
nombre_poly.append(len(poly))
start = time()
print(len(main(poly, crossing_number)))
end = time()
time_1.append(end - start)
start_2 = time()
print(len(main(poly, quadrant_product)))
end_2 = time()
time_2.append(end_2 - start_2)
start_3 = time()
print(len(main(poly, cutting_triangle)))
end_3 = time()
time_3.append(end_3 - start_3)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
from utils import get_files_matching_ext
from main import trouve_inclusions_sorted
from tycat import read_instance
POLY_FILES = get_files_matching_ext(".poly")
for poly_file in POLY_FILES:
# print(poly_file)
polygones = read_instance(poly_file)
inclusions = trouve_inclusions_sorted(polygones)
np.savetxt(poly_file + ".result", inclusions, fmt="%i", newline=", ")
def test_point_in_polygon(function, expected, file):
"""on vérifie qu'un point du polygone est inclut dans l'autre polygone"""
polygones = read_instance(file)
assert len(polygones) == 2
assert function(polygones[0], polygones[1].points[0]) == expected
def test_inclusions(expected, file, function=trouve_inclusions_sorted):
polygones = read_instance(file)
assert function(polygones) == expected
def test_compare_functions(file, functions=TROUVE_INCLUSIONS_FUNCTIONS):
polygones = read_instance(file)
results = [function(polygones) for function in functions]
for indice, (res1, res2) in enumerate(zip(results, results[1:])):
print("Numéro de la comparaison : ", indice)
assert(res1 == res2)
def test_all_points_in_polygon(function, expected, file):
"""on vérifie que tous les points du polygone sont inclus dans l'autre polygone"""
polygones = read_instance(file)
assert len(polygones) == 2
for point in polygones[1].points:
assert function(polygones[0], point) == expected
def test_compare_functions(file, functions=POINT_IN_POLYGON_FUNCTIONS):
polygones = read_instance(file)
results = [function(polygones[0], polygones[1].points[0]) for function in functions]
for indice, (res1, res2) in enumerate(zip(results, results[1:])):
print("Numéro de la comparaison : ", indice)
assert res1 == res2
