def main(): B = util.Benchmark() H = B.size[0] W = B.size[1] A1 = B.random_array((H, W)) A2 = B.random_array((H, W)) A3 = B.random_array((H, W)) A4 = B.random_array((H, W)) B.start() R = solve_tridiag(A1, A2, A3, A4, B) if util.Benchmark().bohrium: R.copy2numpy() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.verbose: print(R)
def main(): B = util.Benchmark() # Initialize Benchpress N, T = B.size # Grab command-line arguments if B.inputfn: dataset = B.load_array() else: dataset = np.arange(N, dtype=B.dtype) / B.dtype( N) # Create psuedo-data if B.dumpinput: B.dump_arrays("rosenbrock", {'input': dataset}) B.start() # Sample wall-clock start res = 0.0 for _ in range(0, T): # Do T trials of.. res += rosen(dataset) # ..executing rosenbrock. util.Benchmark().flush() res /= T B.stop() # Sample wall-clock stop B.pprint() # Print elapsed wall-clock etc. R = np.zeros((1), dtype=B.dtype) R[0] = res if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.verbose: # Print more, such as results print(R)
def main(): B = util.Benchmark() N = B.size[0] if B.inputfn: S = B.load_array() else: S = B.random_array((N, N)) if B.dumpinput: B.dump_arrays("gauss", {'input':S}) B.start() for c in range(1, S.shape[0]): S[c:, c - 1:] -= (S[c:,c-1:c] / S[c-1:c,c-1:c]) * S[c-1:c,c-1:] B.flush() S /= np.diagonal(S)[:, None] R = S if util.Benchmark().bohrium: R.copy2numpy() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.verbose: print (R)
def main(): B = util.Benchmark() k = B.size[0] # number of plane waves stripes = B.size[1] # number of stripes per wave N = B.size[2] # image size in pixels ite = B.size[3] # iterations phases = np.arange(0, 2*np.pi, 2*np.pi/ite) image = np.empty((N, N), dtype=B.dtype) d = np.arange(-N/2, N/2, dtype=B.dtype) xv, yv = np.meshgrid(d, d) theta = np.arctan2(yv, xv) r = np.log(np.sqrt(xv*xv + yv*yv)) r[np.isinf(r) == True] = 0 tcos = theta * np.cos(np.arange(0, np.pi, np.pi/k))[:, np.newaxis, np.newaxis] rsin = r * np.sin(np.arange(0, np.pi, np.pi/k))[:, np.newaxis, np.newaxis] inner = (tcos - rsin) * stripes cinner = np.cos(inner) sinner = np.sin(inner) B.start() for phase in phases: image[:] = np.sum(cinner * np.cos(phase) - sinner * np.sin(phase), axis=0) + k util.Benchmark().flush() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': image})
def main(): B = util.Benchmark() N = B.size[0] if B.inputfn: S = B.load_array() else: S = B.random_array((N, N)) if B.dumpinput: B.dump_arrays("gauss", {'input': S}) B.start() R = la.gauss(S) if util.Benchmark().bohrium: R.copy2numpy() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.verbose: print(R)
def main(): B = util.Benchmark() # Initialize Benchpress nplanets, nbodies, timesteps = B.size # Grab arguments x_max = 1e18 # Simulation constants y_max = 1e18 z_max = 1e18 dt = 1e12 solarsystem, asteroids = random_system( # Setup galaxy x_max, y_max, z_max, nplanets, nbodies, B.dtype) if B.visualize: # Init visuals plt, P3 = gfx_init(x_max, y_max, z_max) B.start() # Timer start for timestep in range(0, timesteps): # Run simulation if B.visualize and timestep % 10 == 0: # With or without.. gfx_show(plt, P3, solarsystem, asteroids) # ..visuals move(solarsystem, asteroids, dt) util.Benchmark().flush() B.stop() # Timer stop B.pprint() # Print results.. if B.verbose: # ..and more. print(R) if B.visualize: # Keep showing visuals plt.show(block=True)
def solve(samples, iterations, B): acc = 0.0 for _ in range(iterations): acc += montecarlo_pi(samples, B) util.Benchmark().flush() acc /= iterations return acc
def main(): B = util.Benchmark() if B.inputfn is None: B_x0 = B.random_array((B.size[0], B.size[1]), dtype=B.dtype) else: inputfn = B.inputfn if B.inputfn else '../idl_input-float64_512*512.npz' sd = {512: 1, 256: 2, 128: 4, 64: 8, 32: 16, 16: 32, 8: 64} try: h = sd[B.size[0]] w = sd[B.size[1]] except KeyError: raise ValueError('Only valid sizes are: ' + str(sd.keys())) B_x0 = B.load_array(inputfn, 'input', dtype=B.dtype)[::h, ::w] B.start() for _ in range(B.size[2]): Rx, Ry, Rz = calcB_numba(window(B_x0.copy())) """ Rx1, Ry1, Rz1 = calcB_loop(window(B_x0.copy())) assert np.allclose(Rx, Rx1) assert np.allclose(Ry, Ry1) assert np.allclose(Rz, Rz1) """ B.stop() B.pprint() if B.outputfn: R = Rx + Ry + Rz B.tofile(B.outputfn, {'res': R, 'res_x': Rx, 'res_y': Ry, 'res_z': Rz})
def main(): B = util.Benchmark() (H, W, I, V) = B.size if V not in [1, 2]: raise Exception("Unsupported rule-implementation.") if B.inputfn: if "LIF" in B.inputfn: paths = pattern_paths("cells") S = world_zeros(H, W, B) cells = cells_from_file(B.inputfn) insert_cells(S, cells) else: S = B.load_array() else: S = world(H, W, B) B.start() R = play(S, I, V, B.visualize) B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.visualize: util.confirm_exit()
def main(): B = util.Benchmark() num_asteroids = B.size[0] num_planets = B.size[1] num_iteratinos = B.size[2] x_max = 1e18 y_max = 1e18 z_max = 1e18 dt = 1e12 solarsystem, astoroids = random_system(x_max, y_max, z_max, num_planets, num_asteroids, B) if B.verbose: P3 = gfx_init(x_max, y_max, z_max) B.start() for _ in range(num_iteratinos): move(solarsystem, astoroids, dt) if B.verbose: show(P3, solarsystem, astoroids) R = solarsystem['x'] B.stop() B.pprint() if B.verbose: print(R) if B.outputfn: B.tofile(B.outputfn, {'res': R})
def main(): B = util.Benchmark() fig = plt.figure() plt.xticks([]) plt.yticks([]) k = B.size[0] # number of plane waves stripes = B.size[1] # number of stripes per wave N = B.size[2] # image size in pixels ite = B.size[3] # iterations phases = np.array([i * (2 * np.pi / (ite)) for i in range(ite)]) image = np.empty((N, N), dtype=B.dtype) d = np.arange(-N / 2, N / 2, dtype=B.dtype) xv, yv = np.meshgrid(d, d) theta = np.arctan2(yv, xv) r = np.log(np.sqrt(xv * xv + yv * yv)) r[np.isinf(r) == True] = 0 arr = np.array([i * np.pi / k for i in range(k)]) tcos = theta * np.cos(arr)[:, np.newaxis, np.newaxis] rsin = r * np.sin(arr)[:, np.newaxis, np.newaxis] inner = (tcos - rsin) * stripes cinner = np.cos(inner) sinner = np.sin(inner) B.start() for phase in phases: image[:] = np.sum(cinner * np.cos(phase) - sinner * np.sin(phase), axis=0) + k util.Benchmark().flush() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': image}) if B.verbose: print(image)
def main(): B = util.Benchmark() samples, iterations = B.size B.start() R = solve(samples, iterations, B) B.stop() B.pprint() if B.verbose: print(R)
def simulate(galaxy, timesteps, visualize=False): for i in range(timesteps): move(galaxy, dt) util.Benchmark().flush() if visualize: #NB: this is only for experiments T = np.zeros((3, len(galaxy['x'])), dtype=np.float32) T[0, :] = galaxy['x'] T[1, :] = galaxy['y'] T[2, :] = galaxy['z'] np.visualize(T, "3d", 0, 0.0, 10)
def main(): B = util.Benchmark() scene_res = B.size[0] detector_res = B.size[1] iterations = B.size[2] scene = setup(scene_res, detector_res) B.start() for _ in range(iterations): detector_results = xraysim(*scene, visualize=B.visualize) if util.Benchmark().bohrium: B.flush() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': detector_results[0]}) if B.visualize: util.confirm_exit()
def main(): B = util.Benchmark() N = B.size[0] I = B.size[1] if B.inputfn: galaxy = B.load_arrays(B.inputfn) else: galaxy = random_galaxy(N, B, B.dtype) util.Benchmark().flush() if B.dumpinput: B.dump_arrays("nbody", galaxy) B.start() simulate(galaxy, I, visualize=B.visualize) R = galaxy['x'] + galaxy['y'] + galaxy['z'] B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R})
def main(): B = util.Benchmark() N = B.size[0] if B.inputfn: a = B.load_array() else: a = B.random_array((N, N), dtype=B.dtype) if B.dumpinput: B.dump_arrays("lu", {'input': a}) B.start() (l, u) = la.lu(a) if util.Benchmark().bohrium: l.copy2numpy() u.copy2numpy() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': u}) if B.verbose: print(u)
def main(): B = util.Benchmark() # Initialize Benchpress try: N, I = B.size # Grab command-line arguments except ValueError: N, I = (B.size[0], 1) B.start() # Sample wall-clock start R = 0.0 for _ in range(I): R += 4.0 * leibnitz_pi(N) # Execute benchmark B.flush() B.stop() # Sample wall-clock stop B.pprint() # Print elapsed wall-clock etc. if B.verbose: # Print more, such as results print(R)
def play(state, iterations, version=1, visualize=False): cells = state[1:-1, 1:-1] ul = state[0:-2, 0:-2] um = state[0:-2, 1:-1] ur = state[0:-2, 2:] ml = state[1:-1, 0:-2] mr = state[1:-1, 2:] ll = state[2:, 0:-2] lm = state[2:, 1:-1] lr = state[2:, 2:] def update(): """ This is the first implementation of the game rules. """ neighbors = ul + um + ur + ml + mr + ll + lm + lr # count neighbors live = neighbors * cells # extract live cells neighbors stay = (live >= SURVIVE_LOW) & (live <= SURVIVE_HIGH ) # find cells the stay alive dead = neighbors * (cells == 0) # extract dead cell neighbors spawn = dead == SPAWN # find cells that spaw new life cells[:] = stay | spawn # save result for next iteration def update_optimized(): """ This is an optimized implementation of the game rules. """ neighbors = ul + um + ur + ml + mr + ll + lm + lr # Count neighbors c1 = (neighbors == SURVIVE_LOW) # Life conditions c2 = (neighbors == SPAWN) cells[:] = cells * c1 + c2 # Update if version == 1: # Select the update function update_func = update elif version == 2: update_func = update_optimized for i in range(iterations): # Run the game if visualize: util.plot_surface(state, "3d", 16, 1, 0) update_func() util.Benchmark().flush() return state
def main(): B = util.Benchmark() H = B.size[0] W = B.size[1] I = B.size[2] state = B.load_data() if state is None: state = cylinder(H, W) B.start() solve(B, state, I, B.visualize) B.stop() B.save_data(state) B.pprint() if B.verbose: print("Iterations=%s, State: %s." % (I, state)) if B.visualize: util.confirm_exit()
def main(): B = util.Benchmark() (image_size, filter_size, I) = B.size image = B.random_array((image_size,)) image_filter = B.random_array((filter_size,)) B.start() for _ in range(I): R = np.convolve(image, image_filter) B.flush() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.verbose: print (R)
def main(): B = util.Benchmark() H = B.size[0] W = B.size[1] I = B.size[2] state = B.load_data() if state is None: state = model(H, W, dtype=B.dtype) B.start() simulate(B, state, I, visualize=B.visualize) B.stop() B.save_data(state) B.pprint() if B.verbose: print("Iterations=%s, State: %s." % (I, state)) if B.visualize: util.confirm_exit()
def wireworld(world, iterations): """TODO: Describe the benchmark.""" sim = no_border(world, 1) # Active Machine stencil = D2P8(world) # Stencil for counting heads NC = sum([v == 2 for v in stencil]) # Count number of head neighbors for _ in range(iterations): # Mask conductor->head MASK = ((NC == 1) & (sim == 8)) | ((NC == 2) & (sim == 8)) sim *= ~MASK # New head pos->0 sim += np.array(MASK * 1, np.uint8) # New head pos->1 MASK = (sim == 8) # Mask non conductors sim *= ~MASK # conductors->0 sim += np.array(MASK * 4, np.uint8) # conductors->4 sim *= 2 # Upgrade all to new state util.Benchmark().flush() return sim
def main(): B = util.Benchmark() H = B.size[0] W = B.size[1] I = B.size[2] grid = B.load_data() if grid is not None: grid = grid['grid'] else: grid = init_grid(H, W, dtype=B.dtype) B.start() grid = jacobi(B, grid, max_iterations=I, visualize=B.visualize) B.stop() B.save_data({'grid': grid}) B.pprint() if B.verbose: print("Iterations=%s, Grid: %s." % (I, grid)) if B.visualize: util.confirm_exit()
def main(): B = util.Benchmark() num_beans, height = B.size B.start() R = bean(B, num_beans, height) B.stop() B.pprint() if B.verbose: print(R) if B.visualize: from matplotlib import pyplot bins = 100 pyplot.hist(R, bins) pyplot.title("Galton Normal distribution") pyplot.xlabel("Value") pyplot.ylabel("Frequency") pyplot.show() if B.outputfn: B.tofile(B.outputfn, {'res': R})
def main(): """ Example parameter: --size=100*10. This will execute on a 1000x1000 dataset for 10 iterations. """ B = util.Benchmark() (N, I) = B.size if B.inputfn: world = B.load_array() else: world = wireworld_init(N) if B.dumpinput: B.dump_arrays("wireworld", {"input": world}) B.start() R = wireworld(world, I) B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {"res": R})
def main(): B = util.Benchmark() H = B.size[0] W = B.size[1] I = B.size[2] state = cylinder(H, W, obstacle=False) viz = None if B.verbose: viz = setup_viz(state) B.start() if viz: thread = threading.Thread(target=solve, args=(state, I, B, viz)) thread.start() viz['tk'].mainloop() else: R = solve(state, I, B, viz) B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': np.array(R)})
def main(): """ Convolve filter (any dimensional) Parameter: `--size<image-size>*<filter-size>*<ndims>*<niters>` where image and filter size is the size of each dimension (not their total size). """ B = util.Benchmark() (image_size, filter_size, ndims, I) = B.size image = B.random_array((image_size**ndims, )).reshape([image_size] * ndims) image_filter = B.random_array( (filter_size**ndims, )).reshape([filter_size] * ndims) B.start() for _ in range(I): R = bh.convolve_scipy(image, image_filter) B.flush() B.stop() B.pprint() if B.outputfn: B.tofile(B.outputfn, {'res': R}) if B.verbose: print(R)
def xraysim(sourcelist, detectordeflist, scenegrid, scenematerials, materials, scene_resolution, detector_resolution, verbose=False, visualize=False): """ performs the calculations figuring out what is detected INPUT: sourcelist: list of np.array([ px,py,pz, position relative_power, relative to other sources simulated energy]) MeV detectorlist: list of np.array([ px0,py0,pz0, position lower left corner px1,py1,pz1, position upper right corner res1,res2 ]) resolution of detector scenegrid: a numpy array 'meshgrid' shaped (xs+1,ys+1,zs+1) containing absolute coordinates of grid at 'intersections' as returned by buildscene scenematerials: a numpy array shaped (xs,ys,zs) containing information of which MATERIAL inhibits any voxel, as an integer value. ## for a better model this should also contain ## information of how much of the voxel is filled.. materials: a dict containing all materials used in the scenematerials as Material objects scene_resolution: resolution of the scene cubic, e.g. 32 equals 32^3 detector_resolution: resolution of the detectors squared, e.g. 22 equals 22^2 """ ## indexing constants power = 3 # generate an array of endpoints for rays (at the detector) detectors = [] for ddef in detectordeflist: detectors.append(detectorgeometry(ddef)) for source in sourcelist: # unpack source sx, sy, sz, spower, senergy = source rayorigin = sx, sy, sz # preprocess the scene physics # building a map of attenuation coefficients sceneattenuates = np.zeros(scenematerials.shape) for material_id in materials.keys(): sceneattenuates += (scenematerials == material_id) \ * materials[material_id].getMu(senergy) ret = [] for pixelpositions, pixelareavector, dshape, result in detectors: # do geometry rayudirs, raylengths, rayinverse = raygeometry( rayorigin, pixelpositions) raydst = runAABB(scenegrid, rayudirs, rayorigin, rayinverse) #raydst is now to be correlated with material/attenuation grid t = sceneattenuates[..., np.newaxis] * raydst #We sums the three dimensions t = np.sum(t, axis=(0, 1, 2)) dtectattenuates = t.reshape(detector_resolution, detector_resolution) pixelintensity = ((Const.invsqr * source[power] * np.ones(raylengths.shape[0])[..., np.newaxis]) / raylengths).reshape(dshape) area = np.dot(rayudirs, pixelareavector.reshape(3, 1)).reshape(dshape) result += pixelintensity * area * np.exp(-dtectattenuates) ret.append(result) if visualize: low = np.minimum.reduce(result.flatten()) high = np.maximum.reduce(result.flatten()) if util.Benchmark().bohrium: low = low.copy2numpy() high = high.copy2numpy() util.plot_surface(result, "2d", 0, low - 0.001 * low, high - 0.5 * high) util.plot_surface(result, "2d", 0, low - 0.001 * low, high - 0.5 * high) #We return only the result of the detectors return ret
def main(): B = util.Benchmark() size = B.size[0] iterations = B.size[1] if B.visualize: from matplotlib import pyplot if B.inputfn: arrays = B.load_arrays(B.inputfn) a = arrays['a'] p = arrays['p'] else: a = np.array(np.zeros(size + 1, dtype=B.dtype)) p = np.array(nullgame(size, dtype=B.dtype)) if B.dumpinput: B.dump_arrays("snakes_and_ladders", {"a": a, "p": p}) m = p # Initial matrix is p pr_end = np.array(np.zeros(iterations, dtype=B.dtype)) B.start() for k in range(iterations): if B.visualize: # Plot the probability distribution at the k-th iteration pyplot.figure(1) pyplot.plot(m[0][0:size]) # Store the probability of ending after the k-th iteration pr_end[k] = m[0][size] # Store/plot the accumulated marginal probability at the k-th iteration a = a + m[0] util.Benchmark().flush() if B.visualize: pyplot.figure(2) pyplot.plot(a[0:size]) #calculate the stocastic matrix for iteration k+1 if B.bohrium and B.no_extmethods: m = np.array(np.dot(m.copy2numpy(), p.copy2numpy())) else: m = np.dot(m, p) B.stop() B.pprint() #plot the probability of ending the game # after k iterations if B.visualize: pyplot.figure(3) pyplot.plot(pr_end[0:iterations - 1]) #show the three graphs pyplot.show() if B.verbose: print(pr_end) if B.outputfn: B.tofile(B.outputfn, {'res': pr_end})
GPL @author: Rasmus Nordfang """ from benchpress import util import numpy as np import time as tid from salt import salt from temp import temp from density_imr import dens from heat_imr import heatcap B = util.Benchmark() length = 1 #size of the grid unit m width = 1 #size of the grid unit m N_L = B.size[0] #number of grids in Length direction N_W = B.size[1] #number of grids in width direction n_years = 10 #number of years #parameters #Generel Start Values #temp,[C] density[kg/m^3], depth,[m] mass[kg] Salinity[g/kg] T_ML = -4 p_ML = 10 h_ML = 50