def test_binary_int(A_numpy, B_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
B_coocs = cn.array(B_numpy)
assert np.allclose(cn.bitwise_and(A_cocos, B_coocs),
np.bitwise_and(A_numpy, B_numpy))
assert np.allclose(cn.bitwise_or(A_cocos, B_coocs),
np.bitwise_or(A_numpy, B_numpy))
assert np.allclose(cn.bitwise_xor(A_cocos, B_coocs),
np.bitwise_xor(A_numpy, B_numpy))
assert np.allclose(cn.minimum(A_cocos, B_coocs),
np.minimum(A_numpy, B_numpy))
assert np.allclose(cn.maximum(A_cocos, B_coocs),
np.maximum(A_numpy, B_numpy))
assert np.allclose(cn.left_shift(A_cocos, B_coocs),
np.left_shift(A_numpy, B_numpy))
assert np.allclose(cn.right_shift(A_cocos, B_coocs),
np.right_shift(A_numpy, B_numpy))
assert np.allclose(A_cocos + B_coocs, A_numpy + B_numpy)
assert np.allclose(A_cocos - B_coocs, A_numpy - B_numpy)
assert np.allclose(A_cocos * B_coocs, A_numpy * B_numpy)
def test_average(A_numpy, weights):
print(A_numpy)
cocos.device.init()
print('init')
A_cocos = cn.array(A_numpy)
if isinstance(weights, np.ndarray):
weights_cocos = cn.array(weights)
else:
weights_cocos = None
# conduct tests
average_numpy = np.average(A_numpy)
average_cocos = cn.average(A_cocos)
assert np.allclose(average_numpy, average_cocos)
average_numpy_axis_0 = np.average(A_numpy, axis=0, weights=weights)
average_cocos_axis_0 = cn.average(A_cocos, axis=0, weights=weights_cocos)
truth_value = np.allclose(average_numpy_axis_0, average_cocos_axis_0)
if not truth_value:
print("input array")
print(A_numpy)
print("input weights")
print(weights)
print("output numpy axis 0")
print(average_numpy_axis_0)
print("output cocos axis 0")
print(average_cocos_axis_0)
assert truth_value
# ToDo: Taking the average over axis 1 with weights produces results that are identical to the operation without weights
average_numpy_axis_1 = np.average(A_numpy, axis=1, weights=weights)
average_cocos_axis_1 = cn.average(A_cocos, axis=1, weights=weights_cocos)
truth_value = np.allclose(average_numpy_axis_1, average_cocos_axis_1)
if not truth_value:
print("input array")
print(A_numpy)
print("input weights")
print(weights)
print("output numpy axis 0")
print(average_numpy_axis_0)
print("output cocos axis 0")
print(average_cocos_axis_0)
print("output numpy axis 1")
print(average_numpy_axis_1)
print("output cocos axis 1")
print(average_cocos_axis_1)
print("output numpy axis 0 no weights")
print(np.average(A_numpy, axis=0))
print("output numpy axis 1 no weights")
print(np.average(A_numpy, axis=1))
assert truth_value
def test_concatenate_hstack_v_stack_dstack():
cocos.device.init(backend)
cocos.device.info()
# define data type
dtype = np.int32
# using numpy
first_array_numpy = np.array([[1, 2], [3, 4]], dtype=dtype)
second_array_numpy = np.array([[5, 6], [7, 8]], dtype=dtype)
third_array_numpy = np.array([[9, 10], [11, 12]], dtype=dtype)
h_stacked_array_numpy = np.hstack(
(first_array_numpy, second_array_numpy, third_array_numpy))
v_stacked_array_numpy = np.vstack(
(first_array_numpy, second_array_numpy, third_array_numpy))
d_stacked_array_numpy = np.dstack(
(first_array_numpy, second_array_numpy, third_array_numpy))
# print(d_stacked_array_numpy)
# using Cocos
first_array_cocos = cn.array(first_array_numpy)
second_array_cocos = cn.array(second_array_numpy)
third_array_cocos = cn.array(third_array_numpy)
h_stacked_array_cocos = cn.hstack(
(first_array_cocos, second_array_cocos, third_array_cocos))
v_stacked_array_cocos = cn.vstack(
(first_array_cocos, second_array_cocos, third_array_cocos))
d_stacked_array_cocos = cn.dstack(
(first_array_cocos, second_array_cocos, third_array_cocos))
# print(d_stacked_array_cocos)
assert np.allclose(h_stacked_array_cocos, h_stacked_array_numpy)
assert np.allclose(v_stacked_array_cocos, v_stacked_array_numpy)
assert np.allclose(d_stacked_array_cocos, d_stacked_array_numpy)
# tests concatenate
for axis in range(2):
concatenated_array = np.concatenate(
(first_array_numpy, second_array_numpy, third_array_numpy),
axis=axis)
concatenated_array_cocos = cn.concatenate(
(first_array_cocos, second_array_cocos, third_array_cocos),
axis=axis)
assert np.allclose(concatenated_array_cocos, concatenated_array)
def test_logical(A_numpy, B_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
B_cocos = cn.array(B_numpy)
assert np.allclose(cn.logical_not(A_cocos), np.logical_not(A_numpy))
assert np.allclose(cn.logical_and(A_cocos, B_cocos),
np.logical_and(A_numpy, B_numpy))
assert np.allclose(cn.logical_or(A_cocos, B_cocos),
np.logical_or(A_numpy, B_numpy))
assert np.allclose(cn.logical_xor(A_cocos, B_cocos),
np.logical_xor(A_numpy, B_numpy))
def test_solve(A_numpy, b_numpy):
cocos.device.init()
if cocos.device.is_dbl_supported():
# using numpy
# print(A)
solution = np.linalg.solve(A_numpy, b_numpy)
# using Cocos
A_cocos = cn.array(A_numpy)
b_cocos = cn.array(b_numpy)
solution_cocos = cn.linalg.solve(A_cocos, b_cocos)
# conduct tests
assert np.allclose(solution, solution_cocos)
def test_tril_triu(A_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
# conduct tests
assert np.allclose(np.tril(A_numpy), cn.tril(A_cocos))
assert np.allclose(np.triu(A_numpy), cn.triu(A_cocos))
def test_flip(A_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
# conduct tests
assert np.allclose(np.fliplr(A_numpy), cn.fliplr(A_cocos))
assert np.allclose(np.flipud(A_numpy), cn.flipud(A_cocos))
def test_nonzero(A_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
# flatnonzero
assert np.allclose(cn.flatnonzero(A_cocos), np.flatnonzero(A_numpy))
# nonzero
(nonzero_i, nonzero_j) = np.nonzero(A_numpy)
(nonzero_i_self, nonzero_j_self) = A_numpy.nonzero()
(nonzero_i_cocos, nonzero_j_cocos) = cn.nonzero(A_cocos)
(nonzero_i_cocos_self, nonzero_j_cocos_self) = A_cocos.nonzero()
# print("nonzero numpy i")
# print(nonzero_i)
# print("nonzero numpy j")
# print(nonzero_j)
# print("nonzero cocos i")
# print(nonzero_i_cocos)
# print("nonzero cocos i")
# print(nonzero_j_cocos)
assert np.allclose(nonzero_i_cocos, nonzero_i)
assert np.allclose(nonzero_j_cocos, nonzero_j)
assert np.allclose(nonzero_i_cocos_self, nonzero_i_self)
assert np.allclose(nonzero_j_cocos_self, nonzero_j_self)
def test_sum_prod(A_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
# # using numpy
# mean_numpy = np.mean(A)
#
# # using Cocos
# mean_cocos = cn.mean(A_cocos)
# conduct tests
# tests sum
assert np.allclose(np.sum(A_numpy), cn.sum(A_cocos))
assert np.allclose(np.sum(A_numpy, axis=0), cn.sum(A_cocos, axis=0))
assert np.allclose(np.sum(A_numpy, axis=1), cn.sum(A_cocos, axis=1))
# tests prod
assert np.allclose(np.prod(A_numpy), cn.prod(A_cocos))
assert np.allclose(np.prod(A_numpy, axis=0), cn.prod(A_cocos, axis=0))
assert np.allclose(np.prod(A_numpy, axis=1), cn.prod(A_cocos, axis=1))
# tests cumsum
assert np.allclose(np.cumsum(A_numpy.transpose()), cn.cumsum(A_cocos))
assert np.allclose(np.cumsum(A_numpy, axis=0), cn.cumsum(A_cocos, axis=0))
assert np.allclose(np.cumsum(A_numpy, axis=1), cn.cumsum(A_cocos, axis=1))
def test_lu():
cocos.device.init()
A_numpy = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 20]], dtype=np.float32)
P, L, U = scipy_linalg.lu(A_numpy)
# print("P")
# print(P)
# print("")
#
# print("L")
# print(L)
# print("")
#
# print("U")
# print(U)
# print("")
A_cocos = cn.array(A_numpy)
P_cocos, L_cocos, U_cocos = csl.lu(A_cocos)
# print("P cocos")
# print(np.array(P_cocos))
# print("")
#
# print("L cocos")
# print(np.array(L_cocos))
# print("")
#
# print("U cocos")
# print(np.array(U_cocos))
# print("")
assert compare_cocos_numpy(P_cocos, P)
assert compare_cocos_numpy(L_cocos, L)
assert compare_cocos_numpy(U_cocos, U)
def test_diag_trace(A_numpy):
if A_numpy.ndim != 2:
raise ValueError("A_numpy must be a matrix")
if A_numpy.shape[0] != A_numpy.shape[1]:
raise ValueError("A_numpy must be a square matrix")
cocos.device.init()
A_cocos = cn.array(A_numpy)
# conduct tests
for k in range(-1, 2):
assert np.allclose(np.diag(A_numpy, k=k), cn.diag(A_cocos, k=k))
# tests diag and trace
diag_numpy = np.diag(A_numpy)
diag_cocos = cn.diag(A_cocos)
assert np.allclose(np.diag(diag_numpy), cn.diag(diag_cocos))
assert np.isclose(np.trace(A_numpy), cn.trace(A_cocos))
# tests diagonal
diagonal_numpy = A_numpy.diagonal()
diagonal_cocos = A_cocos.diagonal()
assert np.allclose(diagonal_numpy, diagonal_cocos)
d = A_numpy.shape[0]
for offset in range(-d + 1, d):
diagonal_numpy = A_numpy.diagonal(offset=offset)
diagonal_cocos = A_cocos.diagonal(offset=offset)
assert np.allclose(diagonal_numpy, diagonal_cocos)
# tests diagflat
assert np.allclose(np.diagflat(diag_numpy), cn.diagflat(diag_cocos))
def test_diff():
cocos.device.init()
if cocos.device.is_dbl_supported():
A_numpy = np.random.randn(1000, 1000)
A_cocos = cn.array(A_numpy)
# # using numpy
# mean_numpy = np.mean(A_numpy)
#
# # using Cocos
# mean_cocos = cn.mean(A_cocos)
# conduct tests
# tests sum
for n in range(1, 10):
assert np.allclose(np.diff(A_numpy, n=n), cn.diff(A_cocos, n=n))
assert np.allclose(np.diff(A_numpy, n=n, axis=0),
cn.diff(A_cocos, n=n, axis=0))
assert np.allclose(np.diff(A_numpy, n=n, axis=1),
cn.diff(A_cocos, n=n, axis=1))
def test_sort(A_numpy):
cn.init()
A_cocos = cn.array(A_numpy)
for i in range(2):
# argsort with axis
argsort_numpy = np.argsort(A_numpy, axis=i)
argsort_cocos = cn.argsort(A_cocos, axis=i)
assert np.allclose(argsort_cocos, argsort_numpy)
# sort with axis
sort_numpy = np.sort(A_numpy, axis=i)
sort_cocos = cn.sort(A_cocos, axis=i)
assert np.allclose(sort_cocos, sort_numpy)
# argsort without axis
argsort_numpy = np.argsort(A_numpy, axis=None)
argsort_cocos = cn.argsort(A_cocos.transpose(), axis=None)
# print("argsort numpy")
# print(argsort_numpy)
# print("argsort cocos")
# print(argsort_cocos)
# assert np.allclose(argsort_cocos, argsort_numpy)
# sort without axis
sort_numpy = np.sort(A_numpy)
sort_cocos = cn.sort(A_cocos)
assert np.allclose(sort_cocos, sort_numpy)
def test_binary_float(A_numpy, B_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
B_cocos = cn.array(B_numpy)
assert np.allclose(A_cocos + B_cocos, A_numpy + B_numpy)
assert np.allclose(A_cocos - B_cocos, A_numpy - B_numpy)
assert np.allclose(A_cocos * B_cocos, A_numpy * B_numpy)
assert np.allclose(A_cocos / B_cocos, A_numpy / B_numpy)
assert np.allclose(cn.hypot(A_cocos, B_cocos), np.hypot(A_numpy, B_numpy))
assert np.allclose(cn.arctan2(A_cocos, B_cocos),
np.arctan2(A_numpy, B_numpy))
assert np.allclose(cn.cplx(A_cocos, B_cocos), A_numpy + 1j * B_numpy)
assert np.allclose(np.power(A_numpy, B_numpy), cn.power(A_cocos, B_cocos))
def _check_array_at_right_location_and_convert(array, gpu: bool):
if isinstance(array, np.ndarray) and gpu:
return cn.array(array)
if isinstance(array, cn.ndarray) and not gpu:
return np.array(array)
return array
def test_roll(A_numpy, axis, shift):
print(f'axis={axis}, shift={shift}')
cocos.device.init()
A_cocos = cn.array(A_numpy)
B_numpy = np.roll(A_numpy, shift=shift, axis=axis)
B_cocos = cn.roll(A_cocos, shift=shift, axis=axis)
assert np.allclose(B_cocos, B_numpy)
def test_tile(A_numpy, tiles):
cocos.device.init()
A_cocos = cn.array(A_numpy)
B_numpy = np.tile(A_numpy, tiles)
B_cocos = cn.tile(A_cocos, tiles)
assert np.allclose(B_cocos, B_numpy)
def test_union_intersection():
cocos.device.init()
A_numpy = np.array([1, 2, 3], dtype=np.int32)
B_numpy = np.array([1, 5], dtype=np.int32)
A_cocos = cn.array(A_numpy)
B_cocos = cn.array(B_numpy)
union_AB_numpy = np.union1d(A_numpy, B_numpy)
intersection_AB_numpy = np.union1d(A_numpy, B_numpy)
union_AB_cocos = cn.union1d(A_cocos, B_cocos)
intersection_AB_cocos = cn.union1d(A_cocos, B_cocos)
assert np.allclose(union_AB_cocos, union_AB_numpy)
assert np.allclose(intersection_AB_cocos, intersection_AB_numpy)
def test_any_all(x, y):
cocos.device.init(backend)
cocos.device.info()
# using numpy
# x = np.array([[1.0, -2.0], [-3.0, 4.0]])
# y = np.array([[0.0, -3.0], [0.0, 5.0]])
z1 = x > y
z2 = x < y
z3 = x == y
# print("numpy result")
# print(z1)
# print("numpy dtype = {}".format(z1.dtype))
# using Cocos
a = cn.array(x)
b = cn.array(y)
c1 = a > b
c2 = a < b
c3 = a == b
# print("cocos result")
# print(c1)
# print("cocos dtype = {}".format(c1.dtype))
# assert np.allclose(np.array(c1).astype(bool), z1)
# assert np.allclose(np.array(cn.all(c1)).astype(bool), np.all(z1))
# assert np.allclose(np.array(cn.all(c1, 0)).astype(bool), np.all(z1, 0))
# assert np.allclose(np.array(cn.all(c1, 1)).astype(bool), np.all(z1, 1))
list_of_comparisons = [(c1, z1), (c2, z2), (c3, z3)]
for c, z in list_of_comparisons:
assert compare_numpy_and_cocos(c, z)
assert compare_numpy_and_cocos(cn.all(c), np.all(z))
assert compare_numpy_and_cocos(cn.all(c, 0), np.all(z, 0))
assert compare_numpy_and_cocos(cn.all(c, 1), np.all(z, 1))
assert compare_numpy_and_cocos(cn.any(c), np.any(z))
assert compare_numpy_and_cocos(cn.any(c, 0), np.any(z, 0))
assert compare_numpy_and_cocos(cn.any(c, 1), np.any(z, 1))
def test_lambdify():
x = sym.Symbol('x')
expr = sym.sin(x) + sym.cos(x)
lambdified_cn = cocos.symbolic._lambdification.lambdify(x, expr)
lambdified_sym = sym.lambdify(x, expr)
x_vals = np.linspace(-np.pi, np.pi, 100, dtype=np.float32)
x_vals_gpu = cn.array(x_vals)
assert np.allclose(lambdified_sym(x_vals), lambdified_cn(x_vals_gpu))
def test_gaussian_kde_scipy_vs_cocos_gpu(points: np.ndarray,
xi: np.ndarray):
gkde_cocos = gaussian_kde(cn.array(points.squeeze()),
gpu=True)
gkde_scipy = ss.kde.gaussian_kde(points)
density_estimate_cocos = gkde_cocos.evaluate(xi)
density_estimate_scipy = gkde_scipy.evaluate(xi)
assert np.allclose(density_estimate_cocos,
density_estimate_scipy)
def test_reciprocal(x):
cocos.device.init(backend)
cocos.device.info()
# using numpy
y = np.reciprocal(x)
# using Cocos
x_cocos = cn.array(x)
y_cocos = cn.reciprocal(x_cocos)
assert np.allclose(y_cocos, y)
def test_solve(A_numpy, b_numpy):
cocos.device.init()
if not cocos.device.is_dbl_supported():
A_numpy = A_numpy.astype(np.float32)
b_numpy = b_numpy.astype(np.float32)
# using numpy
lu, piv = scipy_linalg.lu_factor(A_numpy,
overwrite_a=False)
solution = scipy_linalg.lu_solve((lu, piv),
b_numpy,
trans=0,
overwrite_b=False)
# using Cocos
b_cocos = cn.array(b_numpy)
piv_cocos, lu_cocos = csl._lu_internal(cn.array(A_numpy),
permute_l=True,
overwrite_a=True)
solution_cocos = csl.lu_solve((lu_cocos, piv_cocos),
b_cocos,
trans=0,
overwrite_b=False)
lu_cocos_2, piv_cocos_2 = csl.lu_factor(cn.array(A_numpy),
overwrite_a=True)
solution_cocos_2 = csl.lu_solve((lu_cocos_2, piv_cocos_2),
b_cocos,
trans=0,
overwrite_b=False)
# conduct tests
assert np.allclose(solution, solution_cocos)
assert np.allclose(solution, solution_cocos_2)
def _check_array_at_right_location_and_convert(array,
gpu: bool,
dtype: np.generic = np.float32):
if isinstance(array, np.ndarray) and gpu:
array = cn.array(array)
if isinstance(array, cn.ndarray) and not gpu:
array = np.array(array)
if array.dtype != dtype:
array = array.astype(dtype)
return array
def test_average_3_axes():
A_numpy = np.array([[[0.2, 1.0, 0.5], [0.4, 0.5, 0.6], [0.7, 0.2, 0.25]],
[[1, 2, 3], [4, 5, 6], [7, 8, 20]],
[[0.5, 2.3, 3.1], [4, 5.5, 6], [7, 8, 2]]])
A_cocos = cn.array(A_numpy)
weights_numpy = np.array([0.2, 0.3, 0.5], dtype=np.float32)
weights_cocos = cn.array(weights_numpy)
for axis in range(3):
print(f'axis = {axis}')
average_numpy = np.average(A_numpy, axis=axis, weights=weights_numpy)
average_cocos \
= np.array(cn.average(A_cocos, axis=axis, weights=weights_cocos))
truth_value = np.allclose(average_numpy, average_cocos)
if not truth_value:
print('numpy')
print(average_numpy)
print('cocos')
print(average_cocos)
assert truth_value
def test_ptp(A_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
axes = [None, 0, 1]
for axis in axes:
if np.iscomplexobj(A_numpy):
ptp_cocos = A_cocos.ptp(axis=axis)
ptp_numpy = A_numpy.ptp(axis=axis)
print(np.array(ptp_cocos))
print(np.array(ptp_numpy))
assert np.allclose(ptp_cocos.real, ptp_numpy.real)
assert np.allclose(ptp_numpy.imag, ptp_cocos.imag)
else:
assert np.allclose(A_cocos.ptp(axis=axis), A_numpy.ptp(axis=axis))
def test_mean(A):
cocos.device.init()
A_arch = cn.array(A)
# # using numpy
# mean_numpy = np.mean(A)
#
# # using Archimedes
# mean_arch = cn.mean(A_arch)
# conduct tests
# tests mean
assert np.allclose(np.mean(A), cn.mean(A_arch))
assert np.allclose(np.mean(A, axis=0), cn.mean(A_arch, axis=0))
assert np.allclose(np.mean(A, axis=1), cn.mean(A_arch, axis=1))
def test_argmin(A_numpy):
cocos.device.init()
A_cocos = cn.array(A_numpy)
# tests argmin
assert np.allclose(np.argmin(A_numpy.transpose()), cn.argmin(A_cocos))
assert np.allclose(np.argmin(A_numpy, axis=0), cn.argmin(A_cocos, axis=0))
assert np.allclose(np.argmin(A_numpy, axis=1), cn.argmin(A_cocos, axis=1))
# tests argmax
print("numpy argmax")
print(np.argmax(A_numpy.transpose()))
print("cocos argmax")
print(cn.argmax(A_cocos))
assert np.allclose(np.argmax(A_numpy.transpose()), cn.argmax(A_cocos))
assert np.allclose(np.argmax(A_numpy, axis=0), cn.argmax(A_cocos, axis=0))
assert np.allclose(np.argmax(A_numpy, axis=1), cn.argmax(A_cocos, axis=1))
def test_cholesky():
cocos.device.init()
A_numpy = np.array([[1. + 0.j, 0. - 2.j], [0. + 2.j, 5. + 0.j]],
dtype=np.complex64)
L_numpy = np.linalg.cholesky(A_numpy)
# print("L_numpy")
# print(L_numpy)
# print("")
A_cocos = cn.array(A_numpy)
L_cocos = cn.linalg.cholesky(A_cocos)
# print("L_numpy cocos")
# print(np.array(L_cocos))
# print("")
assert compare_cocos_numpy(L_cocos, L_numpy)
def test_norm(ord):
cocos.device.init()
# using numpy
A_numpy = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 20]], dtype=np.float32)
print(A_numpy)
norm = np.linalg.norm(A_numpy, ord)
print(f"norm python = {norm}")
# using Cocos
A_cocos = cn.array(A_numpy)
norm_cocos = cn.linalg.norm(A_cocos, ord)
print(f"norm cocos = {norm_cocos}")
# conduct tests
assert np.isclose(norm, norm_cocos)
