def test_rotor_cost(self):
# Make a big array of data
n_mvs = 500
mv_a_array = np.array([random_line() for i in range(n_mvs)])
mv_b_array = np.array([random_line() for i in range(n_mvs)])
mv_c_array = np.zeros(n_mvs)
mv_d_array = np.zeros(n_mvs)
# Multiply together a load of them and see how long it takes
print('Starting kernel')
t = time.time()
blockdim = 64
griddim = int(math.ceil(n_mvs / blockdim))
cost_line_to_line_kernel[griddim, blockdim](mv_a_array, mv_b_array, mv_c_array)
end_time = time.time() - t
print('Kernel finished')
print(end_time)
# Now do the non cuda kernel
t = time.time()
for i in range(mv_a_array.shape[0]):
mv_d_array[i] = val_object_cost_function(mv_a_array[i, :], mv_b_array[i, :])
print(time.time() - t)
np.testing.assert_almost_equal(mv_c_array, mv_d_array, 5)
def test_object_set_cost(self):
n_mvs = 100
generator_list = [random_point_pair, random_line, random_circle, \
random_sphere, random_plane]
for generator in generator_list:
mv_a_array = [generator() for i in range(n_mvs)]
mv_b_array = [generator() for i in range(n_mvs)]
print(mv_a_array)
print('Starting kernel')
t = time.time()
mv_c_array = object_set_cost_cuda_mvs(mv_a_array, mv_b_array)
end_time = time.time() - t
print('Kernel finished')
print(end_time)
t = time.time()
mv_d_array = object_set_cost_matrix(mv_a_array, mv_b_array, object_type='generic')
print(time.time() - t)
for i in range(n_mvs):
for j in range(n_mvs):
try:
assert abs(mv_d_array[i,j]-mv_c_array[i,j])/abs(mv_d_array[i,j]) < 10**(-6)
except:
print(generator.__name__)
if generator.__name__ == 'random_line':
print(val_object_cost_function(mv_a_array[i].value, mv_b_array[j].value))
print(mv_d_array[i,j])
print(mv_c_array[i,j])
print(abs(mv_d_array[i,j]-mv_c_array[i,j])/abs(mv_d_array[i,j]))
assert abs(mv_d_array[i,j]-mv_c_array[i,j])/abs(mv_d_array[i,j]) < 10**(-6)
def test_object_set_cost(self):
n_mvs = 100
generator_list = [random_point_pair, random_line, random_circle,
random_sphere, random_plane]
for generator in generator_list:
mv_a_array = [generator() for i in range(n_mvs)]
mv_b_array = [generator() for i in range(n_mvs)]
print(mv_a_array)
print('Starting kernel')
t = time.time()
mv_c_array = object_set_cost_cuda_mvs(mv_a_array, mv_b_array)
end_time = time.time() - t
print('Kernel finished')
print(end_time)
t = time.time()
mv_d_array = object_set_cost_matrix(mv_a_array, mv_b_array, object_type='generic')
print(time.time() - t)
for i in range(n_mvs):
for j in range(n_mvs):
try:
assert abs(mv_d_array[i, j]-mv_c_array[i, j])/abs(mv_d_array[i, j]) < 10**(-6)
except AssertionError:
print(generator.__name__)
if generator.__name__ == 'random_line':
print(val_object_cost_function(mv_a_array[i].value, mv_b_array[j].value))
print(mv_d_array[i, j])
print(mv_c_array[i, j])
print(abs(mv_d_array[i, j]-mv_c_array[i, j])/abs(mv_d_array[i, j]))
assert abs(mv_d_array[i, j]-mv_c_array[i, j])/abs(mv_d_array[i, j]) < 10**(-6)
def test_rotor_cost(self):
# Make a big array of data
n_mvs = 500
mv_a_array = np.array([random_line() for i in range(n_mvs)])
mv_b_array = np.array([random_line() for i in range(n_mvs)])
mv_c_array = np.zeros(n_mvs)
mv_d_array = np.zeros(n_mvs)
# Multiply together a load of them and see how long it takes
print('Starting kernel')
t = time.time()
blockdim = 64
griddim = int(math.ceil(n_mvs / blockdim))
cost_line_to_line_kernel[griddim, blockdim](mv_a_array, mv_b_array, mv_c_array)
end_time = time.time() - t
print('Kernel finished')
print(end_time)
# Now do the non cuda kernel
t = time.time()
for i in range(mv_a_array.shape[0]):
mv_d_array[i] = val_object_cost_function(mv_a_array[i, :], mv_b_array[i, :])
print(time.time() - t)
np.testing.assert_almost_equal(mv_c_array, mv_d_array, 5)