def worstcase1_removed_optimization(): """ Solves a worst case graph G_n for n = 1. """ g = io.load_from_file("assets/strong parity/worstcase_1.txt") removed = bitarray([False] + ([False] * len(g.nodes))) (a, b), (c, d) = sp.strong_parity_solver_non_removed(g, removed) return a == [1, 3, 4, 2, 0] and b == {1: 2, 3: 1} and c == [] and d == {}
def example_1_removed_optimization(): """ Solves a simple example. """ g = io.load_from_file("assets/strong parity/example_1.txt") removed = bitarray([False] + ([False] * len(g.nodes))) (a, b), (c, d) = sp.strong_parity_solver_non_removed(g, removed) return (a == [1, 3, 2]) and b == {1: 1, 3: 3} and c == [] and d == {}
def figure56_removed_optimization(): """ Solves the strong parity game from figure 5.6. """ fig56_graph = io.load_from_file("assets/strong parity/figure56.txt") removed = bitarray([False] + ([False] * len(fig56_graph.nodes))) (a, b), (c, d) = sp.strong_parity_solver_non_removed(fig56_graph, removed) return (a == [2, 4, 1, 6]) and b == { 2: 2, 4: 1 } and c == [5, 3] and d == { 5: 5 }
def worstcase2_removed_optimization(): """ Solves a worst case graph G_n for n = 2. """ g = io.load_from_file("assets/strong parity/worstcase_2.txt") removed = bitarray([False] + ([False] * len(g.nodes))) (a, b), (c, d) = sp.strong_parity_solver_non_removed(g, removed) return a == [] and b == {} and c == [6, 8, 9, 7, 5, 4, 0, 2, 1, 3 ] and d == { 0: 4, 2: 4, 4: 5, 6: 7, 8: 6 }
def example_5_removed_optimization(): """ Solves a simple example. """ g = io.load_from_file("assets/strong parity/example_5.txt") removed = bitarray([False] + ([False] * len(g.nodes))) (a, b), (c, d) = sp.strong_parity_solver_non_removed(g, removed) return a == [2, 1, 5] and b == { 1: 2, 2: 2, 5: 5 } and c == [7, 6, 3, 4] and d == { 3: 6, 4: 3, 6: 6 }
def example_3_removed_optimization(): """ Solves a simple example. """ g = io.load_from_file("assets/strong parity/example_3.txt") removed = bitarray([False] + ([False] * len(g.nodes))) (a, b), (c, d) = sp.strong_parity_solver_non_removed(g, removed) return (a == [2, 1, 3, 4]) and b == { 4: 4, 2: 4, 1: 2 } and c == [6, 7, 5] and d == { 7: 6, 6: 6, 5: 6 }
def ladder(n, iterations=3, step=10, plot=False, path=""): """ Benchmarks the recursive algorithm for strong parity games using the worst case generator which yields an exponential complexity. Calls strong parity solver on games generated using the worst case generator function. Games of size 5 to 5*n are solved and a timer records the time taken to get the solution.The solver can be timed several times and the minimum value is selected using optional parameter iterations (to avoid recording time spikes and delays due to system load). The result can be plotted using matplotlib. :param n: number of nodes in generated graph (nodes is 5*n due to construction). :param iterations: number of times the algorithm is timed (default is 3). :param step: step to be taken in the generation. :param plot: if True, plots the data using matplotlib. :param path: path to the file in which to write the result. """ y = [] # list for the time recordings n_ = [] # list for the x values (5 to 5n) y2 = [] # list for the time recordings n_2 = [] # list for the x values (5 to 5n) total_time = 0 # accumulator to record total time nbr_generated = 0 # conserving the number of generated mesures (used to get the index of a mesure) chrono = timer.Timer(verbose=False) # Timer object info = "Time to solve (s)" # info about the current benchmark # print first line of output print u"Generator".center(40) + "|" + u"Nodes (n)".center(12) + "|" + info.center(40) + "\n" + \ "-" * 108 # games generated are size 1 to n for i in range(1, n + 1, step): temp1 = [] # temp list for #iterations recordings g = generators.ladder(i) # generated game # #iterations calls to the solver are timed for j in range(iterations): with chrono: strong_parity_solver(g) # solver call temp1.append(chrono.interval) # add time recording min_recording = min(temp1) y.append( min_recording) # get the minimum out of #iterations recordings n_.append(2 * i - 1) total_time += min_recording temp2 = [] # #iterations calls to the solver are timed removed = bitarray([False] + ([False] * len(g.nodes))) for j in range(iterations): with chrono: strong_parity_solver_non_removed(g, removed) # solver call temp2.append(chrono.interval) # add time recording min_recording = min(temp2) y2.append( min_recording) # get the minimum out of #iterations recordings n_2.append(2 * i - 1) print "Worst-case graph".center(40) + "|" + str(i * 5).center(12) + "|" \ + str(y[nbr_generated]).center(40) + "\n" + "-" * 108 nbr_generated += 1 # updating the number of generated mesures # at the end, print total time print "-" * 108 + "\n" + "Total (s)".center(40) + "|" + "#".center(12) + "|" + \ str(total_time).center(40) + "\n" + "-" * 108 + "\n" if plot: plt.grid(True) plt.title(u"Graphes 'pire cas' de taille 5 à " + str(2 * n - 1)) plt.xlabel(u'nombre de nœuds') plt.ylabel(u'temps (s)') # plt.yscale("log") allows logatithmic y-axis points, = plt.plot(n_, y, 'g.', label=u"Temps d'exécution") points2, = plt.plot(n_2, y2, 'r.', label=u"Temps d'exécution 2") plt.legend(loc='upper left', handles=[points, points2]) plt.savefig(path, bbox_inches='tight') plt.clf() plt.close()
def benchmark_worst_case_removed_optimization(n, iterations=3, step=10, plot=False, path=""): """ Analyzes the influence of the removed list optimization on the recursive algorithm for worst-case graphs. :param n: number of nodes in generated graph (nodes is 5*n due to construction). :param iterations: number of times the algorithm is timed (default is 3). :param step: step to be taken in the generation. :param plot: if True, plots the data using matplotlib. :param path: path to the file in which to write the result. """ y = [] # list for the time recordings n_ = [] # list for the x values (5 to 5n) y2 = [] # list for the time recordings n_2 = [] # list for the x values (5 to 5n) total_time = 0 # accumulator to record total time nbr_generated = 0 # conserving the number of generated mesures (used to get the index of a mesure) chrono = timer.Timer(verbose=False) # Timer object info = "Time to solve (s)" # info about the current benchmark # print first line of output print u"Generator".center(40) + "|" + u"Nodes (n)".center(12) + "|" + info.center(40) + "\n" + \ "-" * 108 # games generated are size 1 to n for i in range(1, n + 1, step): temp = [] # temp list for #iterations recordings g = generators.strong_parity_worst_case(i) # generated game # #iterations calls to the solver are timed for j in range(iterations): with chrono: strong_parity_solver(g) # solver call temp.append(chrono.interval) # add time recording min_recording = min(temp) y.append( min_recording) # get the minimum out of #iterations recordings n_.append(5 * i) total_time += min_recording temp = [] # #iterations calls to the solver are timed for j in range(iterations): removed = bitarray([False] + ([False] * len(g.nodes))) with chrono: strong_parity_solver_non_removed(g, removed) # solver call temp.append(chrono.interval) # add time recording min_recording = min(temp) y2.append( min_recording) # get the minimum out of #iterations recordings n_2.append(5 * i) min_recording = min(temp) print "Worst-case graph".center(40) + "|" + str(i * 5).center(12) + "|" \ + str(y[nbr_generated]).center(40) + "\n" + "-" * 108 nbr_generated += 1 # updating the number of generated mesures # at the end, print total time print "-" * 108 + "\n" + "Total (s)".center(40) + "|" + "#".center(12) + "|" + \ str(total_time).center(40) + "\n" + "-" * 108 + "\n" if plot: plt.grid(True) plt.title( u"Recursive algorithm runtime comparison : worst-case graphs of size 1 to " + str(5 * n)) plt.xlabel(u'number of nodes') plt.ylabel(u'time (s)') # plt.yscale("log") allows logatithmic y-axis points, = plt.plot(n_, y, 'g.', label=u"Regular") points2, = plt.plot(n_2, y2, 'r.', label=u"Without sub-game construction") plt.legend(loc='upper left', handles=[points, points2]) plt.savefig(path, bbox_inches='tight') plt.clf() plt.close()