def test_main_versions(): assert_(NumpyVersion('1.8.0') == '1.8.0') for ver in ['1.9.0', '2.0.0', '1.8.1']: assert_(NumpyVersion('1.8.0') < ver) for ver in ['1.7.0', '1.7.1', '0.9.9']: assert_(NumpyVersion('1.8.0') > ver)
def test_main_versions(): assert_(NumpyVersion("1.8.0") == "1.8.0") for ver in ["1.9.0", "2.0.0", "1.8.1"]: assert_(NumpyVersion("1.8.0") < ver) for ver in ["1.7.0", "1.7.1", "0.9.9"]: assert_(NumpyVersion("1.8.0") > ver)
def test_alpha_beta_rc(): assert_(NumpyVersion('1.8.0rc1') == '1.8.0rc1') for ver in ['1.8.0', '1.8.0rc2']: assert_(NumpyVersion('1.8.0rc1') < ver) for ver in ['1.8.0a2', '1.8.0b3', '1.7.2rc4']: assert_(NumpyVersion('1.8.0rc1') > ver) assert_(NumpyVersion('1.8.0b1') > '1.8.0a2')
def test_alpha_beta_rc(): assert_(NumpyVersion("1.8.0rc1") == "1.8.0rc1") for ver in ["1.8.0", "1.8.0rc2"]: assert_(NumpyVersion("1.8.0rc1") < ver) for ver in ["1.8.0a2", "1.8.0b3", "1.7.2rc4"]: assert_(NumpyVersion("1.8.0rc1") > ver) assert_(NumpyVersion("1.8.0b1") > "1.8.0a2")
def test_input_validation(self): match = r"`order` must be either 1, 3, or 5." with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), order=2) match = "`cdf` required but not found" with pytest.raises(ValueError, match=match): NumericalInverseHermite("norm") match = "could not convert string to float" with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), u_resolution='ekki') match = "`max_intervals' must be..." with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), max_intervals=-1) match = "`qmc_engine` must be an instance of..." with pytest.raises(ValueError, match=match): fni = NumericalInverseHermite(StandardNormal()) fni.qrvs(qmc_engine=0) if NumpyVersion(np.__version__) >= '1.18.0': # issues with QMCEngines and old NumPy fni = NumericalInverseHermite(StandardNormal()) match = "`d` must be consistent with dimension of `qmc_engine`." with pytest.raises(ValueError, match=match): fni.qrvs(d=3, qmc_engine=stats.qmc.Halton(2))
def test_QRVS_size_tuple(self): # QMCEngine samples are always of shape (n, d). When `size` is a tuple, # we set `n = prod(size)` in the call to qmc_engine.random, transform # the sample, and reshape it to the final dimensions. When we reshape, # we need to be careful, because the _columns_ of the sample returned # by a QMCEngine are "independent"-ish, but the elements within the # columns are not. We need to make sure that this doesn't get mixed up # by reshaping: qrvs[..., i] should remain "independent"-ish of # qrvs[..., i+1], but the elements within qrvs[..., i] should be # transformed from the same low-discrepancy sequence. if NumpyVersion(np.__version__) <= '1.18.0': pytest.skip("QMC doesn't play well with old NumPy") dist = StandardNormal() fni = NumericalInverseHermite(dist) size = (3, 4) d = 5 qrng = stats.qmc.Halton(d, seed=0) qrng2 = stats.qmc.Halton(d, seed=0) uniform = qrng2.random(np.prod(size)) qrvs = fni.qrvs(size=size, d=d, qmc_engine=qrng) qrvs2 = stats.norm.ppf(uniform) for i in range(d): sample = qrvs[..., i] sample2 = qrvs2[:, i].reshape(size) assert_allclose(sample, sample2, atol=1e-12)
def _fix_ndimage_mode(mode): # SciPy 1.6.0 introduced grid variants of constant and wrap which # have less surprising behavior for images. Use these when available grid_modes = {'constant': 'grid-constant', 'wrap': 'grid-wrap'} if NumpyVersion(scipy.__version__) >= '1.6.0': mode = grid_modes.get(mode, mode) return mode
def test_equality_constraints(): """Test out the ability to handle equality constraints""" # Create the system (double integrator, continuous time) sys = ct.ss2io(ct.ss(np.zeros((2, 2)), np.eye(2), np.eye(2), 0)) # Shortest path to a point is a line Q = np.zeros((2, 2)) R = np.eye(2) cost = opt.quadratic_cost(sys, Q, R) # Set up the terminal constraint to be the origin final_point = [opt.state_range_constraint(sys, [0, 0], [0, 0])] # Create the optimal control problem time = np.arange(0, 3, 1) optctrl = opt.OptimalControlProblem(sys, time, cost, terminal_constraints=final_point) # Find a path to the origin x0 = np.array([4, 3]) res = optctrl.compute_trajectory(x0, squeeze=True, return_x=True) t, u1, x1 = res.time, res.inputs, res.states # Bug prior to SciPy 1.6 will result in incorrect results if NumpyVersion(sp.__version__) < '1.6.0': pytest.xfail("SciPy 1.6 or higher required") np.testing.assert_almost_equal(x1[:, -1], 0, decimal=4) # Set up terminal constraints as a nonlinear constraint def final_point_eval(x, u): return x final_point = [(sp.optimize.NonlinearConstraint, final_point_eval, [0, 0], [0, 0])] optctrl = opt.OptimalControlProblem(sys, time, cost, terminal_constraints=final_point) # Find a path to the origin x0 = np.array([4, 3]) res = optctrl.compute_trajectory(x0, squeeze=True, return_x=True) t, u2, x2 = res.time, res.inputs, res.states np.testing.assert_almost_equal(x2[:, -1], 0, decimal=4) np.testing.assert_almost_equal(u1, u2) np.testing.assert_almost_equal(x1, x2) # Try passing and unknown constraint type final_point = [(None, final_point_eval, [0, 0], [0, 0])] with pytest.raises(TypeError, match="unknown constraint type"): optctrl = opt.OptimalControlProblem(sys, time, cost, terminal_constraints=final_point) res = optctrl.compute_trajectory(x0, squeeze=True, return_x=True)
def parse_targets(filename): """ Load a text file with target coordinates. Returns an array of target locations in Galactic coordinates. File description: [NAME] [LON] [LAT] [RADIUS] [COORD] The values of LON and LAT will depend on COORD: COORD = [GAL | CEL | HPX ], LON = [GLON | RA | NSIDE] LAT = [GLAT | DEC | PIX ] """ base, ext = os.path.splitext(filename) if (ext == '.fits'): import fitsio data = fitsio.read(filename) else: from numpy.lib import NumpyVersion if NumpyVersion(np.__version__) < '1.14.0': data = np.genfromtxt(filename, names=True, dtype=None) else: data = np.genfromtxt(filename, names=True, dtype=None, encoding=None) #data = np.genfromtxt(filename,unpack=True,usecols=list(range(5)),dtype=object,names=True) data = np.atleast_1d(data) data.dtype.names = list(map(str.lower, data.dtype.names)) # Deal with one-line input files #if data.ndim == 1: data = np.array([data]).T names = data['name'] out = data[['lon', 'lat', 'radius']].copy() coord = np.char.lower(data['coord']) gal = (coord == 'gal') cel = (coord == 'cel') hpx = (coord == 'hpx') if cel.any(): glon, glat = cel2gal(data['lon'][cel], data['lat'][cel]) out['lon'][cel] = glon out['lat'][cel] = glat if hpx.any(): glon, glat = pix2ang(data['lat'][hpx], data['lon'][hpx]) out['lon'][hpx] = glon out['lat'][hpx] = glat return names, out.view(np.ndarray)
def test_axis_nan_policy_decorated_positional_axis(axis): # Test for correct behavior of function decorated with # _axis_nan_policy_decorator whether `axis` is provided as positional or # keyword argument if NumpyVersion(np.__version__) < '1.18.0': pytest.xfail("Avoid test failures due to old version of NumPy") shape = (8, 9, 10) rng = np.random.default_rng(0) x = rng.random(shape) y = rng.random(shape) res1 = stats.mannwhitneyu(x, y, True, 'two-sided', axis) res2 = stats.mannwhitneyu(x, y, True, 'two-sided', axis=axis) assert_equal(res1, res2) message = "mannwhitneyu() got multiple values for argument 'axis'" with pytest.raises(TypeError, match=re.escape(message)): stats.mannwhitneyu(x, y, True, 'two-sided', axis, axis=axis)
def test_axis_nan_policy_decorated_keyword_samples(): # Test for correct behavior of function decorated with # _axis_nan_policy_decorator whether samples are provided as positional or # keyword arguments if NumpyVersion(np.__version__) < '1.18.0': pytest.xfail("Avoid test failures due to old version of NumPy") shape = (2, 8, 9, 10) rng = np.random.default_rng(0) x = rng.random(shape) x[0, 0, 0, 0] = np.nan res1 = stats.mannwhitneyu(*x) res2 = stats.mannwhitneyu(x=x[0], y=x[1]) assert_equal(res1, res2) message = "mannwhitneyu() got multiple values for argument" with pytest.raises(TypeError, match=re.escape(message)): stats.mannwhitneyu(*x, x=x[0], y=x[1])
def test_axis_nan_policy_decorated_positional_args(): # Test for correct behavior of function decorated with # _axis_nan_policy_decorator when function accepts *args if NumpyVersion(np.__version__) < '1.18.0': pytest.xfail("Avoid test failures due to old version of NumPy") shape = (3, 8, 9, 10) rng = np.random.default_rng(0) x = rng.random(shape) x[0, 0, 0, 0] = np.nan stats.kruskal(*x) message = "kruskal() got an unexpected keyword argument 'samples'" with pytest.raises(TypeError, match=re.escape(message)): stats.kruskal(samples=x) with pytest.raises(TypeError, match=re.escape(message)): stats.kruskal(*x, samples=x)
def test_axis_nan_policy_decorated_pickled(hypotest, args, kwds, n_samples, paired, unpacker): if NumpyVersion(np.__version__) < '1.18.0': rng = np.random.RandomState(0) else: rng = np.random.default_rng(0) # Some hypothesis tests return a non-iterable that needs an `unpacker` to # extract the statistic and p-value. For those that don't: if not unpacker: def unpacker(res): return res data = rng.uniform(size=(n_samples, 2, 30)) pickled_hypotest = pickle.dumps(hypotest) unpickled_hypotest = pickle.loads(pickled_hypotest) res1 = unpacker(hypotest(*data, *args, axis=-1, **kwds)) res2 = unpacker(unpickled_hypotest(*data, *args, axis=-1, **kwds)) assert_allclose(res1, res2, rtol=1e-12)
def test_random_state(method, kwargs): Method = getattr(stats, method) # simple seed that works for any version of NumPy seed = 123 rng1 = Method(**kwargs, random_state=seed) rng2 = Method(**kwargs, random_state=seed) assert_equal(rng1.rvs(100), rng2.rvs(100)) # global seed np.random.seed(123) rng1 = Method(**kwargs) rvs1 = rng1.rvs(100) np.random.seed(None) rng2 = Method(**kwargs, random_state=123) rvs2 = rng2.rvs(100) assert_equal(rvs1, rvs2) # RandomState seed for old numpy if NumpyVersion(np.__version__) < '1.19.0': seed1 = np.random.RandomState(123) seed2 = 123 rng1 = Method(**kwargs, random_state=seed1) rng2 = Method(**kwargs, random_state=seed2) assert_equal(rng1.rvs(100), rng2.rvs(100)) rvs11 = rng1.rvs(550) rvs12 = rng1.rvs(50) rvs2 = rng2.rvs(600) assert_equal(rvs11, rvs2[:550]) assert_equal(rvs12, rvs2[550:]) else: # Generator seed for new NumPy # when a RandomState is given, it should take the bitgen_t # member of the class and create a Generator instance. seed1 = np.random.RandomState(np.random.MT19937(123)) seed2 = np.random.Generator(np.random.MT19937(123)) rng1 = Method(**kwargs, random_state=seed1) rng2 = Method(**kwargs, random_state=seed2) assert_equal(rng1.rvs(100), rng2.rvs(100))
def test_dev0_version(): assert_(NumpyVersion("1.9.0.dev0+Unknown") < "1.9.0") for ver in ["1.9.0", "1.9.0a1", "1.9.0b2", "1.9.0b2.dev0+ffffffff"]: assert_(NumpyVersion("1.9.0.dev0+f16acvda") < ver) assert_(NumpyVersion("1.9.0.dev0+f16acvda") == "1.9.0.dev0+11111111")
def resize(image, output_shape, order=None, mode='reflect', cval=0, clip=True, preserve_range=False, anti_aliasing=None, anti_aliasing_sigma=None): """Resize image to match a certain size. Performs interpolation to up-size or down-size N-dimensional images. Note that anti-aliasing should be enabled when down-sizing images to avoid aliasing artifacts. For down-sampling with an integer factor also see `skimage.transform.downscale_local_mean`. Parameters ---------- image : ndarray Input image. output_shape : tuple or ndarray Size of the generated output image `(rows, cols[, ...][, dim])`. If `dim` is not provided, the number of channels is preserved. In case the number of input channels does not equal the number of output channels a n-dimensional interpolation is applied. Returns ------- resized : ndarray Resized version of the input. Other parameters ---------------- order : int, optional The order of the spline interpolation, default is 0 if image.dtype is bool and 1 otherwise. The order has to be in the range 0-5. See `skimage.transform.warp` for detail. mode : {'constant', 'edge', 'symmetric', 'reflect', 'wrap'}, optional Points outside the boundaries of the input are filled according to the given mode. Modes match the behaviour of `numpy.pad`. cval : float, optional Used in conjunction with mode 'constant', the value outside the image boundaries. clip : bool, optional Whether to clip the output to the range of values of the input image. This is enabled by default, since higher order interpolation may produce values outside the given input range. preserve_range : bool, optional Whether to keep the original range of values. Otherwise, the input image is converted according to the conventions of `img_as_float`. Also see https://scikit-image.org/docs/dev/user_guide/data_types.html anti_aliasing : bool, optional Whether to apply a Gaussian filter to smooth the image prior to down-scaling. It is crucial to filter when down-sampling the image to avoid aliasing artifacts. If input image data type is bool, no anti-aliasing is applied. anti_aliasing_sigma : {float, tuple of floats}, optional Standard deviation for Gaussian filtering to avoid aliasing artifacts. By default, this value is chosen as (s - 1) / 2 where s is the down-scaling factor, where s > 1. For the up-size case, s < 1, no anti-aliasing is performed prior to rescaling. Notes ----- Modes 'reflect' and 'symmetric' are similar, but differ in whether the edge pixels are duplicated during the reflection. As an example, if an array has values [0, 1, 2] and was padded to the right by four values using symmetric, the result would be [0, 1, 2, 2, 1, 0, 0], while for reflect it would be [0, 1, 2, 1, 0, 1, 2]. Examples -------- >>> from skimage import data >>> from skimage.transform import resize >>> image = data.camera() >>> resize(image, (100, 100)).shape (100, 100) """ output_shape = tuple(output_shape) output_ndim = len(output_shape) input_shape = image.shape if output_ndim > image.ndim: # append dimensions to input_shape input_shape = input_shape + (1, ) * (output_ndim - image.ndim) image = np.reshape(image, input_shape) elif output_ndim == image.ndim - 1: # multichannel case: append shape of last axis output_shape = output_shape + (image.shape[-1], ) elif output_ndim < image.ndim - 1: raise ValueError("len(output_shape) cannot be smaller than the image " "dimensions") if anti_aliasing is None: anti_aliasing = not image.dtype == bool if image.dtype == bool and anti_aliasing: warn("Input image dtype is bool. Gaussian convolution is not defined " "with bool data type. Please set anti_aliasing to False or " "explicitely cast input image to another data type. Starting " "from version 0.19 a ValueError will be raised instead of this " "warning.", FutureWarning, stacklevel=2) factors = (np.asarray(input_shape, dtype=float) / np.asarray(output_shape, dtype=float)) # Translate modes used by np.pad to those used by scipy.ndimage ndi_mode = _to_ndimage_mode(mode) if anti_aliasing: if anti_aliasing_sigma is None: anti_aliasing_sigma = np.maximum(0, (factors - 1) / 2) else: anti_aliasing_sigma = \ np.atleast_1d(anti_aliasing_sigma) * np.ones_like(factors) if np.any(anti_aliasing_sigma < 0): raise ValueError("Anti-aliasing standard deviation must be " "greater than or equal to zero") elif np.any((anti_aliasing_sigma > 0) & (factors <= 1)): warn("Anti-aliasing standard deviation greater than zero but " "not down-sampling along all axes") image = ndi.gaussian_filter(image, anti_aliasing_sigma, cval=cval, mode=ndi_mode) if NumpyVersion(scipy.__version__) >= '1.6.0': # The grid_mode kwarg was introduced in SciPy 1.6.0 order = _validate_interpolation_order(image.dtype, order) zoom_factors = [1 / f for f in factors] image = convert_to_float(image, preserve_range) out = ndi.zoom(image, zoom_factors, order=order, mode=ndi_mode, cval=cval, grid_mode=True) _clip_warp_output(image, out, order, mode, cval, clip) # TODO: Remove the fallback code below once SciPy >= 1.6.0 is required. # 2-dimensional interpolation elif len(output_shape) == 2 or (len(output_shape) == 3 and output_shape[2] == input_shape[2]): rows = output_shape[0] cols = output_shape[1] input_rows = input_shape[0] input_cols = input_shape[1] if rows == 1 and cols == 1: tform = AffineTransform(translation=(input_cols / 2.0 - 0.5, input_rows / 2.0 - 0.5)) else: # 3 control points necessary to estimate exact AffineTransform src_corners = np.array([[1, 1], [1, rows], [cols, rows]]) - 1 dst_corners = np.zeros(src_corners.shape, dtype=np.double) # take into account that 0th pixel is at position (0.5, 0.5) dst_corners[:, 0] = factors[1] * (src_corners[:, 0] + 0.5) - 0.5 dst_corners[:, 1] = factors[0] * (src_corners[:, 1] + 0.5) - 0.5 tform = AffineTransform() tform.estimate(src_corners, dst_corners) # Make sure the transform is exactly metric, to ensure fast warping. tform.params[2] = (0, 0, 1) tform.params[0, 1] = 0 tform.params[1, 0] = 0 out = warp(image, tform, output_shape=output_shape, order=order, mode=mode, cval=cval, clip=clip, preserve_range=preserve_range) else: # n-dimensional interpolation order = _validate_interpolation_order(image.dtype, order) coord_arrays = [factors[i] * (np.arange(d) + 0.5) - 0.5 for i, d in enumerate(output_shape)] coord_map = np.array(np.meshgrid(*coord_arrays, sparse=False, indexing='ij')) image = convert_to_float(image, preserve_range) out = ndi.map_coordinates(image, coord_map, order=order, mode=ndi_mode, cval=cval) _clip_warp_output(image, out, order, mode, cval, clip) return out
def test_version_1_point_10(): # regression test for gh-2998. assert_(NumpyVersion("1.9.0") < "1.10.0") assert_(NumpyVersion("1.11.0") < "1.11.1") assert_(NumpyVersion("1.11.0") == "1.11.0") assert_(NumpyVersion("1.99.11") < "1.99.12")
class TestRDF: def test_generateR(self): r_max = 5 for r_min in [0, 0.05, 0.1, 1.0, 3.0]: bins = round((r_max - r_min) / 0.1) dr = (r_max - r_min) / bins # make sure the radius for each bin is generated correctly r_list = np.array([ r_min + dr * (i + 1 / 2) for i in range(bins) if r_min + dr * (i + 1 / 2) < r_max ]) rdf = freud.density.RDF(bins, r_max, r_min=r_min) npt.assert_allclose(rdf.bin_centers, r_list, rtol=1e-4, atol=1e-4) npt.assert_allclose((rdf.bin_edges + dr / 2)[:-1], r_list, rtol=1e-4, atol=1e-4) def test_attribute_access(self): r_max = 10.0 bins = 10 num_points = 100 box_size = r_max * 3.1 box, points = freud.data.make_random_system(box_size, num_points, is2D=True) rdf = freud.density.RDF(r_max=r_max, bins=bins) # Test protected attribute access with pytest.raises(AttributeError): rdf.rdf with pytest.raises(AttributeError): rdf.box with pytest.raises(AttributeError): rdf.n_r rdf.compute((box, points), reset=False) # Test if accessible now rdf.rdf rdf.box rdf.n_r rdf.compute((box, points)) # Test if accessible now rdf.rdf rdf.box rdf.n_r def test_invalid_rdf(self): # Make sure that invalid RDF objects raise errors with pytest.raises(ValueError): freud.density.RDF(r_max=-1, bins=10) with pytest.raises(ValueError): freud.density.RDF(r_max=1, bins=0) with pytest.raises(ValueError): freud.density.RDF(r_max=1, bins=10, r_min=2) def test_random_point(self): r_max = 10.0 bins = 10 num_points = 10000 tolerance = 0.1 box_size = r_max * 3.1 for i, r_min in enumerate([0, 0.05, 0.1, 1.0, 3.0]): box, points = freud.data.make_random_system(box_size, num_points) test_set = util.make_raw_query_nlist_test_set( box, points, points, "ball", r_max, 0, True) for nq, neighbors in test_set: rdf = freud.density.RDF(bins, r_max, r_min) if i < 3: rdf.compute(nq, neighbors=neighbors, reset=False) else: rdf.compute(nq, neighbors=neighbors) assert rdf.box == box correct = np.ones(bins, dtype=np.float32) npt.assert_allclose(rdf.rdf, correct, atol=tolerance) # Numerical integration to compute the running coordination # number will be highly inaccurate, so we can only test up to # a limited precision. Also, since dealing with nonzero r_min # values requires extrapolation, we only test when r_min=0. ndens = points.shape[0] / box.volume dr = (r_max - r_min) / bins bin_boundaries = np.array([ r_min + dr * i for i in range(bins + 1) if r_min + dr * i <= r_max ]) bin_volumes = 4 / 3 * np.pi * np.diff(bin_boundaries**3) avg_counts = rdf.rdf * ndens * bin_volumes npt.assert_allclose(rdf.n_r, np.cumsum(avg_counts), rtol=tolerance) def test_repr(self): rdf = freud.density.RDF(r_max=10, bins=100, r_min=0.5) assert str(rdf) == str(eval(repr(rdf))) def test_repr_png(self): r_max = 10.0 bins = 10 num_points = 10 box_size = r_max * 3.1 box, points = freud.data.make_random_system(box_size, num_points) rdf = freud.density.RDF(bins, r_max) with pytest.raises(AttributeError): rdf.plot() assert rdf._repr_png_() is None rdf.compute((box, points), reset=False) rdf.plot() rdf._repr_png_() plt.close("all") def test_points_ne_query_points(self): r_max = 100.0 bins = 100 box_size = r_max * 5 box = freud.box.Box.square(box_size) rdf = freud.density.RDF(bins, r_max) query_points = [] supposed_RDF = [0] N = 100 # With points closely centered around the origin, # the cumulative average bin counts should be same as # having a single point at the origin. # Also, we can check for whether points are not considered against # each other. dr = r_max / bins points = [[dr / 4, 0, 0], [-dr / 4, 0, 0], [0, dr / 4, 0], [0, -dr / 4, 0]] for r in rdf.bin_centers: for k in range(N): query_points.append([ r * np.cos(2 * np.pi * k / N), r * np.sin(2 * np.pi * k / N), 0 ]) supposed_RDF.append(supposed_RDF[-1] + N) supposed_RDF = np.array(supposed_RDF[1:]) test_set = util.make_raw_query_nlist_test_set(box, points, query_points, "ball", r_max, 0, False) for nq, neighbors in test_set: rdf = freud.density.RDF(bins, r_max) rdf.compute(nq, query_points, neighbors=neighbors) npt.assert_allclose(rdf.n_r, supposed_RDF, atol=1e-6) def test_empty_histogram(self): r_max = 0.5 bins = 10 box_size = 5 box = freud.box.Box.cube(box_size) rdf = freud.density.RDF(bins, r_max) points = [[0, 0, 0], [2, 2, 2]] rdf.compute(system=(box, points)) # Test that properties are accessible even though there's no data npt.assert_array_equal(rdf.rdf, np.zeros(bins)) npt.assert_array_equal(rdf.n_r, np.zeros(bins)) @pytest.mark.skipif(NumpyVersion(np.__version__) < "1.15.0", reason="Requires numpy>=1.15.0.") def test_bin_precision(self): # Ensure bin edges are precise bins = 500 r_min = 0 r_max = 50 rdf = freud.density.RDF(bins=bins, r_max=r_max, r_min=r_min) expected_bin_edges = np.histogram_bin_edges(np.array([0], dtype=np.float32), bins=bins, range=[r_min, r_max]) npt.assert_allclose(rdf.bin_edges, expected_bin_edges, atol=1e-6)
from numpy.lib import NumpyVersion version: NumpyVersion NumpyVersion(b"1.8.0") # E: incompatible type version >= b"1.8.0" # E: Unsupported operand types
def test_dev0_a_b_rc_mixed(): assert_(NumpyVersion('1.9.0a2.dev0+f16acvda') == '1.9.0a2.dev0+11111111') assert_(NumpyVersion('1.9.0a2.dev0+6acvda54') < '1.9.0a2')
class TestNumericalInverseHermite: # / (1 +sin(2 Pi x))/2 if |x| <= 1 # f(x) = < # \ 0 otherwise # Taken from UNU.RAN test suite (from file t_hinv.c) class dist0: def pdf(self, x): return 0.5 * (1. + np.sin(2. * np.pi * x)) def dpdf(self, x): return np.pi * np.cos(2. * np.pi * x) def cdf(self, x): return (1. + 2. * np.pi * (1 + x) - np.cos(2. * np.pi * x)) / (4. * np.pi) def support(self): return -1, 1 # / Max(sin(2 Pi x)),0)Pi/2 if -1 < x <0.5 # f(x) = < # \ 0 otherwise # Taken from UNU.RAN test suite (from file t_hinv.c) class dist1: def pdf(self, x): if (x <= -0.5): return np.sin((2. * np.pi) * x) * 0.5 * np.pi if (x < 0.): return 0. if (x <= 0.5): return np.sin((2. * np.pi) * x) * 0.5 * np.pi def dpdf(self, x): if (x <= -0.5): return np.cos((2. * np.pi) * x) * np.pi * np.pi if (x < 0.): return 0. if (x <= 0.5): return np.cos((2. * np.pi) * x) * np.pi * np.pi def cdf(self, x): if (x <= -0.5): return 0.25 * (1 - np.cos((2. * np.pi) * x)) if (x < 0.): return 0.5 if (x <= 0.5): return 0.75 - 0.25 * np.cos((2. * np.pi) * x) def support(self): return -1, 0.5 dists = [dist0(), dist1()] # exact mean and variance of the distributions in the list dists mv0 = [-1 / (2 * np.pi), 1 / 3 - 1 / (4 * np.pi * np.pi)] mv1 = [-1 / 4, 3 / 8 - 1 / (2 * np.pi * np.pi) - 1 / 16] mvs = [mv0, mv1] @pytest.mark.parametrize("dist, mv_ex", zip(dists, mvs)) @pytest.mark.parametrize("order", [3, 5]) def test_basic(self, dist, mv_ex, order): rng = NumericalInverseHermite(dist, order=order, random_state=42) check_cont_samples(rng, dist, mv_ex) # test domains with inf + nan in them. need to write a custom test for # this because not all methods support infinite tails. @pytest.mark.parametrize("domain, err, msg", inf_nan_domains) def test_inf_nan_domains(self, domain, err, msg): with pytest.raises(err, match=msg): NumericalInverseHermite(StandardNormal(), domain=domain) @pytest.mark.xslow @pytest.mark.parametrize(("distname", "shapes"), distcont) def test_basic_all_scipy_dists(self, distname, shapes): slow_dists = {'ksone', 'kstwo', 'levy_stable', 'skewnorm'} fail_dists = { 'beta', 'gausshyper', 'geninvgauss', 'ncf', 'nct', 'norminvgauss', 'genhyperbolic', 'studentized_range', 'vonmises', 'kappa4', 'invgauss', 'wald' } if distname in slow_dists: pytest.skip("Distribution is too slow") if distname in fail_dists: # specific reasons documented in gh-13319 # https://github.com/scipy/scipy/pull/13319#discussion_r626188955 pytest.xfail("Fails - usually due to inaccurate CDF/PDF") np.random.seed(0) dist = getattr(stats, distname)(*shapes) with np.testing.suppress_warnings() as sup: sup.filter(RuntimeWarning, "overflow encountered") sup.filter(RuntimeWarning, "divide by zero") sup.filter(RuntimeWarning, "invalid value encountered") fni = NumericalInverseHermite(dist) x = np.random.rand(10) p_tol = np.max(np.abs(dist.ppf(x) - fni.ppf(x)) / np.abs(dist.ppf(x))) u_tol = np.max(np.abs(dist.cdf(fni.ppf(x)) - x)) assert p_tol < 1e-8 assert u_tol < 1e-12 def test_input_validation(self): match = r"`order` must be either 1, 3, or 5." with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), order=2) match = "`cdf` required but not found" with pytest.raises(ValueError, match=match): NumericalInverseHermite("norm") match = "could not convert string to float" with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), u_resolution='ekki') rngs = [None, 0, np.random.RandomState(0)] if NumpyVersion(np.__version__) >= '1.18.0': rngs.append(np.random.default_rng(0)) # type: ignore sizes = [(None, tuple()), (8, (8, )), ((4, 5, 6), (4, 5, 6))] @pytest.mark.parametrize('rng', rngs) @pytest.mark.parametrize('size_in, size_out', sizes) def test_RVS(self, rng, size_in, size_out): dist = StandardNormal() fni = NumericalInverseHermite(dist) rng2 = deepcopy(rng) rvs = fni.rvs(size=size_in, random_state=rng) if size_in is not None: assert (rvs.shape == size_out) if rng2 is not None: rng2 = check_random_state(rng2) uniform = rng2.uniform(size=size_in) rvs2 = stats.norm.ppf(uniform) assert_allclose(rvs, rvs2) def test_inaccurate_CDF(self): # CDF function with inaccurate tail cannot be inverted; see gh-13319 # https://github.com/scipy/scipy/pull/13319#discussion_r626188955 shapes = (2.3098496451481823, 0.6268795430096368) match = ("98 : one or more intervals very short; possibly due to " "numerical problems with a pole or very flat tail") # fails with default tol with pytest.warns(RuntimeWarning, match=match): NumericalInverseHermite(stats.beta(*shapes)) # no error with coarser tol NumericalInverseHermite(stats.beta(*shapes), u_resolution=1e-8) def test_custom_distribution(self): dist1 = StandardNormal() fni1 = NumericalInverseHermite(dist1) dist2 = stats.norm() fni2 = NumericalInverseHermite(dist2) assert_allclose(fni1.rvs(random_state=0), fni2.rvs(random_state=0)) u = [ # check the correctness of the PPF for equidistant points between # 0.02 and 0.98. np.linspace(0., 1., num=10000), # test the PPF method for empty arrays [], [[]], # test if nans and infs return nan result. [np.nan], [-np.inf, np.nan, np.inf], # test if a scalar is returned for a scalar input. 0, # test for arrays with nans, values greater than 1 and less than 0, # and some valid values. [[np.nan, 0.5, 0.1], [0.2, 0.4, np.inf], [-2, 3, 4]] ] @pytest.mark.parametrize("u", u) def test_ppf(self, u): dist = StandardNormal() rng = NumericalInverseHermite(dist, u_resolution=1e-12) # Older versions of NumPy throw RuntimeWarnings for comparisons # with nan. with suppress_warnings() as sup: sup.filter(RuntimeWarning, "invalid value encountered in greater") sup.filter(RuntimeWarning, "invalid value encountered in " "greater_equal") sup.filter(RuntimeWarning, "invalid value encountered in less") sup.filter(RuntimeWarning, "invalid value encountered in " "less_equal") res = rng.ppf(u) expected = stats.norm.ppf(u) assert_allclose(res, expected, rtol=1e-9, atol=3e-10) assert res.shape == expected.shape def test_u_error(self): dist = StandardNormal() rng = NumericalInverseHermite(dist, u_resolution=1e-10) max_error, mae = rng.u_error() assert max_error < 1e-10 assert mae <= max_error with suppress_warnings() as sup: # ignore warning about u-resolution being too small. sup.filter(RuntimeWarning) rng = NumericalInverseHermite(dist, u_resolution=1e-14) max_error, mae = rng.u_error() assert max_error < 1e-14 assert mae <= max_error
class TestNumericalInverseHermite: # / (1 +sin(2 Pi x))/2 if |x| <= 1 # f(x) = < # \ 0 otherwise # Taken from UNU.RAN test suite (from file t_hinv.c) class dist0: def pdf(self, x): return 0.5 * (1. + np.sin(2. * np.pi * x)) def dpdf(self, x): return np.pi * np.cos(2. * np.pi * x) def cdf(self, x): return (1. + 2. * np.pi * (1 + x) - np.cos(2. * np.pi * x)) / (4. * np.pi) def support(self): return -1, 1 # / Max(sin(2 Pi x)),0)Pi/2 if -1 < x <0.5 # f(x) = < # \ 0 otherwise # Taken from UNU.RAN test suite (from file t_hinv.c) class dist1: def pdf(self, x): if (x <= -0.5): return np.sin((2. * np.pi) * x) * 0.5 * np.pi if (x < 0.): return 0. if (x <= 0.5): return np.sin((2. * np.pi) * x) * 0.5 * np.pi def dpdf(self, x): if (x <= -0.5): return np.cos((2. * np.pi) * x) * np.pi * np.pi if (x < 0.): return 0. if (x <= 0.5): return np.cos((2. * np.pi) * x) * np.pi * np.pi def cdf(self, x): if (x <= -0.5): return 0.25 * (1 - np.cos((2. * np.pi) * x)) if (x < 0.): return 0.5 if (x <= 0.5): return 0.75 - 0.25 * np.cos((2. * np.pi) * x) def support(self): return -1, 0.5 dists = [dist0(), dist1()] # exact mean and variance of the distributions in the list dists mv0 = [-1 / (2 * np.pi), 1 / 3 - 1 / (4 * np.pi * np.pi)] mv1 = [-1 / 4, 3 / 8 - 1 / (2 * np.pi * np.pi) - 1 / 16] mvs = [mv0, mv1] @pytest.mark.parametrize("dist, mv_ex", zip(dists, mvs)) @pytest.mark.parametrize("order", [3, 5]) def test_basic(self, dist, mv_ex, order): rng = NumericalInverseHermite(dist, order=order, random_state=42) check_cont_samples(rng, dist, mv_ex) # test domains with inf + nan in them. need to write a custom test for # this because not all methods support infinite tails. @pytest.mark.parametrize("domain, err, msg", inf_nan_domains) def test_inf_nan_domains(self, domain, err, msg): with pytest.raises(err, match=msg): NumericalInverseHermite(StandardNormal(), domain=domain) @pytest.mark.xslow @pytest.mark.parametrize(("distname", "shapes"), distcont) def test_basic_all_scipy_dists(self, distname, shapes): slow_dists = {'ksone', 'kstwo', 'levy_stable', 'skewnorm'} fail_dists = { 'beta', 'gausshyper', 'geninvgauss', 'ncf', 'nct', 'norminvgauss', 'genhyperbolic', 'studentized_range', 'vonmises', 'kappa4', 'invgauss', 'wald' } if distname in slow_dists: pytest.skip("Distribution is too slow") if distname in fail_dists: # specific reasons documented in gh-13319 # https://github.com/scipy/scipy/pull/13319#discussion_r626188955 pytest.xfail("Fails - usually due to inaccurate CDF/PDF") np.random.seed(0) dist = getattr(stats, distname)(*shapes) with np.testing.suppress_warnings() as sup: sup.filter(RuntimeWarning, "overflow encountered") sup.filter(RuntimeWarning, "divide by zero") sup.filter(RuntimeWarning, "invalid value encountered") fni = NumericalInverseHermite(dist) x = np.random.rand(10) p_tol = np.max(np.abs(dist.ppf(x) - fni.ppf(x)) / np.abs(dist.ppf(x))) u_tol = np.max(np.abs(dist.cdf(fni.ppf(x)) - x)) assert p_tol < 1e-8 assert u_tol < 1e-12 def test_input_validation(self): match = r"`order` must be either 1, 3, or 5." with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), order=2) match = "`cdf` required but not found" with pytest.raises(ValueError, match=match): NumericalInverseHermite("norm") match = "could not convert string to float" with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), u_resolution='ekki') match = "`max_intervals' must be..." with pytest.raises(ValueError, match=match): NumericalInverseHermite(StandardNormal(), max_intervals=-1) match = "`qmc_engine` must be an instance of..." with pytest.raises(ValueError, match=match): fni = NumericalInverseHermite(StandardNormal()) fni.qrvs(qmc_engine=0) if NumpyVersion(np.__version__) >= '1.18.0': # issues with QMCEngines and old NumPy fni = NumericalInverseHermite(StandardNormal()) match = "`d` must be consistent with dimension of `qmc_engine`." with pytest.raises(ValueError, match=match): fni.qrvs(d=3, qmc_engine=stats.qmc.Halton(2)) rngs = [None, 0, np.random.RandomState(0)] if NumpyVersion(np.__version__) >= '1.18.0': rngs.append(np.random.default_rng(0)) # type: ignore sizes = [(None, tuple()), (8, (8, )), ((4, 5, 6), (4, 5, 6))] @pytest.mark.parametrize('rng', rngs) @pytest.mark.parametrize('size_in, size_out', sizes) def test_RVS(self, rng, size_in, size_out): dist = StandardNormal() fni = NumericalInverseHermite(dist) rng2 = deepcopy(rng) rvs = fni.rvs(size=size_in, random_state=rng) if size_in is not None: assert (rvs.shape == size_out) if rng2 is not None: rng2 = check_random_state(rng2) uniform = rng2.uniform(size=size_in) rvs2 = stats.norm.ppf(uniform) assert_allclose(rvs, rvs2) if NumpyVersion(np.__version__) >= '1.18.0': qrngs = [None, stats.qmc.Sobol(1, seed=0), stats.qmc.Halton(3, seed=0)] else: qrngs = [] # `size=None` should not add anything to the shape, `size=1` should sizes = [(None, tuple()), (1, (1, )), (4, (4, )), ((4, ), (4, )), ((2, 4), (2, 4))] # type: ignore # Neither `d=None` nor `d=1` should add anything to the shape ds = [(None, tuple()), (1, tuple()), (3, (3, ))] @pytest.mark.parametrize('qrng', qrngs) @pytest.mark.parametrize('size_in, size_out', sizes) @pytest.mark.parametrize('d_in, d_out', ds) def test_QRVS(self, qrng, size_in, size_out, d_in, d_out): dist = StandardNormal() fni = NumericalInverseHermite(dist) # If d and qrng.d are inconsistent, an error is raised if d_in is not None and qrng is not None and qrng.d != d_in: match = "`d` must be consistent with dimension of `qmc_engine`." with pytest.raises(ValueError, match=match): fni.qrvs(size_in, d=d_in, qmc_engine=qrng) return # Sometimes d is really determined by qrng if d_in is None and qrng is not None and qrng.d != 1: d_out = (qrng.d, ) shape_expected = size_out + d_out qrng2 = deepcopy(qrng) qrvs = fni.qrvs(size=size_in, d=d_in, qmc_engine=qrng) if size_in is not None: assert (qrvs.shape == shape_expected) if qrng2 is not None: uniform = qrng2.random(np.prod(size_in) or 1) qrvs2 = stats.norm.ppf(uniform).reshape(shape_expected) assert_allclose(qrvs, qrvs2, atol=1e-12) def test_QRVS_size_tuple(self): # QMCEngine samples are always of shape (n, d). When `size` is a tuple, # we set `n = prod(size)` in the call to qmc_engine.random, transform # the sample, and reshape it to the final dimensions. When we reshape, # we need to be careful, because the _columns_ of the sample returned # by a QMCEngine are "independent"-ish, but the elements within the # columns are not. We need to make sure that this doesn't get mixed up # by reshaping: qrvs[..., i] should remain "independent"-ish of # qrvs[..., i+1], but the elements within qrvs[..., i] should be # transformed from the same low-discrepancy sequence. if NumpyVersion(np.__version__) <= '1.18.0': pytest.skip("QMC doesn't play well with old NumPy") dist = StandardNormal() fni = NumericalInverseHermite(dist) size = (3, 4) d = 5 qrng = stats.qmc.Halton(d, seed=0) qrng2 = stats.qmc.Halton(d, seed=0) uniform = qrng2.random(np.prod(size)) qrvs = fni.qrvs(size=size, d=d, qmc_engine=qrng) qrvs2 = stats.norm.ppf(uniform) for i in range(d): sample = qrvs[..., i] sample2 = qrvs2[:, i].reshape(size) assert_allclose(sample, sample2, atol=1e-12) def test_inaccurate_CDF(self): # CDF function with inaccurate tail cannot be inverted; see gh-13319 # https://github.com/scipy/scipy/pull/13319#discussion_r626188955 shapes = (2.3098496451481823, 0.6268795430096368) match = ("98 : one or more intervals very short; possibly due to " "numerical problems with a pole or very flat tail") # fails with default tol with pytest.warns(RuntimeWarning, match=match): NumericalInverseHermite(stats.beta(*shapes)) # no error with coarser tol NumericalInverseHermite(stats.beta(*shapes), u_resolution=1e-8) def test_custom_distribution(self): dist1 = StandardNormal() fni1 = NumericalInverseHermite(dist1) dist2 = stats.norm() fni2 = NumericalInverseHermite(dist2) assert_allclose(fni1.rvs(random_state=0), fni2.rvs(random_state=0)) u = [ # check the correctness of the PPF for equidistant points between # 0.02 and 0.98. np.linspace(0., 1., num=10000), # test the PPF method for empty arrays [], [[]], # test if nans and infs return nan result. [np.nan], [-np.inf, np.nan, np.inf], # test if a scalar is returned for a scalar input. 0, # test for arrays with nans, values greater than 1 and less than 0, # and some valid values. [[np.nan, 0.5, 0.1], [0.2, 0.4, np.inf], [-2, 3, 4]] ] @pytest.mark.parametrize("u", u) def test_ppf(self, u): dist = StandardNormal() rng = NumericalInverseHermite(dist, u_resolution=1e-12) # Older versions of NumPy throw RuntimeWarnings for comparisons # with nan. with suppress_warnings() as sup: sup.filter(RuntimeWarning, "invalid value encountered in greater") sup.filter(RuntimeWarning, "invalid value encountered in " "greater_equal") sup.filter(RuntimeWarning, "invalid value encountered in less") sup.filter(RuntimeWarning, "invalid value encountered in " "less_equal") res = rng.ppf(u) expected = stats.norm.ppf(u) assert_allclose(res, expected, rtol=1e-9, atol=3e-10) assert res.shape == expected.shape def test_u_error(self): dist = StandardNormal() rng = NumericalInverseHermite(dist, u_resolution=1e-10) max_error, mae = rng.u_error() assert max_error < 1e-10 assert mae <= max_error with suppress_warnings() as sup: # ignore warning about u-resolution being too small. sup.filter(RuntimeWarning) rng = NumericalInverseHermite(dist, u_resolution=1e-14) max_error, mae = rng.u_error() assert max_error < 1e-14 assert mae <= max_error def test_deprecations(self): msg = ("`tol` has been deprecated and replaced with `u_resolution`. " "It will be completely removed in a future release.") with pytest.warns(DeprecationWarning, match=msg): NumericalInverseHermite(StandardNormal(), tol=1e-12)
def test_version_1_point_10(): # regression test for gh-2998. assert_(NumpyVersion('1.9.0') < '1.10.0') assert_(NumpyVersion('1.11.0') < '1.11.1') assert_(NumpyVersion('1.11.0') == '1.11.0') assert_(NumpyVersion('1.99.11') < '1.99.12')
def setup(self, name): from numpy.lib import NumpyVersion if NumpyVersion(np.__version__) < '1.11.0.dev0': raise NotImplementedError
from the individual packages. The end-user should not need to instantiate this class directly. some more info """ from __future__ import division, print_function import os import warnings import numpy as np from ..datbase import DataInterface, DataListInterface, DataType try: from numpy.lib import NumpyVersion numpy114 = NumpyVersion(np.__version__) >= '1.14.0' except ImportError: numpy114 = False class MfList(DataInterface, DataListInterface): """ a generic object for handling transient boundary condition lists Parameters ---------- package : package object The package object (of type :class:`hataripy.pakbase.Package`) to which this MfList will be added. data : varies the data of the transient list (optional). (the default is None)
def _axis_nan_policy_test(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker, nan_policy, axis, data_generator): # Tests the 1D and vectorized behavior of hypothesis tests against a # reference implementation (nan_policy_1d with np.ndenumerate) # Some hypothesis tests return a non-iterable that needs an `unpacker` to # extract the statistic and p-value. For those that don't: if not unpacker: def unpacker(res): return res if NumpyVersion(np.__version__) < '1.18.0': pytest.xfail("Generator `permutation` method doesn't support `axis`") rng = np.random.default_rng(0) # Generate multi-dimensional test data with all important combinations # of patterns of nans along `axis` n_repetitions = 3 # number of repetitions of each pattern data_gen_kwds = { 'n_samples': n_samples, 'n_repetitions': n_repetitions, 'axis': axis, 'rng': rng, 'paired': paired } if data_generator == 'mixed': inherent_size = 6 # number of distinct types of patterns data = _mixed_data_generator(**data_gen_kwds) elif data_generator == 'all_nans': inherent_size = 2 # hard-coded in _homogeneous_data_generator data_gen_kwds['all_nans'] = True data = _homogeneous_data_generator(**data_gen_kwds) elif data_generator == 'all_finite': inherent_size = 2 # hard-coded in _homogeneous_data_generator data_gen_kwds['all_nans'] = False data = _homogeneous_data_generator(**data_gen_kwds) output_shape = [n_repetitions] + [inherent_size] * n_samples # To generate reference behavior to compare against, loop over the axis- # slices in data. Make indexing easier by moving `axis` to the end and # broadcasting all samples to the same shape. data_b = [np.moveaxis(sample, axis, -1) for sample in data] data_b = [ np.broadcast_to(sample, output_shape + [sample.shape[-1]]) for sample in data_b ] statistics = np.zeros(output_shape) pvalues = np.zeros(output_shape) for i, _ in np.ndenumerate(statistics): data1d = [sample[i] for sample in data_b] with np.errstate(divide='ignore', invalid='ignore'): try: res1d = nan_policy_1d(hypotest, data1d, unpacker, *args, n_outputs=n_outputs, nan_policy=nan_policy, paired=paired, _no_deco=True, **kwds) # Eventually we'll check the results of a single, vectorized # call of `hypotest` against the arrays `statistics` and # `pvalues` populated using the reference `nan_policy_1d`. # But while we're at it, check the results of a 1D call to # `hypotest` against the reference `nan_policy_1d`. res1db = unpacker( hypotest(*data1d, *args, nan_policy=nan_policy, **kwds)) assert_equal(res1db[0], res1d[0]) if len(res1db) == 2: assert_equal(res1db[1], res1d[1]) # When there is not enough data in 1D samples, many existing # hypothesis tests raise errors instead of returning nans . # For vectorized calls, we put nans in the corresponding elements # of the output. except (RuntimeWarning, ValueError, ZeroDivisionError) as e: # whatever it is, make sure same error is raised by both # `nan_policy_1d` and `hypotest` with pytest.raises(type(e), match=re.escape(str(e))): nan_policy_1d(hypotest, data1d, unpacker, *args, n_outputs=n_outputs, nan_policy=nan_policy, paired=paired, _no_deco=True, **kwds) with pytest.raises(type(e), match=re.escape(str(e))): hypotest(*data1d, *args, nan_policy=nan_policy, **kwds) if any([ str(e).startswith(message) for message in too_small_messages ]): res1d = np.full(n_outputs, np.nan) else: raise e statistics[i] = res1d[0] if len(res1d) == 2: pvalues[i] = res1d[1] # Perform a vectorized call to the hypothesis test. # If `nan_policy == 'raise'`, check that it raises the appropriate error. # If not, compare against the output against `statistics` and `pvalues` if nan_policy == 'raise' and not data_generator == "all_finite": message = 'The input contains nan values' with pytest.raises(ValueError, match=message): hypotest(*data, axis=axis, nan_policy=nan_policy, *args, **kwds) else: with np.errstate(divide='ignore', invalid='ignore'): res = unpacker( hypotest(*data, axis=axis, nan_policy=nan_policy, *args, **kwds)) assert_equal(res[0], statistics) assert_equal(res[0].dtype, statistics.dtype) if len(res) == 2: assert_equal(res[1], pvalues) assert_equal(res[1].dtype, pvalues.dtype)
def test_dev0_a_b_rc_mixed(): assert_(NumpyVersion("1.9.0a2.dev0+f16acvda") == "1.9.0a2.dev0+11111111") assert_(NumpyVersion("1.9.0a2.dev0+6acvda54") < "1.9.0a2")
def test_dev0_version(): assert_(NumpyVersion('1.9.0.dev0+Unknown') < '1.9.0') for ver in ['1.9.0', '1.9.0a1', '1.9.0b2', '1.9.0b2.dev0+ffffffff']: assert_(NumpyVersion('1.9.0.dev0+f16acvda') < ver) assert_(NumpyVersion('1.9.0.dev0+f16acvda') == '1.9.0.dev0+11111111')
widget.resize(640, 480) widget.show() widget.initialize(force=True) yield widget widget.close() @flaky(max_runs=5) @pytest.mark.order(1) @pytest.mark.parametrize( "lib", [('str', 'class str', [0, 1]), ('numpy.testing', 'numpy.testing', [5, 10])] ) @pytest.mark.skipif( (sys.platform == 'darwin' or NumpyVersion(np.__version__) < NumpyVersion('1.21.0')), reason="Fails on Mac and older versions of Numpy" ) @pytest.mark.skipif( sys.platform.startswith('linux') or os.name == 'nt' and running_in_ci(), reason="Stalls CI frequenly on Linux and Windows" ) def test_get_pydoc(pydocbrowser, qtbot, lib): """ Go to the documentation by url. Regression test for spyder-ide/spyder#10740 """ browser = pydocbrowser element, doc, matches = lib webview = browser.webview
def test_axis_nan_policy_axis_is_None(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker, nan_policy, data_generator): # check for correct behavior when `axis=None` if not unpacker: def unpacker(res): return res if NumpyVersion(np.__version__) < '1.18.0': pytest.xfail("Generator `permutation` method doesn't support `axis`") rng = np.random.default_rng(0) if data_generator == "empty": data = [rng.random((2, 0)) for i in range(n_samples)] else: data = [rng.random((2, 20)) for i in range(n_samples)] if data_generator == "mixed": masks = [rng.random((2, 20)) > 0.9 for i in range(n_samples)] for sample, mask in zip(data, masks): sample[mask] = np.nan elif data_generator == "all_nans": data = [sample * np.nan for sample in data] data_raveled = [sample.ravel() for sample in data] if nan_policy == 'raise' and data_generator not in {"all_finite", "empty"}: message = 'The input contains nan values' # check for correct behavior whether or not data is 1d to begin with with pytest.raises(ValueError, match=message): hypotest(*data, axis=None, nan_policy=nan_policy, *args, **kwds) with pytest.raises(ValueError, match=message): hypotest(*data_raveled, axis=None, nan_policy=nan_policy, *args, **kwds) else: # behavior of reference implementation with 1d input, hypotest with 1d # input, and hypotest with Nd input should match, whether that means # that outputs are equal or they raise the same exception ea_str, eb_str, ec_str = None, None, None with np.errstate(divide='ignore', invalid='ignore'): try: res1da = nan_policy_1d(hypotest, data_raveled, unpacker, *args, n_outputs=n_outputs, nan_policy=nan_policy, paired=paired, _no_deco=True, **kwds) except (RuntimeWarning, ValueError, ZeroDivisionError) as ea: ea_str = str(ea) try: res1db = unpacker( hypotest(*data_raveled, *args, nan_policy=nan_policy, **kwds)) except (RuntimeWarning, ValueError, ZeroDivisionError) as eb: eb_str = str(eb) try: res1dc = unpacker( hypotest(*data, *args, axis=None, nan_policy=nan_policy, **kwds)) except (RuntimeWarning, ValueError, ZeroDivisionError) as ec: ec_str = str(ec) if ea_str or eb_str or ec_str: assert any([ str(ea_str).startswith(message) for message in too_small_messages ]) assert ea_str == eb_str == ec_str else: assert_equal(res1db, res1da) assert_equal(res1dc, res1da)