def test_uniform_double(self): rs = Generator(self.bit_generator(*self.data1['seed'])) assert_array_equal(uniform_from_dsfmt(self.data1['data']), rs.random(1000)) rs = Generator(self.bit_generator(*self.data2['seed'])) assert_equal(uniform_from_dsfmt(self.data2['data']), rs.random(1000))
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_reset_state_float(self): rg = Generator(self.bit_generator(*self.seed, mode="legacy")) rg.random(dtype="float32") state = rg.bit_generator.state n1 = rg.random(size=10, dtype="float32") rg2 = Generator(self.bit_generator(mode="sequence")) rg2.bit_generator.state = state n2 = rg2.random(size=10, dtype="float32") assert_((n1 == n2).all())
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_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_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_uniform_float(self): rs = Generator(self.bit_generator(*self.data1['seed'])) vals = uniform32_from_uint(self.data1['data'], self.bits) uniforms = rs.random(len(vals), dtype=np.float32) assert_allclose(uniforms, vals) assert_equal(uniforms.dtype, np.float32) rs = Generator(self.bit_generator(*self.data2['seed'])) vals = uniform32_from_uint(self.data2['data'], self.bits) uniforms = rs.random(len(vals), dtype=np.float32) assert_allclose(uniforms, vals) assert_equal(uniforms.dtype, np.float32)
def test_pickle(self): import pickle bit_generator = self.bit_generator(*self.data1['seed']) bit_generator_pkl = pickle.dumps(bit_generator) reloaded = pickle.loads(bit_generator_pkl) orig_gen = Generator(bit_generator) reloaded_gen = Generator(reloaded) assert_array_equal(orig_gen.standard_normal(1000), reloaded_gen.standard_normal(1000)) assert bit_generator is not reloaded assert_state_equal(reloaded.state, bit_generator.state)
def test_gamma_floats(self): rg = Generator(self.bit_generator(mode="sequence")) warmup(rg) state = rg.bit_generator.state r1 = rg.standard_gamma(4.0, 11, dtype=np.float32) rg2 = Generator(self.bit_generator(mode="legacy")) 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_array(self): s = Generator(MT19937(range(10), mode="legacy")) assert_equal(s.integers(1000), 468) s = np.random.RandomState(range(10)) assert_equal(s.randint(1000), 468) s = Generator(MT19937(np.arange(10), mode="legacy")) assert_equal(s.integers(1000), 468) s = Generator(MT19937([0], mode="legacy")) assert_equal(s.integers(1000), 973) s = Generator(MT19937([4294967295], mode="legacy")) assert_equal(s.integers(1000), 265)
def prob(): base = Generator(PCG64()) return ([0.5], [0.5, (6, 5, 4, 3)], [0.3], [base.random((20, 2, 2))], [base.random(3)])
def positive_param(): base = Generator(PCG64()) return [ base.chisquare(10), base.chisquare(10, (5, 1, 3)), base.chisquare(10, (6, 5, 4, 3)), ]
def integers(): dtypes = [ np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64, ] base = Generator(PCG64()) shape = tuple(base.integers(5, 10, size=2)) configs = [] for dt in dtypes: s1 = np.ones(shape, dtype=dt) s2 = np.ones((1, ) + shape, dtype=dt) lo = np.iinfo(dt).min hi = np.iinfo(dt).max configs.extend([ (0, np.iinfo(dt).max, None, dt), (lo, hi // 2, None, dt), (lo, hi, (10, 2), dt), (lo // 2 * s1, hi // 2 * s2, None, dt), ]) return configs
def test_seed_out_of_range_array(self): # GH #82 rs = Generator(self.bit_generator(*self.data1['seed'])) assert_raises(ValueError, rs.bit_generator.seed, [2**(self.bits + 1)]) assert_raises(ValueError, rs.bit_generator.seed, [-1]) assert_raises(TypeError, rs.bit_generator.seed, [2**(2 * self.bits + 1)])
def test_seed_out_of_range(self): # GH #82 rs = Generator(self.bit_generator(*self.data1['seed'])) assert_raises(ValueError, rs.bit_generator.seed, 2**(self.bits + 1)) assert_raises(ValueError, rs.bit_generator.seed, -1) assert_raises(ValueError, rs.bit_generator.seed, 2**(2 * self.bits + 1))
def int_prob(): base = Generator(PCG64()) return ([100, 0.5], [100, 0.5, (6, 5, 4, 3)], [base.integers(10, 100, size=(10, 2)), 0.3], [10, base.random((20, 2, 2))], [base.integers(10, 100, size=(5, 4, 3)), base.random(3)])
def test_scalar(self): s = Generator(MT19937(0, mode="legacy")) assert_equal(s.integers(1000), 684) s1 = np.random.RandomState(0) assert_equal(s1.randint(1000), 684) assert_equal(s1.randint(1000), s.integers(1000)) s = Generator(MT19937(4294967295, mode="legacy")) assert_equal(s.integers(1000), 419) s1 = np.random.RandomState(4294967295) assert_equal(s1.randint(1000), 419) assert_equal(s1.randint(1000), s.integers(1000)) self.rg.bit_generator.seed(4294967295) self.nprs.seed(4294967295) self._is_state_common()
def setup_class(cls): cls.bit_generator = PCG32 cls.advance = 2**48 + 2**21 + 2**16 + 2**5 + 1 cls.seed = [2**48 + 2**21 + 2**16 + 2**5 + 1, 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 = None cls._extra_setup()
def setup_class(cls): cls.bit_generator = Xoshiro512StarStar 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 setup_class(cls): cls.bit_generator = DSFMT cls.advance = None cls.seed = [12345] cls.rg = Generator(cls.bit_generator(*cls.seed)) cls.initial_state = cls.rg.bit_generator.state cls._extra_setup() cls.seed_vector_bits = 32
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 setup_class(cls): cls.bit_generator = ThreeFry 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()
def setup_class(cls): cls.np = numpy.random cls.bit_generator = MT19937 cls.seed = [2**21 + 2**16 + 2**5 + 1] cls.rg = Generator(cls.bit_generator(*cls.seed, mode="legacy")) cls.rs = RandomState(cls.bit_generator(*cls.seed, mode="legacy")) cls.nprs = cls.np.RandomState(*cls.seed) cls.initial_state = cls.rg.bit_generator.state cls._set_common_state()
def setup_class(cls): # Overridden in test classes. Place holder to silence IDE noise cls.bit_generator = Xoshiro256StarStar 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 setup_class(cls): cls.bit_generator = ThreeFry32 cls.advance = 2**63 + 2**31 + 2**15 + 1 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 = 64 cls._extra_setup() cls.seed_error = ValueError
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 setup_class(cls): super(TestHC128, cls).setup_class() cls.bit_generator = HC128 cls.seed = [2**231 + 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 = 64 cls._extra_setup() cls.seed_error = ValueError
def setup_class(cls): super(TestXorshift1024, cls).setup_class() cls.bit_generator = Xorshift1024 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 setup_class(cls): super(TestJSF32, cls).setup_class() cls.bit_generator = partial(JSF, size=32, seed_size=3) 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()