print 'target_num %d, odd_cnt %d, even_cnt %d, 1 is not included'%(target_num, odd_prime_factors_cnt_comm, even_prime_factors_cnt_comm) if(factor_list_option == g_LIOUVI_FACTOR): assert( (odd_prime_factors_cnt_comm + even_prime_factors_cnt_comm + 1) == target_num) # for Liouvi, unless functions go to very huge number (>10^9), otherwise, it always have negative parity assert(odd_prime_factors_cnt_comm > even_prime_factors_cnt_comm) # liouvi breaks mert limitation, because it can goes to relative large negative value # but let's try to catch any special case verify_mert_conjecture(target_num, odd_prime_factors_cnt_comm, even_prime_factors_cnt_comm, factor_list_option) # if need to save if(mert_settings.g_log_save_option == g_LOG_YES): cnt_nodes, cnt_leaves = log_save_write_results_to_files(target_num, factor_list_option) if(factor_list_option == g_LIOUVI_FACTOR): assert( (cnt_nodes + cnt_leaves) == target_num) # output complete list in 2D output_option = 1 log_save_write_results_in_2d_tree(target_num, factor_list_option, output_option) # output only last number in 2D output_option = 2 log_save_write_results_in_2d_tree(target_num, factor_list_option, output_option) # name for picture file t_range_list = range(MAX_NUM_FACTORS) file_result_pic = 'outputs_mert\\mert_target_num_%d.png'%(target_num)
def mert_fun_sequences(max_num, factor_list_option, log_save_option): mert_settings.g_log_save_option = log_save_option detect_recursive_flag = False # the length of the follow list is same as the number the program will loop parity_1d =[] # 1d list odd_prime_factors_cnt_comm_1d =[] # 1d list even_prime_factors_cnt_comm_1d = [] # 1d list factors_his_2d = [] # 2D list, hold the list of lists, each list hold factors_histogram for a number. # which has the fix size. complete_list_list_3d =[] # each g_complete_list_list is 2D, a collect of them will be 3D # first 2 dimension is not fixed, length of last dimension is the number we will # loop one_number_list_2d = [] # each g_one_number_list is 1D, a collect of them will be 2D # first dimension is not fixed. It is same as the number of square free number < n. # The length of last dimension is the number we will loop binary_list_2d = [] # each g_binary_list is 1D, a collect of them will be 2D # first dimension is not fixed. It is same as the number of square free number < n. # The length of last dimension is the number we will loop # need 'max_num + 1' to include up to max_num range_list = range(2, max_num + 1) # Note, our calculation of mert_fun will NOT include mert(1) and mert(2) # so, we need to remember that our mert_func() starts from mert(3) for target_num in range_list: print '================ starting %d =============='%(target_num) # Have to reset some global data buffer before each run log_save_reset_global_data_buffer() # main result will be output of parity, factors_his, odd_prime_factors_cnt_comm, even_prime_factors_cnt_comm parity, factors_his, odd_prime_factors_cnt_comm, even_prime_factors_cnt_comm = mert_function(target_num, factor_list_option) # save data related to parity, number of odd prime factors, number of even prime factors. parity_1d.append(parity) odd_prime_factors_cnt_comm_1d.append(odd_prime_factors_cnt_comm) even_prime_factors_cnt_comm_1d.append(even_prime_factors_cnt_comm) # save factors_his to 2d list, so that we can compare them. factors_his_2d.append(factors_his) # If we turn on log option, above mert_function() stores tree structure in global data buffer, save them into file cnt_nodes, cnt_leaves = log_save_write_results_to_files(target_num, factor_list_option) # retrieve global data from buffer complete_list_list, one_number_list, binary_list = log_save_get_results(target_num) # Put those results in aggregated data structure complete_list_list_3d.append(complete_list_list) one_number_list_2d.append(one_number_list) binary_list_2d.append(binary_list) print 'Finish the loop for individual number mert calculation, starting to process aggregated data ' # factors_his_2d is written out as json file f_save_factors_his_2d_name = 'outputs_mert\\factors_his_2d_%d_option_%d.txt'%(max_num, factor_list_option) with open(f_save_factors_his_2d_name, 'w') as f: json.dump(factors_his_2d, f, indent=2) # parity_1d is written out as json file f_save_parity_1d_name = 'outputs_mert\\parity_1d_%d_option_%d.txt'%(max_num, factor_list_option) with open(f_save_parity_1d_name, 'w') as f: json.dump(parity_1d, f, indent=2) # complete_list_list_3d is written out as json file f_complete_list_list_3d_name = 'outputs_mert\\complete_list_list_3d_%d_option_%d.txt'%(max_num, factor_list_option) with open(f_complete_list_list_3d_name, 'w') as f: json.dump(complete_list_list_3d, f, indent=2) # one_number_list_2d is written out as json file f_one_number_list_2d_name = 'outputs_mert\\one_number_list_2d_%d_option_%d.txt'%(max_num, factor_list_option) with open(f_one_number_list_2d_name, 'w') as f: json.dump(one_number_list_2d, f, indent=2) # binary_list_2d is written out as json file f_binary_list_2d_name = 'outputs_mert\\binary_list_2d_%d_option_%d.txt'%(max_num, factor_list_option) with open(f_binary_list_2d_name, 'w') as f: json.dump(binary_list_2d, f, indent=2) if(detect_recursive_flag == True): # run detect recursive algorithm to see if we can find interesting recursive patterns print 'Run detect recursive algorithm' found_match_num_list, found_match_num_factor_len_list, num_of_match_found = mert_recursion_detect(binary_list_2d, max_num) file_result_pic = 'outputs_mert\\parity_1d_num_%d_option_%d.png'%(max_num, factor_list_option) title_str = 'num_%d_option_%d.png'%(max_num, factor_list_option) plot_parity_1d(parity_1d, range_list, file_result_pic, title_str, 'parity_his') print 'parity_1d (start from 2, skip 1): ', parity_1d # moving window to detect min and max # We found that if we choose moving_window 40, we will capture major min and max # if we choose smaller number, we will get some min and max maybe not important moving_window = 40 fixed_window_option = 1 len_parity_id = len(parity_1d) # try to detect min and max of mert_function if we have enough sample # plot min and max of mert_function if we have enough samples if (len_parity_id > moving_window*2): detect_and_plot_max_min(parity_1d, moving_window, max_num, factor_list_option, fixed_window_option) file_result_pic = 'outputs_mert\\factors_his_num_%d_option_%d.png'%(max_num, factor_list_option) plot_odd_even_factors(odd_prime_factors_cnt_comm_1d, even_prime_factors_cnt_comm_1d, max_num, range_list, file_result_pic, factor_list_option) return parity_1d