codekingpro/portable-devtools
114k
1import pickle
2from dataclasses import dataclass
3from functools import partial
4
5import pytest
6
7import numpy as np
8from numpy.random import MT19937, PCG64, PCG64DXSM, SFC64, Generator, Philox
9from numpy.testing import assert_, assert_array_equal, assert_equal
10
11DTYPES_BOOL_INT_UINT = (np.bool, np.int8, np.int16, np.int32, np.int64,
12 np.uint8, np.uint16, np.uint32, np.uint64)
13
14
15def params_0(f):
16 val = f()
17 assert_(np.isscalar(val))
18 val = f(10)
19 assert_(val.shape == (10,))
20 val = f((10, 10))
21 assert_(val.shape == (10, 10))
22 val = f((10, 10, 10))
23 assert_(val.shape == (10, 10, 10))
24 val = f(size=(5, 5))
25 assert_(val.shape == (5, 5))
26
27
28def params_1(f, bounded=False):
29 a = 5.0
30 b = np.arange(2.0, 12.0)
31 c = np.arange(2.0, 102.0).reshape((10, 10))
32 d = np.arange(2.0, 1002.0).reshape((10, 10, 10))
33 e = np.array([2.0, 3.0])
34 g = np.arange(2.0, 12.0).reshape((1, 10, 1))
35 if bounded:
36 a = 0.5
37 b = b / (1.5 * b.max())
38 c = c / (1.5 * c.max())
39 d = d / (1.5 * d.max())
40 e = e / (1.5 * e.max())
41 g = g / (1.5 * g.max())
42
43 # Scalar
44 f(a)
45 # Scalar - size
46 f(a, size=(10, 10))
47 # 1d
48 f(b)
49 # 2d
50 f(c)
51 # 3d
52 f(d)
53 # 1d size
54 f(b, size=10)
55 # 2d - size - broadcast
56 f(e, size=(10, 2))
57 # 3d - size
58 f(g, size=(10, 10, 10))
59
60
61def comp_state(state1, state2):
62 identical = True
63 if isinstance(state1, dict):
64 for key in state1:
65 identical &= comp_state(state1[key], state2[key])
66 elif type(state1) != type(state2):
67 identical &= type(state1) == type(state2)
68 elif (isinstance(state1, (list, tuple, np.ndarray)) and isinstance(
69 state2, (list, tuple, np.ndarray))):
70 for s1, s2 in zip(state1, state2):
71 identical &= comp_state(s1, s2)
72 else:
73 identical &= state1 == state2
74 return identical
75
76
77def warmup(rg, n=None):
78 if n is None:
79 n = 11 + np.random.randint(0, 20)
80 rg.standard_normal(n)
81 rg.standard_normal(n)
82 rg.standard_normal(n, dtype=np.float32)
83 rg.standard_normal(n, dtype=np.float32)
84 rg.integers(0, 2 ** 24, n, dtype=np.uint64)
85 rg.integers(0, 2 ** 48, n, dtype=np.uint64)
86 rg.standard_gamma(11.0, n)
87 rg.standard_gamma(11.0, n, dtype=np.float32)
88 rg.random(n, dtype=np.float64)
89 rg.random(n, dtype=np.float32)
90
91
92@dataclass
93class RNGData:
94 bit_generator: type[np.random.BitGenerator]
95 advance: int
96 seed: list[int]
97 rg: Generator
98 seed_vector_bits: int
99
100
101class RNG:
102 @classmethod
103 def _create_rng(cls):
104 # Overridden in test classes. Place holder to silence IDE noise
105 bit_generator = PCG64
106 advance = None
107 seed = [12345]
108 rg = Generator(bit_generator(*seed))
109 seed_vector_bits = 64
110 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
111
112 def test_init(self):
113 data = self._create_rng()
114 data.rg = Generator(data.bit_generator())
115 state = data.rg.bit_generator.state
116 data.rg.standard_normal(1)
117 data.rg.standard_normal(1)
118 data.rg.bit_generator.state = state
119 new_state = data.rg.bit_generator.state
120 assert_(comp_state(state, new_state))
121
122 def test_advance(self):
123 data = self._create_rng()
124 state = data.rg.bit_generator.state
125 if hasattr(data.rg.bit_generator, 'advance'):
126 data.rg.bit_generator.advance(data.advance)
127 assert_(not comp_state(state, data.rg.bit_generator.state))
128 else:
129 bitgen_name = data.rg.bit_generator.__class__.__name__
130 pytest.skip(f'Advance is not supported by {bitgen_name}')
131
132 def test_jump(self):
133 rg = self._create_rng().rg
134 state = rg.bit_generator.state
135 if hasattr(rg.bit_generator, 'jumped'):
136 bit_gen2 = rg.bit_generator.jumped()
137 jumped_state = bit_gen2.state
138 assert_(not comp_state(state, jumped_state))
139 rg.random(2 * 3 * 5 * 7 * 11 * 13 * 17)
140 rg.bit_generator.state = state
141 bit_gen3 = rg.bit_generator.jumped()
142 rejumped_state = bit_gen3.state
143 assert_(comp_state(jumped_state, rejumped_state))
144 else:
145 bitgen_name = rg.bit_generator.__class__.__name__
146 if bitgen_name not in ('SFC64',):
147 raise AttributeError(f'no "jumped" in {bitgen_name}')
148 pytest.skip(f'Jump is not supported by {bitgen_name}')
149
150 def test_uniform(self):
151 rg = self._create_rng().rg
152 r = rg.uniform(-1.0, 0.0, size=10)
153 assert_(len(r) == 10)
154 assert_((r > -1).all())
155 assert_((r <= 0).all())
156
157 def test_uniform_array(self):
158 rg = self._create_rng().rg
159 r = rg.uniform(np.array([-1.0] * 10), 0.0, size=10)
160 assert_(len(r) == 10)
161 assert_((r > -1).all())
162 assert_((r <= 0).all())
163 r = rg.uniform(np.array([-1.0] * 10),
164 np.array([0.0] * 10), size=10)
165 assert_(len(r) == 10)
166 assert_((r > -1).all())
167 assert_((r <= 0).all())
168 r = rg.uniform(-1.0, np.array([0.0] * 10), size=10)
169 assert_(len(r) == 10)
170 assert_((r > -1).all())
171 assert_((r <= 0).all())
172
173 def test_random(self):
174 rg = self._create_rng().rg
175 assert_(len(rg.random(10)) == 10)
176 params_0(rg.random)
177
178 def test_standard_normal_zig(self):
179 rg = self._create_rng().rg
180 assert_(len(rg.standard_normal(10)) == 10)
181
182 def test_standard_normal(self):
183 rg = self._create_rng().rg
184 assert_(len(rg.standard_normal(10)) == 10)
185 params_0(rg.standard_normal)
186
187 def test_standard_gamma(self):
188 rg = self._create_rng().rg
189 assert_(len(rg.standard_gamma(10, 10)) == 10)
190 assert_(len(rg.standard_gamma(np.array([10] * 10), 10)) == 10)
191 params_1(rg.standard_gamma)
192
193 def test_standard_exponential(self):
194 rg = self._create_rng().rg
195 assert_(len(rg.standard_exponential(10)) == 10)
196 params_0(rg.standard_exponential)
197
198 def test_standard_exponential_float(self):
199 rg = self._create_rng().rg
200 randoms = rg.standard_exponential(10, dtype='float32')
201 assert_(len(randoms) == 10)
202 assert randoms.dtype == np.float32
203 params_0(partial(rg.standard_exponential, dtype='float32'))
204
205 def test_standard_exponential_float_log(self):
206 rg = self._create_rng().rg
207 randoms = rg.standard_exponential(10, dtype='float32',
208 method='inv')
209 assert_(len(randoms) == 10)
210 assert randoms.dtype == np.float32
211 params_0(partial(rg.standard_exponential, dtype='float32',
212 method='inv'))
213
214 def test_standard_cauchy(self):
215 rg = self._create_rng().rg
216 assert_(len(rg.standard_cauchy(10)) == 10)
217 params_0(rg.standard_cauchy)
218
219 def test_standard_t(self):
220 rg = self._create_rng().rg
221 assert_(len(rg.standard_t(10, 10)) == 10)
222 params_1(rg.standard_t)
223
224 def test_binomial(self):
225 rg = self._create_rng().rg
226 assert_(rg.binomial(10, .5) >= 0)
227 assert_(rg.binomial(1000, .5) >= 0)
228
229 def test_reset_state(self):
230 rg = self._create_rng().rg
231 state = rg.bit_generator.state
232 int_1 = rg.integers(2**31)
233 rg.bit_generator.state = state
234 int_2 = rg.integers(2**31)
235 assert_(int_1 == int_2)
236
237 def test_entropy_init(self):
238 bit_generator = self._create_rng().bit_generator
239 rg = Generator(bit_generator())
240 rg2 = Generator(bit_generator())
241 assert_(not comp_state(rg.bit_generator.state,
242 rg2.bit_generator.state))
243
244 def test_seed(self):
245 data = self._create_rng()
246 rg = Generator(data.bit_generator(*data.seed))
247 rg2 = Generator(data.bit_generator(*data.seed))
248 rg.random()
249 rg2.random()
250 assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
251
252 def test_reset_state_gauss(self):
253 data = self._create_rng()
254 rg = Generator(data.bit_generator(*data.seed))
255 rg.standard_normal()
256 state = rg.bit_generator.state
257 n1 = rg.standard_normal(size=10)
258 rg2 = Generator(data.bit_generator())
259 rg2.bit_generator.state = state
260 n2 = rg2.standard_normal(size=10)
261 assert_array_equal(n1, n2)
262
263 def test_reset_state_uint32(self):
264 data = self._create_rng()
265 rg = Generator(data.bit_generator(*data.seed))
266 rg.integers(0, 2 ** 24, 120, dtype=np.uint32)
267 state = rg.bit_generator.state
268 n1 = rg.integers(0, 2 ** 24, 10, dtype=np.uint32)
269 rg2 = Generator(data.bit_generator())
270 rg2.bit_generator.state = state
271 n2 = rg2.integers(0, 2 ** 24, 10, dtype=np.uint32)
272 assert_array_equal(n1, n2)
273
274 def test_reset_state_float(self):
275 data = self._create_rng()
276 rg = Generator(data.bit_generator(*data.seed))
277 rg.random(dtype='float32')
278 state = rg.bit_generator.state
279 n1 = rg.random(size=10, dtype='float32')
280 rg2 = Generator(data.bit_generator())
281 rg2.bit_generator.state = state
282 n2 = rg2.random(size=10, dtype='float32')
283 assert_((n1 == n2).all())
284
285 def test_shuffle(self):
286 rg = self._create_rng().rg
287 original = np.arange(200, 0, -1)
288 permuted = rg.permutation(original)
289 assert_((original != permuted).any())
290
291 def test_permutation(self):
292 rg = self._create_rng().rg
293 original = np.arange(200, 0, -1)
294 permuted = rg.permutation(original)
295 assert_((original != permuted).any())
296
297 def test_beta(self):
298 rg = self._create_rng().rg
299 vals = rg.beta(2.0, 2.0, 10)
300 assert_(len(vals) == 10)
301 vals = rg.beta(np.array([2.0] * 10), 2.0)
302 assert_(len(vals) == 10)
303 vals = rg.beta(2.0, np.array([2.0] * 10))
304 assert_(len(vals) == 10)
305 vals = rg.beta(np.array([2.0] * 10), np.array([2.0] * 10))
306 assert_(len(vals) == 10)
307 vals = rg.beta(np.array([2.0] * 10), np.array([[2.0]] * 10))
308 assert_(vals.shape == (10, 10))
309
310 def test_bytes(self):
311 rg = self._create_rng().rg
312 vals = rg.bytes(10)
313 assert_(len(vals) == 10)
314
315 def test_chisquare(self):
316 rg = self._create_rng().rg
317 vals = rg.chisquare(2.0, 10)
318 assert_(len(vals) == 10)
319 params_1(rg.chisquare)
320
321 def test_exponential(self):
322 rg = self._create_rng().rg
323 vals = rg.exponential(2.0, 10)
324 assert_(len(vals) == 10)
325 params_1(rg.exponential)
326
327 def test_f(self):
328 rg = self._create_rng().rg
329 vals = rg.f(3, 1000, 10)
330 assert_(len(vals) == 10)
331
332 def test_gamma(self):
333 rg = self._create_rng().rg
334 vals = rg.gamma(3, 2, 10)
335 assert_(len(vals) == 10)
336
337 def test_geometric(self):
338 rg = self._create_rng().rg
339 vals = rg.geometric(0.5, 10)
340 assert_(len(vals) == 10)
341 params_1(rg.exponential, bounded=True)
342
343 def test_gumbel(self):
344 rg = self._create_rng().rg
345 vals = rg.gumbel(2.0, 2.0, 10)
346 assert_(len(vals) == 10)
347
348 def test_laplace(self):
349 rg = self._create_rng().rg
350 vals = rg.laplace(2.0, 2.0, 10)
351 assert_(len(vals) == 10)
352
353 def test_logitic(self):
354 rg = self._create_rng().rg
355 vals = rg.logistic(2.0, 2.0, 10)
356 assert_(len(vals) == 10)
357
358 def test_logseries(self):
359 rg = self._create_rng().rg
360 vals = rg.logseries(0.5, 10)
361 assert_(len(vals) == 10)
362
363 def test_negative_binomial(self):
364 rg = self._create_rng().rg
365 vals = rg.negative_binomial(10, 0.2, 10)
366 assert_(len(vals) == 10)
367
368 def test_noncentral_chisquare(self):
369 rg = self._create_rng().rg
370 vals = rg.noncentral_chisquare(10, 2, 10)
371 assert_(len(vals) == 10)
372
373 def test_noncentral_f(self):
374 rg = self._create_rng().rg
375 vals = rg.noncentral_f(3, 1000, 2, 10)
376 assert_(len(vals) == 10)
377 vals = rg.noncentral_f(np.array([3] * 10), 1000, 2)
378 assert_(len(vals) == 10)
379 vals = rg.noncentral_f(3, np.array([1000] * 10), 2)
380 assert_(len(vals) == 10)
381 vals = rg.noncentral_f(3, 1000, np.array([2] * 10))
382 assert_(len(vals) == 10)
383
384 def test_normal(self):
385 rg = self._create_rng().rg
386 vals = rg.normal(10, 0.2, 10)
387 assert_(len(vals) == 10)
388
389 def test_pareto(self):
390 rg = self._create_rng().rg
391 vals = rg.pareto(3.0, 10)
392 assert_(len(vals) == 10)
393
394 def test_poisson(self):
395 rg = self._create_rng().rg
396 vals = rg.poisson(10, 10)
397 assert_(len(vals) == 10)
398 vals = rg.poisson(np.array([10] * 10))
399 assert_(len(vals) == 10)
400 params_1(rg.poisson)
401
402 def test_power(self):
403 rg = self._create_rng().rg
404 vals = rg.power(0.2, 10)
405 assert_(len(vals) == 10)
406
407 def test_integers(self):
408 rg = self._create_rng().rg
409 vals = rg.integers(10, 20, 10)
410 assert_(len(vals) == 10)
411
412 def test_rayleigh(self):
413 rg = self._create_rng().rg
414 vals = rg.rayleigh(0.2, 10)
415 assert_(len(vals) == 10)
416 params_1(rg.rayleigh, bounded=True)
417
418 def test_vonmises(self):
419 rg = self._create_rng().rg
420 vals = rg.vonmises(10, 0.2, 10)
421 assert_(len(vals) == 10)
422
423 def test_wald(self):
424 rg = self._create_rng().rg
425 vals = rg.wald(1.0, 1.0, 10)
426 assert_(len(vals) == 10)
427
428 def test_weibull(self):
429 rg = self._create_rng().rg
430 vals = rg.weibull(1.0, 10)
431 assert_(len(vals) == 10)
432
433 def test_zipf(self):
434 rg = self._create_rng().rg
435 vec_1d = np.arange(2.0, 102.0)
436 vec_2d = np.arange(2.0, 102.0)[None, :]
437 mat = np.arange(2.0, 102.0, 0.01).reshape((100, 100))
438 vals = rg.zipf(10, 10)
439 assert_(len(vals) == 10)
440 vals = rg.zipf(vec_1d)
441 assert_(len(vals) == 100)
442 vals = rg.zipf(vec_2d)
443 assert_(vals.shape == (1, 100))
444 vals = rg.zipf(mat)
445 assert_(vals.shape == (100, 100))
446
447 def test_hypergeometric(self):
448 rg = self._create_rng().rg
449 vals = rg.hypergeometric(25, 25, 20)
450 assert_(np.isscalar(vals))
451 vals = rg.hypergeometric(np.array([25] * 10), 25, 20)
452 assert_(vals.shape == (10,))
453
454 def test_triangular(self):
455 rg = self._create_rng().rg
456 vals = rg.triangular(-5, 0, 5)
457 assert_(np.isscalar(vals))
458 vals = rg.triangular(-5, np.array([0] * 10), 5)
459 assert_(vals.shape == (10,))
460
461 def test_multivariate_normal(self):
462 rg = self._create_rng().rg
463 mean = [0, 0]
464 cov = [[1, 0], [0, 100]] # diagonal covariance
465 x = rg.multivariate_normal(mean, cov, 5000)
466 assert_(x.shape == (5000, 2))
467 x_zig = rg.multivariate_normal(mean, cov, 5000)
468 assert_(x.shape == (5000, 2))
469 x_inv = rg.multivariate_normal(mean, cov, 5000)
470 assert_(x.shape == (5000, 2))
471 assert_((x_zig != x_inv).any())
472
473 def test_multinomial(self):
474 rg = self._create_rng().rg
475 vals = rg.multinomial(100, [1.0 / 3, 2.0 / 3])
476 assert_(vals.shape == (2,))
477 vals = rg.multinomial(100, [1.0 / 3, 2.0 / 3], size=10)
478 assert_(vals.shape == (10, 2))
479
480 def test_dirichlet(self):
481 rg = self._create_rng().rg
482 s = rg.dirichlet((10, 5, 3), 20)
483 assert_(s.shape == (20, 3))
484
485 def test_pickle(self):
486 rg = self._create_rng().rg
487 pick = pickle.dumps(rg)
488 unpick = pickle.loads(pick)
489 assert_(type(rg) == type(unpick))
490 assert_(comp_state(rg.bit_generator.state,
491 unpick.bit_generator.state))
492
493 pick = pickle.dumps(rg)
494 unpick = pickle.loads(pick)
495 assert_(type(rg) == type(unpick))
496 assert_(comp_state(rg.bit_generator.state,
497 unpick.bit_generator.state))
498
499 def test_seed_array(self):
500 data = self._create_rng()
501 if data.seed_vector_bits is None:
502 bitgen_name = data.bit_generator.__name__
503 pytest.skip(f'Vector seeding is not supported by {bitgen_name}')
504
505 if data.seed_vector_bits == 32:
506 dtype = np.uint32
507 else:
508 dtype = np.uint64
509 seed = np.array([1], dtype=dtype)
510 bg = data.bit_generator(seed)
511 state1 = bg.state
512 bg = data.bit_generator(1)
513 state2 = bg.state
514 assert_(comp_state(state1, state2))
515
516 seed = np.arange(4, dtype=dtype)
517 bg = data.bit_generator(seed)
518 state1 = bg.state
519 bg = data.bit_generator(seed[0])
520 state2 = bg.state
521 assert_(not comp_state(state1, state2))
522
523 seed = np.arange(1500, dtype=dtype)
524 bg = data.bit_generator(seed)
525 state1 = bg.state
526 bg = data.bit_generator(seed[0])
527 state2 = bg.state
528 assert_(not comp_state(state1, state2))
529
530 seed = 2 ** np.mod(np.arange(1500, dtype=dtype),
531 data.seed_vector_bits - 1) + 1
532 bg = data.bit_generator(seed)
533 state1 = bg.state
534 bg = data.bit_generator(seed[0])
535 state2 = bg.state
536 assert_(not comp_state(state1, state2))
537
538 def test_uniform_float(self):
539 bit_generator = self._create_rng().bit_generator
540 rg = Generator(bit_generator(12345))
541 warmup(rg)
542 state = rg.bit_generator.state
543 r1 = rg.random(11, dtype=np.float32)
544 rg2 = Generator(bit_generator())
545 warmup(rg2)
546 rg2.bit_generator.state = state
547 r2 = rg2.random(11, dtype=np.float32)
548 assert_array_equal(r1, r2)
549 assert_equal(r1.dtype, np.float32)
550 assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
551
552 def test_gamma_floats(self):
553 bit_generator = self._create_rng().bit_generator
554 rg = Generator(bit_generator())
555 warmup(rg)
556 state = rg.bit_generator.state
557 r1 = rg.standard_gamma(4.0, 11, dtype=np.float32)
558 rg2 = Generator(bit_generator())
559 warmup(rg2)
560 rg2.bit_generator.state = state
561 r2 = rg2.standard_gamma(4.0, 11, dtype=np.float32)
562 assert_array_equal(r1, r2)
563 assert_equal(r1.dtype, np.float32)
564 assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
565
566 def test_normal_floats(self):
567 bit_generator = self._create_rng().bit_generator
568 rg = Generator(bit_generator())
569 warmup(rg)
570 state = rg.bit_generator.state
571 r1 = rg.standard_normal(11, dtype=np.float32)
572 rg2 = Generator(bit_generator())
573 warmup(rg2)
574 rg2.bit_generator.state = state
575 r2 = rg2.standard_normal(11, dtype=np.float32)
576 assert_array_equal(r1, r2)
577 assert_equal(r1.dtype, np.float32)
578 assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
579
580 def test_normal_zig_floats(self):
581 bit_generator = self._create_rng().bit_generator
582 rg = Generator(bit_generator())
583 warmup(rg)
584 state = rg.bit_generator.state
585 r1 = rg.standard_normal(11, dtype=np.float32)
586 rg2 = Generator(bit_generator())
587 warmup(rg2)
588 rg2.bit_generator.state = state
589 r2 = rg2.standard_normal(11, dtype=np.float32)
590 assert_array_equal(r1, r2)
591 assert_equal(r1.dtype, np.float32)
592 assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
593
594 def test_output_fill(self):
595 rg = self._create_rng().rg
596 state = rg.bit_generator.state
597 size = (31, 7, 97)
598 existing = np.empty(size)
599 rg.bit_generator.state = state
600 rg.standard_normal(out=existing)
601 rg.bit_generator.state = state
602 direct = rg.standard_normal(size=size)
603 assert_equal(direct, existing)
604
605 sized = np.empty(size)
606 rg.bit_generator.state = state
607 rg.standard_normal(out=sized, size=sized.shape)
608
609 existing = np.empty(size, dtype=np.float32)
610 rg.bit_generator.state = state
611 rg.standard_normal(out=existing, dtype=np.float32)
612 rg.bit_generator.state = state
613 direct = rg.standard_normal(size=size, dtype=np.float32)
614 assert_equal(direct, existing)
615
616 def test_output_filling_uniform(self):
617 rg = self._create_rng().rg
618 state = rg.bit_generator.state
619 size = (31, 7, 97)
620 existing = np.empty(size)
621 rg.bit_generator.state = state
622 rg.random(out=existing)
623 rg.bit_generator.state = state
624 direct = rg.random(size=size)
625 assert_equal(direct, existing)
626
627 existing = np.empty(size, dtype=np.float32)
628 rg.bit_generator.state = state
629 rg.random(out=existing, dtype=np.float32)
630 rg.bit_generator.state = state
631 direct = rg.random(size=size, dtype=np.float32)
632 assert_equal(direct, existing)
633
634 def test_output_filling_exponential(self):
635 rg = self._create_rng().rg
636 state = rg.bit_generator.state
637 size = (31, 7, 97)
638 existing = np.empty(size)
639 rg.bit_generator.state = state
640 rg.standard_exponential(out=existing)
641 rg.bit_generator.state = state
642 direct = rg.standard_exponential(size=size)
643 assert_equal(direct, existing)
644
645 existing = np.empty(size, dtype=np.float32)
646 rg.bit_generator.state = state
647 rg.standard_exponential(out=existing, dtype=np.float32)
648 rg.bit_generator.state = state
649 direct = rg.standard_exponential(size=size, dtype=np.float32)
650 assert_equal(direct, existing)
651
652 def test_output_filling_gamma(self):
653 rg = self._create_rng().rg
654 state = rg.bit_generator.state
655 size = (31, 7, 97)
656 existing = np.zeros(size)
657 rg.bit_generator.state = state
658 rg.standard_gamma(1.0, out=existing)
659 rg.bit_generator.state = state
660 direct = rg.standard_gamma(1.0, size=size)
661 assert_equal(direct, existing)
662
663 existing = np.zeros(size, dtype=np.float32)
664 rg.bit_generator.state = state
665 rg.standard_gamma(1.0, out=existing, dtype=np.float32)
666 rg.bit_generator.state = state
667 direct = rg.standard_gamma(1.0, size=size, dtype=np.float32)
668 assert_equal(direct, existing)
669
670 def test_output_filling_gamma_broadcast(self):
671 rg = self._create_rng().rg
672 state = rg.bit_generator.state
673 size = (31, 7, 97)
674 mu = np.arange(97.0) + 1.0
675 existing = np.zeros(size)
676 rg.bit_generator.state = state
677 rg.standard_gamma(mu, out=existing)
678 rg.bit_generator.state = state
679 direct = rg.standard_gamma(mu, size=size)
680 assert_equal(direct, existing)
681
682 existing = np.zeros(size, dtype=np.float32)
683 rg.bit_generator.state = state
684 rg.standard_gamma(mu, out=existing, dtype=np.float32)
685 rg.bit_generator.state = state
686 direct = rg.standard_gamma(mu, size=size, dtype=np.float32)
687 assert_equal(direct, existing)
688
689 def test_output_fill_error(self):
690 rg = self._create_rng().rg
691 size = (31, 7, 97)
692 existing = np.empty(size)
693 with pytest.raises(TypeError):
694 rg.standard_normal(out=existing, dtype=np.float32)
695 with pytest.raises(ValueError):
696 rg.standard_normal(out=existing[::3])
697 existing = np.empty(size, dtype=np.float32)
698 with pytest.raises(TypeError):
699 rg.standard_normal(out=existing, dtype=np.float64)
700
701 existing = np.zeros(size, dtype=np.float32)
702 with pytest.raises(TypeError):
703 rg.standard_gamma(1.0, out=existing, dtype=np.float64)
704 with pytest.raises(ValueError):
705 rg.standard_gamma(1.0, out=existing[::3], dtype=np.float32)
706 existing = np.zeros(size, dtype=np.float64)
707 with pytest.raises(TypeError):
708 rg.standard_gamma(1.0, out=existing, dtype=np.float32)
709 with pytest.raises(ValueError):
710 rg.standard_gamma(1.0, out=existing[::3])
711
712 @pytest.mark.parametrize("dtype", DTYPES_BOOL_INT_UINT)
713 def test_integers_broadcast(self, dtype):
714 rg = self._create_rng().rg
715 initial_state = rg.bit_generator.state
716
717 def reset_state(rng):
718 rng.bit_generator.state = initial_state
719
720 if dtype == np.bool:
721 upper = 2
722 lower = 0
723 else:
724 info = np.iinfo(dtype)
725 upper = int(info.max) + 1
726 lower = info.min
727 reset_state(rg)
728 rg.bit_generator.state = initial_state
729 a = rg.integers(lower, [upper] * 10, dtype=dtype)
730 reset_state(rg)
731 b = rg.integers([lower] * 10, upper, dtype=dtype)
732 assert_equal(a, b)
733 reset_state(rg)
734 c = rg.integers(lower, upper, size=10, dtype=dtype)
735 assert_equal(a, c)
736 reset_state(rg)
737 d = rg.integers(np.array(
738 [lower] * 10), np.array([upper], dtype=object), size=10,
739 dtype=dtype)
740 assert_equal(a, d)
741 reset_state(rg)
742 e = rg.integers(
743 np.array([lower] * 10), np.array([upper] * 10), size=10,
744 dtype=dtype)
745 assert_equal(a, e)
746
747 reset_state(rg)
748 a = rg.integers(0, upper, size=10, dtype=dtype)
749 reset_state(rg)
750 b = rg.integers([upper] * 10, dtype=dtype)
751 assert_equal(a, b)
752
753 @pytest.mark.parametrize("dtype", DTYPES_BOOL_INT_UINT)
754 def test_integers_numpy(self, dtype):
755 rg = self._create_rng().rg
756 high = np.array([1])
757 low = np.array([0])
758
759 out = rg.integers(low, high, dtype=dtype)
760 assert out.shape == (1,)
761
762 out = rg.integers(low[0], high, dtype=dtype)
763 assert out.shape == (1,)
764
765 out = rg.integers(low, high[0], dtype=dtype)
766 assert out.shape == (1,)
767
768 @pytest.mark.parametrize("dtype", DTYPES_BOOL_INT_UINT)
769 def test_integers_broadcast_errors(self, dtype):
770 rg = self._create_rng().rg
771 if dtype == np.bool:
772 upper = 2
773 lower = 0
774 else:
775 info = np.iinfo(dtype)
776 upper = int(info.max) + 1
777 lower = info.min
778 with pytest.raises(ValueError):
779 rg.integers(lower, [upper + 1] * 10, dtype=dtype)
780 with pytest.raises(ValueError):
781 rg.integers(lower - 1, [upper] * 10, dtype=dtype)
782 with pytest.raises(ValueError):
783 rg.integers([lower - 1], [upper] * 10, dtype=dtype)
784 with pytest.raises(ValueError):
785 rg.integers([0], [0], dtype=dtype)
786
787
788class TestMT19937(RNG):
789 @classmethod
790 def _create_rng(cls):
791 bit_generator = MT19937
792 advance = None
793 seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
794 rg = Generator(bit_generator(*seed))
795 seed_vector_bits = 32
796 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
797
798 def test_numpy_state(self):
799 rg = self._create_rng().rg
800 nprg = np.random.RandomState()
801 nprg.standard_normal(99)
802 state = nprg.get_state()
803 rg.bit_generator.state = state
804 state2 = rg.bit_generator.state
805 assert_((state[1] == state2['state']['key']).all())
806 assert_(state[2] == state2['state']['pos'])
807
808
809class TestPhilox(RNG):
810 @classmethod
811 def _create_rng(cls):
812 bit_generator = Philox
813 advance = 2**63 + 2**31 + 2**15 + 1
814 seed = [12345]
815 rg = Generator(bit_generator(*seed))
816 seed_vector_bits = 64
817 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
818
819
820class TestSFC64(RNG):
821 @classmethod
822 def _create_rng(cls):
823 bit_generator = SFC64
824 advance = None
825 seed = [12345]
826 rg = Generator(bit_generator(*seed))
827 seed_vector_bits = 192
828 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
829
830
831class TestPCG64(RNG):
832 @classmethod
833 def _create_rng(cls):
834 bit_generator = PCG64
835 advance = 2**63 + 2**31 + 2**15 + 1
836 seed = [12345]
837 rg = Generator(bit_generator(*seed))
838 seed_vector_bits = 64
839 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
840
841
842class TestPCG64DXSM(RNG):
843 @classmethod
844 def _create_rng(cls):
845 bit_generator = PCG64DXSM
846 advance = 2**63 + 2**31 + 2**15 + 1
847 seed = [12345]
848 rg = Generator(bit_generator(*seed))
849 seed_vector_bits = 64
850 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
851
852
853class TestDefaultRNG(RNG):
854 @classmethod
855 def _create_rng(cls):
856 # This will duplicate some tests that directly instantiate a fresh
857 # Generator(), but that's okay.
858 bit_generator = PCG64
859 advance = 2**63 + 2**31 + 2**15 + 1
860 seed = [12345]
861 rg = np.random.default_rng(*seed)
862 seed_vector_bits = 64
863 return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
864
865 def test_default_is_pcg64(self):
866 # In order to change the default BitGenerator, we'll go through
867 # a deprecation cycle to move to a different function.
868 rg = self._create_rng().rg
869 assert_(isinstance(rg.bit_generator, PCG64))
870
871 def test_seed(self):
872 np.random.default_rng()
873 np.random.default_rng(None)
874 np.random.default_rng(12345)
875 np.random.default_rng(0)
876 np.random.default_rng(43660444402423911716352051725018508569)
877 np.random.default_rng([43660444402423911716352051725018508569,
878 279705150948142787361475340226491943209])
879 with pytest.raises(ValueError):
880 np.random.default_rng(-1)
881 with pytest.raises(ValueError):
882 np.random.default_rng([12345, -1])
883