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()
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 xraysim(sourcelist, detectordeflist, scenegrid, scenematerials, materials,
scene_resolution, detector_resolution):
""" 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 bench.args.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
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 31 14:14:15 2015
@author: Mads Thoudahl
"""
from xraysimphysics import emptyAAscene, addobjtoscene
from xraysimgeometry import coordsAAscene, raygeometry, detectorgeometry, runAABB
import numpy as np
from material import Material
from scene_objects import snake
from benchpress.benchmarks import util
bench = util.Benchmark("X-ray sim", "<screen-res>*<detector-res>*<iterations>")
class Const:
EPS = 1e-5
invsqr = 1.0 / (np.pi * 4)
def buildscene(
scenedefs, # scenedefinitions
objlist, # list of objects, obj=
verbose=False # printing status updates along the way
):
""" Builds and returns a (sparse) scenegrid, and a (dense) voxel array,
describing what materials are in which voxels
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("LU decomposition on the matrix so that A = L*U",
"<size>")
def lu(a):
"""
Perform LU decomposition on the matrix `a` so that A = L*U
"""
u = a.copy()
l = np.identity(a.shape[0], a.dtype)
for c in range(1, u.shape[0]):
l[c:, c - 1] = (u[c:, c - 1] / u[c - 1, c - 1:c])
u[c:,
c - 1:] = u[c:, c - 1:] - l[c:, c - 1][:, None] * u[c - 1, c - 1:]
bench.flush()
return (l, u)
def main():
n = bench.args.size[0]
matrix = bench.random_array((n, n))
bench.start()
res = lu(matrix)
bench.stop()
bench.pprint()
from __future__ import print_function """ The Lattice Boltzmann Methods D2Q9 ------------ Channel flow past a cylindrical obstacle, using a LB method Copyright (C) 2006 Jonas Latt Address: Rue General Dufour 24, 1211 Geneva 4, Switzerland E-mail: [email protected] """ import numpy as np from benchpress.benchmarks import util bench = util.Benchmark("The Lattice Boltzmann Methods D2Q9", "height*width*iterations") # D2Q9 Lattice constants t = [ 4 / 9., 1 / 9., 1 / 9., 1 / 9., 1 / 9., 1 / 36., 1 / 36., 1 / 36., 1 / 36. ] cx = [0, 1, 0, -1, 0, 1, -1, -1, 1] cy = [0, 0, 1, 0, -1, 1, 1, -1, -1] opp = [0, 3, 4, 1, 2, 7, 8, 5, 6] uMax = 0.02 # maximum velocity of Poiseuille inflow Re = 100 # Reynolds number def cylinder(height, width, obstacle=True): assert (height > 2) assert (width > 2)
from __future__ import print_function
from benchpress.benchmarks import util
# if Bohrium is installed we use its convolve else we use the convolve from SciPy
try:
raise ImportError
import bohrium as bh
convolveNd = bh.convolve_scipy
except ImportError:
import scipy
from scipy import signal
convolveNd = signal.convolve
bench = util.Benchmark("Convolution Filter (any dimensional)", "<image-size>*<filter-size>*<ndims>*<niters>")
def main():
"""
Convolve filter (any dimensional)
Parameter: `<image-size>*<filter-size>*<ndims>*<niters>`
where image and filter size is the size of each dimension (not their total size).
"""
(image_size, filter_size, ndims, I) = bench.args.size
image = bench.random_array((image_size ** ndims,)).reshape([image_size] * ndims)
image_filter = bench.random_array((filter_size ** ndims,)).reshape([filter_size] * ndims)
bench.start()
for _ in range(I):
R = convolveNd(image, image_filter)
bench.flush()
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Leibnitz Pi", "<size>*<niters>")
def leibnitz_pi(N):
n = np.arange(0, N)
return np.sum(1.0 / (4 * n + 1) - 1.0 / (4 * n + 3))
def main():
(size, niter) = bench.args.size
bench.start()
pi = 0.0
for _ in range(niter):
pi += 4.0 * leibnitz_pi(size) # Execute benchmark
bench.flush()
pi /= niter
bench.stop()
bench.pprint()
if bench.args.verbose:
print(pi)
if __name__ == "__main__":
main()
# This Python file uses the following encoding: utf-8
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
import math
bench = util.Benchmark("Magnetic Field Extrapolation", "<x-size>*<y-size>*<iterations>")
def window(B, a=0.37):
assert (len(B.shape) == 2)
assert (B.shape[0] == B.shape[1])
n = B.shape[0]
wl = np.ones_like(B[0])
b = int(np.ceil((a * (n - 1) / 2)))
wl[:b] = 0.5 * (1 + np.cos(math.pi * (2 * np.arange(b) / (a * (n - 1)) - 1)))
wl[-b:] = 0.5 * (1 + np.cos(math.pi * (2 * np.arange(b - 1, -1, -1) / (a * (n - 1)) - 1)))
wl *= wl
w = np.sqrt(wl + wl[:, None])
return B * w
def calcB(B_x0, alpha=0.0,
x_min=0.0, x_max=0.25,
y_min=0.0, y_max=1.0,
z_min=0.0, z_max=1.0):
n = len(B_x0)
x = np.linspace(x_min, x_max, num=n, endpoint=False).astype(B_x0.dtype, copy=False)
y = np.linspace(y_min, y_max, num=n).astype(B_x0.dtype, copy=False)
z = np.linspace(z_min, z_max, num=n).astype(B_x0.dtype, copy=False)
u = np.arange(n, dtype=B_x0.dtype)
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Monte Carlo Pi", "samples*iterations")
def montecarlo_pi(samples):
x = bench.random_array((samples,))
y = bench.random_array((samples,))
m = np.sqrt(x * x + y * y) <= 1.0
return np.sum(m) * 4.0 / samples
def solve(samples, iterations):
acc = 0.0
for _ in range(iterations):
acc += montecarlo_pi(samples)
bench.flush()
acc /= iterations
return acc
def main():
samples, iterations = bench.args.size
bench.start()
res = solve(samples, iterations)
bench.stop()
bench.pprint()
if bench.args.verbose:
print(res)
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Galton Bean Machine", "<num_of_beans>*<height>")
def bean(num_beans, height):
return np.sum(np.sign(bench.random_array((num_beans, height)) - 0.5),
axis=1)
def main():
num_beans, height = bench.args.size
bench.start()
R = bean(num_beans, height)
bench.stop()
bench.save_data({'res': R})
bench.pprint()
if bench.args.visualize:
from matplotlib import pyplot
bins = 100
pyplot.hist(R, bins)
pyplot.title("Galton Normal distribution")
pyplot.xlabel("Value")
pyplot.ylabel("Frequency")
pyplot.show()
# -*- coding: utf-8 -*-
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Quasi Crystal simulation",
"k*stripes*image_size*iterations")
def main():
k = bench.args.size[0] # number of plane waves
stripes = bench.args.size[1] # number of stripes per wave
N = bench.args.size[2] # image size in pixels
ite = bench.args.size[3] # iterations
phases = np.arange(0, 2 * np.pi, 2 * np.pi / ite)
image = np.empty((N, N), dtype=bench.dtype)
d = np.arange(-N / 2, N / 2, dtype=bench.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)
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Rosenbrock", "size*iterations")
def rosen(x):
return np.sum(
100.0 * (x[1:] - x[:-1] ** 2.0) ** 2.0 + \
(1 - x[:-1]) ** 2.0
)
def main():
N, T = bench.args.size # Grab command-line arguments
dataset = np.arange(N, dtype=bench.dtype) / bench.dtype(N)
bench.start() # Sample wall-clock start
res = 0.0
for _ in range(0, T): # Do T trials of..
res += rosen(dataset) # ..executing rosenbrock.
bench.flush()
res /= T
bench.stop() # Sample wall-clock stop
bench.pprint() # Print elapsed wall-clock etc.
if __name__ == "__main__":
main()
from __future__ import print_function
"""
Shallow Water
-------------
So what does this code example illustrate?
Adapted from: http://people.sc.fsu.edu/~jburkardt/m_src/shallow_water_2d/
"""
import numpy as np
from benchpress.benchmarks import util
bench = util.Benchmark("Shallow Water", "height*width*iterations")
g = 9.80665 # gravitational acceleration
def droplet(height, width, data_type=np.float32):
"""Generate grid of droplets"""
x = np.array(np.linspace(-1, 1, num=width, endpoint=True), dtype=data_type)
y = np.array(np.linspace(-1, 1, num=width, endpoint=True), dtype=data_type)
(xx, yy) = np.meshgrid(x, y)
droplet = height * np.exp(-5 * (xx**2 + yy**2))
return droplet
def model(height, width, dtype=np.float32):
assert height >= 16
assert width >= 16
m = np.ones((height, width), dtype=dtype)
D = droplet(8, 8) # simulate a water drop
from __future__ import print_function
"""
Game of Life
------------
"""
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Game of Life", "height*width*iterations*rules")
SURVIVE_LOW = 2
SURVIVE_HIGH = 3
SPAWN = 3
def world(height, width):
state = np.ones((height + 2, width + 2), dtype=bench.dtype)
state[2:-2, 2:-2] = bench.dtype(0)
return state
def world_zeros(height, width):
state = np.zeros((height + 2, width + 2), dtype=bench.dtype)
return state
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]
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 20 10:47:25 2014
GPL
@author: Rasmus Nordfang
"""
from benchpress.benchmarks import util
import numpy as np
from salt import salt
from temp import temp
from density_imr import dens
from heat_imr import heatcap
bench = util.Benchmark("Wisp", "length*width*steps")
length = 1 # size of the grid unit m
width = 1 # size of the grid unit m
N_L = bench.args.size[0] # number of grids in Length direction
N_W = bench.args.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
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
import math
try:
import numpy_force as npf
except ImportError:
import numpy as npf
bench = util.Benchmark("Black Scholes", "samples*iterations")
def model(N):
"""Construct pseudo-data representing price samples?"""
# Create the outside of bohrium
S = npf.random.random(N).astype(
bench.dtype) * 4.0 + 58.0 # Price is between 58-62
S = np.array(S)
return S
def CND(X):
"""
Cumulative normal distribution.
Helper function used by BS(...).
"""
(a1, a2, a3, a4, a5) = (0.31938153, -0.356563782, 1.781477937,
-1.821255978, 1.330274429)
L = np.absolute(X)
from __future__ import print_function
import cupy as np
from benchpress.benchmarks import util
bench = util.Benchmark("Solving the heat equation using the jacobi method",
"height*width*iterations")
def init_grid(height, width, dtype=np.float32):
grid = np.zeros((height + 2, width + 2), dtype=dtype)
grid[:, 0] = dtype(-273.15)
grid[:, -1] = dtype(-273.15)
grid[-1, :] = dtype(-273.15)
grid[0, :] = dtype(40.0)
return grid
def jacobi(grid, epsilon=0.005, max_iterations=None):
def loop_body(grid):
center = grid[1:-1, 1:-1]
north = grid[0:-2, 1:-1]
east = grid[1:-1, 2:]
west = grid[1:-1, 0:-2]
south = grid[2:, 1:-1]
work = 0.2 * (center + north + east + west + south)
delta = np.sum(np.absolute(work - center))
center[:] = work
bench.plot_surface(grid, "2d", 0, 200, -200)
return delta > epsilon
bench.do_while(loop_body, max_iterations, grid)
# By Natalino Busa <https://gist.github.com/natalinobusa/4633275>
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Snakes and Ladders", "size*iterations")
def nullgame(size, dtype):
p = np.zeros((size + 1, size + 1), dtype=dtype)
for i in range(size + 1):
for j in range(6):
if i + j < size:
p[i][i + j + 1] = 1.0 / 6.0
p[size][size] = 1
p[size - 1][size] = 6.0 / 6.0
p[size - 2][size] = 5.0 / 6.0
p[size - 3][size] = 4.0 / 6.0
p[size - 4][size] = 3.0 / 6.0
p[size - 5][size] = 2.0 / 6.0
p[size - 6][size] = 1.0 / 6.0
return p
def main():
size, iterations = bench.args.size
if bench.args.visualize:
from matplotlib import pyplot
"""
Convolve filter (1. dimensional)
Parameter: `--size<image-size>*<filter-size>*<niters>`.
"""
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Convolution Filter 1D", "<image-size>*<filter-size>*<niters>")
def main():
(image_size, filter_size, I) = bench.args.size
image = bench.random_array((image_size,))
image_filter = bench.random_array((filter_size,))
bench.start()
for _ in range(I):
R = np.convolve(image, image_filter)
bench.flush()
bench.stop()
bench.save_data({'res': R})
bench.pprint()
if __name__ == "__main__":
main()
from __future__ import print_function
from benchpress.benchmarks import util
import numpy as np
bench = util.Benchmark("Gaussian elimination on matrix a without pivoting",
"<size>")
def gauss(a):
"""
Perform Gaussian elimination on matrix a without pivoting
"""
for c in range(1, a.shape[0]):
a[c:, c -
1:] = a[c:, c - 1:] - (a[c:, c - 1] /
a[c - 1, c - 1:c])[:, None] * a[c - 1, c - 1:]
bench.flush()
a /= np.diagonal(a)[:, None]
return a
def main():
n = bench.args.size[0]
matrix = bench.load_data()
if matrix is not None:
matrix = matrix['matrix']
else:
matrix = bench.random_array((n, n))
bench.start()