def main(): # Handles command line args if len(sys.argv) != 3: print("Incorrect amount of args") return args = sys.argv[1:] try: int(args[0]) float(args[1]) except ValueError: print("Incorrect arg types") return if(int(args[0]) != 1 and float(args[1]) != 2): print("Turn arg must be 1 or 2") return # Initializes board board = init_board() turn = int(args[0]) print("Initial board:") utils.print_board(board) # Loops until someone wins while len(utils.get_next_board_states(board, turn)) > 0: board = montecarlo(board, turn, float(args[1])) print(f"{turn} goes") utils.print_board(board) turn = utils.next_turn(turn) print(f"{utils.next_turn(turn)} wins!")
def parallel(N, comm=MPI.COMM_WORLD): rank = comm.Get_rank() size = comm.Get_size() # usamos seed=rank para ter resultados diferentes para cada processo # cada processo eh responsavel por calcular o resultado para uma parcela menor do problema, de tamanho N/size return montecarlo(int(N / size), seed=rank)
interval = num_episodes - 1 decay = num_episodes / 10 QSAtable = tdlambda(sim, l=0.5, alpha=0.1, initial_epsilon=0.1, num_episodes=num_episodes, interval=interval, decay=decay, return_qsa=True) plot_QSAtable(QSAtable, title='q(s, a) values for TD Lambda(0.5)', path='plots/tdlambda', name='QSA %d' % num_episodes, show=False) PItable = derive_pi_table(QSAtable) plot_PItable(PItable, title='Optimal Policy using TD Lambda(0.5)', path='plots/tdlambda', name='PI %d' % num_episodes, show=False) # Evaluating the policy Qtable = montecarlo(sim, PItable, num_episodes=500000) plot_Qtable(Qtable, title='V(s) values for TD Lambda(0.5)', path='plots/tdlambda', name='V %d' % num_episodes, show=False)
P = int( np.log2( N - 1 ) ) ## Loop over the base scale methods for delta_method in [ 'med', ] : ## Create the necessary directory structure target_path = os.path.join( basepath, "FBM_%d" % ( P, ), delta_method ) os.makedirs( target_path ) ## Run simulations for different Hurst exponents for H in np.linspace( .5, .9, num = 5 ) : ## Initalize the generator generator = fbm( N = N, H = H, time = True ) print "Monte-Carlo (%d) for FBM(2**%d+1, %.4f), %s:" % ( M, P, H, delta_method, ) ## Get the current timestamp start_dttm = datetime.utcnow( ) ## Run the experiment results = montecarlo( generator, mc_kernel, processes = 2, debug = False, quiet = False, parallel = True, replications = M, delta = delta_method, L = 20, K = 40 ) ## Create a meaningful name for the output data blob file_name = "FBM_%s_%s_%d_%.4f_%d" % ( delta_method.lower( ), start_dttm.strftime( "%Y%m%d-%H%M%S" ), P, H, M ) ## Save the data blob sim_save( os.path.join( target_path, file_name ), results, save_durations = True ) #################################################################################################### if False : ## Hermite processes ## The parameters of the simulation N, K, M = 2**18+1, 2**4, 1000 P = int( np.log2( N - 1 ) ) for delta_method in [ 'med', ] : for D in [ 2, 3, 4, ] : target_path = os.path.join( basepath,
from montecarlo import montecarlo from random import randint def flip_is_heads(g): return randint(0, 1) == 0 mc = montecarlo(flip_is_heads) result = mc.run() print("Result returned: " + str(result))
from montecarlo import montecarlo from random import randint def flip_is_heads(g): return randint(0, 1) == 0 mc = montecarlo(flip_is_heads) result = mc.run() print "Result returned: " + str(result)
def sequential(N): acertos = montecarlo(N) return (acertos / N) * 4
else : T = T[ 0 ] return path_kernel( T, X, **op ) if __name__ == '__main__' : # basepath = os.path.join( '.', 'output', 'HRM_2_20-32' ) basepath = os.path.join( '.', 'output', 'HRM_3_20-32' ) path = [ os.path.join( basepath, H ) for H in [ '0.5000', '0.6000', '0.7000', '0.8000', ] ] for p in path : ## Go! files = list_files( p, pattern = r"\.mat$" ) print( "Sweeping through %s: %d files found." %( p, len( files ), ) ) ## Pick the first file and extract as much information as possible from its filename prefix, degree, size, hurst = os.path.basename( files[0] ).split( "_" )[:4] prefix += "-%s"%( degree, ) ## Loop thorugh all the possible base scale calculation methods for delta_method in [ 'std', 'iqr', 'med', ] : ## Get the current timestamp run_dttm = datetime.utcnow( ) ## Run the analyzer in parallel result = montecarlo( empty( ), offline_kernel, processes = 1, debug = False, quiet = False, parallel = False, replications = files, delta = delta_method, L = 20, K = 40 ) ## Get the datetime after the simulation has finished end_dttm = datetime.utcnow( ) ## Create a meaningful name for the output data blob sim_save( os.path.join( basepath, "%s_%s_%s_%s_%s_%d" % ( prefix, delta_method.lower( ), run_dttm.strftime( "%Y%m%d-%H%M%S" ), size, hurst, len( files ) ) ), result, save_durations = True )
import montecarlo a = montecarlo.montecarlo() a.diffusion_tree() a.structure_geometry() a.rebar_calc() a.crack_calc() a.derating_calc() a.parameter_fill() a.monte_zeroes() a.monte_fill() a.histogram() a.outputs() a.normalization() a.plot_damage() print a.monte_bincount print a.x
import sys #import time #import numpy as np # from header import header from montecarlo import montecarlo from fire import fire from control import control effect = "" try: effect = sys.argv[1] except IndexError: print("") # Initialize Pixels num_pixels, pixels = header(300) if (effect == "montecarlo"): montecarlo(num_pixels, pixels) elif (effect == "fire"): fire(num_pixels, pixels) elif (effect == "control"): control(num_pixels, pixels)