def generate_all_data_two_param(agents_quantities, dic_fun, p_v=None, q_v=None): """ Generates data for all agents_quantities in the current as .csv files Args: agents_quantities (list of ints): list of population sized to be used dic_fun (dict): dictionary population size to list of rational functions p_v (float/None): value of the first parameter - p q_v (float/None): value of the second parameter - q """ # create distribution data, by Tanja, 14.1.2019 # edited, by xhajnal, 18.1.2019, still name 'a' is not defined # edited, by xhajnal, 26.1.2019, a set as [] but does not work # totally rewritten to not paste empty line, doc added, by xhajnal, 03.02.2019 import random if p_v is None: p_v = random.uniform(0., 1.) p_v = round(p_v, 2) if q_v is None: q_v = random.uniform(0., 1.) q_v = round(q_v, 2) a = [] # create the files called "data_n=N.csv" where the first line is # "n=5, p_v--q1_v--q2_v--q3_v--q4_v in the multiparam. case, and, e.g. # 0.03 -- 0.45 -- 0.002 -- 0.3 (for N=5, there are 4 entries) for N in agents_quantities: file = open('data_n=' + str(N) + ".csv", "w") file.write('n=' + str(N) + ', p_v=' + str(p_v) + ', q_v=' + str(q_v) + "\n") second_line = "" for polynome in dic_fun[N]: parameters = set() if len(parameters) < N: parameters.update(find_param(polynome)) parameters = sorted(list(parameters)) parameter_value = [p_v, q_v] for param in range(len(parameters)): a.append(parameter_value[param]) globals()[parameters[param]] = parameter_value[param] x = eval(polynome) x = round(x, 2) second_line = second_line + str(x) + "," file.write(second_line[:-1]) file.close()
def eval_and_show(functions, parameter_value, parameters=False, data=False, data_intervals=False, cumulative=False, debug: bool = False, where=False): """ Creates bar plot of evaluation of given functions for given point in parameter space Args: functions (list of strings): list of rational functions parameter_value: (list of floats) array of param values parameters (list of strings): parameter names (used for faster eval) data (list): Data comparison next to respective function data_intervals (list): intervals obtained from the data to check if the function are within the intervals cumulative (bool): if True cdf instead of pdf is visualised debug (bool): if debug extensive output is provided where (tuple/list): output matplotlib sources to output created figure """ ## Convert z3 functions for index, function in enumerate(functions): if is_this_z3_function(function): functions[index] = translate_z3_function(function) if not parameters: parameters = set() for polynome in functions: parameters.update(find_param(polynome, debug)) parameters = sorted(list(parameters)) if debug: print("Parameters: ", parameters) title = "Rational functions sampling \n parameter values:" values = [] add = 0 for param in range(len(parameters)): if debug: print("Parameters[param]", parameters[param]) print("Parameter_value[param]", parameter_value[param]) globals()[parameters[param]] = parameter_value[param] title = "{} {}={},".format(title, parameters[param], parameter_value[param]) title = title[:-1] title = f"{title}\n values: " for polynome in functions: expression = eval(polynome) if debug: print(polynome) print("Eval ", polynome, expression) if cumulative: ## Add sum of all values add = add + expression values.append(add) title = f"{title} {add} , " del expression else: values.append(expression) title = f"{title} {expression} ," title = title[:-2] if data: title = f"{title}\n Comparing with the data: \n{data}" if cumulative: for index in range(1, len(data)): data[index] = data[index] + data[index - 1] if where: fig = where[0] ax = where[1] plt.autoscale() ax.autoscale() else: fig, ax = plt.subplots() width = 0.2 ax.set_ylabel(f'{("Value", "Cumulative value")[cumulative]}') if data: ax.set_xlabel( 'Rational function indices (blue), Data point indices (red)') if data_intervals: functions_inside_of_intervals = [] for index in range(len(data)): if values[index] in data_intervals[index]: functions_inside_of_intervals.append(True) else: functions_inside_of_intervals.append(False) title = f"{title} \n Function value within the respective interval:\n {functions_inside_of_intervals} \n Intervals: {data_intervals}" else: ax.set_xlabel('Rational function indices') ax.xaxis.set_major_locator(MaxNLocator(integer=True)) if debug: print("title: \n", title) ax.set_title(wraper.fill(title)) if debug: print("Len(fun_list): ", len(functions)) print("values:", values) print("range:", range(1, len(values) + 1)) print("title", title) ax.bar(range(1, len(values) + 1), values, width, color='b') if data: ax.bar(list(map(lambda x: x + width, range(1, len(data) + 1))), data, width, color='r') if where: return fig, ax else: plt.show() return values
def visualise(dic_fun, agents_quantities, size_q, cumulative=False, debug: bool = False, show_all_in_one=False, where=False): """ Creates bar plot of probabilities of i successes for sampled parametrisation Args: dic_fun (dictionary N -> list of rational functions) size_q (int): sample size in each parameter agents_quantities (int): pop sizes to be used cumulative (bool): if True cdf instead of pdf is visualised debug (bool): if debug extensive output is provided show_all_in_one (bool): if True all plots are put into one window where (tuple/list): output matplotlib sources to output created figure """ for N in agents_quantities: parameters = set() for index, polynome in enumerate(dic_fun[N]): if is_this_z3_function(polynome): dic_fun[N][index] = translate_z3_function(polynome) if debug: print("Polynome: ", polynome) parameters.update(find_param(polynome, debug)) ## THIS THING IS WORKING ONLY FOR THE CASE STUDY # if len(parameters) < N: # parameters.update(find_param(polynome, debug)) if debug: print("Parameters: ", parameters) parameters = sorted(list(parameters)) if debug: print("Sorted parameters: ", parameters) parameter_values = get_param_values(parameters, size_q, debug) for parameter_value in parameter_values: if debug: print("Parameter_value: ", parameter_value) add = 0 a = [N, dic_fun[N].index(polynome)] if N == 0: title = f"Rational functions sampling \n parameters:" else: title = f"Rational functions sampling \n N={N}, parameters:" for param in range(len(parameters)): a.append(parameter_value[param]) if debug: print("Parameter[param]: ", parameters[param]) print("Parameter_value[param]: ", parameter_value[param]) globals()[parameters[param]] = parameter_value[param] title = "{} {}={},".format(title, parameters[param], parameter_value[param]) title = title[:-1] if debug: print("Eval ", polynome, eval(polynome)) for polynome in dic_fun[N]: value = eval(polynome) if cumulative: ## Add sum of all values add = add + value a.append(add) del value else: a.append(value) # print(a) fig, ax = plt.subplots() width = 0.2 ax.set_ylabel('Value') ax.set_xlabel('Rational function indices') ax.set_title(wraper.fill(title)) # print(title) rects1 = ax.bar(range(len(dic_fun[N])), a[len(parameters) + 2:], width, color='b') plt.show()
def heatmap(function, region, sampling_sizes, posttitle="", where=False, parameters=False): """ Creates 2D heatmap plot of sampled points of given function Args: function (string): function to be analysed region (list of intervals): boundaries of parameter space to be sampled sampling_sizes (int): tuple of sample size of respective parameter posttitle (string): A string to be put after the title where (tuple/list): output matplotlib sources to output created figure parameters (list):: list of parameters Example: heatmap("p+q",[[0,1],[3,4]],[5,5]) """ ## Convert z3 function if is_this_z3_function(function): function = translate_z3_function(function) if not parameters: parameters = sorted(list(find_param(function))) # print(parameters) if len(parameters) != 2: raise Exception( f"Number of parameters of given function is not equal to 2 but {len(parameters)}" ) arr = np.zeros((sampling_sizes[0] * sampling_sizes[1], 3)) # f = lambda locals()[parameters[0]),locals()[parameters[1]): fun ii = -1 jj = -1 for i in np.linspace(region[0][0], region[0][1], sampling_sizes[0], endpoint=True): ii += 1 # print("ii: ",ii) locals()[parameters[0]] = i for j in np.linspace(region[1][0], region[1][1], sampling_sizes[1], endpoint=True): jj += 1 # print("jj: ",jj) locals()[parameters[1]] = j arr[jj, 0] = round(i, 2) arr[jj, 1] = round(j, 2) arr[jj, 2] = eval(function) # print(arr) # d = pd.DataFrame(arr, columns=["p","q","E"]) heatmap_data = pd.DataFrame(arr, columns=[parameters[0], parameters[1], "E"]) # d = d.pivot("p", "q", "E") heatmap_data = heatmap_data.pivot(parameters[0], parameters[1], "E") if where: f, ax = plt.subplots() ax = sns.heatmap(heatmap_data) title = f"Heatmap \n{posttitle}" ax.set_title(wraper.fill(title)) ax.invert_yaxis() return f else: ax = sns.heatmap(heatmap_data) title = f"Heatmap of the parameter space \n function: {function}" ax.set_title(wraper.fill(title)) ax.invert_yaxis() plt.show()
def sample_list_funs(functions, size_q, parameters=False, intervals=False, silent: bool = False, debug: bool = False): """ Returns a list of function values for sampled parametrisations Args: functions: (list of functions) to be sampled size_q (int): sample size in each parameter parameters (list of strings): parameter names (used for faster eval) intervals (list of pairs of numbers): intervals of parameters silent (bool): if silent command line output is set to minimum debug (bool): if debug extensive output is provided Returns: (array): [function index, [parameter values], function value] """ arr = [] if debug: print("Inside of sample_n_visualise.sample_list_funs()") print("List_fun: ", functions) print("Intervals: ", intervals) for index, polynome in enumerate(functions): if is_this_z3_function(polynome): functions[index] = translate_z3_function(polynome) if debug: print("Polynome: ", polynome) if parameters: fun_parameters = parameters else: fun_parameters = set() fun_parameters.update(find_param(polynome, debug)) ## THIS THING IS WORKING ONLY FOR THE CASE STUDY # if len(parameters) < N: # parameters.update(find_param(polynome, debug)) if debug: print("Parameters: ", fun_parameters) fun_parameters = sorted(list(fun_parameters)) if debug: print("Sorted parameters: ", fun_parameters) parameter_values = get_param_values(fun_parameters, size_q, intervals=intervals, debug=debug) for parameter_value in parameter_values: if debug: print("Parameter_value: ", parameter_value) a = [functions.index(polynome)] for param_index in range(len(fun_parameters)): a.append(parameter_value[param_index]) if debug: print("Parameter[param]: ", fun_parameters[param_index]) print("Parameter_value[param]: ", parameter_value[param_index]) locals()[fun_parameters[param_index]] = float( parameter_value[param_index]) print("polynome", polynome) value = eval(polynome) if debug: print("Eval ", polynome, value) a.append(value) arr.append(a) return arr