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