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)