def main(): usage_msg = "Usage: python %s player_balance [ number_of_card_decks ]" % __file__ num_argv = len(sys.argv) if num_argv not in (2, 3): print usage_msg sys.exit() else: is_valid, num = check_int(sys.argv[1]) if is_valid: player_balance = num else: print "Invalid parameter: %s" % sys.argv[1] print usage_msg sys.exit() num_decks = None if num_argv == 3: is_valid, num = check_int(sys.argv[2]) if is_valid: num_decks = num else: print "Invalid parameter: %s" % sys.argv[2] print usage_msg sys.exit() player = Player(player_balance) dealer = Dealer(num_decks) if num_decks else Dealer() game = Game(dealer, player) while game.run(): pass
def main(): usage_msg = "Usage: python %s player_balance [ number_of_card_decks ]" % __file__ num_argv = len(sys.argv) if num_argv not in (2, 3): print usage_msg; sys.exit() else: is_valid, num = check_int(sys.argv[1]) if is_valid: player_balance = num else: print "Invalid parameter: %s" % sys.argv[1] print usage_msg; sys.exit() num_decks = None if num_argv == 3: is_valid, num = check_int(sys.argv[2]) if is_valid: num_decks = num else: print "Invalid parameter: %s" % sys.argv[2] print usage_msg; sys.exit() player = Player(player_balance) dealer = Dealer(num_decks) if num_decks else Dealer() game = Game(dealer, player) while game.run(): pass
def pickle_data(folder_name, data=None, curr_time=None): if not os.path.exists(folder_name): os.makedirs(folder_name) if data is None: random_millisec = "" while not utils.check_int(random_millisec): random_millisec = np.random.choice(os.listdir(folder_name))[:11] print random_millisec with open(folder_name + random_millisec + "_gp", 'rb') as f: gp = pickle.load(f) with open(folder_name + random_millisec + "_gplist", 'rb') as f: gp_list = pickle.load(f) with open(folder_name + random_millisec + "_slist", 'rb') as f: s_list = pickle.load(f) with open(folder_name + random_millisec + "_losslist", 'rb') as f: loss_list = pickle.load(f) else: with open(folder_name + str(curr_time) + "_gp", 'wb') as f: pickle.dump(data[0], f) with open(folder_name + str(curr_time) + "_gplist", 'wb') as f: pickle.dump(data[1], f) with open(folder_name + str(curr_time) + "_slist", 'wb') as f: pickle.dump(data[2], f) with open(folder_name + str(curr_time) + "_losslist", 'wb') as f: pickle.dump(data[3], f) if data is None: return (gp, gp_list, s_list, loss_list)
def from_json_dict( data: Any ) -> 'NewsItem': """Create news item from dictionary loaded from JSON.""" if not isinstance(data, dict): raise TypeError(data) name = check_str(data['name']) title = check_str(data['title']) category_slug = check_str(data['category_slug']) category_id = check_int(data['category_id']) category_title: Optional[str] = None if 'category_title' in data: category_title = check_str(data['category_title']) date_str = check_str(data['date']) date = datetime.datetime.fromisoformat(date_str) url = check_optional_str(data['url']) url_ok: Optional[bool] = None if 'url_ok' in data: url_ok = check_bool(data['url_ok']) wikitext_paragraphs: Optional[List[str]] = None if 'wikitext_paragraphs' in data: wikitext_paragraphs = check_list_str(data['wikitext_paragraphs']) tag_titles: List[str] = [] if 'tag_titles' in data: tag_titles = check_list_str(data['tag_titles']) author_name: Optional[str] = None if 'author_name' in data: author_name = check_str(data['author_name']) return NewsItem( name, title, category_id, category_slug, category_title, date, tag_titles, author_name, url, url_ok, wikitext_paragraphs )
def process_categories( input_from_js_file: TextIO, input_bonus_file: TextIO, input_colors_file: TextIO, output_file: TextIO, ) -> None: """Build categories_by_slug list from file.""" categories_data_from_js = json.load(input_from_js_file) categories_data_bonus = json.load(input_bonus_file) categories_data_colors = json.load(input_colors_file) categories_by_slug: Dict[str, str] = {} for category_url_data in load_category_urls(categories_data_from_js): category_url = check_str(category_url_data) category_slug = category_url.split('/')[-1] categories_by_slug[category_slug] = '/'.join( category_url.split('/')[2:] ) for category_url_data in categories_data_bonus: category_url = check_str(category_url_data) category_slug = category_url.split('/')[-1] categories_by_slug[category_slug] = category_url categories_by_id_data: Dict[int, str] = {} for category_color_data, category_ids in categories_data_colors.items(): category_color = check_str(category_color_data) for category_id_data in category_ids: category_id = check_int(category_id_data) categories_by_id_data[category_id] = category_color data = { 'categories_by_id': categories_by_id_data, 'categories_by_slug': categories_by_slug } json.dump(data, output_file, indent=4)
def _check_params(self): """Check PHATE parameters This allows us to fail early - otherwise certain unacceptable parameter choices, such as mds='mmds', would only fail after minutes of runtime. Raises ------ ValueError : unacceptable choice of parameters """ utils.check_positive(n_components=self.n_components, k=self.knn) utils.check_int(n_components=self.n_components, k=self.knn, n_jobs=self.n_jobs) utils.check_between(-1, 1, gamma=self.gamma) utils.check_if_not(None, utils.check_positive, a=self.decay) utils.check_if_not(None, utils.check_positive, utils.check_int, n_landmark=self.n_landmark, n_pca=self.n_pca) utils.check_if_not('auto', utils.check_positive, utils.check_int, t=self.t) if not callable(self.knn_dist): utils.check_in([ 'euclidean', 'precomputed', 'cosine', 'correlation', 'cityblock', 'l1', 'l2', 'manhattan', 'braycurtis', 'canberra', 'chebyshev', 'dice', 'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule', 'precomputed_affinity', 'precomputed_distance' ], knn_dist=self.knn_dist) if not callable(self.mds_dist): utils.check_in([ 'euclidean', 'cosine', 'correlation', 'braycurtis', 'canberra', 'chebyshev', 'cityblock', 'dice', 'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'matching', 'minkowski', 'rogerstanimoto', 'russellrao', 'seuclidean', 'sokalmichener', 'sokalsneath', 'sqeuclidean', 'yule' ], mds_dist=self.mds_dist) utils.check_in(['classic', 'metric', 'nonmetric'], mds=self.mds)
def on_arduino(): global lv, rv, dist t = threading.currentThread() while getattr(t, 'do_run', True): s = arduino.readline() if s and check_int(s): lv, rv, dist = decode(int(s)) print 'arduino: ', lv, ' ', rv, ' ', dist
def plot_experiment(params, output_path): folder_name = get_folder_name(params, output_path) all_experiments = set([f[:11] for f in os.listdir(folder_name) if utils.check_int(f[:11])]) all_experiments = sorted(all_experiments) for experiment in all_experiments: gp, gp_list, s_list = pickle_data(folder_name, file_prefix=experiment) data, X_range, X, Y, Z, is_us, goal_func = datasets.load_data(params["data_name"], True) print X_range.shape h, w = X_range.shape for i in range(len(gp_list)): gpi = gp_list[i] X_new, Y_new = s_list[i] print X_new.shape mean = np.zeros((X_range.shape[0], 1)) var = np.zeros((X_range.shape[0], 1)) for j in range(X_range.shape[0]): mean[j], var[j] = gpi.predict(X_range[j, :][np.newaxis, :]) print gpi.Xtrain.shape print gpi.Ytrain.shape print Z.shape, is_us.shape, mean.flatten().shape, var.flatten().shape Z[is_us] = mean.flatten() p.contourf(X, Y, Z) # GP mean p.colorbar() p.scatter(gpi.Xtrain[:, 0], gpi.Xtrain[:, 1], color='green', marker='x', s=50) # training data p.scatter(X_new[:, 0], X_new[:, 1], color='purple', marker='*', s=100) # test data p.show() Z[is_us] = var.flatten() ** 0.5 p.contourf(X, Y, Z) # GP mean p.colorbar() p.scatter(gpi.Xtrain[:, 0], gpi.Xtrain[:, 1], color='green', marker='x', s=50) # training data p.scatter(X_new[:, 0], X_new[:, 1], color='purple', marker='*', s=100) # test data p.show() Z[is_us] = data.flatten() p.contourf(X, Y, Z) # GP mean p.colorbar() p.scatter(gpi.Xtrain[:, 0], gpi.Xtrain[:, 1], color='green', marker='x', s=50) # training data p.scatter(X_new[:, 0], X_new[:, 1], color='purple', marker='*', s=100) # test data p.show() Z[is_us] = mean.flatten() fig = p.figure() ax = fig.gca(projection='3d') # surf = ax.plot_surface(X,Y,Z, rstride=1, cstride=1, cmap=cm.coolwarm, # linewidth=0, antialiased=False) ax.contourf(X, Y, Z) # fig.colorbar(surf, shrink=0.5, aspect=5) ax.set_zlim(-15, 90) # p.colorbar() ax.scatter(gpi.Xtrain[:, 0], gpi.Xtrain[:, 1], gpi.Ytrain_original, color='green', marker='x', s=50) # training data # p.scatter(X_new[:,0],X_new[:,1],color='purple',marker='*', s=100) # test data p.show() print X_new, Y_new
def __getitem_part__(self, item, num): """ returns an inter block value or in-block... :param item: [1.5, 3.5], not [1.5][3.5] :return: """ # major case - tuple if (type(item) == tuple) & (len(item) == 2): i, j = item # bound if i < 0: return self.k[num][0, j] if i >= self.shape[0] - 0.6: return self.k[num][self.shape[0] - 1, j] if j < 0: return self.k[num][i, 0] if j >= self.shape[1] - 0.6: return self.k[num][i, self.shape[1] - 1] if u.check_int(i) & u.check_half(j): out = self.dy[floor(j)] / self.k[num][floor(i), floor(j)] out += self.dy[ceil(j)] / self.k[num][floor(i), ceil(j)] out = 1 / out out *= self.dy[floor(j)] + self.dy[ceil(j)] return out if u.check_half(i) & u.check_int(j): out = self.dx[floor(i)] / self.k[num][floor(i), floor(j)] out += self.dx[ceil(i)] / self.k[num][ceil(i), floor(j)] out = 1 / out out *= self.dx[floor(i)] + self.dx[ceil(i)] return out # if for bound condition reason not inter cell condition if u.check_int(i) & u.check_int(j): return self.k[num][item] elif type(item) == int: return self.k[num][item]
def __getitem__(self, item): """ returns an inter block value or in-block... :param item: [1.5, 3.5], not [1.5][3.5] :return: """ # simplest case if u.check_if_numerical(self.__d): return self.__d # major case - tuple if (type(item) == tuple) & (len(item) == 2): i, j = item # bound if i == -0.5: return self.__d[0, j] if i == self.__d.shape[0] - 0.5: return self.__d[self.__d.shape[0] - 1, j] if j == -0.5: return self.__d[i, 0] if j == self.__d.shape[1] - 0.5: return self.__d[i, self.__d.shape[1] - 1] if u.check_int(i) & u.check_half(j): out = self.__d[floor(i), floor(j)] + self.__d[floor(i), ceil(j)] out *= 0.5 return out if u.check_half(i) & u.check_int(j): out = self.__d[floor(i), floor(j)] + self.__d[ceil(i), floor(j)] out *= 0.5 return out # if for some reason not boundary condition if u.check_int(i) & u.check_int(j): return self.__d[item] elif type(item) == int: return self.__d[item]
def inner(*args, **kwargs): tag_category = utils.request.form.get("category") if not utils.check_int(tag_category): return utils.generate_error_msg(utils.ERR_INVALID_ARGUMENTS, "category") tag_name = utils.request.form.get("name") if not utils.check_str(tag_name): return utils.generate_error_msg(utils.ERR_INVALID_ARGUMENTS, "name") def curry(model_arguments, *args_in, **kwargs_in): return func(tag_category=int(tag_category), tag_name=tag_name, tag_property=generate_property(int(tag_category), **model_arguments), *args_in, **kwargs_in) return check_model_arguments(int(tag_category))(curry)(*args, **kwargs)
def main(): ciphers = 'caesar (c), railfence (r), playfair (p)\ substitution (su), beale (b), straddle (st)' while True: cmd = input('encrypt, decrypt, or exit (en, de, ex)? ') # ENCRYPT while cmd == 'en': enc = input('select cipher: \n \ caesar (c), railfence (r), playfair (p) \n \ substitution (su), beale (b), straddle (st): \n') # caesar if enc == 'c': t = input('enter plain text: ') if t != '' and utils.check_latin(t): pass else: print('text can only consist of latin letters') break k = input('enter integer key: ') if utils.check_int(k): print(caesar.encrypt(t, int(k))) cmd = '' else: cmd = '' # railfence elif enc == 'r': t = input('enter plain text: ') k = input('enter integer key: ') if utils.check_int(k): if int(k) > 1: print(railfence.encrypt(t, int(k))) cmd = '' else: print('key must be at least 2') cmd = '' else: cmd = '' # playfair elif enc == 'p': t = input('enter plain text: ') if t != '' and utils.check_latin(t): pass else: print('text can only consist of latin letters') break k = input('enter string key: ') if k != '' and utils.check_latin(k): print(playfair.encrypt(t, k)) pass else: print('key can only consist of latin letters') break cmd = '' # substitution elif enc == 'su': t = input('enter plain text: ') if t != '' and utils.check_latin(t): pass else: print('text can only consist of latin letters') break k = input('enter string key: ') if k != '' and utils.check_latin(k): try: utils.check_full(k) except ValueError: print('key should bee full alphabet') break try: print(substitution.encrypt(t, k)) except ValueError: print('check errors for parameter issues') pass else: print('key can only consist of latin letters') break cmd = '' # beale elif enc == 'b': t = input('enter plain text: ') if t != '' and utils.check_latin(t): pass else: print('text can have letters + punctuation') break k = input('enter file name key: ') if k != '': pass s = input('enter an integer seed: ') if s != '': try: s = int(s) except ValueError: print('seed must be integer') break try: print(beale.encrypt(t, k, s)) except ValueError: print('make sure your file is correct') pass else: print('text cannot be empty') break cmd = '' # straddle elif enc == 'st': t = input('enter plain text: ') warn = 0 for x in t: if (t not in string.ascii_letters and t != '0' and t != '1' and t != ' '): warn += 1 if warn > 0: print('warning: text should include only letters, 0, or 1') if t != '': pass else: print('text cannot be empty') break alk = input('enter alpha key: ') if alk != '': pass else: print('alpha_key cannot be empty') break try: utils.check_full(alk) except ValueError: print('alpha_key must be full alphabet') break nk = input('enter 2 digit numeric key: ') if nk != '': pass if (len(nk) != 2 or not nk[0].isnumeric() or not nk[1].isnumeric() or '0' in nk): print('num_key must be a 2 digit int with unique digits') print('cannot contain 0') break adk = input('enter adding key:') if adk != '': try: print(straddle.encrypt(t, alk, nk, adk)) except ValueError: print('make sure your add key is an integer') pass else: print('input cannot be empty') break cmd = '' else: print('Please enter a valid input for a cipher.') # DECRYPT while cmd == 'de': dec = input('select cipher: \n \ caesar (c), railfence (r), playfair (p) \n \ substitution (su), beale (b), straddle (st): \n') # caesar if dec == 'c': t = input('enter cipher text: ') if t != '' and utils.check_latin(t): pass else: print('text can only consist of latin letters') break k = input('enter integer key: ') if utils.check_int(k): print(caesar.decrypt(t, int(k))) cmd = '' else: cmd = '' # railfence elif dec == 'r': t = input('enter cipher text: ') k = input('enter integer key: ') if utils.check_int(k): if int(k) > 1: print(railfence.decrypt(t, int(k))) cmd = '' else: print('key must be at least 2') cmd = '' else: cmd = '' # playfair elif dec == 'p': t = input('enter cipher text: ') if t != '' and utils.check_latin(t): pass else: print('text can only consist of latin letters') break k = input('enter string key: ') if k != '' and utils.check_latin(k): print(playfair.decrypt(t, k)) pass else: print('text can only consist of latin letters') break cmd = '' # substitution elif dec == 'su': t = input('enter cipher text: ') if t != '' and utils.check_latin(t): pass else: print('text can only consist of latin letters') break k = input('enter string key: ') if k != '' and utils.check_latin(k): try: utils.check_full(k) except ValueError: print('key should be full alphabet') break try: print(substitution.decrypt(t, k)) except ValueError: print('check errors for parameter issues') pass else: print('key can only consist of latin letters') break cmd = '' # beale elif dec == 'b': t = input('enter cipher text: ') for x in t: if x != ' ': if not x.isnumeric(): print('text should consist of int literals') break if t != '': pass else: print('warning: text should only consist of integers') break k = input('enter file name key: ') if k != '': try: print(beale.decrypt(t, k)) except ValueError: print('check that your text file is correct') pass else: print('text cannot be empty') break cmd = '' # straddle elif dec == 'st': t = input('enter cipher text: ') warn = 0 for x in t: if (t not in string.ascii_letters and t != '0' and t != '1' and t != ' '): warn += 1 if warn > 0: print('warning: text should include only letters, 0, or 1') if t != '': pass else: print('text cannot be empty') break alk = input('enter alpha key: ') if alk != '': pass else: print('alpha_key cannot be empty') break try: utils.check_full(alk) except ValueError: print('alpha_key must be full alphabet') break nk = input('enter 2 digit numeric key: ') if nk != '': pass if (len(nk) != 2 or not nk[0].isnumeric() or not nk[1].isnumeric() or '0' in nk): print('num_key must be a 2 digit int with unique digits') print('cannot contain 0') break adk = input('enter adding key:') if adk != '': try: print(straddle.decrypt(t, alk, nk, adk)) except ValueError: print('make sure your add key is an integer') pass else: print('text cannot be empty') break cmd = '' else: print('Please enter a valid input for a cipher.') if cmd == 'ex': print('exit') return False elif cmd == '' or cmd == 'en' or cmd == 'de': pass else: print('Please enter a valid input of en, de, or ex.')
intuitive_theory, inference_params) # Create a directory to save the plots in directory = os.path.join(os.getcwd(), 'plots') # Check whether directory exists, if not create it if not os.path.exists(directory): os.makedirs(directory) print( 'This is supposed to be an interactive guide to setting up and running an experiment' ) name_experiment = input('What is the name of your experiment? (string): ') num_conditions = input( 'How many conditions does the experiment have? (0-10): ') num_conditions = check_int(num_conditions, 0, 10) variables_input = input( 'What variables should be manipulated? Enter their abbreviations (in brackets) with spaces inbetween. A possible list follows\n' 'success - (success)\n' 'task importance - (TI)\n' 'self-awareness - (SA)\n' 'probability of improvement - (PI)\n' 'number of samples in experiment - (L)\n' 'skill - (skill)\n' 'effort - (effort)\n' 'external - (external)\n' 'luck - (luck)\n' 'E.g. SI TI PI' 'Any variable that is not set is sampled from a default distribution\n' 'The possible values for the variables will be displayed at choosing time\n'
def evaluate_experiment(params, output_path): folder_name = get_folder_name(params, output_path) all_experiments = set([f[:11] for f in os.listdir(folder_name) if utils.check_int(f[:11])]) all_experiments = sorted(all_experiments) print "Starting EVALUATION for", folder_name data, X_range, X, Y, Z, is_us, goal_func = datasets.load_data(params["data_name"], True, noise=False) all_gap_m = [] all_closeness_m = [] all_dist_m = [] k = 0 for experiment in all_experiments: gp, gp_list, s_list = pickle_data(folder_name, file_prefix=experiment) gap_measure = [] closeness_measure = [] dist_m = [] dist = 0 y_opt = data[np.argmax(data)] x_opt = X_range[np.argmax(data), :] for i in range(len(gp_list)): gpi = gp_list[i] if i % 5 == 0 or i == (len(gp_list) - 1): mean = np.zeros((X_range.shape[0], 1)) var = np.zeros((X_range.shape[0], 1)) for j in range(X_range.shape[0]): mean[j], var[j] = gpi.predict(X_range[j, :][np.newaxis, :]) x_best = X_range[np.argmax(mean), :] x_first = gpi.Xtrain[0, :] gap_measure.append(utils.gap_measure(goal_func, x_first, x_best, y_opt)) closeness_measure.append(utils.closeness_measure(x_best, x_opt)) #print "Gap measure:", utils.gap_measure(goal_func, x_first, x_best, y_opt) #print "Closeness measure:", utils.closeness_measure(x_best, x_opt) if params["data_name"] == "ozone" or params["data_name"] == "population": dist += utils.haversine(gpi.Xtrain[-1,0], gpi.Xtrain[-1,1], gpi.Xtrain[-2,0], gpi.Xtrain[-2,1]) else: dist += np.linalg.norm(gpi.Xtrain[-1,:] - gpi.Xtrain[-2,:]) dist_m.append(dist) all_gap_m.append(gap_measure) all_closeness_m.append(closeness_measure) all_dist_m.append(dist_m) k += 1 print "Evaluation", k, "of", len(all_experiments), "done" with open(folder_name + "evaluation_gap_mtx", 'wb') as f: pickle.dump(np.matrix(all_gap_m), f) with open(folder_name + "evaluation_closeness_mtx", 'wb') as f: pickle.dump(np.matrix(all_closeness_m), f) with open(folder_name + "evaluation_distance_mtx", 'wb') as f: pickle.dump(np.matrix(all_dist_m), f)
def validate_arguments(args): if "length" not in args or not (utils.check_int(args["length"]) or utils.ARG_VEC_TABLE[float](args["length"])): return False return True
def validate_arguments(args): if "amount" not in args or not utils.check_int(args["amount"]): return False return True
print_search_result(service, index) index += 1 print horizontal_bar except shodan.APIError, e: print 'Encountered error: %s' % e validate_still_logged_in() print 'Look up host from results? ', while (1): user_input = raw_input('Enter host index number (<num>/no): ') if any(user_input == answer for answer in utils.negative_answers): user_input = raw_input('Perform another search? (ENTER/no): ') if any(user_input == answer for answer in utils.negative_answers): print 'ShodanCLI shutting down.' sys.exit(1) else: break # Looking up host from results. val = check_int(user_input) if val < 0 or val > (index - 1): print 'Invalid index, try again.', continue host_ip = results['matches'][val]['ip_str'] try: host = api.host(host_ip) print_host_result(host) except shodan.APIError, e: print 'Encountered error: %s' % e continue
def __getitem__(self, item): """ returns an inter block value or in-block... :param item: [1.5, 3.5], not [1.5][3.5] :return: """ # simplest case # major case - tuple if (type(item) == tuple) & (len(item) == 2): i, j = item nx, ny = self.shape # here are bounds if self.__boundary_condition == 'const_pressure': if (i == -0.5) & (j <= ny - 1) & (0 <= j) & u.check_int(j): i = 0 out = self.__d_matrix[i, j] * self.__dy_matrix[floor(i)] * self.__k_matrix[i, j] out /= self.__dx_matrix[j] return 2 * out # return 0 # one of bound if (i == nx - 0.5) & (j <= ny - 1) & (0 <= j) & u.check_int(j): i = nx - 1 out = self.__d_matrix[i, j] * self.__dy_matrix[j] * self.__k_matrix[i, j] out /= self.__dx_matrix[i] return 2 * out # return 0 # other 2 line bounds if (j == -0.5) & (i <= nx - 1) & (0 <= i) & u.check_int(i): j = 0 out = self.__d_matrix[i, j] * self.__dx_matrix[i] * self.__k_matrix[i, j] out /= self.__dy_matrix[j] return 2 * out # return 0 # bound if (j == ny - 0.5) & (i <= nx - 1) & (0 <= i) & u.check_int(i): j = ny - 1 out = self.__d_matrix[i, j] * self.__dx_matrix[i] * self.__k_matrix[i, j] out /= self.__dy_matrix[j] return 2 * out # return 0 elif self.__boundary_condition == 'no_flux': if (i == -0.5) & (j <= ny - 1) & (0 <= j) & u.check_int(j): return 0 # one of bound if (i == nx - 0.5) & (j <= ny - 1) & (0 <= j) & u.check_int(j): return 0 # other 2 line bounds if (j == -0.5) & (i <= nx - 1) & (0 <= i) & u.check_int(i): return 0 # bound if (j == ny - 0.5) & (i <= nx - 1) & (0 <= i) & u.check_int(i): return 0 # major cases if u.check_int(i) & u.check_half(j): out = self.__d_matrix[i, j] * self.__dx_matrix[floor(i)] * self.__k_matrix[i, j] out /= (self.__dy_matrix[floor(j)] + self.__dy_matrix[ceil(j)]) / 2 return out elif u.check_half(i) & u.check_int(j): out = self.__d_matrix[i, j] * self.__dy_matrix[floor(j)] * self.__k_matrix[i, j] out /= (self.__dx_matrix[floor(i)] + self.__dx_matrix[ceil(i)]) / 2 return out else: assert False, "wrong index, not int + int and a half-like int"
def validate_arguments(args): if "socket" not in args or not utils.check_int(args["socket"]) or\ int(args["socket"]) < SOCKET_TYPE_MIN or int(args["socket"]) > SOCKET_TYPE_MAX: return False return True