def create_plots(begin, end, stride): """ Plot the function double, square, and exp from beginning to end using the provided stride (step) The x-coordinates of the plotted points start at begin, terminate at end and are spaced by distance stride, similar to range(start, stop, step) function """ # generate x coordinates for plot points x_coords = [] current_x = begin while current_x < end: x_coords.append(current_x) current_x += stride # compute list of tuples, (x, y) coordinates, for each function # y coordinate can be thought of as f(x) double_plot = [(x_val, double(x_val)) for x_val in x_coords] square_plot = [(x_val, square(x_val)) for x_val in x_coords] exp_plot = [(x_val, exp(x_val)) for x_val in x_coords] # plot the list of points # arguments: simpleplot.plot_lines(framename, width, height, xlabel, ylabel, datasets, points, legends) simpleplot.plot_lines("Plots of three functions", 600, 400, "x", "f(x)", [double_plot, square_plot, exp_plot], True, ["double", "square", "exp"])
def run_strategy(strategy_name, time, strategy): """ Run a simulation for the given time with one strategy. :param strategy_name: :param time: :param strategy: """ state = simulate_clicker(provided.BuildInfo(), time, strategy) print strategy_name, ":", state print state._total_num_cookies # Plot total cookies over time # Uncomment out the lines below to see a plot of total cookies vs. time # Be sure to allow popups, if you do want to see it history = state.get_history() history = [(item[0], item[3]) for item in history] simpleplot.plot_lines(strategy_name, 1000, 500, 'Time', 'Total Cookies', [history], True, _block=True)
def create_plots(begin, end, stride): """ Plot the function double, square, and exp from beginning to end using the provided stride The x-coordinates of the plotted points start at begin, terminate at end and are spaced by distance stride """ # generate x coordinates for plot points x_coords = [] current_x = begin while current_x < end: x_coords.append(current_x) current_x += stride # compute list of (x, y) coordinates for each function double_plot = [(x_val, double(x_val)) for x_val in x_coords] square_plot = [(x_val, square(x_val)) for x_val in x_coords] exp_plot = [(x_val, exp(x_val)) for x_val in x_coords] # plot the list of points simpleplot.plot_lines("Plots of three functions", 600, 400, "x", "f(x)", [double_plot, square_plot, exp_plot], True, ["double", "square", "exp"])
def create_plots(begin, end, stride): """ Plot the function double, square, and exp from beginning to end using the provided stride The x-coordinates of the plotted points start at begin, terminate at end and are spaced by distance stride """ # generate x coordinates for plot points x_coords = [] current_x = begin while current_x < end: x_coords.append(current_x) current_x += stride # compute list of (x, y) coordinates for each function exp1_plot = [(x_val, exp1(x_val)) for x_val in x_coords] log1_plot = [(x_val, log1(x_val)) for x_val in x_coords] for (x, y) in log1_plot: if y > 0: print '(' + str(x) + ',' + str(y) + ')' # plot the list of points simpleplot.plot_lines("Plots of three functions", 600, 400, "x", "f(x)", [exp1_plot, log1_plot], True, ["exp1", "log1"])
def run_simulations(): """ Run simulations for several possible bribe increments The plot of the resulting graph approaches a straight line as the number of days increase. This observation signals that the function might be a polynomial function. Compute the slope of this line and round it to the nearest integer to estimate the degree of this polynomial. Use two of those points with the formula above (m = rise/run = (y2-y1)/(x2-x1)) >>> y=8.699514748210191-8.006367567650246 >>> y 0.6931471805599454 >>> x=3.4011973816621555-2.995732273553991 >>> x 0.4054651081081646 >>> 0.6931471805599454/0.4054651081081646 1.709511291351454 >>>round(1.709511291351454) ~ 2 """ plot_type = LOGLOG days = 35 inc_1000 = greedy_boss(days, 1000, plot_type) print inc_1000 simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", [inc_1000], False, ["Bribe increment = 1000"])
def q1_legend(low, high): xvals = [] slow = [] fast = [] for num_clusters in range(low, high, 100): xvals.append(num_clusters) cluster_list = gen_random_clusters(num_clusters) time1 = time.time() slow_closest_pair(cluster_list) time2 = time.time() slow.append(time2 - time1) time1 = time.time() fast_closest_pair(cluster_list) time2 = time.time() fast.append(time2 - time1) yvals1 = slow yvals2 = fast curve1 = [[xvals[idx], yvals1[idx]] for idx in range(len(xvals))] curve2 = [[xvals[idx], yvals2[idx]] for idx in range(len(xvals))] print curve1 print curve2 simpleplot.plot_lines("The running times of closest-pair-find functions", 800, 600, "the number of initial clusters", "the running time of the function in seconds", [curve1, curve2], True, ["slow_closest_pair", "fast_closest_pair"])
def q10_legend(DATA_URL): data_table = load_data_table(DATA_URL) singleton_list = [] hierarchical_cluster_list = [] for line in data_table: singleton_list.append( alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4])) hierarchical_cluster_list.append( alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4])) xvals = [] yvals1 = [] yvals2 = [] for num_clusters in range(20, 5, -1): xvals.append(num_clusters) hierarchical_cluster_list = alg_project3_solution.hierarchical_clustering( hierarchical_cluster_list, num_clusters) yvals1.append(compute_distortion(hierarchical_cluster_list, data_table)) yvals2.append( compute_distortion( alg_project3_solution.kmeans_clustering( singleton_list, num_clusters, 5), data_table)) curve1 = [[xvals[idx], yvals1[idx]] for idx in range(len(xvals))] curve2 = [[xvals[idx], yvals2[idx]] for idx in range(len(xvals))] simpleplot.plot_lines( "The distortion of output clusters uesd " + str(len(data_table)) + "-county data set", 800, 600, "the number of output clusters", "the distortion associated with each output clustering", [curve1, curve2], True, ["hierarchical cluster", "kmeans cluster"])
def plot_performance(plot_length, plot_type): """ Build list that estimates running of physics update for ball_list """ simulation = Simulation() plot = [] for index in range(10, plot_length): # add a ball to ball_list while simulation.num_balls() != index: simulation.add_ball([ random.randrange(CANVAS_WIDTH), random.randrange(CANVAS_HEIGHT) ]) # run update for all balls, num_updates times start_time = time.time() simulation.update() estimated_time = (time.time() - start_time) / float(NUM_UPDATES) if plot_type == TIME_PLOT: plot.append([index, estimated_time]) else: plot.append([index, estimated_time / (index)]) if plot_type == TIME_PLOT: simpleplot.plot_lines("Running time for linear update", 400, 400, "# balls", "time to update", [plot]) else: simpleplot.plot_lines("Comparison of running time to linear function", 400, 400, "# balls", "ratio", [plot])
def run_simulations(): """ Run simulations for several possible bribe increments Do some manual experimentation to locate an expression in d that grows at a similar rate to total salary earned when bribe_cost_increment == 0. Compare the growth rates of the expressions below to the growth rate of total salary earned using the plotting technique described in the Math notes. Which expression grows at approximately the same rate as total salary earned? e**0.095d or e**9.5d or 9.5*d**4 or 95*d**2 Answer: 9.5*d**4 Find prove for question 8: https://class.coursera.org/principlescomputing1-004/forum/thread?thread_id=537 """ plot_type = LOGLOG days = 120 inc_1000 = greedy_boss(days, 0, plot_type) inc_fx = fx(days, plot_type) simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", [inc_1000, inc_fx], False, [ "Bribe increment = 1000", "Fx Q8 Simulation", ])
def plot_performance(plot_length, plot_type): """ Build list that estimates running of physics update for ball_list """ simulation = Simulation() plot = [] for index in range(10, plot_length): # add a ball to ball_list while simulation.num_balls() != index: simulation.add_ball([random.randrange(CANVAS_WIDTH), random.randrange(CANVAS_HEIGHT)]) # run update for all balls, num_updates times start_time = time.time() simulation.update() estimated_time = (time.time() - start_time) / float(NUM_UPDATES) if plot_type == TIME_PLOT: plot.append([index, estimated_time]) else: plot.append([index, estimated_time / (index)]) if plot_type == TIME_PLOT: simpleplot.plot_lines("Running time for linear update", 400, 400, "# balls", "time to update", [plot]) else: simpleplot.plot_lines("Comparison of running time to linear function", 400, 400, "# balls", "ratio", [plot])
def analyze_running_time(): fast_target_order_list = [] targeted_order_list = [] xvals = [] m = 5 for n in range(10, 1000, 10): upa_graph = make_upa_graph(n, m) xvals.append(n) time1 = time.time() fast_target_order(upa_graph) time2 = time.time() fast_target_order_list.append(time2 - time1) time1 = time.time() targeted_order(upa_graph) time2 = time.time() targeted_order_list.append(time2 - time1) curve1 = [[xvals[idx], fast_target_order_list[idx]] for idx in range(len(xvals))] curve2 = [[xvals[idx], targeted_order_list[idx]] for idx in range(len(xvals))] simpleplot.plot_lines("CodeSkulptor running times ", 800, 600, "the number of nodes", "running time", [curve1, curve2], False, ["fast_target_order", "targeted_order"])
def run_simulations(): """ Run simulations for several possible bribe increments """ plot_type = LOGLOG days = 120 inc_0 = greedy_boss(days, 0, plot_type) graph_1 = [] graph_2 = [] graph_3 = [] graph_4 = [] for point in inc_0: d = math.exp(point[0]) graph_1.append((point[0], math.log(math.exp(0.095 * d)))) #graph_2.append((point[0], math.log(95 * d * d))) #graph_3.append((point[0], math.log(math.exp(9.5 * d)))) #graph_4.append((point[0], math.log(9.5 * d * d * d *d))) #inc_500 = greedy_boss(days, 500, plot_type) #inc_1000 = greedy_boss(days, 1000, plot_type) #inc_2000 = greedy_boss(days, 2000, plot_type) # simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", # [inc_0, inc_500, inc_1000, inc_2000], False, # ["Bribe increment = 0", "Bribe increment = 500", # "Bribe increment = 1000", "Bribe increment = 2000"] # ) simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", [inc_0, graph_1], False, ["Bribe increment = 0", "graph_1"] ) x1 = -1 y1 = -1
def target_attack_legend(): """ Plot three curves with legends """ network_ugraph = load_graph(NETWORK_URL) num_network_nodes = len(network_ugraph) num_network_edges = sum(map(len, network_ugraph.values())) / 2 max_network_edges = num_network_nodes * (num_network_nodes - 1) / 2 prop = num_network_edges * 1.0 / max_network_edges er_graph = make_er_graph(num_network_nodes, prop) upa_graph = make_upa_graph(num_network_nodes, 2) yvals1 = target_attack(network_ugraph) yvals2 = target_attack(er_graph) yvals3 = target_attack(upa_graph) xvals = range(max(len(yvals1), len(yvals2), len(yvals3))) curve1 = [[xvals[idx], yvals1[idx]] for idx in range(len(yvals1))] curve2 = [[xvals[idx], yvals2[idx]] for idx in range(len(yvals2))] curve3 = [[xvals[idx], yvals3[idx]] for idx in range(len(yvals3))] simpleplot.plot_lines("Resilience of graphs under targeted attack", 800, 600, "the number of nodes removed", "the size of the largest connect component", [curve1, curve2, curve3], False, [ "network_ugraph", "er_graph (p = " + str(prop) + ")", "upa_graph (m = 2)" ])
def init(): # type: () -> None """Init list of shapes, corresponding to the current step.""" global FPS # pylint: disable=global-statement global FREEZED # pylint: disable=global-statement global NB_SHAPES # pylint: disable=global-statement global NB_FRAMES_DRAWED # pylint: disable=global-statement global NB_SECONDS # pylint: disable=global-statement global SHAPES # pylint: disable=global-statement global TO_NEXT_STEP # pylint: disable=global-statement if len(LIST_NB_SHAPES) == 0: TIMER.stop() final_result = dict_to_ordered_list(RESULTS) print('Results: {' + ', ' .join(['%d: %d' % result for result in final_result]) + '}') try: FRAME.stop() except Exception as e: # pylint: disable=broad-except # To avoid failed when run with simpleguitk print('FRAME.stop():' + str(e)) if PLOT: try: simpleplot.plot_lines('Stress Balls', 800, 650, '# balls', 'FPS', (final_result, ), True) if SIMPLEGUICS2PYGAME: simpleplot._block() # pylint: disable=protected-access except Exception as e: # pylint: disable=broad-except # To avoid fail if no simpleplot print('simpleplot.plot_lines():' + str(e)) flush() return if LIST_NB_SHAPES: NB_SHAPES = LIST_NB_SHAPES.pop(0) assert isinstance(NB_SHAPES, int) FPS = 0 FREEZED = False NB_FRAMES_DRAWED = 0 NB_SECONDS = 0 TO_NEXT_STEP = False SHAPES = tuple([Shape((47 + n % (WIDTH - 100), 47 + n % (HEIGHT - 100)), # position 19 + n % 11, # radius n_to_rgba((n + 1) % len(RGB_COLORS), .2 + float(n % 13) / 15), # color of border # noqa n_to_rgba((n + 2) % len(RGB_COLORS), .2 + float((n + 3) % 14) / 17), # fill color # noqa (3 + n % 7, 2 + n % 5), # velocity (n + 2) % 6) # shape for n in range(NB_SHAPES)])
def make_plot(fun1, fun2, plot_length): """ Create a plot relating the growth of fun1 vs. fun2 """ answer = [] for index in range(10, plot_length): answer.append([index, fun1(index) / float(fun2(index))]) simpleplot.plot_lines("Growth rate comparison", 300, 300, "n", "f(n)/g(n)", [answer])
def test(): """ Testing code for resources_vs_time """ ## q10, q11 data1 = resources_vs_time(-1, 45) data2 = resources_vs_time(1.0, 100) simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2])
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(0.5, 20) data2 = resources_vs_time(1.5, 10) print data1 print data2 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2])
def make_plot(fun1, fun2, plot_length): points = [] fun1_points = [(x, fun1(x)) for x in range(1, plot_length)] fun2_points = [(x, fun2(x)) for x in range(1, plot_length)] for x in range(1, plot_length): points.append((x, float(fun1(x)) / fun2(x))) simpleplot.plot_lines("Growth rate comparison", 400, 600, "x", "f(x) / g(x)", [points, fun1_points, fun2_points], True, ["f(x) / g(x)", "f(x)", "g(x)"])
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(1, 60) print data1 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1])
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(0.0, 50) data2 = resources_vs_time(1.0, 10) data3 = resources_vs_time(2.0, 10) data4 = resources_vs_time(0.5, 10) print data1 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1])
def test2(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(1.0, 50) data2 = resources_vs_time2(0.15, 100) print(data1) print(data2) simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2])
def plot_pred_prey(populations, pred_name, prey_name): """ This function plots the prey populations (x-axis) vs. the predator populations (y-axis). """ newlist = [] for item in populations: newlist.append((item[1], item[2])) simpleplot.plot_lines('Populations', 400, 400, prey_name, pred_name, [newlist])
def plot_example(length): global counter poly_func = [] fib_func = [] for iter in range(length): counter = 0 poly_func.append([iter, 2 * iter - 1]) answer = memoized_fib(iter, {0 : 0, 1 : 1}) fib_func.append([iter, counter]) simpleplot.plot_lines("Recurrence solutions", 600, 600, "number", "value", [poly_func, fib_func], legends = ["Ideal. Plot", "Fib plot"])
def plot_example(length): """ Plot computed solutions to recurrences """ rec_plot = [] sol_plot = [] sol = SOL_DICT[INDEX] for num in range(2, length): rec_plot.append([num, recur(num)]) sol_plot.append([num, sol(num)]) simpleplot.plot_lines("Recurrence solutions", 600, 600, "number", "value", [rec_plot, sol_plot], False, ["rec_plot", "sol_plot"])
def run_strategy(strategy_name, time, strategy): """ Run a simulation for the given time with one strategy. """ state = simulate_clicker(provided.BuildInfo(), time, strategy) print "\n", strategy_name, ":\n", state # Plot total cookies over time history = state.get_history() history = [(item[0], item[3]) for item in history] simpleplot.plot_lines(strategy_name, 1000, 400, "Time", "Total Cookies", [history], True)
def init(): global balls global fps global freezed global nb_balls global nb_frames_drawed global nb_seconds global results global to_next_step if len(list_nb_balls) == 0: timer.stop() results = dict_to_ordered_list(results) print('Results: {' + ', '.join(['%d: %d' % result for result in results]) + '}') try: frame.stop() except Exception as e: # to avoid simpleguitk failed print('frame.stop():' + str(e)) try: simpleplot.plot_lines('Stress Balls', 800, 650, '# balls', 'FPS', (results, ), True) if SIMPLEGUICS2PYGAME: simpleplot._block() except Exception as e: # to avoid fail if no simpleplot print('simpleplot.plot_lines():' + str(e)) return if list_nb_balls: nb_balls = list_nb_balls.pop(0) fps = 0 freezed = False nb_frames_drawed = 0 nb_seconds = 0 to_next_step = False balls = tuple([ Ball( [47 + n % (WIDTH - 100), 47 + n % (HEIGHT - 100)], # position 19 + n % 11, # radius n_to_rgba((n + 1) % len(RGB_COLORS), .2 + float(n % 13) / 15), # color of border n_to_rgba((n + 2) % len(RGB_COLORS), .2 + float( (n + 3) % 14) / 17), # fill color [3 + n % 7, 2 + n % 5], # velocity (n + 2) % 6) # shape for n in range(nb_balls) ])
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(0.0, 50) data2 = resources_vs_time(0.5, 40) data3 = resources_vs_time(1.0, 30) data4 = resources_vs_time(2.0, 20) # print data1 # print data2 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2, data3, data4])
def plot_example(length): """ Plot computed solutions to recurrences """ rec_plot = [] sol_plot = [] sol = SOL_DICT[INDEX] for num in range(2, length): rec_plot.append([num, recur(num)]) sol_plot.append([num, sol(num)]) simpleplot.plot_lines("Recurrence solutions", 600, 600, "number", "value", [rec_plot, sol_plot], legends = ["Approx. Plot", "Ideal plot"])
def run_strategy(strategy_name, time, strategy): """ Run a simulation for the given time with one strategy. """ state = simulate_clicker(provided.BuildInfo(), time, strategy) print strategy_name, ":", state # Plot total cookies over time history = state.get_history() history_item0_item3 = [(item[0], item[3]) for item in history] simpleplot.plot_lines(strategy_name, 1000, 400, 'Time', 'Total Cookies', [history_item0_item3], True)
def test(): """ Testing code for resources_vs_time """ loop = 20 data1 = resources_vs_time(1.0, loop) #data2 = resources_vs_time(0.5, loop) #data3 = resources_vs_time(1.0, loop) #data4 = resources_vs_time(2.0, loop) print data1 #print data2 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1])
def init(): global balls global fps global freezed global nb_balls global nb_frames_drawed global nb_seconds global results global to_next_step if len(list_nb_balls) == 0: timer.stop() results = dict_to_ordered_list(results) print('Results: {' + ', ' .join(['%d: %d' % result for result in results]) + '}') try: frame.stop() except Exception as e: # to avoid simpleguitk failed print('frame.stop():' + str(e)) try: simpleplot.plot_lines('Stress Balls', 800, 650, '# balls', 'FPS', (results, ), True) if SIMPLEGUICS2PYGAME: simpleplot._block() except Exception as e: # to avoid fail if no simpleplot print('simpleplot.plot_lines():' + str(e)) return if list_nb_balls: nb_balls = list_nb_balls.pop(0) fps = 0 freezed = False nb_frames_drawed = 0 nb_seconds = 0 to_next_step = False balls = tuple([Ball([47 + n % (WIDTH - 100), 47 + n % (HEIGHT - 100)], # position 19 + n % 11, # radius n_to_rgba((n + 1) % len(RGB_COLORS), .2 + float(n % 13)/15), # color of border n_to_rgba((n + 2) % len(RGB_COLORS), .2 + float((n + 3) % 14)/17), # fill color [3 + n % 7, 2 + n % 5], # velocity (n + 2) % 6) # shape for n in range(nb_balls)])
def run_simulations(): """ Run simulations for several possible bribe increments """ plot_type = LOGLOG days = 150 inc_0 = greedy_boss(days, 0, plot_type) inc_500 = greedy_boss(days, 500, plot_type) inc_1000 = greedy_boss(days, 1000, plot_type) inc_2000 = greedy_boss(days, 2000, plot_type) simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", [inc_0], False, ["Bribe increment = 0"])
def plot_time_populations(populations, pred_name, prey_name): """ This function plots the predator and prey populations vs. elapsed time. """ pred_pops = [] prey_pops = [] for elapsedtime, preypop, predpop in populations: pred_pops.append((elapsedtime, predpop)) prey_pops.append((elapsedtime, preypop)) simpleplot.plot_lines('Populations', 400, 300, 'year', 'populations', [pred_pops, prey_pops], True, [pred_name, prey_name])
def run(): """ Run the simulator. """ cursor_broken = run_strategy("Cursor", SIM_TIME, strategy_cursor_broken) cheap = run_strategy("Cheap", SIM_TIME, strategy_cheap) expensive = run_strategy("Expensive", SIM_TIME, strategy_expensive) best = run_strategy("Best", SIM_TIME, strategy_best) simpleplot.plot_lines("Comparison of strategies", 1000, 400, 'Time', 'Total Cookies', [cursor_broken, cheap, expensive, best], True, ["cursor_broken", "cheap", "expensive", "best"])
def run_simulations(): """ Run simulations for several possible bribe increments """ plot_type = STANDARD days = 80 inc_0 = greedy_boss(days, 0, plot_type) #inc_500 = greedy_boss(days, 500, plot_type) #inc_1000 = greedy_boss(days, 1000, plot_type) #inc_2000 = greedy_boss(days, 2000, plot_type) simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", [inc_0], False, ["Bribe increment = 0"])
def run_strategy(strategy_name, time, strategy): """ Runs a simulation for the given time with the given strategy. Prints final strategy statistics to the console and graphs the time versus total cookies. """ state = simulate_clicker(provided.BuildInfo(), time, strategy) print strategy_name, " Strategy:", state # Plot total cookies over time history = state.get_history() history = [(item[0], item[3]) for item in history] simpleplot.plot_lines(strategy_name, 1000, 400, 'Time', 'Total Cookies', [ history], True)
def run_strategy(strategy_name, time, strategy): """ Run a simulation for the given time with one strategy. """ state = simulate_clicker(provided.BuildInfo(), time, strategy) print strategy_name, ":", state # Plot total cookies over time # Uncomment out the lines below to see a plot of total cookies vs. time # Be sure to allow popups, if you do want to see it history = state.get_history() history = [(item[0], item[3]) for item in history] simpleplot.plot_lines(strategy_name, 1000, 400, 'Time', 'Total Cookies', [history], True)
def run_example(): """ Load a data table, compute a list of clusters and plot a list of clusters Set DESKTOP = True/False to use either matplotlib or simplegui """ data_table = load_data_table(DATA_896_URL) singleton_list = [] for line in data_table: singleton_list.append( alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4])) #cluster_list = sequential_clustering(singleton_list, 15) #print "Displaying", len(cluster_list), "sequential clusters" #cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, 16) #print "Displaying", len(cluster_list), "hierarchical clusters" #cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, 16, 5) #print "Displaying", len(cluster_list), "k-means clusters" kmeans = [] for clusters_number in xrange(6, 21): cluster_list = alg_project3_solution.kmeans_clustering( singleton_list, clusters_number, 5) kmeans.append([ clusters_number, 0.0 + alg_project3_solution.compute_distortion(cluster_list, data_table) ]) #cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, 20) #hierarchical = [[20, alg_project3_solution.compute_distortion(cluster_list, data_table)]] hierarchical = [] for clusters_number in xrange(20, 5, -1): cluster_list = alg_project3_solution.hierarchical_clustering( singleton_list, clusters_number) hierarchical.append([ clusters_number, 0.0 + alg_project3_solution.compute_distortion(cluster_list, data_table) ]) hierarchical.reverse() #print hierarchical[10], kmeans[10] simpleplot.plot_lines( "Distortion of the clusterings produced by hierarchical and k-means metods on 896 county data set", 800, 600, "Number of clusters n [6 .. 20]", "Distortion", [hierarchical, kmeans], False, ["Hierarchical clustering", "k-means clustering with 5 iterations"])
def run(): """ Run the simulator. """ # run_strategy("Cursor", SIM_TIME, strategy_cursor_broken) # Add calls to run_strategy to run additional strategies plots = [] plots.append(run_strategy("Cheap", 600, strategy_cheap)) plots.append(run_strategy("Expensive", 600, strategy_expensive)) plots.append(run_strategy("Best", 600, strategy_best)) simpleplot.plot_lines("Growth rate", 1000, 400, 'Time', 'Total Cookies', plots, True, ["Cheap", "Expensive", "Best"]) return plots
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(0.5, 20) data2 = resources_vs_time(1.5, 10) data3 = resources_vs_time(0.0, 10) data4 = resources_vs_time(1.0, 10) print(data1) print(data2) print(data3) print(data4) simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2, data3, data4])
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(0.5, 20, STANDARD) data2 = resources_vs_time(1.5, 10, STANDARD) #print data1 #print data2 #test1 = [[1.0, 1], [1.75, 2.5], [2.41666666667, 4.5], [3.04166666667, 7.0], [3.64166666667, 10.0], [4.225, 13.5], [4.79642857143, 17.5], [5.35892857143, 22.0], [5.91448412698, 27.0], [6.46448412698, 32.5], [7.00993867244, 38.5], [7.55160533911, 45.0], [8.09006687757, 52.0], [8.62578116328, 59.5], [9.15911449661, 67.5], [9.69036449661, 76.0], [10.2197762613, 85.0], [10.7475540391, 94.5], [11.2738698286, 104.5], [11.7988698286, 115.0]] #test2 = [[1.0, 1], [2.25, 3.5], [3.58333333333, 7.5], [4.95833333333, 13.0], [6.35833333333, 20.0], [7.775, 28.5], [9.20357142857, 38.5], [10.6410714286, 50.0], [12.085515873, 63.0], [13.535515873, 77.5]] print "\n############### Question 1 ##################" question1_a = resources_vs_time(0.0, 10, STANDARD) question1_b = resources_vs_time(1.0, 10, STANDARD) #print question1_a print question1_b #simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2]) #simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [test1, test2]) print "\n############### Question 2 ##################" question2_a = resources_vs_time(0.0, 100, STANDARD) question2_b = resources_vs_time(0.5, 18, STANDARD) question2_c = resources_vs_time(1.0, 14, STANDARD) question2_d = resources_vs_time(2.0, 10, STANDARD) #print question2_a #print question2_b #print question2_c #print question2_d simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [question2_a, question2_b, question2_c, question2_d]) print "\n############### Question 3 ##################" question3 = resources_vs_time(0.0, 10, LOGLOG) #print question3 #simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [question3]) print "\n############### Question 7 ##################" question7 = resources_vs_time(1.0, 10, LOGLOG) print question7 #simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [question1_b]) print "\n############### Question 9 ##################" question9a = resources_vs_time(1.0, 10, STANDARD) question9b = resources_vs_time(1.0, 20, STANDARD) print question9a print question9b
def plot(diagraph): """ plot a diagraph """ values = diagraph.values() summ = float(sum(values)) logdiag = dict() for key,value in diagraph.items(): if key != 0: key = math.log(key) value = math.log(value / summ) logdiag[key] = value simpleplot.plot_lines('A normalized distribution on a log/log scale', 400, 300, 'In degrees', 'Number of Nodes', [logdiag], True)
def run_simulations(): """ Run simulations for several possible bribe increments """ plot_type = LOGLOG # we choose the logarithmic plot days = 70 inc_0 = greedy_boss(days, 0, plot_type) inc_500 = greedy_boss(days, 500, plot_type) inc_1000 = greedy_boss(days, 1000, plot_type) inc_2000 = greedy_boss(days, 2000, plot_type) simpleplot.plot_lines( "Greedy boss", 600, 600, "days", "total earnings", [inc_0, inc_500, inc_1000, inc_2000], False, [ "Bribe increment = 0", "Bribe increment = 500", "Bribe increment = 1000", "Bribe increment = 2000" ]) simpleplot._block()
def test(): """ Testing code for resources_vs_time """ #data1 = resources_vs_time(0.5, 20) #data2 = resources_vs_time(1.5, 10) data1 = resources_vs_time(1.0, 60) data2 = rvt(1.0, 60) #data3 = resources_vs_time(1.0, 10) #data4 = resources_vs_time(2.0, 5) print data1 #print data2 #print data3 #print data4 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2])
def test(): """ Testing code for resources_vs_time """ data1 = resources_vs_time(0.0, 10) data2 = resources_vs_time(0.5, 10) data3 = resources_vs_time(1.0, 10) data4 = resources_vs_time(2.0, 10) data5 = cookie_clicker(10) print data1 print data2 print data3 print data4 print data5 simpleplot.plot_lines("Growth", 600, 600, "time", "total resources", [data1, data2, data3, data4, data5])
def plot_example(length): global counter poly_func = [] fib_func = [] for iter in range(length): counter = 0 poly_func.append([iter, 2 * iter - 1]) answer = memoized_fib(iter, {0: 0, 1: 1}) fib_func.append([iter, counter]) simpleplot.plot_lines("Recurrence solutions", 600, 600, "number", "value", [poly_func, fib_func], legends=["Ideal. Plot", "Fib plot"])
def plot_fairness(side, num_sides, max_trials): """ Plot the mathematical probability for an outcome vs. computed estimate """ plot = [] for num_trials in range(TRIAL_STRIDE, max_trials, TRIAL_STRIDE): side_count = 0 for _ in range(num_trials): if roll_die(num_sides) == side: side_count += 1 mathematical = 1.0 / num_sides computed = float(side_count) / num_trials plot.append([num_trials, mathematical - computed]) simpleplot.plot_lines("Fairness test", 400, 300, "number of rolls", "mathematical - computed", [plot], False, ["plot"])
def create_plots_2(begin, end, stride): x_coords = [] current_x = begin while current_x < end: x_coords.append(current_x) current_x += stride func1_plot = [(x, func1(x)) for x in x_coords] func2_plot = [(x, func2(x)) for x in x_coords] func3_plot = [(x, func3(x)) for x in x_coords] func4_plot = [(x, func4(x)) for x in x_coords] # plot the list of points simpleplot.plot_lines("Plots of four functions", 600, 400, "x", "f(x)", [func1_plot, func2_plot, func3_plot, func4_plot], True, ["1", "2", "3", "4"])
def plot_fairness(side, num_sides, max_trials): """ Plot the mathematical probability for an outcome vs. computed estimate """ plot = [] for num_trials in range(TRIAL_STRIDE, max_trials, TRIAL_STRIDE): side_count = 0 for _ in range(num_trials): if roll_die(num_sides) == side: side_count += 1 mathematical = 1.0 / num_sides computed = float(side_count) / num_trials plot.append([num_trials, mathematical - computed]) simpleplot.plot_lines("Fairness test", 400, 300, "number of rolls", "mathematical - computed", [plot])
def run_simulations(): """ Run simulations for several possible bribe increments """ plot_type = LOGLOG days = 70 inc_0 = greedy_boss(days, 0, plot_type) #inc_500 = greedy_boss(days, 500, plot_type) inc_1000 = greedy_boss(days, 1000, plot_type) print inc_1000 #inc_2000 = greedy_boss(days, 2000, plot_type) #simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", # [inc_0, inc_500, inc_1000, inc_2000], False, # ["Bribe increment = 0", "Bribe increment = 500", # "Bribe increment = 1000", "Bribe increment = 2000"]) simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", [ inc_1000], False, ["Bribe increment = 1000"])
def run_strategy(strategy_name, time, strategy): """ Run a simulation with one strategy """ state = simulate_clicker(provided.BuildInfo(), time, strategy) print strategy_name, ":", state # Plot total cookies over time # Uncomment out the lines below to see a plot of total cookies vs. time # Be sure to allow popups, if you do want to see it history = state.get_history() history = [(item[0], item[3]) for item in history] #"undefined: TypeError: Cannot read property 'document' of undefined" #That error is Chrome blocking the pop-up window for simpleplot. Click the #red X in the right portion of the URL bar to unblock. simpleplot.plot_lines(strategy_name, 1000, 400, 'Time', 'Total Cookies', [history], True)
def run_example(): """ Load a data table, compute a list of clusters and plot a list of clusters Set DESKTOP = True/False to use either matplotlib or simplegui """ data_table = load_data_table(DATA_896_URL) singleton_list = [] for line in data_table: singleton_list.append(alg_cluster.Cluster(set([line[0]]), line[1], line[2], line[3], line[4])) #cluster_list = sequential_clustering(singleton_list, 15) #print "Displaying", len(cluster_list), "sequential clusters" #cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, 16) #print "Displaying", len(cluster_list), "hierarchical clusters" #cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, 16, 5) #print "Displaying", len(cluster_list), "k-means clusters" kmeans = [] for clusters_number in xrange(6, 21): cluster_list = alg_project3_solution.kmeans_clustering(singleton_list, clusters_number, 5) kmeans.append([clusters_number, 0.0 + alg_project3_solution.compute_distortion(cluster_list, data_table)]) #cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, 20) #hierarchical = [[20, alg_project3_solution.compute_distortion(cluster_list, data_table)]] hierarchical = [] for clusters_number in xrange(20, 5, -1): cluster_list = alg_project3_solution.hierarchical_clustering(singleton_list, clusters_number) hierarchical.append([clusters_number, 0.0 + alg_project3_solution.compute_distortion(cluster_list, data_table)]) hierarchical.reverse() #print hierarchical[10], kmeans[10] simpleplot.plot_lines("Distortion of the clusterings produced by hierarchical and k-means metods on 896 county data set", 800, 600, "Number of clusters n [6 .. 20]", "Distortion", [hierarchical, kmeans], False, ["Hierarchical clustering", "k-means clustering with 5 iterations"])
def run_simulations(): """ Run simulations for several possible bribe increments """ plot_type = LOGLOG days = 150 inc_0 = greedy_boss(days, 0, plot_type) inc_500 = greedy_boss(days, 500, plot_type) inc_1000 = greedy_boss(days, 1000, plot_type) inc_2000 = greedy_boss(days, 2000, plot_type) d1 = [(math.log(day), math.log(95*math.pow(day, 2))) for day in range(days)] d2 = [(math.log(day), math.log(math.exp(0.095*day))) for day in range(days)] d3 = [(math.log(day), math.log(math.exp(9.5*day))) for day in range(days)] d4 = [(math.log(day), math.log(9.5*math.pow(day, 4))) for day in range(days)] simpleplot.plot_lines("Greedy boss", 600, 600, "days", "total earnings", #[inc_0, inc_500, inc_1000, inc_2000], False, #[inc_1000], False, [inc_0, d1, d2, d4], False, ["Bribe increment = 0", "Bribe increment = 500", "Bribe increment = 1000", "Bribe increment = 2000"])
def build_plot(plot_size, plot_function, plot_type = STANDARD): """ Build plot of the number of increments in mystery function """ global counter plot = [] for input_val in range(2, plot_size): counter = 0 plot_function(input_val) if plot_type == STANDARD: plot.append([input_val, counter]) else: plot.append([math.log(input_val), math.log(counter)]) return plot ############################################### # plottting code plot_type = STANDARD plot_size = 40 # Pass name of mystery function in as a parameter plot1 = build_plot(plot_size, mystery1, plot_type) plot2 = build_plot(plot_size, mystery2, plot_type) plot3 = build_plot(plot_size, mystery3, plot_type) simpleplot.plot_lines("Iteration counts", 600, 600, "input", "counter", [plot1, plot2, plot3])
r = [] for nb in nb_balls: r.append((nb, data[nb])) datas.append(r) # Display print('|'.join(['%4d' % nb for nb in alls_nb]) + '|Environment') print('----+'*len(alls_nb) + '-----------') for legend in legends: l = [] for nb in alls_nb: fps = all_results[legend].get(nb, None) l.append(('%4d' % fps if fps is not None else ' '*4)) print('|'.join(l) + '|' + legend) # Graph try: simpleplot.plot_lines('Stress Balls', 800, 650, '# balls', 'FPS', datas, True, legends) if SIMPLEGUICS2PYGAME: simpleplot._block() except Exception as e: # to avoid fail if no simpleplot print('!simpleplot.plot_lines():' + str(e))
else: PYTHON_VERSION = 'CodeSkulptor' # http://www.codeskulptor.org/ MATPLOTLIB_VERSION = '' datalist = [(1, 2), (2, 3), (5, 4), (8, 3), (9, 2)] dataset = {1: 3, 2: 4, 5: 5, 8: 4, 9: 3} filename = None if SIMPLEGUICS2PYGAME: from sys import argv if len(argv) == 2: filename = argv[1] simpleplot.plot_lines('Test plot_lines 1', 400, 400, 'x', 'y', (datalist, dataset)) if filename is None: simpleplot.plot_lines('Test plot_lines 2', 400, 400, 'x', 'y', (datalist, dataset), True, ('datalist', 'dataset')) else: simpleplot.plot_lines('Test plot_lines 2', 400, 400, 'x', 'y', (datalist, dataset), True, ('datalist', 'dataset'), _filename=filename) if SIMPLEGUICS2PYGAME and (len(argv) != 2): simpleplot._block()