Spaces:
Sleeping
Sleeping
| import pickle | |
| from functools import partial | |
| import numpy as np | |
| import pytest | |
| from numpy.testing import assert_equal, assert_, assert_array_equal | |
| from numpy.random import (Generator, MT19937, PCG64, PCG64DXSM, Philox, SFC64) | |
| def dtype(request): | |
| return request.param | |
| def params_0(f): | |
| val = f() | |
| assert_(np.isscalar(val)) | |
| val = f(10) | |
| assert_(val.shape == (10,)) | |
| val = f((10, 10)) | |
| assert_(val.shape == (10, 10)) | |
| val = f((10, 10, 10)) | |
| assert_(val.shape == (10, 10, 10)) | |
| val = f(size=(5, 5)) | |
| assert_(val.shape == (5, 5)) | |
| def params_1(f, bounded=False): | |
| a = 5.0 | |
| b = np.arange(2.0, 12.0) | |
| c = np.arange(2.0, 102.0).reshape((10, 10)) | |
| d = np.arange(2.0, 1002.0).reshape((10, 10, 10)) | |
| e = np.array([2.0, 3.0]) | |
| g = np.arange(2.0, 12.0).reshape((1, 10, 1)) | |
| if bounded: | |
| a = 0.5 | |
| b = b / (1.5 * b.max()) | |
| c = c / (1.5 * c.max()) | |
| d = d / (1.5 * d.max()) | |
| e = e / (1.5 * e.max()) | |
| g = g / (1.5 * g.max()) | |
| # Scalar | |
| f(a) | |
| # Scalar - size | |
| f(a, size=(10, 10)) | |
| # 1d | |
| f(b) | |
| # 2d | |
| f(c) | |
| # 3d | |
| f(d) | |
| # 1d size | |
| f(b, size=10) | |
| # 2d - size - broadcast | |
| f(e, size=(10, 2)) | |
| # 3d - size | |
| f(g, size=(10, 10, 10)) | |
| def comp_state(state1, state2): | |
| identical = True | |
| if isinstance(state1, dict): | |
| for key in state1: | |
| identical &= comp_state(state1[key], state2[key]) | |
| elif type(state1) != type(state2): | |
| identical &= type(state1) == type(state2) | |
| else: | |
| if (isinstance(state1, (list, tuple, np.ndarray)) and isinstance( | |
| state2, (list, tuple, np.ndarray))): | |
| for s1, s2 in zip(state1, state2): | |
| identical &= comp_state(s1, s2) | |
| else: | |
| identical &= state1 == state2 | |
| return identical | |
| def warmup(rg, n=None): | |
| if n is None: | |
| n = 11 + np.random.randint(0, 20) | |
| rg.standard_normal(n) | |
| rg.standard_normal(n) | |
| rg.standard_normal(n, dtype=np.float32) | |
| rg.standard_normal(n, dtype=np.float32) | |
| rg.integers(0, 2 ** 24, n, dtype=np.uint64) | |
| rg.integers(0, 2 ** 48, n, dtype=np.uint64) | |
| rg.standard_gamma(11.0, n) | |
| rg.standard_gamma(11.0, n, dtype=np.float32) | |
| rg.random(n, dtype=np.float64) | |
| rg.random(n, dtype=np.float32) | |
| class RNG: | |
| def setup_class(cls): | |
| # Overridden in test classes. Place holder to silence IDE noise | |
| cls.bit_generator = PCG64 | |
| cls.advance = None | |
| cls.seed = [12345] | |
| cls.rg = Generator(cls.bit_generator(*cls.seed)) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 64 | |
| cls._extra_setup() | |
| def _extra_setup(cls): | |
| cls.vec_1d = np.arange(2.0, 102.0) | |
| cls.vec_2d = np.arange(2.0, 102.0)[None, :] | |
| cls.mat = np.arange(2.0, 102.0, 0.01).reshape((100, 100)) | |
| cls.seed_error = TypeError | |
| def _reset_state(self): | |
| self.rg.bit_generator.state = self.initial_state | |
| def test_init(self): | |
| rg = Generator(self.bit_generator()) | |
| state = rg.bit_generator.state | |
| rg.standard_normal(1) | |
| rg.standard_normal(1) | |
| rg.bit_generator.state = state | |
| new_state = rg.bit_generator.state | |
| assert_(comp_state(state, new_state)) | |
| def test_advance(self): | |
| state = self.rg.bit_generator.state | |
| if hasattr(self.rg.bit_generator, 'advance'): | |
| self.rg.bit_generator.advance(self.advance) | |
| assert_(not comp_state(state, self.rg.bit_generator.state)) | |
| else: | |
| bitgen_name = self.rg.bit_generator.__class__.__name__ | |
| pytest.skip(f'Advance is not supported by {bitgen_name}') | |
| def test_jump(self): | |
| state = self.rg.bit_generator.state | |
| if hasattr(self.rg.bit_generator, 'jumped'): | |
| bit_gen2 = self.rg.bit_generator.jumped() | |
| jumped_state = bit_gen2.state | |
| assert_(not comp_state(state, jumped_state)) | |
| self.rg.random(2 * 3 * 5 * 7 * 11 * 13 * 17) | |
| self.rg.bit_generator.state = state | |
| bit_gen3 = self.rg.bit_generator.jumped() | |
| rejumped_state = bit_gen3.state | |
| assert_(comp_state(jumped_state, rejumped_state)) | |
| else: | |
| bitgen_name = self.rg.bit_generator.__class__.__name__ | |
| if bitgen_name not in ('SFC64',): | |
| raise AttributeError(f'no "jumped" in {bitgen_name}') | |
| pytest.skip(f'Jump is not supported by {bitgen_name}') | |
| def test_uniform(self): | |
| r = self.rg.uniform(-1.0, 0.0, size=10) | |
| assert_(len(r) == 10) | |
| assert_((r > -1).all()) | |
| assert_((r <= 0).all()) | |
| def test_uniform_array(self): | |
| r = self.rg.uniform(np.array([-1.0] * 10), 0.0, size=10) | |
| assert_(len(r) == 10) | |
| assert_((r > -1).all()) | |
| assert_((r <= 0).all()) | |
| r = self.rg.uniform(np.array([-1.0] * 10), | |
| np.array([0.0] * 10), size=10) | |
| assert_(len(r) == 10) | |
| assert_((r > -1).all()) | |
| assert_((r <= 0).all()) | |
| r = self.rg.uniform(-1.0, np.array([0.0] * 10), size=10) | |
| assert_(len(r) == 10) | |
| assert_((r > -1).all()) | |
| assert_((r <= 0).all()) | |
| def test_random(self): | |
| assert_(len(self.rg.random(10)) == 10) | |
| params_0(self.rg.random) | |
| def test_standard_normal_zig(self): | |
| assert_(len(self.rg.standard_normal(10)) == 10) | |
| def test_standard_normal(self): | |
| assert_(len(self.rg.standard_normal(10)) == 10) | |
| params_0(self.rg.standard_normal) | |
| def test_standard_gamma(self): | |
| assert_(len(self.rg.standard_gamma(10, 10)) == 10) | |
| assert_(len(self.rg.standard_gamma(np.array([10] * 10), 10)) == 10) | |
| params_1(self.rg.standard_gamma) | |
| def test_standard_exponential(self): | |
| assert_(len(self.rg.standard_exponential(10)) == 10) | |
| params_0(self.rg.standard_exponential) | |
| def test_standard_exponential_float(self): | |
| randoms = self.rg.standard_exponential(10, dtype='float32') | |
| assert_(len(randoms) == 10) | |
| assert randoms.dtype == np.float32 | |
| params_0(partial(self.rg.standard_exponential, dtype='float32')) | |
| def test_standard_exponential_float_log(self): | |
| randoms = self.rg.standard_exponential(10, dtype='float32', | |
| method='inv') | |
| assert_(len(randoms) == 10) | |
| assert randoms.dtype == np.float32 | |
| params_0(partial(self.rg.standard_exponential, dtype='float32', | |
| method='inv')) | |
| def test_standard_cauchy(self): | |
| assert_(len(self.rg.standard_cauchy(10)) == 10) | |
| params_0(self.rg.standard_cauchy) | |
| def test_standard_t(self): | |
| assert_(len(self.rg.standard_t(10, 10)) == 10) | |
| params_1(self.rg.standard_t) | |
| def test_binomial(self): | |
| assert_(self.rg.binomial(10, .5) >= 0) | |
| assert_(self.rg.binomial(1000, .5) >= 0) | |
| def test_reset_state(self): | |
| state = self.rg.bit_generator.state | |
| int_1 = self.rg.integers(2**31) | |
| self.rg.bit_generator.state = state | |
| int_2 = self.rg.integers(2**31) | |
| assert_(int_1 == int_2) | |
| def test_entropy_init(self): | |
| rg = Generator(self.bit_generator()) | |
| rg2 = Generator(self.bit_generator()) | |
| assert_(not comp_state(rg.bit_generator.state, | |
| rg2.bit_generator.state)) | |
| def test_seed(self): | |
| rg = Generator(self.bit_generator(*self.seed)) | |
| rg2 = Generator(self.bit_generator(*self.seed)) | |
| rg.random() | |
| rg2.random() | |
| assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state)) | |
| def test_reset_state_gauss(self): | |
| rg = Generator(self.bit_generator(*self.seed)) | |
| rg.standard_normal() | |
| state = rg.bit_generator.state | |
| n1 = rg.standard_normal(size=10) | |
| rg2 = Generator(self.bit_generator()) | |
| rg2.bit_generator.state = state | |
| n2 = rg2.standard_normal(size=10) | |
| assert_array_equal(n1, n2) | |
| def test_reset_state_uint32(self): | |
| rg = Generator(self.bit_generator(*self.seed)) | |
| rg.integers(0, 2 ** 24, 120, dtype=np.uint32) | |
| state = rg.bit_generator.state | |
| n1 = rg.integers(0, 2 ** 24, 10, dtype=np.uint32) | |
| rg2 = Generator(self.bit_generator()) | |
| rg2.bit_generator.state = state | |
| n2 = rg2.integers(0, 2 ** 24, 10, dtype=np.uint32) | |
| assert_array_equal(n1, n2) | |
| def test_reset_state_float(self): | |
| rg = Generator(self.bit_generator(*self.seed)) | |
| rg.random(dtype='float32') | |
| state = rg.bit_generator.state | |
| n1 = rg.random(size=10, dtype='float32') | |
| rg2 = Generator(self.bit_generator()) | |
| rg2.bit_generator.state = state | |
| n2 = rg2.random(size=10, dtype='float32') | |
| assert_((n1 == n2).all()) | |
| def test_shuffle(self): | |
| original = np.arange(200, 0, -1) | |
| permuted = self.rg.permutation(original) | |
| assert_((original != permuted).any()) | |
| def test_permutation(self): | |
| original = np.arange(200, 0, -1) | |
| permuted = self.rg.permutation(original) | |
| assert_((original != permuted).any()) | |
| def test_beta(self): | |
| vals = self.rg.beta(2.0, 2.0, 10) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.beta(np.array([2.0] * 10), 2.0) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.beta(2.0, np.array([2.0] * 10)) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.beta(np.array([2.0] * 10), np.array([2.0] * 10)) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.beta(np.array([2.0] * 10), np.array([[2.0]] * 10)) | |
| assert_(vals.shape == (10, 10)) | |
| def test_bytes(self): | |
| vals = self.rg.bytes(10) | |
| assert_(len(vals) == 10) | |
| def test_chisquare(self): | |
| vals = self.rg.chisquare(2.0, 10) | |
| assert_(len(vals) == 10) | |
| params_1(self.rg.chisquare) | |
| def test_exponential(self): | |
| vals = self.rg.exponential(2.0, 10) | |
| assert_(len(vals) == 10) | |
| params_1(self.rg.exponential) | |
| def test_f(self): | |
| vals = self.rg.f(3, 1000, 10) | |
| assert_(len(vals) == 10) | |
| def test_gamma(self): | |
| vals = self.rg.gamma(3, 2, 10) | |
| assert_(len(vals) == 10) | |
| def test_geometric(self): | |
| vals = self.rg.geometric(0.5, 10) | |
| assert_(len(vals) == 10) | |
| params_1(self.rg.exponential, bounded=True) | |
| def test_gumbel(self): | |
| vals = self.rg.gumbel(2.0, 2.0, 10) | |
| assert_(len(vals) == 10) | |
| def test_laplace(self): | |
| vals = self.rg.laplace(2.0, 2.0, 10) | |
| assert_(len(vals) == 10) | |
| def test_logitic(self): | |
| vals = self.rg.logistic(2.0, 2.0, 10) | |
| assert_(len(vals) == 10) | |
| def test_logseries(self): | |
| vals = self.rg.logseries(0.5, 10) | |
| assert_(len(vals) == 10) | |
| def test_negative_binomial(self): | |
| vals = self.rg.negative_binomial(10, 0.2, 10) | |
| assert_(len(vals) == 10) | |
| def test_noncentral_chisquare(self): | |
| vals = self.rg.noncentral_chisquare(10, 2, 10) | |
| assert_(len(vals) == 10) | |
| def test_noncentral_f(self): | |
| vals = self.rg.noncentral_f(3, 1000, 2, 10) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.noncentral_f(np.array([3] * 10), 1000, 2) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.noncentral_f(3, np.array([1000] * 10), 2) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.noncentral_f(3, 1000, np.array([2] * 10)) | |
| assert_(len(vals) == 10) | |
| def test_normal(self): | |
| vals = self.rg.normal(10, 0.2, 10) | |
| assert_(len(vals) == 10) | |
| def test_pareto(self): | |
| vals = self.rg.pareto(3.0, 10) | |
| assert_(len(vals) == 10) | |
| def test_poisson(self): | |
| vals = self.rg.poisson(10, 10) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.poisson(np.array([10] * 10)) | |
| assert_(len(vals) == 10) | |
| params_1(self.rg.poisson) | |
| def test_power(self): | |
| vals = self.rg.power(0.2, 10) | |
| assert_(len(vals) == 10) | |
| def test_integers(self): | |
| vals = self.rg.integers(10, 20, 10) | |
| assert_(len(vals) == 10) | |
| def test_rayleigh(self): | |
| vals = self.rg.rayleigh(0.2, 10) | |
| assert_(len(vals) == 10) | |
| params_1(self.rg.rayleigh, bounded=True) | |
| def test_vonmises(self): | |
| vals = self.rg.vonmises(10, 0.2, 10) | |
| assert_(len(vals) == 10) | |
| def test_wald(self): | |
| vals = self.rg.wald(1.0, 1.0, 10) | |
| assert_(len(vals) == 10) | |
| def test_weibull(self): | |
| vals = self.rg.weibull(1.0, 10) | |
| assert_(len(vals) == 10) | |
| def test_zipf(self): | |
| vals = self.rg.zipf(10, 10) | |
| assert_(len(vals) == 10) | |
| vals = self.rg.zipf(self.vec_1d) | |
| assert_(len(vals) == 100) | |
| vals = self.rg.zipf(self.vec_2d) | |
| assert_(vals.shape == (1, 100)) | |
| vals = self.rg.zipf(self.mat) | |
| assert_(vals.shape == (100, 100)) | |
| def test_hypergeometric(self): | |
| vals = self.rg.hypergeometric(25, 25, 20) | |
| assert_(np.isscalar(vals)) | |
| vals = self.rg.hypergeometric(np.array([25] * 10), 25, 20) | |
| assert_(vals.shape == (10,)) | |
| def test_triangular(self): | |
| vals = self.rg.triangular(-5, 0, 5) | |
| assert_(np.isscalar(vals)) | |
| vals = self.rg.triangular(-5, np.array([0] * 10), 5) | |
| assert_(vals.shape == (10,)) | |
| def test_multivariate_normal(self): | |
| mean = [0, 0] | |
| cov = [[1, 0], [0, 100]] # diagonal covariance | |
| x = self.rg.multivariate_normal(mean, cov, 5000) | |
| assert_(x.shape == (5000, 2)) | |
| x_zig = self.rg.multivariate_normal(mean, cov, 5000) | |
| assert_(x.shape == (5000, 2)) | |
| x_inv = self.rg.multivariate_normal(mean, cov, 5000) | |
| assert_(x.shape == (5000, 2)) | |
| assert_((x_zig != x_inv).any()) | |
| def test_multinomial(self): | |
| vals = self.rg.multinomial(100, [1.0 / 3, 2.0 / 3]) | |
| assert_(vals.shape == (2,)) | |
| vals = self.rg.multinomial(100, [1.0 / 3, 2.0 / 3], size=10) | |
| assert_(vals.shape == (10, 2)) | |
| def test_dirichlet(self): | |
| s = self.rg.dirichlet((10, 5, 3), 20) | |
| assert_(s.shape == (20, 3)) | |
| def test_pickle(self): | |
| pick = pickle.dumps(self.rg) | |
| unpick = pickle.loads(pick) | |
| assert_((type(self.rg) == type(unpick))) | |
| assert_(comp_state(self.rg.bit_generator.state, | |
| unpick.bit_generator.state)) | |
| pick = pickle.dumps(self.rg) | |
| unpick = pickle.loads(pick) | |
| assert_((type(self.rg) == type(unpick))) | |
| assert_(comp_state(self.rg.bit_generator.state, | |
| unpick.bit_generator.state)) | |
| def test_seed_array(self): | |
| if self.seed_vector_bits is None: | |
| bitgen_name = self.bit_generator.__name__ | |
| pytest.skip(f'Vector seeding is not supported by {bitgen_name}') | |
| if self.seed_vector_bits == 32: | |
| dtype = np.uint32 | |
| else: | |
| dtype = np.uint64 | |
| seed = np.array([1], dtype=dtype) | |
| bg = self.bit_generator(seed) | |
| state1 = bg.state | |
| bg = self.bit_generator(1) | |
| state2 = bg.state | |
| assert_(comp_state(state1, state2)) | |
| seed = np.arange(4, dtype=dtype) | |
| bg = self.bit_generator(seed) | |
| state1 = bg.state | |
| bg = self.bit_generator(seed[0]) | |
| state2 = bg.state | |
| assert_(not comp_state(state1, state2)) | |
| seed = np.arange(1500, dtype=dtype) | |
| bg = self.bit_generator(seed) | |
| state1 = bg.state | |
| bg = self.bit_generator(seed[0]) | |
| state2 = bg.state | |
| assert_(not comp_state(state1, state2)) | |
| seed = 2 ** np.mod(np.arange(1500, dtype=dtype), | |
| self.seed_vector_bits - 1) + 1 | |
| bg = self.bit_generator(seed) | |
| state1 = bg.state | |
| bg = self.bit_generator(seed[0]) | |
| state2 = bg.state | |
| assert_(not comp_state(state1, state2)) | |
| def test_uniform_float(self): | |
| rg = Generator(self.bit_generator(12345)) | |
| warmup(rg) | |
| state = rg.bit_generator.state | |
| r1 = rg.random(11, dtype=np.float32) | |
| rg2 = Generator(self.bit_generator()) | |
| warmup(rg2) | |
| rg2.bit_generator.state = state | |
| r2 = rg2.random(11, dtype=np.float32) | |
| assert_array_equal(r1, r2) | |
| assert_equal(r1.dtype, np.float32) | |
| assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state)) | |
| def test_gamma_floats(self): | |
| rg = Generator(self.bit_generator()) | |
| warmup(rg) | |
| state = rg.bit_generator.state | |
| r1 = rg.standard_gamma(4.0, 11, dtype=np.float32) | |
| rg2 = Generator(self.bit_generator()) | |
| warmup(rg2) | |
| rg2.bit_generator.state = state | |
| r2 = rg2.standard_gamma(4.0, 11, dtype=np.float32) | |
| assert_array_equal(r1, r2) | |
| assert_equal(r1.dtype, np.float32) | |
| assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state)) | |
| def test_normal_floats(self): | |
| rg = Generator(self.bit_generator()) | |
| warmup(rg) | |
| state = rg.bit_generator.state | |
| r1 = rg.standard_normal(11, dtype=np.float32) | |
| rg2 = Generator(self.bit_generator()) | |
| warmup(rg2) | |
| rg2.bit_generator.state = state | |
| r2 = rg2.standard_normal(11, dtype=np.float32) | |
| assert_array_equal(r1, r2) | |
| assert_equal(r1.dtype, np.float32) | |
| assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state)) | |
| def test_normal_zig_floats(self): | |
| rg = Generator(self.bit_generator()) | |
| warmup(rg) | |
| state = rg.bit_generator.state | |
| r1 = rg.standard_normal(11, dtype=np.float32) | |
| rg2 = Generator(self.bit_generator()) | |
| warmup(rg2) | |
| rg2.bit_generator.state = state | |
| r2 = rg2.standard_normal(11, dtype=np.float32) | |
| assert_array_equal(r1, r2) | |
| assert_equal(r1.dtype, np.float32) | |
| assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state)) | |
| def test_output_fill(self): | |
| rg = self.rg | |
| state = rg.bit_generator.state | |
| size = (31, 7, 97) | |
| existing = np.empty(size) | |
| rg.bit_generator.state = state | |
| rg.standard_normal(out=existing) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_normal(size=size) | |
| assert_equal(direct, existing) | |
| sized = np.empty(size) | |
| rg.bit_generator.state = state | |
| rg.standard_normal(out=sized, size=sized.shape) | |
| existing = np.empty(size, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| rg.standard_normal(out=existing, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_normal(size=size, dtype=np.float32) | |
| assert_equal(direct, existing) | |
| def test_output_filling_uniform(self): | |
| rg = self.rg | |
| state = rg.bit_generator.state | |
| size = (31, 7, 97) | |
| existing = np.empty(size) | |
| rg.bit_generator.state = state | |
| rg.random(out=existing) | |
| rg.bit_generator.state = state | |
| direct = rg.random(size=size) | |
| assert_equal(direct, existing) | |
| existing = np.empty(size, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| rg.random(out=existing, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| direct = rg.random(size=size, dtype=np.float32) | |
| assert_equal(direct, existing) | |
| def test_output_filling_exponential(self): | |
| rg = self.rg | |
| state = rg.bit_generator.state | |
| size = (31, 7, 97) | |
| existing = np.empty(size) | |
| rg.bit_generator.state = state | |
| rg.standard_exponential(out=existing) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_exponential(size=size) | |
| assert_equal(direct, existing) | |
| existing = np.empty(size, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| rg.standard_exponential(out=existing, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_exponential(size=size, dtype=np.float32) | |
| assert_equal(direct, existing) | |
| def test_output_filling_gamma(self): | |
| rg = self.rg | |
| state = rg.bit_generator.state | |
| size = (31, 7, 97) | |
| existing = np.zeros(size) | |
| rg.bit_generator.state = state | |
| rg.standard_gamma(1.0, out=existing) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_gamma(1.0, size=size) | |
| assert_equal(direct, existing) | |
| existing = np.zeros(size, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| rg.standard_gamma(1.0, out=existing, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_gamma(1.0, size=size, dtype=np.float32) | |
| assert_equal(direct, existing) | |
| def test_output_filling_gamma_broadcast(self): | |
| rg = self.rg | |
| state = rg.bit_generator.state | |
| size = (31, 7, 97) | |
| mu = np.arange(97.0) + 1.0 | |
| existing = np.zeros(size) | |
| rg.bit_generator.state = state | |
| rg.standard_gamma(mu, out=existing) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_gamma(mu, size=size) | |
| assert_equal(direct, existing) | |
| existing = np.zeros(size, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| rg.standard_gamma(mu, out=existing, dtype=np.float32) | |
| rg.bit_generator.state = state | |
| direct = rg.standard_gamma(mu, size=size, dtype=np.float32) | |
| assert_equal(direct, existing) | |
| def test_output_fill_error(self): | |
| rg = self.rg | |
| size = (31, 7, 97) | |
| existing = np.empty(size) | |
| with pytest.raises(TypeError): | |
| rg.standard_normal(out=existing, dtype=np.float32) | |
| with pytest.raises(ValueError): | |
| rg.standard_normal(out=existing[::3]) | |
| existing = np.empty(size, dtype=np.float32) | |
| with pytest.raises(TypeError): | |
| rg.standard_normal(out=existing, dtype=np.float64) | |
| existing = np.zeros(size, dtype=np.float32) | |
| with pytest.raises(TypeError): | |
| rg.standard_gamma(1.0, out=existing, dtype=np.float64) | |
| with pytest.raises(ValueError): | |
| rg.standard_gamma(1.0, out=existing[::3], dtype=np.float32) | |
| existing = np.zeros(size, dtype=np.float64) | |
| with pytest.raises(TypeError): | |
| rg.standard_gamma(1.0, out=existing, dtype=np.float32) | |
| with pytest.raises(ValueError): | |
| rg.standard_gamma(1.0, out=existing[::3]) | |
| def test_integers_broadcast(self, dtype): | |
| if dtype == np.bool_: | |
| upper = 2 | |
| lower = 0 | |
| else: | |
| info = np.iinfo(dtype) | |
| upper = int(info.max) + 1 | |
| lower = info.min | |
| self._reset_state() | |
| a = self.rg.integers(lower, [upper] * 10, dtype=dtype) | |
| self._reset_state() | |
| b = self.rg.integers([lower] * 10, upper, dtype=dtype) | |
| assert_equal(a, b) | |
| self._reset_state() | |
| c = self.rg.integers(lower, upper, size=10, dtype=dtype) | |
| assert_equal(a, c) | |
| self._reset_state() | |
| d = self.rg.integers(np.array( | |
| [lower] * 10), np.array([upper], dtype=object), size=10, | |
| dtype=dtype) | |
| assert_equal(a, d) | |
| self._reset_state() | |
| e = self.rg.integers( | |
| np.array([lower] * 10), np.array([upper] * 10), size=10, | |
| dtype=dtype) | |
| assert_equal(a, e) | |
| self._reset_state() | |
| a = self.rg.integers(0, upper, size=10, dtype=dtype) | |
| self._reset_state() | |
| b = self.rg.integers([upper] * 10, dtype=dtype) | |
| assert_equal(a, b) | |
| def test_integers_numpy(self, dtype): | |
| high = np.array([1]) | |
| low = np.array([0]) | |
| out = self.rg.integers(low, high, dtype=dtype) | |
| assert out.shape == (1,) | |
| out = self.rg.integers(low[0], high, dtype=dtype) | |
| assert out.shape == (1,) | |
| out = self.rg.integers(low, high[0], dtype=dtype) | |
| assert out.shape == (1,) | |
| def test_integers_broadcast_errors(self, dtype): | |
| if dtype == np.bool_: | |
| upper = 2 | |
| lower = 0 | |
| else: | |
| info = np.iinfo(dtype) | |
| upper = int(info.max) + 1 | |
| lower = info.min | |
| with pytest.raises(ValueError): | |
| self.rg.integers(lower, [upper + 1] * 10, dtype=dtype) | |
| with pytest.raises(ValueError): | |
| self.rg.integers(lower - 1, [upper] * 10, dtype=dtype) | |
| with pytest.raises(ValueError): | |
| self.rg.integers([lower - 1], [upper] * 10, dtype=dtype) | |
| with pytest.raises(ValueError): | |
| self.rg.integers([0], [0], dtype=dtype) | |
| class TestMT19937(RNG): | |
| def setup_class(cls): | |
| cls.bit_generator = MT19937 | |
| cls.advance = None | |
| cls.seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1] | |
| cls.rg = Generator(cls.bit_generator(*cls.seed)) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 32 | |
| cls._extra_setup() | |
| cls.seed_error = ValueError | |
| def test_numpy_state(self): | |
| nprg = np.random.RandomState() | |
| nprg.standard_normal(99) | |
| state = nprg.get_state() | |
| self.rg.bit_generator.state = state | |
| state2 = self.rg.bit_generator.state | |
| assert_((state[1] == state2['state']['key']).all()) | |
| assert_((state[2] == state2['state']['pos'])) | |
| class TestPhilox(RNG): | |
| def setup_class(cls): | |
| cls.bit_generator = Philox | |
| cls.advance = 2**63 + 2**31 + 2**15 + 1 | |
| cls.seed = [12345] | |
| cls.rg = Generator(cls.bit_generator(*cls.seed)) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 64 | |
| cls._extra_setup() | |
| class TestSFC64(RNG): | |
| def setup_class(cls): | |
| cls.bit_generator = SFC64 | |
| cls.advance = None | |
| cls.seed = [12345] | |
| cls.rg = Generator(cls.bit_generator(*cls.seed)) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 192 | |
| cls._extra_setup() | |
| class TestPCG64(RNG): | |
| def setup_class(cls): | |
| cls.bit_generator = PCG64 | |
| cls.advance = 2**63 + 2**31 + 2**15 + 1 | |
| cls.seed = [12345] | |
| cls.rg = Generator(cls.bit_generator(*cls.seed)) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 64 | |
| cls._extra_setup() | |
| class TestPCG64DXSM(RNG): | |
| def setup_class(cls): | |
| cls.bit_generator = PCG64DXSM | |
| cls.advance = 2**63 + 2**31 + 2**15 + 1 | |
| cls.seed = [12345] | |
| cls.rg = Generator(cls.bit_generator(*cls.seed)) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 64 | |
| cls._extra_setup() | |
| class TestDefaultRNG(RNG): | |
| def setup_class(cls): | |
| # This will duplicate some tests that directly instantiate a fresh | |
| # Generator(), but that's okay. | |
| cls.bit_generator = PCG64 | |
| cls.advance = 2**63 + 2**31 + 2**15 + 1 | |
| cls.seed = [12345] | |
| cls.rg = np.random.default_rng(*cls.seed) | |
| cls.initial_state = cls.rg.bit_generator.state | |
| cls.seed_vector_bits = 64 | |
| cls._extra_setup() | |
| def test_default_is_pcg64(self): | |
| # In order to change the default BitGenerator, we'll go through | |
| # a deprecation cycle to move to a different function. | |
| assert_(isinstance(self.rg.bit_generator, PCG64)) | |
| def test_seed(self): | |
| np.random.default_rng() | |
| np.random.default_rng(None) | |
| np.random.default_rng(12345) | |
| np.random.default_rng(0) | |
| np.random.default_rng(43660444402423911716352051725018508569) | |
| np.random.default_rng([43660444402423911716352051725018508569, | |
| 279705150948142787361475340226491943209]) | |
| with pytest.raises(ValueError): | |
| np.random.default_rng(-1) | |
| with pytest.raises(ValueError): | |
| np.random.default_rng([12345, -1]) | |