def paul(M, s=1.0, n=4): """ Paul wavelet. Parameters ---------- M : int Length of the wavelet. n : int Order of the Paul wavelet. Default is 4 s : float Scaling factor . Default is 1. Returns ------- Paul : (M,) ndarray Notes ----- """ x = linspace(-M/2.0, M/2.0, M) output = 2**n * math.factorial(n) * (1-1j*(x/s))**-(n+1) output /= 2*pi*sqrt(math.factorial(2*n)/2) output /= sqrt(s) return output
def multichoose(string): tot = sum([int(a) for a in string]) resid = len(string) - tot out = math.factorial(len(string)) / prod( [math.factorial(int(a)) for a in string]) if string == '1' + '0' * (len(string) - 1): return out / math.factorial(resid) - 1 return out / math.factorial(resid) if resid >= 0 else 0
def anagram_counter(words): return int( sum( map( lambda n: np_math.factorial(n) / (np_math.factorial(2) * np_math.factorial(n - 2)), [ n for n in Counter([''.join(sorted(word)) for word in words]).values() if n > 1 ])))
def nCx(n, x): """Gives the number of combinations with n trials when selecting x successes. (N choose x) An example. Args: n (int) : The number of events x (int) : The number of outcomes of the event Returns: int : the number of combinations of that event occurring within the sample space """ return int(math.factorial(n) / (math.factorial(x) * math.factorial(n - x)))
def __init__(self, paths, aug, inch, sample_rate=1, puzzle_num=4, original_img=False): self.sample_rate = sample_rate self.inch = inch self.original_img = original_img self.aug = aug self.root_path = paths self.inputs = [] self.outputs = [] self.lens = [0] self.len = 0 for p in paths: self.read_data_to_memory(p) if sample_rate == 1: self.len += read_length(p, 'output') else: self.len += sample_rate self.lens.append(self.len) self.ch_out = read_ch(paths[0], 'output') self.puzzle_num = int(np.sqrt(puzzle_num)) self.pnc = PN_converter(puzzle_num, pnumber=min(math.factorial(puzzle_num), 50)) if aug: self.len *= 4 if inch == 1: self.len *= 64
def calculate(self): m = self.calculate_m() multiplication = self.multiplication() expression = (f'{multiplication} * ({m}/({self.order}!))') factorial_of_order_plus_one = math.factorial(self.order) result = multiplication * m / factorial_of_order_plus_one self.result['erro'] = {'expression': expression, 'result': result}
def f(n: int) -> int: """ Function takes an integer and give a sum of factorial of the digits :param n: :return: """ return sum([npm.factorial(int(i)) for i in str(n)])
def __init__(self, in_ch=3, out_ch=2, ss=True, num_puzzle=9, bench=False): super(SUNET, self).__init__() self.in_ch = in_ch self.extractor = Extractor(in_ch) self.regressor = Regressor(out_ch) self.num_puzzle = num_puzzle self.decoder = Sorter(in_ch, num_perm=min(math.factorial(self.num_puzzle), 50)) if ss: self.criterion = nn.CrossEntropyLoss() else: self.criterion = nn.MSELoss() self.opt_all = optim.Adam(self.parameters(), lr=0.001) if ss: self.opt_ext = optim.Adam(self.extractor.parameters(), lr=0.001) self.opt_dec = optim.Adam(self.decoder.parameters(), lr=0.001) self.scheduler_dec = StepLR(self.opt_dec, step_size=1, gamma=0.5) self.scheduler_ext = StepLR(self.opt_ext, step_size=1, gamma=0.5) elif bench: self.opt_ext = optim.Adam(self.extractor.parameters(), lr=0.0001) self.opt_reg = optim.Adam(self.regressor.parameters(), lr=0.001) self.scheduler_ext = StepLR(self.opt_ext, step_size=1, gamma=0.5) self.scheduler_reg = StepLR(self.opt_reg, step_size=1, gamma=0.5) else: self.opt_ext = optim.Adam(self.extractor.parameters(), lr=0.00001) self.opt_reg = optim.Adam(self.regressor.parameters(), lr=0.001) self.scheduler_ext = StepLR(self.opt_ext, step_size=1, gamma=0.5) self.scheduler_reg = StepLR(self.opt_reg, step_size=1, gamma=0.5) self.out_ch = out_ch self.imshown = False
def __getitem__(self, item): # light = item % self.img_num light = item % self.img_num item = (item - light) // self.img_num light = 27 if self.aug: aug = item % 4 item = (item - aug) // 4 else: aug = 0 input = self.input input = np.expand_dims(input[item, light, :, :], axis=0) input= input/np.max(input)*2-1 output = self.output[item, :, :, :] if aug % 2 == 0: input = np.ascontiguousarray(np.flip(input, 1)) output = np.ascontiguousarray(np.flip(output, 1)) if aug > 1: input = np.ascontiguousarray(np.flip(input, 2)) output = np.ascontiguousarray(np.flip(output, 2)) puzzle = np.repeat(input.copy(), 3, axis=0) puzzle_num = self.puzzle_num puzzle=np.zeros_like(puzzle) # white back ground # idxs_array = np.random.permutation(puzzle_num * puzzle_num) self.perm_id = np.random.randint(min(math.factorial(puzzle_num**2), 50)) idxs = self.pnc.num2perm(self.perm_id) # hard coded for laziness if 'Nut' in self.root_path or 'panel' in self.root_path or 'T' in self.root_path: edge = 10 else: edge = 10 stride = (puzzle.shape[1] - edge * 2) // puzzle_num-edge//2 for i in range(puzzle_num*puzzle_num): giggle=int(((np.random.rand()+1)*edge)//8) giggle2=int(((np.random.rand()+1)*edge)//8) col = i % puzzle_num row = (i - col) // puzzle_num tcol = idxs[i] % puzzle_num trow = (idxs[i] - tcol) // puzzle_num # puzzle[:, edge + trow * stride:edge + trow * stride + stride, # edge + tcol * stride:edge + tcol * stride + stride] = input[:, # edge + row * stride:edge + row * stride + stride, # edge + col * stride:edge + col * stride + stride] puzzle[:, edge//2 + trow * (stride+edge)+giggle:edge//2 + trow * (stride+edge) + stride+giggle, edge//2 + tcol * (stride+edge)+giggle2:edge//2 + tcol * (stride+edge) + stride+giggle2] = input[:, edge + row * stride+giggle2:edge + row * stride + stride+giggle2, edge + col * stride+giggle:edge + col * stride + stride+giggle] # plt.subplot(2,1,1) # plt.imshow(puzzle[0,:,:]) # plt.subplot(2,1,2) # plt.imshow(input.squeeze()) # plt.show() # print(self.perm_id) return puzzle, int(self.perm_id)
def __getitem__(self, item): if self.inch == 1: light = item % 64 item = (item - light) // 64 if self.aug: aug = item % 4 item = (item - aug) // 4 else: aug = 0 if self.inch == 1: input = np.expand_dims(self.input[item, light, :, :], axis=0) else: input = self.input[item, :, :, :] if aug % 2 == 1: # plt.imshow(input[0,:,:]) # plt.show() input = np.ascontiguousarray(np.flip(input, 1)) if self.inch == 3: input[0, :, :] *= -1 if aug > 1: input = np.ascontiguousarray(np.flip(input, 2)) if self.inch == 3: input[1, :, :] *= -1 puzzle = input.copy() puzzle_num = self.puzzle_num puzzle = np.zeros_like(puzzle) # white back ground # idxs_array = np.random.permutation(puzzle_num * puzzle_num) self.perm_id = np.random.randint(min(math.factorial(puzzle_num**2), 50)) idxs = self.pnc.num2perm(self.perm_id) # hard coded for laziness if 'Nut' in self.root_path or 'panel' in self.root_path or 'T' in self.root_path: edge = 10 else: edge = 10 stride = (puzzle.shape[1] - edge * 2) // puzzle_num - edge // 2 for i in range(puzzle_num * puzzle_num): giggle = int(((np.random.rand() + 1) * edge) // 8) giggle2 = int(((np.random.rand() + 1) * edge) // 8) col = i % puzzle_num row = (i - col) // puzzle_num tcol = idxs[i] % puzzle_num trow = (idxs[i] - tcol) // puzzle_num puzzle[:, edge // 2 + trow * (stride + edge) + giggle:edge // 2 + trow * (stride + edge) + stride + giggle, edge // 2 + tcol * (stride + edge) + giggle2:edge // 2 + tcol * (stride + edge) + stride + giggle2] = input[:, edge + row * stride + giggle2:edge + row * stride + stride + giggle2, edge + col * stride + giggle:edge + col * stride + stride + giggle] return puzzle, self.perm_id
def __init__(self, in_ch=3, out_ch=2, ss=True, num_puzzle=9, scale_lr=1, multitask=False, para_reduce=1): super(SUNET, self).__init__() self.in_ch = in_ch self.out_ch = out_ch self.imshown = False self.multi = multitask self.extractor = Extractor(in_ch, para_reduce=para_reduce) if multitask: self.classifier = Classifier(bn=False, para_reduce=para_reduce) self.opt_c = optim.Adam(self.classifier.parameters(), lr=0.001) self.scheduler_cls = StepLR(self.opt_c, step_size=1, gamma=0.5) if ss: self.disc = Discriminator(para_reduce=para_reduce) self.num_puzzle = num_puzzle self.decoder = Sorter(in_ch, num_perm=min(math.factorial(self.num_puzzle), 50), para_reduce=para_reduce) self.criterion = nn.CrossEntropyLoss() self.opt_dics = optim.Adam(self.disc.parameters(), lr=0.001) self.opt_ext = optim.Adam(self.extractor.parameters(), lr=0.001) self.opt_dec = optim.Adam(self.decoder.parameters(), lr=0.001) self.scheduler_dec = StepLR(self.opt_dec, step_size=1, gamma=0.5) self.scheduler_ext = StepLR(self.opt_ext, step_size=1, gamma=0.5) else: self.regressor = Regressor(out_ch, para_reduce=para_reduce) self.criterion = nn.MSELoss() paras1 = list(self.extractor.parameters()) # paras1=list(self.extractor.E1.parameters())+list(self.extractor.E2.parameters())+list(self.extractor.E3.parameters()) # paras2=list(self.extractor.E4.parameters())+list(self.regressor.parameters()) paras2 = list(self.regressor.parameters()) # self.opt_ext = optim.Adam(paras, lr=0.00001) if not scale_lr == 1: self.opt_ext = optim.Adam(paras1, lr=0.001 * scale_lr) self.scheduler_ext = StepLR(self.opt_ext, step_size=1, gamma=0.5) self.opt_reg = optim.Adam(paras2, lr=0.001 * scale_lr) else: self.opt_ext = optim.Adam(self.extractor.parameters(), lr=0.001) self.scheduler_ext = StepLR(self.opt_ext, step_size=1, gamma=0.5) self.opt_reg = optim.Adam(self.regressor.parameters(), lr=0.001) self.scheduler_reg = StepLR(self.opt_reg, step_size=1, gamma=0.5)
def fact(nn,exact=True): ''' Implements the factorial ''' if scipy_misc_loaded: return sc_m.factorial(nn, exact=exact) elif numpy_math_loaded: return np_m.factorial(nn) else: return m.factorial(nn)
def __init__(self, path, aug, inch, sample_rate=1, puzzle_num=4): self.root_path = path self.sample_rate = sample_rate self.inch = inch self.aug = aug # self.ch_out = read_ch(path, 'output') self.read_data_to_memory() self.len = read_length(path, 'output') self.puzzle_num = int(np.sqrt(puzzle_num)) self.pnc = PN_converter(puzzle_num, pnumber=min(math.factorial(puzzle_num), 50)) if aug: self.len *= 4 if inch == 1: self.len *= 64
def __init__(self, path, aug, pnc=None, puzzle_num=0, img_number=1): self.root_path = path self.ch_out = read_ch(path, 'output') self.len = read_length(path, 'output') self.read_data_to_memory() self.puzzle_num = int(np.sqrt(puzzle_num)) self.img_num=img_number if pnc is None: self.pnc = PN_converter(puzzle_num, pnumber=min(math.factorial(puzzle_num), 50)) else: self.pnc=pnc if aug: self.aug = 4 else: self.aug = 1
def __init__(self, paths, aug, pnc=None, puzzle_num=0, img_number=1, sample_rate=1, original_img=False, more_ri=False): self.root_path = paths self.original_img = original_img self.inputs = [] self.outputs = [] self.lens = [0] self.len = 0 self.more_ri = more_ri for p in paths: self.read_data_to_memory(p) if sample_rate == 1: self.len += read_length(p, 'output') else: self.len += sample_rate self.lens.append(self.len) self.ch_out = read_ch(paths[0], 'output') self.puzzle_num = int(np.sqrt(puzzle_num)) self.img_num = img_number if pnc is None: self.pnc = PN_converter(puzzle_num, pnumber=min(math.factorial(puzzle_num), 50)) else: self.pnc = pnc if aug: self.aug = 1 self.len *= 4 else: self.aug = 0
def __getitem__(self, item): # light = item % self.img_num # light = item % self.img_num # item = (item - light) // self.img_num light = 27 # light = np.random.permutation(range(64))[:3] if self.aug: aug = item % 4 item = (item - aug) // 4 else: aug = 0 for c in range(len(self.lens)): if item >= self.lens[c]: continue else: item = item - self.lens[c - 1] self.input = self.inputs[c - 1] self.output = self.outputs[c - 1] type = c - 1 break input = self.input input = np.expand_dims(input[item, light, :, :], axis=0) # input = self.input[item,light,:,:] # input= input/np.max(input) input = input - np.mean(input) # zero centered input = input / (np.std(input) + 0.00000001) # normalize variance output = self.output[item, :, :, :] # flip to match the normal map input = np.ascontiguousarray(np.flip(input, 1)) output = np.ascontiguousarray(np.flip(output, 1)) if aug % 2 == 0: input = np.ascontiguousarray(np.flip(input, 1)) output = np.ascontiguousarray(np.flip(output, 1)) if aug > 1: input = np.ascontiguousarray(np.flip(input, 2)) output = np.ascontiguousarray(np.flip(output, 2)) puzzle = np.repeat(input.copy(), 3, axis=0) puzzle_num = self.puzzle_num #puzzle=np.zeros_like(puzzle) # white back ground # idxs_array = np.random.permutation(puzzle_num * puzzle_num) self.perm_id = np.random.randint(min(math.factorial(puzzle_num**2), 50)) idxs = self.pnc.num2perm(self.perm_id) # hard coded for laziness if 'Nut' in self.root_path[type] or 'panel' in self.root_path[ type] or 'T' in self.root_path[type]: edge = 10 else: edge = 10 stride = (puzzle.shape[1] - edge * 2) // puzzle_num - edge // 2 for i in range(puzzle_num * puzzle_num): giggle = int(((np.random.rand() + 1) * edge) // 8) giggle2 = int(((np.random.rand() + 1) * edge) // 8) col = i % puzzle_num row = (i - col) // puzzle_num tcol = idxs[i] % puzzle_num trow = (idxs[i] - tcol) // puzzle_num # puzzle[:, edge + trow * stride:edge + trow * stride + stride, # edge + tcol * stride:edge + tcol * stride + stride] = input[:, # edge + row * stride:edge + row * stride + stride, # edge + col * stride:edge + col * stride + stride] puzzle[:, edge // 2 + trow * (stride + edge) + giggle:edge // 2 + trow * (stride + edge) + stride + giggle, edge // 2 + tcol * (stride + edge) + giggle2:edge // 2 + tcol * (stride + edge) + stride + giggle2] = input[:, edge + row * stride + giggle2:edge + row * stride + stride + giggle2, edge + col * stride + giggle:edge + col * stride + stride + giggle] # plt.subplot(2,1,1) # plt.imshow(puzzle[0,:,:]) # plt.subplot(2,1,2) # plt.imshow(input.squeeze()) # plt.show() # print(self.perm_id) if self.more_ri: idx = np.random.randint(self.len) input = np.expand_dims( self.input[idx, np.random.randint(self.img_num), :, :], axis=0) input = input / np.max(input) np.repeat(input, 3, axis=0) return puzzle, int(self.perm_id), np.repeat(input, 3, axis=0), output if self.original_img: return puzzle, int(self.perm_id), np.repeat(input, 3, axis=0), output else: return puzzle, int(self.perm_id)
def poisson_dist(n_ave, n): f = ((n_ave**n) / (math.factorial(n))) * (np.exp(-n_ave)) return f
def run_overall_ga(self): possible_solutions = m.factorial(self.number_of_cities - 1) ninitpop = self.initial_pop_size ## create an empty dataframe to store the solutions all_solutions_generated = pd.DataFrame(columns=["Route", "Cost"]) """start a for loop and run the whole process for mentioned number of times""" print("Starting {} iterations of the GA".format(self.noverall)) # generating initial population """We only generate a population initially, after the first run , we take the best solutions from the previous run and continue with the process""" if all_solutions_generated.shape[0] == 0: initial_pop_cost = self.initial_pop_cost() sorted_init_pop = initial_pop_cost.sort_values("Cost") else: sorted_init_pop = all_solutions_generated.head( self.initial_pop_size) # selecting the elite few elite_few_df = self.the_elite_few() best_sol = [] """Generating a random number based on which we either mutate or do a crossover""" mating_factor = np.random.uniform( 0, 1, 1) # Random pick to decide on Mutation / crossover for i in range(self.noverall): if mating_factor < 0.2: mutated_population_wth_cost = self.mutation_function( all_solutions_generated) all_solutions_generated.append(mutated_population_wth_cost) else: crossover_population = self.routes_after_cross_over() all_solutions_generated = all_solutions_generated.append( crossover_population) all_solutions_generated.Route = all_solutions_generated.Route.map( lambda x: tuple(x)) unique_sols_generated = ( all_solutions_generated.drop_duplicates().sort_values("Cost")) all_solutions_generated = all_solutions_generated.sort_values( "Cost").head( ninitpop) # only take the top ninitpop number of solutions all_solutions_generated.Route = all_solutions_generated.Route.map( lambda x: list(x)) print( "-----------------------------------------------------------------" ) print("""Best solution for initial population size of {} and number of runs {} is \n {}""".format( self.initial_pop_size, self.noverall, all_solutions_generated.sort_values("Cost").head(1), )) print("Generated {}({}%) of the {} solutions".format( all_solutions_generated.shape[0], np.round((len(all_solutions_generated) / possible_solutions) * 100, 3), possible_solutions, )) final_sol = all_solutions_generated.sort_values("Cost").head(1) #### Final Solution ( Cities) final_route = [] starting_point = self.dist_mat.index[0] for i in final_sol.Route.values[0]: final_route.append(self.cities_mapping[i]) final_route = [starting_point] + final_route + [starting_point] total_cost = ray.get( self.fitness_function.remote(self, list(final_sol.Route.values[0]))) print( """Total distance travelled to cover the final route of \n {} is {} KM. (Generated from initial population size of {})""".format( " => ".join(final_route), total_cost, self.initial_pop_size)) print( "-----------------------------------------------------------------" ) best_sol.append(final_sol) return (final_sol, total_cost)
def evaluate_hand(hand): # unpack the hand into single lists values = [hand[i][1] for i in range(len(hand))] suits = [hand[i][2] for i in range(len(hand))] checked_values = [] # set up booleans pair = False two_pair = False three_of_a_kind = False four_of_a_kind = False full_house = False straight = False flush = False straight_flush = False royal_flush = False # check for multiples (there's probably a less sloppy way to do this) for i in values: if values.count(i) == 2 and pair is True and i not in checked_values: two_pair = True if values.count(i) == 2 and pair is False: pair = True if values.count(i) == 3: three_of_a_kind = True if values.count(i) == 4: four_of_a_kind = True checked_values.append(i) # check for a full house if pair is True and three_of_a_kind is True: pair = False three_of_a_kind = False full_house = True # check for a straight if suits.count(suits[0]) == 5: straight = True # check for flushes flush_products = [] # store result of flush values multiplied together for i in range(1, 13): flush_products.append(math.factorial(i + 4) / math.factorial(i)) flush_products.append(13 * 12 * 11 * 10 * 1) # royal flush value... duct tape solution if np.prod(values) in flush_products: flush = True if flush is True and straight: straight = False flush = False straight_flush = True if np.prod(values) == 13 * 12 * 11 * 10 * 1 and straight_flush: straight_flush = False royal_flush = True # find the high card for tie-breakers high_card = max(values) # record hand results hand_results = [ pair, two_pair, three_of_a_kind, straight, flush, full_house, four_of_a_kind, straight_flush, royal_flush ] hand_rank = 1 for i in range( len(hand_results) ): # objects in hand_results are in order of rank, so finding the idx in hand_results tells you the rank of the hand if hand_results[i]: hand_rank = i + 2 return hand_rank, high_card
def normalization(v,α): N_v = math.sqrt(α/(2.**v * math.factorial(v) * math.sqrt(math.pi))) return N_v
def combination(self, n, m): if n == m: return 1 return math.factorial(n) / (math.factorial(n - m) * math.factorial(m))
def choose(n, r): return npm.factorial(n) / (npm.factorial(r) * npm.factorial(n - r))
def fac(self, a): # a! return math.factorial(a)
def omega(N,Q): top = math.factorial(N+Q-1) bottom = math.factorial(Q)*math.factorial(N-1) return top/bottom
from numpy import math total = 0 for i in range(0, 100000): a = str(i) current = 0 for x in a: current += math.factorial(int(x)) if (current == i): total += i print(i) print(current) print(total)
def factorial(n): return math.factorial(n)
def main(version, *args): global n global k global M try: config_path = args[0][0] except IndexError: print( 'Fatal error: Please specify the path of the configuration file as the first argument.\nExiting' ) quit() num_runs = 1 scalarizer = scalarizers_list[0] flag_create_snapshots = False ### Read all command-line parameters ### try: opts, args = getopt.getopt( args[0][1:], 'r:s:hv', ['runs=', 'scal=', 'snapshots', 'help', 'version']) for opt, arg in opts: if opt in ('-r', '--runs'): try: num_runs = int(arg) print('Executing {0} runs.'.format(num_runs)) except ValueError: print( '\nInvalid number of runs provided. Defaulting to 1.') elif opt in ('-s', '--scal'): scalarizer = str(arg).upper() if scalarizer not in scalarizers_list: print('\nError: Provided scalarizer name not implemented.') print('Available scalarization functions: {0}'.format( ', '.join(scalarizers_list))) print('Defaulting to {0}.\n'.format(scalarizers_list[0])) scalarizer = scalarizers_list[0] else: print('Using {0} scalarizer.'.format(scalarizer)) elif opt in ('--snapshots'): flag_create_snapshots = True print('Creating snapshots in the \'snapshots\' folder.') elif opt in ('-h', '--help'): print( 'Usage: python3 iMOACOR.py <path to configuration file> [OPTIONS]\n' ) print('Options:') print(' -r N, --runs=N the number of runs to execute') print( ' -s NAME, --scal=NAME use the scalarization method named NAME' ) print( ' --snapshots write generational snapshots to the \'snapshots\' folder' ) print( ' -h, --help display this help page and exit') print( ' -v, --version display version information and exit' ) print('\n') quit() elif opt in ('-v', '--version'): print('iMOACOR version {0}'.format(version)) print( 'License LGPLv3: GNU LGPL version 3 <https://www.gnu.org/licenses/lgpl>.' ) print('Written by Mykel Shumay.') print('\n') quit() except getopt.GetoptError: print('\nError: Unrecognized option provided,' + ' or an option that requires an argument was given none.') print('Call with option \'--help\' for the help page.\n\n') quit() try: # Searches for the appropriate configuration file. config = ConfigParser() config.read(config_path) chosenConfig = config['Parameters'] # Reads from configuration file. obj_function_name = chosenConfig['Function'] n = int(chosenConfig['n']) k = int(chosenConfig['k']) Rmin = float(chosenConfig['Rmin']) Rmax = float(chosenConfig['Rmax']) q = float(chosenConfig['q']) xi = float(chosenConfig['xi']) Gmax = int(chosenConfig['Gmax']) MAX_RECORD_SIZE = int(chosenConfig['MAX_RECORD_SIZE']) EPSILON = 1e-4 var_threshold = float(chosenConfig['varThreshold']) tol_threshold = float(chosenConfig['tolThreshold']) H = int(chosenConfig['H']) M = N = np_math.factorial(H + k - 1) // np_math.factorial( k - 1) // np_math.factorial(H) except KeyError: print('Fatal error: Unable to read configuration file.\n' + 'Ensure that the provided path is correct.') quit() print('\nParameters:') print('Objective Function:\t{0:5>}'.format(obj_function_name)) print('\tScalarizer:\t{0:>5}'.format(scalarizer)) print('\tn:\t\t{0:5}'.format(n)) print('\tk:\t\t{0:5}'.format(k)) print('\tRmin:\t\t{0:5}'.format(Rmin)) print('\tRmax:\t\t{0:5}'.format(Rmax)) print('\tq:\t\t{0:5}'.format(q)) print('\txi:\t\t{0:5}'.format(xi)) print('\tGmax:\t\t{0:5}'.format(Gmax)) print('\tM:\t\t{0:5}'.format(M)) print('\tH:\t\t{0:5}'.format(H)) print('\tN:\t\t{0:5}\n'.format(N)) return (obj_function_name, n, k, M, Rmin, Rmax, q, xi, Gmax, N, H, EPSILON, MAX_RECORD_SIZE, var_threshold, tol_threshold, num_runs, scalarizer, flag_create_snapshots)
''' sinsum.py v. 1 8/27/18 calculate the sine of an angle from the series expansion ''' # Import factorial from numpy from numpy import math # Initialization of variables # Get the angle from the user x = input("Enter the angle in degrees: ") # convert angle to radians x = x * math.pi / 180 # get the number of terms to compute from user N = input("Enter number of terms to compute: ") sum = 0 #create the loop for our calculation for j in range (0, N+1): sum = sum + (-1)**j*x**(2*j+1)/math.factorial(2*j+1) #print out result print "sin(x) = ", sum print "Percent error = ", math.fabs((math.sin(x)) - sum) / (math.sin(x)) * 100