def banner(): while True: print "1. Press 1 for running the tokenizer usually" print "2. Press 2 for creating the inverted index" print "3. Press 3 for creating the vectors for the documents" print "4. Press any other number to search" choice = int(raw_input("$ ")) if not os.path.exists(TEXT): print "No Data at All. No Valid Corpus. Please add something to\n" + str(TEXT) if not os.path.exists(DATA_PATH): print "No Data Existed, Path Created" os.mkdir(DATA) if not os.path.exists(TOKENS) or choice == 1: print "Creating tokens as they don't exist/You Chose To" os.mkdir(TOKENS) tokenizer() if not os.path.exists(INDICES) or choice == 2: print "Creating indices as they don't exist" os.mkdir(INDICES) counter() if not os.path.exists(SCORES) or choice == 3: print "Creating Vectors as they don't exist" os.mkdir(SCORES) score() mod() if choice > 3 or choice == 0: print "Search begins" break
def test_mod_type(self): result = mod.mod(30, 4) self.assertIsInstance(result, int) result = mod.mod(10, 6) self.assertIsInstance(result, int) result = mod.mod(12, 6.5) self.assertFalse(type(result) is int) result = mod.mod(100, 2.5) self.assertFalse(type(result) is int) result = mod.mod(10, 1.5) self.assertFalse(type(result) is int)
def addMod(self, fileList, modPath): m = mod.mod() m.open(os.path.join(modPath, mod.mod.MODCFG)) pathLength = len(modPath) for f in fileList: alias = f[pathLength:] self.cur.execute("INSERT INTO files VALUES (?, ?, ?, ?)", (f, alias, m.name, m.version)) self.cur.execute("INSERT INTO mods VALUES (?, ?, ?, ?, ?)", (modPath, m.name, m.version, m.author, m.description)) self.con.commit()
class modHandler(): modlist = [] current_mod = mod() def __init__(self): # imports the available mods and sets the current mod to default modlist = self.importModList() # this will probably change current_mod = modlist[0] def importModList(self): #not done yet pass
def test_mult_result(self): result = mod.mod(10, 4) self.assertEqual(result, 2) result = mod.mod(20, 8) self.assertEqual(result, 4) result = mod.mod(30, 11) self.assertEqual(result, 8) result = mod.mod(10, 3) self.assertNotEqual(result, 5) result = mod.mod(14, 3) self.assertNotEqual(result, 35) result = mod.mod(45, 4) self.assertNotEqual(result, 2) result = mod.mod(120, 25) self.assertNotEqual(result, 6)
def decrypt(x,gy,mgxy,g): gxyinvrs = mod.mod(gy,(p-1-x),p) return (mgxy*gxyinvrs)%p
def genkey(x,p): return mod.mod(long(g),x,p)
import multiplication import addition import division import mod import subtraction x = 8 y = 5 result_of_subtraction = subtraction.sub(x, y) result_of_addition = addition.add(x, y) result_of_multiplication = multiplication.multiply(x, y) result_of_division = division.divide(x, y) result_of_mod = mod.mod(x, y) print("X=8 and Y=5") print("Result of subtraction: " + str(result_of_subtraction)) print("Result of addition: " + str(result_of_addition)) print("Result of multiplication: " + str(result_of_multiplication)) print("Result of division: " + str(result_of_division)) print("Result of mod: " + str(result_of_mod))
def encrypt(gy,p,gx,m,y): return (m*mod.mod(gx,y,p))%p
def calculator(): print('\tWELOCME TO OUR SCIENTIFIC CALCULATOR......') print('\t==========================================') print(''' 1. Addition 2. Subtraction 3. Multiplication 4. Division 5. Square 6. Cube 7. Square root 8. Cube root 9. log 10. Antilog 11. Nth Root 12. Nth Power 13. Factorial 14. Matrix(2x2) 15. Matrix(3x3) 16. ln 17. Reciprocal 18. Percentage 19. Exponential 20. Quadratic Equation 21. Sin() 22. Cos() 23. Tan() 24. Sinh 25. Cosh 26. Tanh 27. Length Conversion 28.Temperature Conversion 29. Angle Conversion 30. Permutation 31. Combination ''') #calculator() while True: choice = int(input('Please choose from the following given options!')) if choice == 1: import simple simple.add() elif choice == 2: import simple simple.subtract() elif choice == 3: import simple simple.multiply() elif choice == 4: import simple simple.divide() elif choice == 5: import Square Square.square() elif choice == 6: import Cube Cube.cube() elif choice == 7: import square_root square_root.square_root() elif choice == 8: import cube_root cube_root.cube_root() elif choice == 9: import log log.log() elif choice == 10: antilog.antilog() elif choice == 11: import nth_root nth_root.nth_root() elif choice == 12: import nth_power nth_power.nth_power() elif choice == 13: import factorial factorial.factorial() elif choice == 14: import matrix matrix.matrix() elif choice == 15: matrix_3() elif choice == 16: ln.ln() elif choice == 17: import reciprocal reciprocal.reciprocal() elif choice == 18: import Percentage Percentage.percentage() elif choice == 19: import exponential exponential.exponential() elif choice == 20: import quadratic_eq quadraric_eq.Quadratic() elif choice == 21: import sine sine.sin() elif choice == 22: import cosine cosine.cos() elif choice == 23: import tangent tangent.tan() elif choice == 24: import sinh sinh.sinh() elif choice == 25: import cosh cosh.cosh() elif choice == 26: import tanh tanh.tanh() elif choice == 27: import length_converter length_converter.length_converter() elif choice == 28: import Temp_converter Temp_converter.temperature_converter() elif choice == 29: import angle_converter angle_converter.rad() angle_converter.deg() elif choice == 30: import Combination Combination.npr(x, y) elif choice == 31: import Combination Combination.ncr(x, y) elif choice == 32: import mod mod.mod()
return num1, num2 if command == 1: num1, num2 = takingInput() result = addition.add(num1, num2) print("Sum: ", result) elif command == 2: num1, num2 = takingInput() result = sub.subtraction(num1, num2) print("Subtraction: ", result) elif command == 3: num1, num2 = takingInput() result = divide.divide(num1, num2) print("Division: ", result) elif command == 4: num1, num2 = takingInput() result = multiply.multiply(num1, num2) print("Multiplication: ", result) elif command == 5: num1, num2 = takingInput() result = mod.mod(num1, num2) print("Remainder: ", result) else: print("Invalid Command")
def ana_bfn(config,dict_obs=None, *args, **kwargs): """ NAME ana_bfn DESCRIPTION Perform a BFN experiment on altimetric data and save the results on output directory """ import bfn_functions as bfn # Flag initialization bfn_first_window = True bfn_last_window = False if dict_obs is None: call_obs_func = True import obs else: call_obs_func = False # BFN middle date initialization middle_bfn_date = config.init_date # In the case of Nudging (i.e. bfn_max_iteration=1), set the bfn window length as the entire period of the experience if config.bfn_max_iteration==1: print('bfn_max_iteration has been set to 1 --> ' + 'Only one forth loop will be done on the entiere period of the experience') new_bfn_window_size = config.final_date - config.init_date else: new_bfn_window_size = config.bfn_window_size # Use temp_DA_path to save the projections if config.save_obs_proj: if config.path_save_proj is None: pathsaveproj = config.tmp_DA_path else: pathsaveproj = config.path_save_proj else: pathsaveproj = None # Main time loop while (middle_bfn_date <= config.final_date) and not bfn_last_window : print('\n*** BFN window ***') ############# # 1. SET-UP # ############# # BFN period init_bfn_date = max(config.init_date, middle_bfn_date - new_bfn_window_size/2) init_bfn_date += timedelta(seconds=(init_bfn_date - config.init_date).total_seconds()\ / config.bfn_propation_timestep.total_seconds()%1) middle_bfn_date = max(middle_bfn_date, config.init_date + new_bfn_window_size/2) if ((middle_bfn_date + new_bfn_window_size/2) >= config.final_date): bfn_last_window = True final_bfn_date = config.final_date else: final_bfn_date = init_bfn_date + new_bfn_window_size print('\nfrom ', init_bfn_date, ' to ', final_bfn_date) # propagation timestep one_time_step = config.bfn_propation_timestep # Initialize nc files if bfn_first_window: present_date_forward0 = init_bfn_date present_file_forward0 = config.tmp_DA_path + "/state_forward0.nc" present_file_backward0 = config.tmp_DA_path + "/state_backward0.nc" present_file_forward = config.tmp_DA_path + "/state_forward.nc" present_file_backward = config.tmp_DA_path + "/state_backward.nc" analyzed_vectors_names = config.tmp_DA_path + "/state_analyzed.nc" ######################## # 2.READING STATE GRID # ######################## print('\n* Reading state grid *') # Read box boundaries with xr.open_dataset(config.tmp_DA_path+config.name_init_file) as grd: lon = grd[config.name_mod_lon].values lat = grd[config.name_mod_lat].values if len(lon.shape)==1: ny,nx = lat.size,lon.size else: ny,nx = lon.shape ######################## # 3. Create BFN object # ######################## print('\n* Initialize BFN *') if config.name_model == 'QG1L': bfn_obj = bfn.bfn_qg1l( init_bfn_date, final_bfn_date, config.assimilation_time_step, one_time_step, lon, lat, config.name_mod_var, config.name_grd, config.dist_scale, pathsaveproj, 'projections_' + config.name_domain + '_' + '_'.join(config.satellite), config.c, config.flag_plot, config.scalenudg) elif config.name_model == 'QGML': bfn_obj = bfn.bfn_qgml( init_bfn_date, final_bfn_date, config.assimilation_time_step, one_time_step, lon, lat, config.name_mod_var, config.name_grd, config.dist_scale, config.Rom, config.Fr, config.dh, config.N, config.L0, pathsaveproj, 'projections_' + config.name_domain + '_' + '_'.join(config.satellite), config.flag_plot, config.scalenudg) else: print('Error: No BFN class implemented for', config.name_model, 'model') sys.exit() ###################################### # 4. BOUNDARY AND INITIAL CONDITIONS # ###################################### print("\n* Boundary and initial conditions *") # Boundary condition if config.flag_use_boundary_conditions: timestamps = np.arange(calendar.timegm(init_bfn_date.timetuple()), calendar.timegm(final_bfn_date.timetuple()), one_time_step.total_seconds()) bc_field, bc_weight = grid.boundary_conditions(config.file_boundary_conditions, config.lenght_bc, config.name_var_bc, timestamps, lon, lat, config.flag_plot, bfn_obj.sponge) else: bc_field = bc_weight = bc_field_t = None # Initial condition if bfn_first_window: # Use previous state as initialization init_file = config.path_save + config.name_exp_save\ + '_y' + str(init_bfn_date.year)\ + 'm' + str(init_bfn_date.month).zfill(2)\ + 'd' + str(init_bfn_date.day).zfill(2)\ + 'h' + str(init_bfn_date.hour).zfill(2)\ + str(init_bfn_date.minute).zfill(2) + '.nc' if not os.path.isfile(init_file) : restart = False print(init_file, " : Init file is not present for nudging." + "We will use the current state vectors...") cmd = "cp "+ config.tmp_DA_path+config.name_init_file + " " +\ present_file_forward0 os.system(cmd) else: restart = True print(init_file, " is used as initialization") cmd = "cp " + init_file + " " + present_file_forward0 os.system(cmd) elif config.bfn_window_overlap: # Use last state from the last forward loop as initialization name_previous = config.name_exp_save\ + '_y' + str(init_bfn_date.year)\ + 'm' + str(init_bfn_date.month).zfill(2)\ + 'd' + str(init_bfn_date.day).zfill(2)\ + 'h' + str(init_bfn_date.hour).zfill(2)\ + str(init_bfn_date.minute).zfill(2) + '.nc' filename_forward = config.tmp_DA_path + '/BFN_forth_' + name_previous cmd = 'cp ' + filename_forward + ' ' + present_file_forward0 os.system(cmd) ################### # 5. Observations # ################### # Selection print('\n* Select observations *') if call_obs_func: print('Calling obs_all_observationcheck function...') dict_obs_it = obs.obs(config) bfn_obj.select_obs(dict_obs_it) dict_obs_it.clear() del dict_obs_it else: bfn_obj.select_obs(dict_obs) # Projection print('\n* Project observations *') bfn_obj.do_projections() ############### # 6. BFN LOOP # ############### err_bfn0 = 0 err_bfn1 = 0 bfn_iter = 0 Nold_t = None while bfn_iter==0 or\ (bfn_iter < config.bfn_max_iteration and abs(err_bfn0-err_bfn1)/err_bfn1 > config.bfn_criterion): if bfn_iter>0: present_date_forward0 = init_bfn_date # Save last backward analysis as init forward file cmd0 = "cp " + present_file_backward0 + " " + present_file_forward0 os.system(cmd0) err_bfn0 = err_bfn1 bfn_iter += 1 if bfn_iter == config.bfn_max_iteration: print('\nMaximum number of iterations achieved (' + str(config.bfn_max_iteration) + ') --> last Forth loop !!') ################### # 6.1. FORTH LOOP # ################### print("\n* Forward loop " + str(bfn_iter) + " *") while present_date_forward0 < final_bfn_date : #print('i = ' + str(bfn_iter) + ' forward : ' +str(present_date_forward0) ) # Retrieve corresponding time index for the forward loop iforward = int((present_date_forward0 - init_bfn_date)/one_time_step) # Get BC field if bc_field is not None: bc_field_t = bc_field[iforward] # Propagate the state by nudging the model vorticity towards the 2D observations present_file_forward = mod.mod(config, state_vector0_name=present_file_forward0, present_date0=present_date_forward0, tint=+one_time_step.total_seconds(), Nudging_term=Nold_t, Hbc=bc_field_t, Wbc=bc_weight, state_vector_name=present_file_forward) # Time increment present_date_forward = present_date_forward0 + one_time_step # Get analysis analysis = tools.vectorize(present_file_forward, config.name_mod_var, ) # Nudging term (next time step) N_t = bfn_obj.compute_nudging_term( present_date_forward, analysis ) # Update model parameter if config.name_model == 'QG1L': analysis_updated = bfn_obj.update_parameter( analysis, Nold_t, N_t, bc_weight, way=1 ) if np.any(analysis_updated!=analysis): tools.vector_save( analysis_updated, lon, lat, config.n_mod_var, config.name_mod_var, config.name_mod_lon, config.name_mod_lat, present_file_forward) # Save output every *saveoutput_time_step* if (((present_date_forward - config.init_date)/config.saveoutput_time_step)%1 == 0)\ & (present_date_forward>config.init_date) : name_save = config.name_exp_save + '_' + str(iforward).zfill(5) + '.nc' filename_forward = config.tmp_DA_path + '/BFN_forth_' + name_save save_presentoutputs(present_file_forward, present_date_forward, filename=filename_forward) if config.save_bfn_trajectory: filename_traj = config.path_save + 'BFN_' + str(middle_bfn_date)[:10]\ + '_forth_' + str(bfn_iter) + '/' + name_save if not os.path.exists(os.path.dirname(filename_traj)): os.makedirs(os.path.dirname(filename_traj)) save_presentoutputs(present_file_forward, present_date_forward, filename=filename_traj) # Save updated state vector as initial state vector cmd0 = "cp " + present_file_forward + " " + present_file_forward0 os.system(cmd0) # Time update present_date_forward0 = present_date_forward Nold_t = N_t # Plot for debugging if config.flag_plot > 0: analysis = analysis.reshape((config.n_mod_var, ny, nx)) # SSH, PV fig, (ax1, ax2) = plt.subplots(1, 2, figsize=((10, 5))) p1 = ax1.pcolormesh(lon, lat, analysis[1],shading='auto') p2 = ax2.pcolormesh(lon, lat, analysis[0],shading='auto') plt.colorbar(p1, ax=ax1) plt.colorbar(p2, ax=ax2) ax1.set_title('Potential vorticity') ax2.set_title('SSH') plt.show() ################## # 6.2. BACK LOOP # ################## if bfn_iter < config.bfn_max_iteration: print("\n* Backward loop " + str(bfn_iter) + " *") present_date_backward0 = final_bfn_date # Save last forward analysis as init backward file cmd0 = "cp " + present_file_forward0 + " " + present_file_backward0 os.system(cmd0) while present_date_backward0 > init_bfn_date : #print('i = ' + str(bfn_iter) + ' backward : ' +str(present_date_backward0) ) # Retrieve corresponding time index for the backward loop ibackward = int((present_date_backward0 - init_bfn_date)/one_time_step) # Get BC field if bc_field is not None: bc_field_t = bc_field[ibackward-1] # Propagate the state by nudging the model vorticity towards the 2D observations present_file_backward = mod.mod(config, state_vector0_name=present_file_backward0, present_date0=present_date_backward0, tint=-one_time_step.total_seconds(), Nudging_term=Nold_t, Hbc=bc_field_t, Wbc=bc_weight, state_vector_name=present_file_backward) # Time increment present_date_backward = present_date_backward0 - one_time_step # Get analysis analysis = tools.vectorize(present_file_backward, config.name_mod_var) # Nudging term (next time step) N_t = bfn_obj.compute_nudging_term( present_date_backward, analysis ) # Update model parameter if config.name_model == 'QG1L': analysis_updated = bfn_obj.update_parameter( analysis, Nold_t, N_t, bc_weight, way=-1 ) if np.any(analysis_updated!=analysis): tools.vector_save( analysis_updated, lon, lat, config.n_mod_var, config.name_mod_var, config.name_mod_lon, config.name_mod_lat, present_file_backward) # Save output every *saveoutput_time_step* if (((present_date_backward - config.init_date)/config.saveoutput_time_step)%1 == 0)\ & (present_date_backward>=config.init_date) : name_save = config.name_exp_save + '_' + str(ibackward).zfill(5) + '.nc' filename_backward = config.tmp_DA_path + '/BFN_back_' + name_save save_presentoutputs(present_file_backward, present_date_backward, filename=filename_backward) if config.save_bfn_trajectory: filename_traj = config.path_save + 'BFN_' + str(middle_bfn_date)[:10]\ + '_back_' + str(bfn_iter) + '/' + name_save if not os.path.exists(os.path.dirname(filename_traj)): os.makedirs(os.path.dirname(filename_traj)) save_presentoutputs(present_file_backward, present_date_backward, filename=filename_traj) # Save updated state vector as initial state vector cmd0 = "cp " + present_file_backward + " " + present_file_backward0 os.system(cmd0) # Time update present_date_backward0 = present_date_backward Nold_t = N_t if config.flag_plot > 0: analysis = analysis.reshape((config.n_mod_var, ny, nx)) # SSH, PV fig, (ax1, ax2) = plt.subplots(1, 2, figsize=((10, 5))) p1 = ax1.pcolormesh(lon, lat, analysis[1],shading='auto') p2 = ax2.pcolormesh(lon, lat, analysis[0],shading='auto') plt.colorbar(p1, ax=ax1) plt.colorbar(p2, ax=ax2) ax1.set_title('Potential vorticity') ax2.set_title('SSH') plt.show() ######################### # 6.3. CONVERGENCE TEST # ######################### if bfn_iter < config.bfn_max_iteration: print('\n* Convergence test *') err_bfn1 = bfn_obj.convergence( path_forth=config.tmp_DA_path + '/BFN_forth_', path_back=config.tmp_DA_path + '/BFN_back_' ) print("\n* End of the BFN loop after " + str(bfn_iter) + " iterations *") ##################### # 7. SAVING OUTPUTS # ##################### print('\n* Saving last forth loop as outputs for the following dates : *') # Set the saving temporal window if config.bfn_max_iteration==1: write_date_min = init_bfn_date write_date_max = final_bfn_date elif bfn_first_window: write_date_min = init_bfn_date write_date_max = init_bfn_date + new_bfn_window_size/2 + config.bfn_window_output/2 elif bfn_last_window: write_date_min = middle_bfn_date - config.bfn_window_output/2 write_date_max = final_bfn_date else: write_date_min = middle_bfn_date - config.bfn_window_output/2 write_date_max = middle_bfn_date + config.bfn_window_output/2 # Write outputs in the saving temporal window present_date = init_bfn_date while present_date < final_bfn_date : present_date += one_time_step if (present_date > write_date_min) & (present_date <= write_date_max) : # Save output every *saveoutput_time_step* if (((present_date - config.init_date).total_seconds() /config.saveoutput_time_step.total_seconds())%1 == 0)\ & (present_date>config.init_date)\ & (present_date<=config.final_date) : print(present_date, end=' / ') # Read current converged state iforward = int((present_date - init_bfn_date)/one_time_step) - 1 name_save = config.name_exp_save + '_' + str(iforward).zfill(5) + '.nc' current_file = config.tmp_DA_path + '/BFN_forth_' + name_save vars_current = tools.vectorize(current_file, config.name_mod_var, ) # Smooth with previous BFN window if config.bfn_window_overlap and (not bfn_first_window or restart): # Read previous output at this timestamp previous_file = config.path_save + config.name_exp_save\ + '_y'+str(present_date.year)\ + 'm'+str(present_date.month).zfill(2)\ + 'd'+str(present_date.day).zfill(2)\ + 'h'+str(present_date.hour).zfill(2)\ + str(present_date.minute).zfill(2) + \ '.nc' if os.path.isfile(previous_file): vars_previous = tools.vectorize(previous_file, config.name_mod_var ) # weight coefficients W1 = max((middle_bfn_date - present_date) / (config.bfn_window_output/2), 0) W2 = min((present_date - write_date_min) / (config.bfn_window_output/2), 1) analysis = W1*vars_previous + W2*vars_current else: analysis = vars_current else: analysis = vars_current tools.vector_save(analysis, lon, lat, config.n_mod_var, config.name_mod_var, config.name_mod_lon, config.name_mod_lat, analyzed_vectors_names, date=present_date) # Save output if config.saveoutputs: save_presentoutputs(analyzed_vectors_names,present_date, name_exp=config.name_experiment, path=config.path_save) print() ######################## # 8. PARAMETERS UPDATE # ######################## if config.bfn_window_overlap: window_lag = config.bfn_window_output/2 else: window_lag = config.bfn_window_output if bfn_first_window: middle_bfn_date = config.init_date + new_bfn_window_size/2 + window_lag bfn_first_window = False else: middle_bfn_date += window_lag ############### # 9. CLEANING # ############### print("Cleaning") # Remove state file cmd = "rm " + present_file_forward + " " + present_file_forward0\ + " " + present_file_backward + " " + present_file_backward0\ + " " + analyzed_vectors_names os.system(cmd)
def test_mod_20_6(): line = '20,6\n' expected = 20 % 6 actual = mod(line) assert actual == expected
def test_mod_2_3(): line = '2,3\n' expected = 2 % 3 actual = mod(line) assert actual == expected
def keygen(g,p,y): return mod.mod(g,y,p)
def test_endpoint(self): #assign the x, y and modulus url variables x_arg = '?x=' y_arg = '&y=' modURL = 'http://mod.40175607.qpc.hal.davecutting.uk/' #internal private cloud endpoint #set the x and y values and the expected result from their mod calculation x_string = '100' y_string = '11' expected_result = mod.mod(100, 11) #combine the above variables into one url string http_output = modURL + x_arg + x_string + y_arg + y_string #use the urllib module to call the mod url and parse the result value from the json object url_output = urlopen(http_output) json_obj = url_output.read() json_data = json.loads(json_obj) result = json_data['answer'] #assert that the produced result == expected_result self.assertEqual(result, expected_result) x_string = '10' y_string = '6' expected_result = mod.mod(10, 6) http_output = modURL + x_arg + x_string + y_arg + y_string url_output = urlopen(http_output) json_obj = url_output.read() json_data = json.loads(json_obj) result = json_data['answer'] self.assertEqual(result, expected_result) x_string = '39' y_string = '26' expected_result = mod.mod(39, 26) http_output = modURL + x_arg + x_string + y_arg + y_string url_output = urlopen(http_output) json_obj = url_output.read() json_data = json.loads(json_obj) result = json_data['answer'] self.assertEqual(result, expected_result) x_string = '59' y_string = '3' expected_result = mod.mod(59, 14) http_output = modURL + x_arg + x_string + y_arg + y_string url_output = urlopen(http_output) json_obj = url_output.read() json_data = json.loads(json_obj) result = json_data['answer'] self.assertNotEqual(result, expected_result) x_string = '400' y_string = '9' expected_result = mod.mod(400, 21) http_output = modURL + x_arg + x_string + y_arg + y_string url_output = urlopen(http_output) json_obj = url_output.read() json_data = json.loads(json_obj) result = json_data['answer'] self.assertNotEqual(result, expected_result) x_string = '22' y_string = '10' expected_result = mod.mod(22, 8) http_output = modURL + x_arg + x_string + y_arg + y_string url_output = urlopen(http_output) json_obj = url_output.read() json_data = json.loads(json_obj) result = json_data['answer'] self.assertNotEqual(result, expected_result)
import mod mod.mod() mod.fn()