def test_padecases_dtype_sparse_complex(self): # float32 and complex64 lead to errors in spsolve/UMFpack dtype = np.complex128 for scale in [1e-2, 1e-1, 5e-1, 1, 10]: a = scale * speye(3, 3, dtype=dtype, format='csc') e = exp(scale) * eye(3, dtype=dtype) assert_array_almost_equal_nulp(expm(a).toarray(), e, nulp=100)
def test_interp_linear_array_fill(self): x = np.linspace(1., 10., 10) y = self.f(x) xval = np.linspace(0., 10., 100) ref = self.f(xval) ref[xval < x[0]] = -2. assert_array_almost_equal_nulp(self.interp(x, y, xval, bounds_error=False, fill_value=-2.), ref, 10)
def test_size_accuracy_large(self, size): x = np.random.rand(size, 3) + 1j*np.random.rand(size, 3) y1 = fftn(x.real.astype(np.float32)) y2 = fftn(x.real.astype(np.float64)).astype(np.complex64) assert_equal(y1.dtype, np.complex64) assert_array_almost_equal_nulp(y1, y2, 2000)
def test_unity_1_withnan(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros, inval, outval): """ Test that a unit kernel with three elements returns the same array (except when boundary is None). This version includes a NaN value in the original array. """ x = inval y = np.array([1.0], dtype="float64") z = convolve_fft( x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, ) # for whatever reason, numpy's fft has very limited precision, and # the comparison fails unless you cast the float64 to a float16 if hasattr(np, "float16"): assert_array_almost_equal_nulp( np.asarray(z, dtype=np.float16), np.array([1.0, 0.0, 3.0], dtype=np.float16), 10 ) assert np.all(np.abs(z - outval) < 1e-14)
def test_unity_3x3_withnan(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros): ''' Test that a 3x3 unit kernel returns the same array (except when boundary is None). This version includes a NaN value in the original array. ''' x = np.array([[1., 2., 3.], [4., np.nan, 6.], [7., 8., 9.]], dtype='float64') y = np.array([[0., 0., 0.], [0., 1., 0.], [0., 0., 0.]], dtype='float64') z = convolve_fft(x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, ) a = x a[1, 1] = 0 # for whatever reason, numpy's fft has very limited precision, and # the comparison fails unless you cast the float64 to a float16 if hasattr(np, 'float16'): assert_array_almost_equal_nulp(np.asarray(z, dtype=np.float16), np.asarray(a, dtype=np.float16), 10) assert np.all(np.abs(z - a) < 1e-14)
def test_apply(self, k, flag): """flag allows the specification of various calling sequences: - flag = 0: apply(b, tau) - flag = 1: apply(b, tau, tau) - flag = 2: apply(b, tau, eta) """ mat = self.material() expected = green_matrix(k, mat) green = mat.green_operator() tau = np.zeros((green.isize,), np.float64) if flag == 0: base = None elif flag == 1: base = tau elif flag == 2: base = np.empty((green.osize,), np.float64) else: raise ValueError() for j in range(green.isize): tau[:] = 0. tau[j] = 1. green.set_frequency(k) actual = green.apply(tau, base) if flag != 0: assert actual.base is base assert_array_almost_equal_nulp(expected[:, j], actual, 325)
def test_padecases_dtype(self): for dtype in [np.float32, np.float64, np.complex64, np.complex128]: # test double-precision cases for scale in [1e-2, 1e-1, 5e-1, 1, 10]: a = scale * eye(3, dtype=dtype) e = exp(scale) * eye(3, dtype=dtype) assert_array_almost_equal_nulp(expm(a), e, nulp=100)
def testArrays(self): arr = np.arange(100); arr = arr.reshape((10, 10)) assert_array_equal(np.array(ujson.decode(ujson.encode(arr))), arr) assert_array_equal(ujson.decode(ujson.encode(arr), numpy=True), arr) arr = arr.reshape((5, 5, 4)) assert_array_equal(np.array(ujson.decode(ujson.encode(arr))), arr) assert_array_equal(ujson.decode(ujson.encode(arr), numpy=True), arr) arr = arr.reshape((100, 1)) assert_array_equal(np.array(ujson.decode(ujson.encode(arr))), arr) assert_array_equal(ujson.decode(ujson.encode(arr), numpy=True), arr) arr = np.arange(96); arr = arr.reshape((2, 2, 2, 2, 3, 2)) assert_array_equal(np.array(ujson.decode(ujson.encode(arr))), arr) assert_array_equal(ujson.decode(ujson.encode(arr), numpy=True), arr) l = ['a', list(), dict(), dict(), list(), 42, 97.8, ['a', 'b'], {'key': 'val'}] arr = np.array(l) assert_array_equal(np.array(ujson.decode(ujson.encode(arr))), arr) arr = np.arange(100.202, 200.202, 1, dtype=np.float32); arr = arr.reshape((5, 5, 4)) outp = np.array(ujson.decode(ujson.encode(arr)), dtype=np.float32) assert_array_almost_equal_nulp(arr, outp) outp = ujson.decode(ujson.encode(arr), numpy=True, dtype=np.float32) assert_array_almost_equal_nulp(arr, outp)
def test_unity_3_withnan(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros): ''' Test that a unit kernel with three elements returns the same array (except when boundary is None). This version includes a NaN value in the original array. ''' x = np.array([1., np.nan, 3.], dtype='float64') y = np.array([0., 1., 0.], dtype='float64') z = convolve_fft(x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros) # for whatever reason, numpy's fft has very limited precision, and # the comparison fails unless you cast the float64 to a float16 if hasattr(np, 'float16'): assert_array_almost_equal_nulp( np.asarray(z, dtype=np.float16), np.array([1., 0., 3.], dtype=np.float16), 10) # ASSERT equality to better than 16 bit but worse than 32 bit precision assert np.all(np.abs(z - np.array([1., 0., 3.])) < 1e-14)
def test_unity_1x1_none(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros, fft_type): """ Test that a 1x1 unit kernel returns the same array """ if fft_type == "fftw" and not HAS_FFTW: pytest.skip("fftw3 is not installed") elif fft_type == "scipy" and not HAS_SCIPY: pytest.skip("scipy is not installed") x = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]], dtype="float64") y = np.array([[1.0]], dtype="float64") z = convolve_fft( x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, fft_type=fft_type, ) assert_array_almost_equal_nulp(z, x, 10)
def test_diags_vs_diag(self): # Check that # # diags([a, b, ...], [i, j, ...]) == diag(a, i) + diag(b, j) + ... # np.random.seed(1234) for n_diags in [1, 2, 3, 4, 5, 10]: n = 1 + n_diags//2 + np.random.randint(0, 10) offsets = np.arange(-n+1, n-1) np.random.shuffle(offsets) offsets = offsets[:n_diags] diagonals = [np.random.rand(n - abs(q)) for q in offsets] mat = construct.diags(diagonals, offsets) dense_mat = sum([np.diag(x, j) for x, j in zip(diagonals, offsets)]) assert_array_almost_equal_nulp(mat.todense(), dense_mat) if len(offsets) == 1: mat = construct.diags(diagonals[0], offsets[0]) dense_mat = np.diag(diagonals[0], offsets[0]) assert_array_almost_equal_nulp(mat.todense(), dense_mat)
def test_unity_1_withnan(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros, fft_type): ''' Test that a unit kernel with three elements returns the same array (except when boundary is None). This version includes a NaN value in the original array. ''' if fft_type == 'fftw' and not HAS_FFTW: pytest.skip('fftw3 is not installed') elif fft_type == 'scipy' and not HAS_SCIPY: pytest.skip('scipy is not installed') x = np.array([1., np.nan, 3.], dtype='float64') y = np.array([1.], dtype='float64') z = convolve_fft(x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, fft_type=fft_type) if fft_type == 'numpy': # for whatever reason, numpy's fft has very limited precision, and # the comparison fails unless you cast the float64 to a float16 # np1.4 incompatible assert_array_almost_equal_nulp(np.asarray(z, dtype=np.float16), np.array([1.,0.,3.], dtype=np.float16), 10) assert np.all(np.abs(z - np.array([1., 0., 3.])) < 1e-14) else: assert_array_almost_equal_nulp(z, np.array([1., 0., 3.], dtype='float64'), 10)
def test_float16_input_large(self, size): x = np.random.rand(size, 3) + 1j*np.random.rand(size, 3) y1 = fftn(x.real.astype(np.float16)) y2 = fftn(x.real.astype(np.float64)).astype(np.complex64) assert_equal(y1.dtype, np.complex64) assert_array_almost_equal_nulp(y1, y2, 2e6)
def test_mask(): length = 100 ramps = [np.linspace(0, 4 * np.pi, length), np.linspace(0, 8 * np.pi, length), np.linspace(0, 6 * np.pi, length)] image = np.vstack(ramps) mask_1d = np.ones((length,), dtype=np.bool) mask_1d[0] = mask_1d[-1] = False for i in range(len(ramps)): # mask all ramps but the i'th one mask = np.zeros(image.shape, dtype=np.bool) mask |= mask_1d.reshape(1, -1) mask[i, :] = False # unmask i'th ramp image_wrapped = np.ma.array(np.angle(np.exp(1j * image)), mask=mask) image_unwrapped = unwrap_phase(image_wrapped) image_unwrapped -= image_unwrapped[0, 0] # remove phase shift # The end of the unwrapped array should have value equal to the # endpoint of the unmasked ramp assert_array_almost_equal_nulp(image_unwrapped[:, -1], image[i, -1]) # Same tests, but forcing use of the 3D unwrapper by reshaping image_wrapped_3d = image_wrapped.reshape((1,) + image_wrapped.shape) image_unwrapped_3d = unwrap_phase(image_wrapped_3d) image_unwrapped_3d -= image_unwrapped_3d[0, 0, 0] # remove phase shift assert_array_almost_equal_nulp(image_unwrapped_3d[:, :, -1], image[i, -1])
def test_unity_1_withnan(self, boundary, nan_treatment, normalize_kernel, preserve_nan, inval, outval): ''' Test that a unit kernel with three elements returns the same array (except when boundary is None). This version includes a NaN value in the original array. ''' x = inval y = np.array([1.], dtype='float64') z = convolve_fft(x, y, boundary=boundary, nan_treatment=nan_treatment, normalize_kernel=normalize_kernel, preserve_nan=preserve_nan) if preserve_nan: assert np.isnan(z[1]) z = np.nan_to_num(z) # for whatever reason, numpy's fft has very limited precision, and # the comparison fails unless you cast the float64 to a float16 if hasattr(np, 'float16'): assert_array_almost_equal_nulp(np.asarray(z, dtype=np.float16), np.array([1., 0., 3.], dtype=np.float16), 10) assert_allclose(z, outval, atol=1e-14)
def test_unity_3x3(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros, fft_type): ''' Test that a 3x3 unit kernel returns the same array (except when boundary is None). ''' if fft_type == 'fftw' and not HAS_FFTW: pytest.skip('fftw3 is not installed') elif fft_type == 'scipy' and not HAS_SCIPY: pytest.skip('scipy is not installed') x = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.]], dtype='float64') y = np.array([[0., 0., 0.], [0., 1., 0.], [0., 0., 0.]], dtype='float64') z = convolve_fft(x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, fft_type=fft_type) assert_array_almost_equal_nulp(z, x, 10)
def test_image_attributes_distance(self): image = self.m.get_image(group=0, units='ergs/cm^2/s', distance=100.) assert image.x_min == -1. assert image.x_max == +2. assert image.y_min == -3. assert image.y_max == +4. lon_min = np.degrees(np.arctan(-1. / 100.)) lon_max = np.degrees(np.arctan(+2. / 100.)) lat_min = np.degrees(np.arctan(-3. / 100.)) lat_max = np.degrees(np.arctan(+4. / 100.)) assert_array_almost_equal_nulp(image.lon_min, lon_min, 5) assert_array_almost_equal_nulp(image.lon_max, lon_max, 5) assert_array_almost_equal_nulp(image.lat_min, lat_min, 5) assert_array_almost_equal_nulp(image.lat_max, lat_max, 5) pix_area_sr = np.radians(lon_max - lon_min) * np.radians(lat_max - lat_min) / 200 assert_array_almost_equal_nulp(image.pix_area_sr, pix_area_sr, 5) assert image.distance == 100. assert not image.inside_observer assert image.units == 'ergs/cm^2/s' assert image.nu.shape == (5,) assert image.wav.shape == (5,) assert image.val.shape == (2, 20, 10, 5)
def test_unity_3(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros, fft_type): """ Test that a unit kernel with three elements returns the same array (except when boundary is None). """ if fft_type == "fftw" and not HAS_FFTW: pytest.skip("fftw3 is not installed") elif fft_type == "scipy" and not HAS_SCIPY: pytest.skip("scipy is not installed") x = np.array([1.0, 2.0, 3.0], dtype="float64") y = np.array([0.0, 1.0, 0.0], dtype="float64") z = convolve_fft( x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, fft_type=fft_type, ) assert_array_almost_equal_nulp(z, x, 10)
def test_padecases_dtype_float(self): for dtype in [np.float32, np.float64]: for scale in [1e-2, 1e-1, 5e-1, 1, 10]: A = scale * eye(3, dtype=dtype) observed = expm(A) expected = exp(scale) * eye(3, dtype=dtype) assert_array_almost_equal_nulp(observed, expected, nulp=100)
def test_unity_3_withnan(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros, fft_type): """ Test that a unit kernel with three elements returns the same array (except when boundary is None). This version includes a NaN value in the original array. """ if fft_type == "fftw" and not HAS_FFTW: pytest.skip("fftw3 is not installed") elif fft_type == "scipy" and not HAS_SCIPY: pytest.skip("scipy is not installed") x = np.array([1.0, np.nan, 3.0], dtype="float64") y = np.array([0.0, 1.0, 0.0], dtype="float64") z = convolve_fft( x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros, fft_type=fft_type, ) if fft_type == "numpy": # for whatever reason, numpy's fft has very limited precision, and # the comparison fails unless you cast the float64 to a float16 # REMOVED because of numpy 1.4 incompatibility assert_array_almost_equal_nulp(np.asarray(z, dtype=np.float16), np.array([1.,0.,3.], dtype=np.float16), 10) # ASSERT equality to better than 16 bit but worse than 32 bit precision assert np.all(np.abs(z - np.array([1.0, 0.0, 3.0])) < 1e-14) else: assert_array_almost_equal_nulp(z, np.array([1.0, 0.0, 3.0], dtype="float64"), 10)
def test_uniform_3_withnan(self, boundary, nan_treatment, normalize_kernel): ''' Test that the different modes are producing the correct results using a uniform kernel with three elements. This version includes a NaN value in the original array. ''' x = np.array([1., np.nan, 3.], dtype='float64') y = np.array([1., 1., 1.], dtype='float64') # if nan_treatment and not normalize_kernel: # with pytest.raises(ValueError): # z = convolve_fft(x, y, boundary=boundary, # nan_treatment=nan_treatment, # normalize_kernel=normalize_kernel, # ignore_edge_zeros=ignore_edge_zeros) # return z = convolve_fft(x, y, boundary=boundary, nan_treatment=nan_treatment, normalize_kernel=normalize_kernel) answer_dict = { 'sum': np.array([1., 4., 3.], dtype='float64'), 'sum_nozeros': np.array([1., 4., 3.], dtype='float64'), 'sum_zeros': np.array([1., 4., 3.], dtype='float64'), 'sum_nozeros_interpnan': np.array([1., 4., 3.], dtype='float64'), 'average': np.array([1., 2., 3.], dtype='float64'), 'sum_wrap': np.array([4., 4., 4.], dtype='float64'), 'average_wrap': np.array([4/3., 4/3., 4/3.], dtype='float64'), 'average_wrap_interpnan': np.array([2, 2, 2], dtype='float64'), 'average_nozeros': np.array([1/2., 4/3., 3/2.], dtype='float64'), #'average_nozeros_interpnan': np.array([1 / 2., 4 / 3., 3 / 2.], dtype='float64'), 'average_nozeros_interpnan': np.array([1., 2., 3.], dtype='float64'), 'average_zeros': np.array([1 / 3., 4 / 3., 3 / 3.], dtype='float64'), 'average_zeros_interpnan': np.array([1 / 2., 4 / 2., 3 / 2.], dtype='float64'), } for key in list(answer_dict.keys()): if 'sum' in key: answer_dict[key+"_interpnan"] = answer_dict[key] * 3./2. if normalize_kernel: answer_key = 'average' else: answer_key = 'sum' if boundary == 'wrap': answer_key += '_wrap' else: # average = average_zeros; sum = sum_zeros answer_key += '_zeros' if nan_treatment == 'interpolate': answer_key += '_interpnan' assert_array_almost_equal_nulp(z, answer_dict[answer_key], 10)
def test_nd_axis_0(self): x = np.arange(20, dtype=np.float64)+0.04 x = x.reshape((10,2,1)) f, p = welch(x, nperseg=10, axis=0) assert_array_equal(p.shape, (6,2,1)) assert_array_almost_equal_nulp(p[:,0,0], p[:,1,0], 60) f0, p0 = welch(x[:,0,0], nperseg=10) assert_array_almost_equal_nulp(p0, p[:,1,0])
def test_definition_float16(self): x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] y = fftn(np.array(x, np.float16)) assert_equal(y.dtype, np.complex64) y_r = np.array(fftn(x), np.complex64) assert_array_almost_equal_nulp(y, y_r)
def test_power_law_envelope_mass_calc(): e = PowerLawEnvelope() e.rmin = 9. e.rmax = 18. e.r_0 = 3. e.power = -1. e.rho_0 = 2. assert_array_almost_equal_nulp(e.mass, 4. * np.pi * 27 * 27, 2)
def test_window_external(self): x = np.zeros(16) x[0] = 1 f, p = periodogram(x, 10, 'hann') win = signal.get_window('hann', 16) fe, pe = periodogram(x, 10, win) assert_array_almost_equal_nulp(p, pe) assert_array_almost_equal_nulp(f, fe)
def testFloatArray(self): arr = np.arange(12.5, 185.72, 1.7322, dtype=np.float) dtypes = (np.float, np.float32, np.float64) for dtype in dtypes: inpt = arr.astype(dtype) outp = np.array(ujson.decode(ujson.encode(inpt, double_precision=15)), dtype=dtype) assert_array_almost_equal_nulp(inpt, outp)
def test_power_law_envelope_rho0_calc(): e = PowerLawEnvelope() e.rmin = 9.0 e.rmax = 18.0 e.r_0 = 3.0 e.power = -1.0 e.mass = 4.0 * np.pi * 27 * 27 assert_array_almost_equal_nulp(e.rho_0, 2.0, 2)
def test_random_stochastic_matrix_sparse(): sparse = True n, k = 5, 3 Ps = [random_stochastic_matrix(n, sparse=sparse), random_stochastic_matrix(n, k, sparse=sparse)] for P in Ps: ok_(np.all(P.data >= 0)) assert_array_almost_equal_nulp(P.sum(axis=1), np.ones(n))
def test_definition(self): x = [[1,2,3],[4,5,6],[7,8,9]] y = fftn(np.array(x, np.float32)) if not y.dtype == np.complex64: raise ValueError("double precision output with single precision") y_r = np.array(fftn(x), np.complex64) assert_array_almost_equal_nulp(y, y_r)
def test_random_stochastic_matrix_k_1(): n, k = 3, 1 P_dense = random_stochastic_matrix(n, k, sparse=False) P_sparse = random_stochastic_matrix(n, k, sparse=True) assert_array_equal(P_dense[P_dense != 0], np.ones(n)) assert_array_equal(P_sparse.data, np.ones(n)) for P in [P_dense, P_sparse]: assert_array_almost_equal_nulp(P.sum(axis=1), np.ones(n))
def test_to_float_with_max_value_specified(max_value): img = np.ones((100, 100, 3), dtype=np.uint16) expected = img.astype('float32') / max_value assert_array_almost_equal_nulp(F.to_float(img, max_value=max_value), expected)
def assert_array_almost_equal_nulp(self, *args, **kwargs): """ Compare two arrays relatively to their spacing. """ return assert_array_almost_equal_nulp(*args, **kwargs)
def test_normalize(): img = np.ones((100, 100, 3), dtype=np.uint8) * 127 normalized = F.normalize(img, mean=50, std=3) expected = (np.ones((100, 100, 3), dtype=np.float32) * 127 / 255 - 50) / 3 assert_array_almost_equal_nulp(normalized, expected)
def test_loglog_subset_special2(xmin, xmax): # Special case for loglog is close to y = x^-1 x = np.array([1., 2., 3., 4., 5.]) y = x**-1.1 assert_array_almost_equal_nulp(integrate_loglog_subset(x, y, xmin, xmax), -10. * (xmax**-0.1 - xmin**-0.1), 50)
def test_set_alpha_range(plane): plane.set_alpha_range() new_alpha_range = plane.alpha_range x = list(range(-10, 13)) npt.assert_array_almost_equal_nulp(new_alpha_range, x, nulp=0)
def test_clip_float(): img = np.array([[-0.02, 0], [0.5, 2.2]], dtype=np.float32) expected = np.array([[0, 0], [0.5, 1.0]], dtype=np.float32) clipped = F.clip(img, dtype=np.float32, maxval=1.0) assert_array_almost_equal_nulp(clipped, expected)
def test_eig(): size = 10 ci = chinfo3 l = gen_random_legcharge(ci, size) A = npc.Array.from_func(np.random.random, [l, l.conj()], qtotal=None, shape_kw='size') print("hermitian A") A += A.conj().itranspose() Aflat = A.to_ndarray() W, V = npc.eigh(A, sort='m>') V.test_sanity() V_W = V.scale_axis(W, axis=-1) recalc = npc.tensordot(V_W, V.conj(), axes=[1, 1]) npt.assert_array_almost_equal_nulp(Aflat, recalc.to_ndarray(), size**3) Wflat, Vflat = np.linalg.eigh(Aflat) npt.assert_array_almost_equal_nulp(np.sort(W), Wflat, size**3) W2 = npc.eigvalsh(A, sort='m>') npt.assert_array_almost_equal_nulp(W, W2, size**3) print("check complex B") B = 1.j * npc.Array.from_func(np.random.random, [l, l.conj()], shape_kw='size') B += B.conj().itranspose() B = A + B Bflat = B.to_ndarray() W, V = npc.eigh(B, sort='m>') V.test_sanity() recalc = npc.tensordot(V.scale_axis(W, axis=-1), V.conj(), axes=[1, 1]) npt.assert_array_almost_equal_nulp(Bflat, recalc.to_ndarray(), size**3) Wflat, Vflat = np.linalg.eigh(Bflat) npt.assert_array_almost_equal_nulp(np.sort(W), Wflat, size**3) print("calculate without 'hermitian' knownledge") W, V = npc.eig(B, sort='m>') assert (np.max(np.abs(W.imag)) < EPS * size**3) npt.assert_array_almost_equal_nulp(np.sort(W.real), Wflat, size**3) print("sparse speigs") qi = 1 ch_sect = B.legs[0].get_charge(qi) k = min(3, B.legs[0].slices[qi + 1] - B.legs[0].slices[qi]) Wsp, Vsp = npc.speigs(B, ch_sect, k=k, which='LM') for W_i, V_i in zip(Wsp, Vsp): V_i.test_sanity() diff = npc.tensordot(B, V_i, axes=1) - V_i * W_i assert (npc.norm(diff, np.inf) < EPS * size**3) print("for trivial charges") A = npc.Array.from_func(np.random.random, [lcTr, lcTr.conj()], shape_kw='size') A = A + A.conj().itranspose() Aflat = A.to_ndarray() W, V = npc.eigh(A) recalc = npc.tensordot(V.scale_axis(W, axis=-1), V.conj(), axes=[1, 1]) npt.assert_array_almost_equal_nulp(Aflat, recalc.to_ndarray(), 5 * A.shape[0]**3)
def test_random_complex(self, maxnlp, size): x = random([size, size]) + 1j * random([size, size]) assert_array_almost_equal_nulp(ifftn(fftn(x)), x, maxnlp) assert_array_almost_equal_nulp(fftn(ifftn(x)), x, maxnlp)
def assert_csc_almost_equal(r, l): r = csc_matrix(r) l = csc_matrix(l) assert_equal(r.indptr, l.indptr) assert_equal(r.indices, l.indices) assert_array_almost_equal_nulp(r.data, l.data, 10000)
def test_random_flip_float(code, func, target): img = np.array([[0.4, 0.4, 0.4], [0.0, 0.4, 0.4], [0.0, 0.0, 0.4]], dtype=np.float32) img = convert_2d_to_target_format([img], target=target) assert_array_almost_equal_nulp(F.random_flip(img, code), func(img))
def test_from_float_with_max_value_specified(max_value): img = np.ones((100, 100, 3), dtype=np.float32) expected = (img * max_value).astype(np.uint32) assert_array_almost_equal_nulp( F.from_float(img, dtype=np.uint32, max_value=max_value), expected)
def test_from_float_without_max_value_specified(dtype, multiplier): img = np.ones((100, 100, 3), dtype=np.float32) expected = (img * multiplier).astype(dtype) assert_array_almost_equal_nulp(F.from_float(img, np.dtype(dtype)), expected)
def test_uniform_3_withnan(self, boundary, nan_treatment, normalize_kernel): ''' Test that the different modes are producing the correct results using a uniform kernel with three elements. This version includes a NaN value in the original array. ''' x = np.array([1., np.nan, 3.], dtype='float64') y = np.array([1., 1., 1.], dtype='float64') # if nan_treatment and not normalize_kernel: # with pytest.raises(ValueError): # z = convolve_fft(x, y, boundary=boundary, # nan_treatment=nan_treatment, # normalize_kernel=normalize_kernel, # ignore_edge_zeros=ignore_edge_zeros) # return z = convolve_fft(x, y, boundary=boundary, nan_treatment=nan_treatment, normalize_kernel=normalize_kernel) answer_dict = { 'sum': np.array([1., 4., 3.], dtype='float64'), 'sum_nozeros': np.array([1., 4., 3.], dtype='float64'), 'sum_zeros': np.array([1., 4., 3.], dtype='float64'), 'sum_nozeros_interpnan': np.array([1., 4., 3.], dtype='float64'), 'average': np.array([1., 2., 3.], dtype='float64'), 'sum_wrap': np.array([4., 4., 4.], dtype='float64'), 'average_wrap': np.array([4 / 3., 4 / 3., 4 / 3.], dtype='float64'), 'average_wrap_interpnan': np.array([2, 2, 2], dtype='float64'), 'average_nozeros': np.array([1 / 2., 4 / 3., 3 / 2.], dtype='float64'), #'average_nozeros_interpnan': np.array([1 / 2., 4 / 3., 3 / 2.], dtype='float64'), 'average_nozeros_interpnan': np.array([1., 2., 3.], dtype='float64'), 'average_zeros': np.array([1 / 3., 4 / 3., 3 / 3.], dtype='float64'), 'average_zeros_interpnan': np.array([1 / 2., 4 / 2., 3 / 2.], dtype='float64'), } for key in list(answer_dict.keys()): if 'sum' in key: answer_dict[key + "_interpnan"] = answer_dict[key] * 3. / 2. if normalize_kernel: answer_key = 'average' else: answer_key = 'sum' if boundary == 'wrap': answer_key += '_wrap' else: # average = average_zeros; sum = sum_zeros answer_key += '_zeros' if nan_treatment == 'interpolate': answer_key += '_interpnan' assert_array_almost_equal_nulp(z, answer_dict[answer_key], 10)
def test_random_brightness_float(beta, expected): img = np.ones((100, 100, 3), dtype=np.float32) * 0.4 expected = np.ones_like(img) * expected img = F.brightness_contrast_adjust(img, beta=beta) assert img.dtype == np.dtype("float32") assert_array_almost_equal_nulp(img, expected)
def test_ext_flux(): Lx, Ly = 3, 4 lat = lattice.Square(Lx, Ly, fermion_site, bc=['periodic', 'periodic'], bc_MPS='infinite') M = model.CouplingModel(lat) strength = 1.23 strength_array = np.ones((Lx, Ly)) * strength for phi in [0, 2 * np.pi]: # flux shouldn't do anything print("phi = ", phi) for dx in [1, 0], [0, 1], [0, 2], [1, -1], [-2, 2]: print("dx = ", dx) strength_flux = M.coupling_strength_add_ext_flux( strength, [1, 0], [0, phi]) npt.assert_array_almost_equal_nulp(strength_flux, strength_array, 10) for phi in [np.pi / 2, 0.123]: print("phi = ", phi) strength_hop_x = M.coupling_strength_add_ext_flux( strength, [1, 0], [0, phi]) npt.assert_array_almost_equal_nulp(strength_hop_x, strength_array, 10) expect_y_1 = np.array(strength_array, dtype=np.complex128) expect_y_1[:, -1:] = strength * np.exp(1.j * phi) for dx in [[0, 1], [0, -1], [1, -1], [1, 1]]: print("dx = ", dx) strength_hop_y_1 = M.coupling_strength_add_ext_flux( strength, dx, [0, phi]) if dx[1] < 0: npt.assert_array_almost_equal_nulp(strength_hop_y_1, expect_y_1, 10) else: npt.assert_array_almost_equal_nulp(strength_hop_y_1, np.conj(expect_y_1), 10) expect_y_2 = np.array(strength_array, dtype=np.complex128) expect_y_2[:, -2:] = strength * np.exp(1.j * phi) for dx in [[0, 2], [0, -2], [1, 2], [3, 2]]: print("dx = ", dx) strength_hop_y_2 = M.coupling_strength_add_ext_flux( strength, dx, [0, phi]) if dx[1] < 0: npt.assert_array_almost_equal_nulp(strength_hop_y_2, expect_y_2, 10) else: npt.assert_array_almost_equal_nulp(strength_hop_y_2, np.conj(expect_y_2), 10)
def test_npc_tensordot(): for sort in [True, False]: print("sort =", sort) a = random_Array((10, 12, 15), chinfo3, qtotal=[0], sort=sort) aflat = a.to_ndarray() legs_b = [l.conj() for l in a.legs[::-1]] b = npc.Array.from_func(np.random.random, legs_b, qtotal=[1], shape_kw='size') bflat = b.to_ndarray() print("axes = 1") # start simple: only one axes c = npc.tensordot(a, b, axes=1) c.test_sanity() a.test_sanity() b.test_sanity() npt.assert_array_almost_equal_nulp(a.to_ndarray(), aflat, 1) npt.assert_array_almost_equal_nulp(b.to_ndarray(), bflat, 1) cflat = np.tensordot(aflat, bflat, axes=1) npt.assert_array_almost_equal_nulp(c.to_ndarray(), cflat, sum(a.shape)) print("axes = 2") # second: more than one axis c = npc.tensordot(a, b, axes=([1, 2], [1, 0])) a.test_sanity() b.test_sanity() npt.assert_array_almost_equal_nulp(a.to_ndarray(), aflat, 1) npt.assert_array_almost_equal_nulp(b.to_ndarray(), bflat, 1) c.test_sanity() cflat = np.tensordot(aflat, bflat, axes=([1, 2], [1, 0])) npt.assert_array_almost_equal_nulp(c.to_ndarray(), cflat, sum(a.shape)) for i in range(b.shape[0]): b2 = b[i, :, :] if b2.stored_blocks > 0: break b2flat = b2.to_ndarray() print("right tensor fully contracted") print(a.shape, b2.shape) d = npc.tensordot(a, b2, axes=([0, 1], [1, 0])) d.test_sanity() dflat = np.tensordot(aflat, b2flat, axes=([0, 1], [1, 0])) npt.assert_array_almost_equal_nulp(d.to_ndarray(), dflat, sum(a.shape)) print("left tensor fully contracted") d = npc.tensordot(b2, a, axes=([0, 1], [1, 0])) d.test_sanity() dflat = np.tensordot(b2flat, aflat, axes=([0, 1], [1, 0])) npt.assert_array_almost_equal_nulp(d.to_ndarray(), dflat, sum(a.shape)) # full/no contraction is tested in test_npc_inner/test_npc_outer print("for trivial charge") a = npc.Array.from_func(np.random.random, [lcTr, lcTr.conj()], shape_kw='size') aflat = a.to_ndarray() b = npc.tensordot(a, a, axes=1) bflat = np.tensordot(aflat, aflat, axes=1) npt.assert_array_almost_equal_nulp(b.to_ndarray(), bflat, sum(a.shape))
def test_parse_csv(self): csv = parse_csv(self.csv) assert_array_almost_equal_nulp(csv.col1, self.col1) assert_array_almost_equal_nulp(csv.col2, self.col2)
def test_complex128_pass(self): nulp = 5 x = np.linspace(-20, 20, 50, dtype=np.float64) x = 10**x x = np.r_[-x, x] xi = x + x*1j eps = np.finfo(x.dtype).eps y = x + x*eps*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) # The test condition needs to be at least a factor of sqrt(2) smaller # because the real and imaginary parts both change y = x + x*eps*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp) epsneg = np.finfo(x.dtype).epsneg y = x - x*epsneg*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) y = x - x*epsneg*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
def test_normalize_float(): img = np.ones((100, 100, 3), dtype=np.float32) * 0.4 normalized = F.normalize(img, mean=50, std=3, max_pixel_value=1.0) expected = (np.ones((100, 100, 3), dtype=np.float32) * 0.4 - 50) / 3 assert_array_almost_equal_nulp(normalized, expected)
def test_uniform_3_withnan(self, boundary, interpolate_nan, normalize_kernel, ignore_edge_zeros): ''' Test that the different modes are producing the correct results using a uniform kernel with three elements. This version includes a NaN value in the original array. ''' x = np.array([1., np.nan, 3.], dtype='float64') y = np.array([1., 1., 1.], dtype='float64') z = convolve_fft(x, y, boundary=boundary, interpolate_nan=interpolate_nan, normalize_kernel=normalize_kernel, ignore_edge_zeros=ignore_edge_zeros) answer_dict = { 'sum': np.array([1., 4., 3.], dtype='float64'), 'sum_nozeros': np.array([1., 4., 3.], dtype='float64'), 'sum_zeros': np.array([1., 4., 3.], dtype='float64'), 'sum_zeros_noignan': np.array([1., 4., 3.], dtype='float64'), 'sum_nozeros_noignan': np.array([1., 4., 3.], dtype='float64'), 'average': np.array([1., 2., 3.], dtype='float64'), 'sum_wrap': np.array([4., 4., 4.], dtype='float64'), 'sum_wrap_noignan': np.array([4., 4., 4.], dtype='float64'), 'average_wrap': np.array([(1 + 3) / 2., 2., 2.], dtype='float64'), 'average_wrap_noignan': np.array([4 / 3., 4 / 3., 4 / 3.], dtype='float64'), 'average_nozeros': np.array([1, 2, 3], dtype='float64'), 'average_nozeros_noignan': np.array([1 / 2., 4 / 3., 3 / 2.], dtype='float64'), 'average_zeros': np.array([1 / 2., 4 / 2., 3 / 2.], dtype='float64'), 'average_zeros_noignan': np.array([1 / 3., 4 / 3., 3 / 3.], dtype='float64'), } if normalize_kernel: answer_key = 'average' else: answer_key = 'sum' if boundary == 'wrap': answer_key += '_wrap' elif ignore_edge_zeros: answer_key += '_nozeros' else: # average = average_zeros; sum = sum_zeros answer_key += '_zeros' if not interpolate_nan: answer_key += '_noignan' assert_array_almost_equal_nulp(z, answer_dict[answer_key], 10)
def test_complex64_pass(self): nulp = 5 x = np.linspace(-20, 20, 50, dtype=np.float32) x = 10**x x = np.r_[-x, x] xi = x + x*1j eps = np.finfo(x.dtype).eps y = x + x*eps*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) y = x + x*eps*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp) epsneg = np.finfo(x.dtype).epsneg y = x - x*epsneg*nulp/2. assert_array_almost_equal_nulp(xi, x + y*1j, nulp) assert_array_almost_equal_nulp(xi, y + x*1j, nulp) y = x - x*epsneg*nulp/4. assert_array_almost_equal_nulp(xi, y + y*1j, nulp)
def test_random_complex(self): for size in [1, 2, 51, 32, 64, 92]: x = random([size, size]) + 1j * random([size, size]) assert_array_almost_equal_nulp(ifftn(fftn(x)), x, self.maxnlp) assert_array_almost_equal_nulp(fftn(ifftn(x)), x, self.maxnlp)
def test_random_contrast_float(alpha, expected): img = np.ones((100, 100, 3), dtype=np.float32) * 0.4 expected = np.ones((100, 100, 3), dtype=np.float32) * expected img = F.brightness_contrast_adjust(img, alpha=alpha) assert img.dtype == np.dtype('float32') assert_array_almost_equal_nulp(img, expected)
def test_simulate(self): beliefs_sequence = \ self.fp.simulate(ts_length=3, init_actions=(0, 1)) # played actions: (0, 1), (1, 0), (0, 1) assert_array_almost_equal_nulp( beliefs_sequence[0], [[0, 1], [1 / 2, 1 / 2], [1 / 3, 2 / 3]])
def test_unit_conversions(): """ Test operations that convert to different units or cast to ndarray """ from yt.units.yt_array import YTQuantity from yt.units.unit_object import Unit km = YTQuantity(1, 'km') km_in_cm = km.in_units('cm') cm_unit = Unit('cm') kpc_unit = Unit('kpc') assert_equal(km_in_cm, km) assert_equal(km_in_cm.in_cgs(), 1e5) assert_equal(km_in_cm.in_mks(), 1e3) assert_equal(km_in_cm.units, cm_unit) km_view = km.ndarray_view() km.convert_to_units('cm') assert_true(km_view.base is km.base) assert_equal(km, YTQuantity(1, 'km')) assert_equal(km.in_cgs(), 1e5) assert_equal(km.in_mks(), 1e3) assert_equal(km.units, cm_unit) km.convert_to_units('kpc') assert_true(km_view.base is km.base) assert_array_almost_equal_nulp(km, YTQuantity(1, 'km')) assert_array_almost_equal_nulp(km.in_cgs(), YTQuantity(1e5, 'cm')) assert_array_almost_equal_nulp(km.in_mks(), YTQuantity(1e3, 'm')) assert_equal(km.units, kpc_unit) assert_isinstance(km.to_ndarray(), np.ndarray) assert_isinstance(km.ndarray_view(), np.ndarray) dyne = YTQuantity(1.0, 'dyne') assert_equal(dyne.in_cgs(), dyne) assert_equal(dyne.in_cgs(), 1.0) assert_equal(dyne.in_mks(), dyne) assert_equal(dyne.in_mks(), 1e-5) assert_equal(str(dyne.in_mks().units), 'kg*m/s**2') assert_equal(str(dyne.in_cgs().units), 'cm*g/s**2') em3 = YTQuantity(1.0, 'erg/m**3') assert_equal(em3.in_cgs(), em3) assert_equal(em3.in_cgs(), 1e-6) assert_equal(em3.in_mks(), em3) assert_equal(em3.in_mks(), 1e-7) assert_equal(str(em3.in_mks().units), 'kg/(m*s**2)') assert_equal(str(em3.in_cgs().units), 'g/(cm*s**2)') em3_converted = YTQuantity(1545436840.386756, 'Msun/(Myr**2*kpc)') assert_equal(em3.in_base(unit_system="galactic"), em3) assert_array_almost_equal(em3.in_base(unit_system="galactic"), em3_converted) assert_equal(str(em3.in_base(unit_system="galactic").units), 'Msun/(Myr**2*kpc)') dimless = YTQuantity(1.0, "") assert_equal(dimless.in_cgs(), dimless) assert_equal(dimless.in_cgs(), 1.0) assert_equal(dimless.in_mks(), dimless) assert_equal(dimless.in_mks(), 1.0) assert_equal(str(dimless.in_cgs().units), "dimensionless")
def test_to_float_without_max_value_specified(dtype, divider): img = np.ones((100, 100, 3), dtype=dtype) expected = img.astype("float32") / divider assert_array_almost_equal_nulp(F.to_float(img), expected)
def assert_fp_equal(x, y, err_msg="", nulp=50): """Assert two arrays are equal, up to some floating-point rounding error""" try: assert_array_almost_equal_nulp(x, y, nulp) except AssertionError as e: raise AssertionError("%s\n%s" % (e, err_msg))
def test_to_float_unknown_dtype_with_max_value(max_value): img = np.ones((100, 100, 3), dtype=np.int16) expected = img.astype("float32") / max_value assert_array_almost_equal_nulp(F.to_float(img, max_value=max_value), expected)
def assert_array_almost_equal_nulp(self, x, y, nulp=1): x = x.tondarray() if hasattr(x, 'tondarray') else x y = y.tondarray() if hasattr(y, 'tondarray') else y return npt.assert_array_almost_equal_nulp(x, y, nulp)