codekingpro/portable-devtools
115k
1import sys
2import warnings
3
4import pytest
5
6import numpy as np
7from numpy import random
8from numpy.testing import (
9 IS_WASM,
10 assert_,
11 assert_array_almost_equal,
12 assert_array_equal,
13 assert_equal,
14 assert_no_warnings,
15 assert_raises,
16)
17
18
19class TestSeed:
20 def test_scalar(self):
21 s = np.random.RandomState(0)
22 assert_equal(s.randint(1000), 684)
23 s = np.random.RandomState(4294967295)
24 assert_equal(s.randint(1000), 419)
25
26 def test_array(self):
27 s = np.random.RandomState(range(10))
28 assert_equal(s.randint(1000), 468)
29 s = np.random.RandomState(np.arange(10))
30 assert_equal(s.randint(1000), 468)
31 s = np.random.RandomState([0])
32 assert_equal(s.randint(1000), 973)
33 s = np.random.RandomState([4294967295])
34 assert_equal(s.randint(1000), 265)
35
36 def test_invalid_scalar(self):
37 # seed must be an unsigned 32 bit integer
38 assert_raises(TypeError, np.random.RandomState, -0.5)
39 assert_raises(ValueError, np.random.RandomState, -1)
40
41 def test_invalid_array(self):
42 # seed must be an unsigned 32 bit integer
43 assert_raises(TypeError, np.random.RandomState, [-0.5])
44 assert_raises(ValueError, np.random.RandomState, [-1])
45 assert_raises(ValueError, np.random.RandomState, [4294967296])
46 assert_raises(ValueError, np.random.RandomState, [1, 2, 4294967296])
47 assert_raises(ValueError, np.random.RandomState, [1, -2, 4294967296])
48
49 def test_invalid_array_shape(self):
50 # gh-9832
51 assert_raises(ValueError, np.random.RandomState,
52 np.array([], dtype=np.int64))
53 assert_raises(ValueError, np.random.RandomState, [[1, 2, 3]])
54 assert_raises(ValueError, np.random.RandomState, [[1, 2, 3],
55 [4, 5, 6]])
56
57
58class TestBinomial:
59 def test_n_zero(self):
60 # Tests the corner case of n == 0 for the binomial distribution.
61 # binomial(0, p) should be zero for any p in [0, 1].
62 # This test addresses issue #3480.
63 zeros = np.zeros(2, dtype='int')
64 for p in [0, .5, 1]:
65 assert_(random.binomial(0, p) == 0)
66 assert_array_equal(random.binomial(zeros, p), zeros)
67
68 def test_p_is_nan(self):
69 # Issue #4571.
70 assert_raises(ValueError, random.binomial, 1, np.nan)
71
72
73class TestMultinomial:
74 def test_basic(self):
75 random.multinomial(100, [0.2, 0.8])
76
77 def test_zero_probability(self):
78 random.multinomial(100, [0.2, 0.8, 0.0, 0.0, 0.0])
79
80 def test_int_negative_interval(self):
81 assert_(-5 <= random.randint(-5, -1) < -1)
82 x = random.randint(-5, -1, 5)
83 assert_(np.all(-5 <= x))
84 assert_(np.all(x < -1))
85
86 def test_size(self):
87 # gh-3173
88 p = [0.5, 0.5]
89 assert_equal(np.random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
90 assert_equal(np.random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
91 assert_equal(np.random.multinomial(1, p, np.uint32(1)).shape, (1, 2))
92 assert_equal(np.random.multinomial(1, p, [2, 2]).shape, (2, 2, 2))
93 assert_equal(np.random.multinomial(1, p, (2, 2)).shape, (2, 2, 2))
94 assert_equal(np.random.multinomial(1, p, np.array((2, 2))).shape,
95 (2, 2, 2))
96
97 assert_raises(TypeError, np.random.multinomial, 1, p,
98 float(1))
99
100 def test_multidimensional_pvals(self):
101 assert_raises(ValueError, np.random.multinomial, 10, [[0, 1]])
102 assert_raises(ValueError, np.random.multinomial, 10, [[0], [1]])
103 assert_raises(ValueError, np.random.multinomial, 10, [[[0], [1]], [[1], [0]]])
104 assert_raises(ValueError, np.random.multinomial, 10, np.array([[0, 1], [1, 0]]))
105
106
107class TestSetState:
108 def _create_rng(self):
109 seed = 1234567890
110 prng = random.RandomState(seed)
111 state = prng.get_state()
112 return prng, state
113
114 def test_basic(self):
115 prng, state = self._create_rng()
116 old = prng.tomaxint(16)
117 prng.set_state(state)
118 new = prng.tomaxint(16)
119 assert_(np.all(old == new))
120
121 def test_gaussian_reset(self):
122 # Make sure the cached every-other-Gaussian is reset.
123 prng, state = self._create_rng()
124 old = prng.standard_normal(size=3)
125 prng.set_state(state)
126 new = prng.standard_normal(size=3)
127 assert_(np.all(old == new))
128
129 def test_gaussian_reset_in_media_res(self):
130 # When the state is saved with a cached Gaussian, make sure the
131 # cached Gaussian is restored.
132 prng, state = self._create_rng()
133 prng.standard_normal()
134 state = prng.get_state()
135 old = prng.standard_normal(size=3)
136 prng.set_state(state)
137 new = prng.standard_normal(size=3)
138 assert_(np.all(old == new))
139
140 def test_backwards_compatibility(self):
141 # Make sure we can accept old state tuples that do not have the
142 # cached Gaussian value.
143 prng, state = self._create_rng()
144 old_state = state[:-2]
145 x1 = prng.standard_normal(size=16)
146 prng.set_state(old_state)
147 x2 = prng.standard_normal(size=16)
148 prng.set_state(state)
149 x3 = prng.standard_normal(size=16)
150 assert_(np.all(x1 == x2))
151 assert_(np.all(x1 == x3))
152
153 def test_negative_binomial(self):
154 # Ensure that the negative binomial results take floating point
155 # arguments without truncation.
156 prng, _ = self._create_rng()
157 prng.negative_binomial(0.5, 0.5)
158
159 def test_set_invalid_state(self):
160 # gh-25402
161 prng, _ = self._create_rng()
162 with pytest.raises(IndexError):
163 prng.set_state(())
164
165
166class TestRandint:
167
168 # valid integer/boolean types
169 itype = [np.bool, np.int8, np.uint8, np.int16, np.uint16,
170 np.int32, np.uint32, np.int64, np.uint64]
171
172 def test_unsupported_type(self):
173 rng = random.RandomState()
174 assert_raises(TypeError, rng.randint, 1, dtype=float)
175
176 def test_bounds_checking(self):
177 rng = random.RandomState()
178 for dt in self.itype:
179 lbnd = 0 if dt is np.bool else np.iinfo(dt).min
180 ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
181 assert_raises(ValueError, rng.randint, lbnd - 1, ubnd, dtype=dt)
182 assert_raises(ValueError, rng.randint, lbnd, ubnd + 1, dtype=dt)
183 assert_raises(ValueError, rng.randint, ubnd, lbnd, dtype=dt)
184 assert_raises(ValueError, rng.randint, 1, 0, dtype=dt)
185
186 def test_rng_zero_and_extremes(self):
187 rng = random.RandomState()
188 for dt in self.itype:
189 lbnd = 0 if dt is np.bool else np.iinfo(dt).min
190 ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
191
192 tgt = ubnd - 1
193 assert_equal(rng.randint(tgt, tgt + 1, size=1000, dtype=dt), tgt)
194
195 tgt = lbnd
196 assert_equal(rng.randint(tgt, tgt + 1, size=1000, dtype=dt), tgt)
197
198 tgt = (lbnd + ubnd) // 2
199 assert_equal(rng.randint(tgt, tgt + 1, size=1000, dtype=dt), tgt)
200
201 def test_full_range(self):
202 # Test for ticket #1690
203 rng = random.RandomState()
204
205 for dt in self.itype:
206 lbnd = 0 if dt is np.bool else np.iinfo(dt).min
207 ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
208
209 try:
210 rng.randint(lbnd, ubnd, dtype=dt)
211 except Exception as e:
212 raise AssertionError("No error should have been raised, "
213 "but one was with the following "
214 "message:\n\n%s" % str(e))
215
216 def test_in_bounds_fuzz(self):
217 # Don't use fixed seed
218 rng = random.RandomState()
219
220 for dt in self.itype[1:]:
221 for ubnd in [4, 8, 16]:
222 vals = rng.randint(2, ubnd, size=2**16, dtype=dt)
223 assert_(vals.max() < ubnd)
224 assert_(vals.min() >= 2)
225
226 vals = rng.randint(0, 2, size=2**16, dtype=np.bool)
227
228 assert_(vals.max() < 2)
229 assert_(vals.min() >= 0)
230
231 def test_repeatability(self):
232 import hashlib
233 # We use a sha256 hash of generated sequences of 1000 samples
234 # in the range [0, 6) for all but bool, where the range
235 # is [0, 2). Hashes are for little endian numbers.
236 tgt = {'bool': '509aea74d792fb931784c4b0135392c65aec64beee12b0cc167548a2c3d31e71', # noqa: E501
237 'int16': '7b07f1a920e46f6d0fe02314155a2330bcfd7635e708da50e536c5ebb631a7d4', # noqa: E501
238 'int32': 'e577bfed6c935de944424667e3da285012e741892dcb7051a8f1ce68ab05c92f', # noqa: E501
239 'int64': '0fbead0b06759df2cfb55e43148822d4a1ff953c7eb19a5b08445a63bb64fa9e', # noqa: E501
240 'int8': '001aac3a5acb935a9b186cbe14a1ca064b8bb2dd0b045d48abeacf74d0203404', # noqa: E501
241 'uint16': '7b07f1a920e46f6d0fe02314155a2330bcfd7635e708da50e536c5ebb631a7d4', # noqa: E501
242 'uint32': 'e577bfed6c935de944424667e3da285012e741892dcb7051a8f1ce68ab05c92f', # noqa: E501
243 'uint64': '0fbead0b06759df2cfb55e43148822d4a1ff953c7eb19a5b08445a63bb64fa9e', # noqa: E501
244 'uint8': '001aac3a5acb935a9b186cbe14a1ca064b8bb2dd0b045d48abeacf74d0203404'} # noqa: E501
245
246 for dt in self.itype[1:]:
247 rng = random.RandomState(1234)
248
249 # view as little endian for hash
250 if sys.byteorder == 'little':
251 val = rng.randint(0, 6, size=1000, dtype=dt)
252 else:
253 val = rng.randint(0, 6, size=1000, dtype=dt).byteswap()
254
255 res = hashlib.sha256(val.view(np.int8)).hexdigest()
256 assert_(tgt[np.dtype(dt).name] == res)
257
258 # bools do not depend on endianness
259 rng = random.RandomState(1234)
260 val = rng.randint(0, 2, size=1000, dtype=bool).view(np.int8)
261 res = hashlib.sha256(val).hexdigest()
262 assert_(tgt[np.dtype(bool).name] == res)
263
264 def test_int64_uint64_corner_case(self):
265 # When stored in Numpy arrays, `lbnd` is casted
266 # as np.int64, and `ubnd` is casted as np.uint64.
267 # Checking whether `lbnd` >= `ubnd` used to be
268 # done solely via direct comparison, which is incorrect
269 # because when Numpy tries to compare both numbers,
270 # it casts both to np.float64 because there is
271 # no integer superset of np.int64 and np.uint64. However,
272 # `ubnd` is too large to be represented in np.float64,
273 # causing it be round down to np.iinfo(np.int64).max,
274 # leading to a ValueError because `lbnd` now equals
275 # the new `ubnd`.
276
277 dt = np.int64
278 tgt = np.iinfo(np.int64).max
279 lbnd = np.int64(np.iinfo(np.int64).max)
280 ubnd = np.uint64(np.iinfo(np.int64).max + 1)
281
282 # None of these function calls should
283 # generate a ValueError now.
284 actual = np.random.randint(lbnd, ubnd, dtype=dt)
285 assert_equal(actual, tgt)
286
287 def test_respect_dtype_singleton(self):
288 # See gh-7203
289 rng = random.RandomState()
290 for dt in self.itype:
291 lbnd = 0 if dt is np.bool else np.iinfo(dt).min
292 ubnd = 2 if dt is np.bool else np.iinfo(dt).max + 1
293
294 sample = rng.randint(lbnd, ubnd, dtype=dt)
295 assert_equal(sample.dtype, np.dtype(dt))
296
297 for dt in (bool, int):
298 # The legacy rng uses "long" as the default integer:
299 lbnd = 0 if dt is bool else np.iinfo("long").min
300 ubnd = 2 if dt is bool else np.iinfo("long").max + 1
301
302 # gh-7284: Ensure that we get Python data types
303 sample = rng.randint(lbnd, ubnd, dtype=dt)
304 assert_(not hasattr(sample, 'dtype'))
305 assert_equal(type(sample), dt)
306
307
308class TestRandomDist:
309 # Make sure the random distribution returns the correct value for a
310 # given seed
311 seed = 1234567890
312
313 def test_rand(self):
314 rng = random.RandomState(self.seed)
315 actual = rng.rand(3, 2)
316 desired = np.array([[0.61879477158567997, 0.59162362775974664],
317 [0.88868358904449662, 0.89165480011560816],
318 [0.4575674820298663, 0.7781880808593471]])
319 assert_array_almost_equal(actual, desired, decimal=15)
320
321 def test_randn(self):
322 rng = random.RandomState(self.seed)
323 actual = rng.randn(3, 2)
324 desired = np.array([[1.34016345771863121, 1.73759122771936081],
325 [1.498988344300628, -0.2286433324536169],
326 [2.031033998682787, 2.17032494605655257]])
327 assert_array_almost_equal(actual, desired, decimal=15)
328
329 def test_randint(self):
330 rng = random.RandomState(self.seed)
331 actual = rng.randint(-99, 99, size=(3, 2))
332 desired = np.array([[31, 3],
333 [-52, 41],
334 [-48, -66]])
335 assert_array_equal(actual, desired)
336
337 def test_random_integers(self):
338 rng = random.RandomState(self.seed)
339 with pytest.warns(DeprecationWarning):
340 actual = rng.random_integers(-99, 99, size=(3, 2))
341 desired = np.array([[31, 3],
342 [-52, 41],
343 [-48, -66]])
344 assert_array_equal(actual, desired)
345
346 def test_random_integers_max_int(self):
347 # Tests whether random_integers can generate the
348 # maximum allowed Python int that can be converted
349 # into a C long. Previous implementations of this
350 # method have thrown an OverflowError when attempting
351 # to generate this integer.
352 with pytest.warns(DeprecationWarning):
353 actual = np.random.random_integers(np.iinfo('l').max,
354 np.iinfo('l').max)
355
356 desired = np.iinfo('l').max
357 assert_equal(actual, desired)
358
359 def test_random_integers_deprecated(self):
360 with warnings.catch_warnings():
361 warnings.simplefilter("error", DeprecationWarning)
362
363 # DeprecationWarning raised with high == None
364 assert_raises(DeprecationWarning,
365 np.random.random_integers,
366 np.iinfo('l').max)
367
368 # DeprecationWarning raised with high != None
369 assert_raises(DeprecationWarning,
370 np.random.random_integers,
371 np.iinfo('l').max, np.iinfo('l').max)
372
373 def test_random(self):
374 rng = random.RandomState(self.seed)
375 actual = rng.random((3, 2))
376 desired = np.array([[0.61879477158567997, 0.59162362775974664],
377 [0.88868358904449662, 0.89165480011560816],
378 [0.4575674820298663, 0.7781880808593471]])
379 assert_array_almost_equal(actual, desired, decimal=15)
380
381 def test_choice_uniform_replace(self):
382 rng = random.RandomState(self.seed)
383 actual = rng.choice(4, 4)
384 desired = np.array([2, 3, 2, 3])
385 assert_array_equal(actual, desired)
386
387 def test_choice_nonuniform_replace(self):
388 rng = random.RandomState(self.seed)
389 actual = rng.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1])
390 desired = np.array([1, 1, 2, 2])
391 assert_array_equal(actual, desired)
392
393 def test_choice_uniform_noreplace(self):
394 rng = random.RandomState(self.seed)
395 actual = rng.choice(4, 3, replace=False)
396 desired = np.array([0, 1, 3])
397 assert_array_equal(actual, desired)
398
399 def test_choice_nonuniform_noreplace(self):
400 rng = random.RandomState(self.seed)
401 actual = rng.choice(4, 3, replace=False,
402 p=[0.1, 0.3, 0.5, 0.1])
403 desired = np.array([2, 3, 1])
404 assert_array_equal(actual, desired)
405
406 def test_choice_noninteger(self):
407 rng = random.RandomState(self.seed)
408 actual = rng.choice(['a', 'b', 'c', 'd'], 4)
409 desired = np.array(['c', 'd', 'c', 'd'])
410 assert_array_equal(actual, desired)
411
412 def test_choice_exceptions(self):
413 sample = np.random.choice
414 assert_raises(ValueError, sample, -1, 3)
415 assert_raises(ValueError, sample, 3., 3)
416 assert_raises(ValueError, sample, [[1, 2], [3, 4]], 3)
417 assert_raises(ValueError, sample, [], 3)
418 assert_raises(ValueError, sample, [1, 2, 3, 4], 3,
419 p=[[0.25, 0.25], [0.25, 0.25]])
420 assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4, 0.2])
421 assert_raises(ValueError, sample, [1, 2], 3, p=[1.1, -0.1])
422 assert_raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4])
423 assert_raises(ValueError, sample, [1, 2, 3], 4, replace=False)
424 # gh-13087
425 assert_raises(ValueError, sample, [1, 2, 3], -2, replace=False)
426 assert_raises(ValueError, sample, [1, 2, 3], (-1,), replace=False)
427 assert_raises(ValueError, sample, [1, 2, 3], (-1, 1), replace=False)
428 assert_raises(ValueError, sample, [1, 2, 3], 2,
429 replace=False, p=[1, 0, 0])
430
431 def test_choice_return_shape(self):
432 p = [0.1, 0.9]
433 # Check scalar
434 assert_(np.isscalar(np.random.choice(2, replace=True)))
435 assert_(np.isscalar(np.random.choice(2, replace=False)))
436 assert_(np.isscalar(np.random.choice(2, replace=True, p=p)))
437 assert_(np.isscalar(np.random.choice(2, replace=False, p=p)))
438 assert_(np.isscalar(np.random.choice([1, 2], replace=True)))
439 assert_(np.random.choice([None], replace=True) is None)
440 a = np.array([1, 2])
441 arr = np.empty(1, dtype=object)
442 arr[0] = a
443 assert_(np.random.choice(arr, replace=True) is a)
444
445 # Check 0-d array
446 s = ()
447 assert_(not np.isscalar(np.random.choice(2, s, replace=True)))
448 assert_(not np.isscalar(np.random.choice(2, s, replace=False)))
449 assert_(not np.isscalar(np.random.choice(2, s, replace=True, p=p)))
450 assert_(not np.isscalar(np.random.choice(2, s, replace=False, p=p)))
451 assert_(not np.isscalar(np.random.choice([1, 2], s, replace=True)))
452 assert_(np.random.choice([None], s, replace=True).ndim == 0)
453 a = np.array([1, 2])
454 arr = np.empty(1, dtype=object)
455 arr[0] = a
456 assert_(np.random.choice(arr, s, replace=True).item() is a)
457
458 # Check multi dimensional array
459 s = (2, 3)
460 p = [0.1, 0.1, 0.1, 0.1, 0.4, 0.2]
461 assert_equal(np.random.choice(6, s, replace=True).shape, s)
462 assert_equal(np.random.choice(6, s, replace=False).shape, s)
463 assert_equal(np.random.choice(6, s, replace=True, p=p).shape, s)
464 assert_equal(np.random.choice(6, s, replace=False, p=p).shape, s)
465 assert_equal(np.random.choice(np.arange(6), s, replace=True).shape, s)
466
467 # Check zero-size
468 assert_equal(np.random.randint(0, 0, size=(3, 0, 4)).shape, (3, 0, 4))
469 assert_equal(np.random.randint(0, -10, size=0).shape, (0,))
470 assert_equal(np.random.randint(10, 10, size=0).shape, (0,))
471 assert_equal(np.random.choice(0, size=0).shape, (0,))
472 assert_equal(np.random.choice([], size=(0,)).shape, (0,))
473 assert_equal(np.random.choice(['a', 'b'], size=(3, 0, 4)).shape,
474 (3, 0, 4))
475 assert_raises(ValueError, np.random.choice, [], 10)
476
477 def test_choice_nan_probabilities(self):
478 a = np.array([42, 1, 2])
479 p = [None, None, None]
480 assert_raises(ValueError, np.random.choice, a, p=p)
481
482 def test_bytes(self):
483 rng = random.RandomState(self.seed)
484 actual = rng.bytes(10)
485 desired = b'\x82Ui\x9e\xff\x97+Wf\xa5'
486 assert_equal(actual, desired)
487
488 def test_shuffle(self):
489 # Test lists, arrays (of various dtypes), and multidimensional versions
490 # of both, c-contiguous or not:
491 for conv in [lambda x: np.array([]),
492 lambda x: x,
493 lambda x: np.asarray(x).astype(np.int8),
494 lambda x: np.asarray(x).astype(np.float32),
495 lambda x: np.asarray(x).astype(np.complex64),
496 lambda x: np.asarray(x).astype(object),
497 lambda x: [(i, i) for i in x],
498 lambda x: np.asarray([[i, i] for i in x]),
499 lambda x: np.vstack([x, x]).T,
500 # gh-11442
501 lambda x: (np.asarray([(i, i) for i in x],
502 [("a", int), ("b", int)])
503 .view(np.recarray)),
504 # gh-4270
505 lambda x: np.asarray([(i, i) for i in x],
506 [("a", object), ("b", np.int32)])]:
507 rng = random.RandomState(self.seed)
508 alist = conv([1, 2, 3, 4, 5, 6, 7, 8, 9, 0])
509 rng.shuffle(alist)
510 actual = alist
511 desired = conv([0, 1, 9, 6, 2, 4, 5, 8, 7, 3])
512 assert_array_equal(actual, desired)
513
514 def test_shuffle_masked(self):
515 # gh-3263
516 a = np.ma.masked_values(np.reshape(range(20), (5, 4)) % 3 - 1, -1)
517 b = np.ma.masked_values(np.arange(20) % 3 - 1, -1)
518 a_orig = a.copy()
519 b_orig = b.copy()
520 for i in range(50):
521 np.random.shuffle(a)
522 assert_equal(
523 sorted(a.data[~a.mask]), sorted(a_orig.data[~a_orig.mask]))
524 np.random.shuffle(b)
525 assert_equal(
526 sorted(b.data[~b.mask]), sorted(b_orig.data[~b_orig.mask]))
527
528 @pytest.mark.parametrize("random",
529 [np.random, np.random.RandomState(), np.random.default_rng()])
530 def test_shuffle_untyped_warning(self, random):
531 # Create a dict works like a sequence but isn't one
532 values = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6}
533 with pytest.warns(UserWarning,
534 match="you are shuffling a 'dict' object") as rec:
535 random.shuffle(values)
536 assert "test_random" in rec[0].filename
537
538 @pytest.mark.parametrize("random",
539 [np.random, np.random.RandomState(), np.random.default_rng()])
540 @pytest.mark.parametrize("use_array_like", [True, False])
541 def test_shuffle_no_object_unpacking(self, random, use_array_like):
542 class MyArr(np.ndarray):
543 pass
544
545 items = [
546 None, np.array([3]), np.float64(3), np.array(10), np.float64(7)
547 ]
548 arr = np.array(items, dtype=object)
549 item_ids = {id(i) for i in items}
550 if use_array_like:
551 arr = arr.view(MyArr)
552
553 # The array was created fine, and did not modify any objects:
554 assert all(id(i) in item_ids for i in arr)
555
556 if use_array_like and not isinstance(random, np.random.Generator):
557 # The old API gives incorrect results, but warns about it.
558 with pytest.warns(UserWarning,
559 match="Shuffling a one dimensional array.*"):
560 random.shuffle(arr)
561 else:
562 random.shuffle(arr)
563 assert all(id(i) in item_ids for i in arr)
564
565 def test_shuffle_memoryview(self):
566 # gh-18273
567 # allow graceful handling of memoryviews
568 # (treat the same as arrays)
569 rng = random.RandomState(self.seed)
570 a = np.arange(5).data
571 rng.shuffle(a)
572 assert_equal(np.asarray(a), [0, 1, 4, 3, 2])
573 rng = random.RandomState(self.seed)
574 rng.shuffle(a)
575 assert_equal(np.asarray(a), [0, 1, 2, 3, 4])
576 rng = np.random.default_rng(self.seed)
577 rng.shuffle(a)
578 assert_equal(np.asarray(a), [4, 1, 0, 3, 2])
579
580 def test_shuffle_not_writeable(self):
581 a = np.zeros(3)
582 a.flags.writeable = False
583 with pytest.raises(ValueError, match='read-only'):
584 np.random.shuffle(a)
585
586 def test_beta(self):
587 rng = random.RandomState(self.seed)
588 actual = rng.beta(.1, .9, size=(3, 2))
589 desired = np.array(
590 [[1.45341850513746058e-02, 5.31297615662868145e-04],
591 [1.85366619058432324e-06, 4.19214516800110563e-03],
592 [1.58405155108498093e-04, 1.26252891949397652e-04]])
593 assert_array_almost_equal(actual, desired, decimal=15)
594
595 def test_binomial(self):
596 rng = random.RandomState(self.seed)
597 actual = rng.binomial(100, .456, size=(3, 2))
598 desired = np.array([[37, 43],
599 [42, 48],
600 [46, 45]])
601 assert_array_equal(actual, desired)
602
603 def test_chisquare(self):
604 rng = random.RandomState(self.seed)
605 actual = rng.chisquare(50, size=(3, 2))
606 desired = np.array([[63.87858175501090585, 68.68407748911370447],
607 [65.77116116901505904, 47.09686762438974483],
608 [72.3828403199695174, 74.18408615260374006]])
609 assert_array_almost_equal(actual, desired, decimal=13)
610
611 def test_dirichlet(self):
612 rng = random.RandomState(self.seed)
613 alpha = np.array([51.72840233779265162, 39.74494232180943953])
614 actual = rng.dirichlet(alpha, size=(3, 2))
615 desired = np.array([[[0.54539444573611562, 0.45460555426388438],
616 [0.62345816822039413, 0.37654183177960598]],
617 [[0.55206000085785778, 0.44793999914214233],
618 [0.58964023305154301, 0.41035976694845688]],
619 [[0.59266909280647828, 0.40733090719352177],
620 [0.56974431743975207, 0.43025568256024799]]])
621 assert_array_almost_equal(actual, desired, decimal=15)
622
623 def test_dirichlet_size(self):
624 # gh-3173
625 p = np.array([51.72840233779265162, 39.74494232180943953])
626 assert_equal(np.random.dirichlet(p, np.uint32(1)).shape, (1, 2))
627 assert_equal(np.random.dirichlet(p, np.uint32(1)).shape, (1, 2))
628 assert_equal(np.random.dirichlet(p, np.uint32(1)).shape, (1, 2))
629 assert_equal(np.random.dirichlet(p, [2, 2]).shape, (2, 2, 2))
630 assert_equal(np.random.dirichlet(p, (2, 2)).shape, (2, 2, 2))
631 assert_equal(np.random.dirichlet(p, np.array((2, 2))).shape, (2, 2, 2))
632
633 assert_raises(TypeError, np.random.dirichlet, p, float(1))
634
635 def test_dirichlet_bad_alpha(self):
636 # gh-2089
637 alpha = np.array([5.4e-01, -1.0e-16])
638 assert_raises(ValueError, np.random.mtrand.dirichlet, alpha)
639
640 # gh-15876
641 assert_raises(ValueError, random.dirichlet, [[5, 1]])
642 assert_raises(ValueError, random.dirichlet, [[5], [1]])
643 assert_raises(ValueError, random.dirichlet, [[[5], [1]], [[1], [5]]])
644 assert_raises(ValueError, random.dirichlet, np.array([[5, 1], [1, 5]]))
645
646 def test_exponential(self):
647 rng = random.RandomState(self.seed)
648 actual = rng.exponential(1.1234, size=(3, 2))
649 desired = np.array([[1.08342649775011624, 1.00607889924557314],
650 [2.46628830085216721, 2.49668106809923884],
651 [0.68717433461363442, 1.69175666993575979]])
652 assert_array_almost_equal(actual, desired, decimal=15)
653
654 def test_exponential_0(self):
655 assert_equal(np.random.exponential(scale=0), 0)
656 assert_raises(ValueError, np.random.exponential, scale=-0.)
657
658 def test_f(self):
659 rng = random.RandomState(self.seed)
660 actual = rng.f(12, 77, size=(3, 2))
661 desired = np.array([[1.21975394418575878, 1.75135759791559775],
662 [1.44803115017146489, 1.22108959480396262],
663 [1.02176975757740629, 1.34431827623300415]])
664 assert_array_almost_equal(actual, desired, decimal=15)
665
666 def test_gamma(self):
667 rng = random.RandomState(self.seed)
668 actual = rng.gamma(5, 3, size=(3, 2))
669 desired = np.array([[24.60509188649287182, 28.54993563207210627],
670 [26.13476110204064184, 12.56988482927716078],
671 [31.71863275789960568, 33.30143302795922011]])
672 assert_array_almost_equal(actual, desired, decimal=14)
673
674 def test_gamma_0(self):
675 assert_equal(np.random.gamma(shape=0, scale=0), 0)
676 assert_raises(ValueError, np.random.gamma, shape=-0., scale=-0.)
677
678 def test_geometric(self):
679 rng = random.RandomState(self.seed)
680 actual = rng.geometric(.123456789, size=(3, 2))
681 desired = np.array([[8, 7],
682 [17, 17],
683 [5, 12]])
684 assert_array_equal(actual, desired)
685
686 def test_gumbel(self):
687 rng = random.RandomState(self.seed)
688 actual = rng.gumbel(loc=.123456789, scale=2.0, size=(3, 2))
689 desired = np.array([[0.19591898743416816, 0.34405539668096674],
690 [-1.4492522252274278, -1.47374816298446865],
691 [1.10651090478803416, -0.69535848626236174]])
692 assert_array_almost_equal(actual, desired, decimal=15)
693
694 def test_gumbel_0(self):
695 assert_equal(np.random.gumbel(scale=0), 0)
696 assert_raises(ValueError, np.random.gumbel, scale=-0.)
697
698 def test_hypergeometric(self):
699 rng = random.RandomState(self.seed)
700 actual = rng.hypergeometric(10, 5, 14, size=(3, 2))
701 desired = np.array([[10, 10],
702 [10, 10],
703 [9, 9]])
704 assert_array_equal(actual, desired)
705
706 # Test nbad = 0
707 actual = rng.hypergeometric(5, 0, 3, size=4)
708 desired = np.array([3, 3, 3, 3])
709 assert_array_equal(actual, desired)
710
711 actual = rng.hypergeometric(15, 0, 12, size=4)
712 desired = np.array([12, 12, 12, 12])
713 assert_array_equal(actual, desired)
714
715 # Test ngood = 0
716 actual = rng.hypergeometric(0, 5, 3, size=4)
717 desired = np.array([0, 0, 0, 0])
718 assert_array_equal(actual, desired)
719
720 actual = rng.hypergeometric(0, 15, 12, size=4)
721 desired = np.array([0, 0, 0, 0])
722 assert_array_equal(actual, desired)
723
724 def test_laplace(self):
725 rng = random.RandomState(self.seed)
726 actual = rng.laplace(loc=.123456789, scale=2.0, size=(3, 2))
727 desired = np.array([[0.66599721112760157, 0.52829452552221945],
728 [3.12791959514407125, 3.18202813572992005],
729 [-0.05391065675859356, 1.74901336242837324]])
730 assert_array_almost_equal(actual, desired, decimal=15)
731
732 def test_laplace_0(self):
733 assert_equal(np.random.laplace(scale=0), 0)
734 assert_raises(ValueError, np.random.laplace, scale=-0.)
735
736 def test_logistic(self):
737 rng = random.RandomState(self.seed)
738 actual = rng.logistic(loc=.123456789, scale=2.0, size=(3, 2))
739 desired = np.array([[1.09232835305011444, 0.8648196662399954],
740 [4.27818590694950185, 4.33897006346929714],
741 [-0.21682183359214885, 2.63373365386060332]])
742 assert_array_almost_equal(actual, desired, decimal=15)
743
744 def test_lognormal(self):
745 rng = random.RandomState(self.seed)
746 actual = rng.lognormal(mean=.123456789, sigma=2.0, size=(3, 2))
747 desired = np.array([[16.50698631688883822, 36.54846706092654784],
748 [22.67886599981281748, 0.71617561058995771],
749 [65.72798501792723869, 86.84341601437161273]])
750 assert_array_almost_equal(actual, desired, decimal=13)
751
752 def test_lognormal_0(self):
753 assert_equal(np.random.lognormal(sigma=0), 1)
754 assert_raises(ValueError, np.random.lognormal, sigma=-0.)
755
756 def test_logseries(self):
757 rng = random.RandomState(self.seed)
758 actual = rng.logseries(p=.923456789, size=(3, 2))
759 desired = np.array([[2, 2],
760 [6, 17],
761 [3, 6]])
762 assert_array_equal(actual, desired)
763
764 def test_multinomial(self):
765 rng = random.RandomState(self.seed)
766 actual = rng.multinomial(20, [1 / 6.] * 6, size=(3, 2))
767 desired = np.array([[[4, 3, 5, 4, 2, 2],
768 [5, 2, 8, 2, 2, 1]],
769 [[3, 4, 3, 6, 0, 4],
770 [2, 1, 4, 3, 6, 4]],
771 [[4, 4, 2, 5, 2, 3],
772 [4, 3, 4, 2, 3, 4]]])
773 assert_array_equal(actual, desired)
774
775 def test_multivariate_normal(self):
776 rng = random.RandomState(self.seed)
777 mean = (.123456789, 10)
778 cov = [[1, 0], [0, 1]]
779 size = (3, 2)
780 actual = rng.multivariate_normal(mean, cov, size)
781 desired = np.array([[[1.463620246718631, 11.73759122771936],
782 [1.622445133300628, 9.771356667546383]],
783 [[2.154490787682787, 12.170324946056553],
784 [1.719909438201865, 9.230548443648306]],
785 [[0.689515026297799, 9.880729819607714],
786 [-0.023054015651998, 9.201096623542879]]])
787
788 assert_array_almost_equal(actual, desired, decimal=15)
789
790 # Check for default size, was raising deprecation warning
791 actual = rng.multivariate_normal(mean, cov)
792 desired = np.array([0.895289569463708, 9.17180864067987])
793 assert_array_almost_equal(actual, desired, decimal=15)
794
795 # Check that non positive-semidefinite covariance warns with
796 # RuntimeWarning
797 mean = [0, 0]
798 cov = [[1, 2], [2, 1]]
799 pytest.warns(RuntimeWarning, rng.multivariate_normal, mean, cov)
800
801 # and that it doesn't warn with RuntimeWarning check_valid='ignore'
802 assert_no_warnings(rng.multivariate_normal, mean, cov,
803 check_valid='ignore')
804
805 # and that it raises with RuntimeWarning check_valid='raises'
806 assert_raises(ValueError, rng.multivariate_normal, mean, cov,
807 check_valid='raise')
808
809 cov = np.array([[1, 0.1], [0.1, 1]], dtype=np.float32)
810 with warnings.catch_warnings():
811 warnings.simplefilter('error')
812 rng.multivariate_normal(mean, cov)
813
814 def test_negative_binomial(self):
815 rng = random.RandomState(self.seed)
816 actual = rng.negative_binomial(n=100, p=.12345, size=(3, 2))
817 desired = np.array([[848, 841],
818 [892, 611],
819 [779, 647]])
820 assert_array_equal(actual, desired)
821
822 def test_noncentral_chisquare(self):
823 rng = random.RandomState(self.seed)
824 actual = rng.noncentral_chisquare(df=5, nonc=5, size=(3, 2))
825 desired = np.array([[23.91905354498517511, 13.35324692733826346],
826 [31.22452661329736401, 16.60047399466177254],
827 [5.03461598262724586, 17.94973089023519464]])
828 assert_array_almost_equal(actual, desired, decimal=14)
829
830 actual = rng.noncentral_chisquare(df=.5, nonc=.2, size=(3, 2))
831 desired = np.array([[1.47145377828516666, 0.15052899268012659],
832 [0.00943803056963588, 1.02647251615666169],
833 [0.332334982684171, 0.15451287602753125]])
834 assert_array_almost_equal(actual, desired, decimal=14)
835
836 rng = random.RandomState(self.seed)
837 actual = rng.noncentral_chisquare(df=5, nonc=0, size=(3, 2))
838 desired = np.array([[9.597154162763948, 11.725484450296079],
839 [10.413711048138335, 3.694475922923986],
840 [13.484222138963087, 14.377255424602957]])
841 assert_array_almost_equal(actual, desired, decimal=14)
842
843 def test_noncentral_f(self):
844 rng = random.RandomState(self.seed)
845 actual = rng.noncentral_f(dfnum=5, dfden=2, nonc=1,
846 size=(3, 2))
847 desired = np.array([[1.40598099674926669, 0.34207973179285761],
848 [3.57715069265772545, 7.92632662577829805],
849 [0.43741599463544162, 1.1774208752428319]])
850 assert_array_almost_equal(actual, desired, decimal=14)
851
852 def test_normal(self):
853 rng = random.RandomState(self.seed)
854 actual = rng.normal(loc=.123456789, scale=2.0, size=(3, 2))
855 desired = np.array([[2.80378370443726244, 3.59863924443872163],
856 [3.121433477601256, -0.33382987590723379],
857 [4.18552478636557357, 4.46410668111310471]])
858 assert_array_almost_equal(actual, desired, decimal=15)
859
860 def test_normal_0(self):
861 assert_equal(np.random.normal(scale=0), 0)
862 assert_raises(ValueError, np.random.normal, scale=-0.)
863
864 def test_pareto(self):
865 rng = random.RandomState(self.seed)
866 actual = rng.pareto(a=.123456789, size=(3, 2))
867 desired = np.array(
868 [[2.46852460439034849e+03, 1.41286880810518346e+03],
869 [5.28287797029485181e+07, 6.57720981047328785e+07],
870 [1.40840323350391515e+02, 1.98390255135251704e+05]])
871 # For some reason on 32-bit x86 Ubuntu 12.10 the [1, 0] entry in this
872 # matrix differs by 24 nulps. Discussion:
873 # https://mail.python.org/pipermail/numpy-discussion/2012-September/063801.html
874 # Consensus is that this is probably some gcc quirk that affects
875 # rounding but not in any important way, so we just use a looser
876 # tolerance on this test:
877 np.testing.assert_array_almost_equal_nulp(actual, desired, nulp=30)
878
879 def test_poisson(self):
880 rng = random.RandomState(self.seed)
881 actual = rng.poisson(lam=.123456789, size=(3, 2))
882 desired = np.array([[0, 0],
883 [1, 0],
884 [0, 0]])
885 assert_array_equal(actual, desired)
886
887 def test_poisson_exceptions(self):
888 lambig = np.iinfo('l').max
889 lamneg = -1
890 assert_raises(ValueError, np.random.poisson, lamneg)
891 assert_raises(ValueError, np.random.poisson, [lamneg] * 10)
892 assert_raises(ValueError, np.random.poisson, lambig)
893 assert_raises(ValueError, np.random.poisson, [lambig] * 10)
894
895 def test_power(self):
896 rng = random.RandomState(self.seed)
897 actual = rng.power(a=.123456789, size=(3, 2))
898 desired = np.array([[0.02048932883240791, 0.01424192241128213],
899 [0.38446073748535298, 0.39499689943484395],
900 [0.00177699707563439, 0.13115505880863756]])
901 assert_array_almost_equal(actual, desired, decimal=15)
902
903 def test_rayleigh(self):
904 rng = random.RandomState(self.seed)
905 actual = rng.rayleigh(scale=10, size=(3, 2))
906 desired = np.array([[13.8882496494248393, 13.383318339044731],
907 [20.95413364294492098, 21.08285015800712614],
908 [11.06066537006854311, 17.35468505778271009]])
909 assert_array_almost_equal(actual, desired, decimal=14)
910
911 def test_rayleigh_0(self):
912 assert_equal(np.random.rayleigh(scale=0), 0)
913 assert_raises(ValueError, np.random.rayleigh, scale=-0.)
914
915 def test_standard_cauchy(self):
916 rng = random.RandomState(self.seed)
917 actual = rng.standard_cauchy(size=(3, 2))
918 desired = np.array([[0.77127660196445336, -6.55601161955910605],
919 [0.93582023391158309, -2.07479293013759447],
920 [-4.74601644297011926, 0.18338989290760804]])
921 assert_array_almost_equal(actual, desired, decimal=15)
922
923 def test_standard_exponential(self):
924 rng = random.RandomState(self.seed)
925 actual = rng.standard_exponential(size=(3, 2))
926 desired = np.array([[0.96441739162374596, 0.89556604882105506],
927 [2.1953785836319808, 2.22243285392490542],
928 [0.6116915921431676, 1.50592546727413201]])
929 assert_array_almost_equal(actual, desired, decimal=15)
930
931 def test_standard_gamma(self):
932 rng = random.RandomState(self.seed)
933 actual = rng.standard_gamma(shape=3, size=(3, 2))
934 desired = np.array([[5.50841531318455058, 6.62953470301903103],
935 [5.93988484943779227, 2.31044849402133989],
936 [7.54838614231317084, 8.012756093271868]])
937 assert_array_almost_equal(actual, desired, decimal=14)
938
939 def test_standard_gamma_0(self):
940 assert_equal(np.random.standard_gamma(shape=0), 0)
941 assert_raises(ValueError, np.random.standard_gamma, shape=-0.)
942
943 def test_standard_normal(self):
944 rng = random.RandomState(self.seed)
945 actual = rng.standard_normal(size=(3, 2))
946 desired = np.array([[1.34016345771863121, 1.73759122771936081],
947 [1.498988344300628, -0.2286433324536169],
948 [2.031033998682787, 2.17032494605655257]])
949 assert_array_almost_equal(actual, desired, decimal=15)
950
951 def test_standard_t(self):
952 rng = random.RandomState(self.seed)
953 actual = rng.standard_t(df=10, size=(3, 2))
954 desired = np.array([[0.97140611862659965, -0.08830486548450577],
955 [1.36311143689505321, -0.55317463909867071],
956 [-0.18473749069684214, 0.61181537341755321]])
957 assert_array_almost_equal(actual, desired, decimal=15)
958
959 def test_triangular(self):
960 rng = random.RandomState(self.seed)
961 actual = rng.triangular(left=5.12, mode=10.23, right=20.34,
962 size=(3, 2))
963 desired = np.array([[12.68117178949215784, 12.4129206149193152],
964 [16.20131377335158263, 16.25692138747600524],
965 [11.20400690911820263, 14.4978144835829923]])
966 assert_array_almost_equal(actual, desired, decimal=14)
967
968 def test_uniform(self):
969 rng = random.RandomState(self.seed)
970 actual = rng.uniform(low=1.23, high=10.54, size=(3, 2))
971 desired = np.array([[6.99097932346268003, 6.73801597444323974],
972 [9.50364421400426274, 9.53130618907631089],
973 [5.48995325769805476, 8.47493103280052118]])
974 assert_array_almost_equal(actual, desired, decimal=15)
975
976 def test_uniform_range_bounds(self):
977 fmin = np.finfo('float').min
978 fmax = np.finfo('float').max
979
980 func = np.random.uniform
981 assert_raises(OverflowError, func, -np.inf, 0)
982 assert_raises(OverflowError, func, 0, np.inf)
983 assert_raises(OverflowError, func, fmin, fmax)
984 assert_raises(OverflowError, func, [-np.inf], [0])
985 assert_raises(OverflowError, func, [0], [np.inf])
986
987 # (fmax / 1e17) - fmin is within range, so this should not throw
988 # account for i386 extended precision DBL_MAX / 1e17 + DBL_MAX >
989 # DBL_MAX by increasing fmin a bit
990 np.random.uniform(low=np.nextafter(fmin, 1), high=fmax / 1e17)
991
992 def test_scalar_exception_propagation(self):
993 # Tests that exceptions are correctly propagated in distributions
994 # when called with objects that throw exceptions when converted to
995 # scalars.
996 #
997 # Regression test for gh: 8865
998
999 class ThrowingFloat(np.ndarray):
1000 def __float__(self):
1001 raise TypeError
1002
1003 throwing_float = np.array(1.0).view(ThrowingFloat)
1004 assert_raises(TypeError, np.random.uniform, throwing_float,
1005 throwing_float)
1006
1007 class ThrowingInteger(np.ndarray):
1008 def __int__(self):
1009 raise TypeError
1010
1011 __index__ = __int__
1012
1013 throwing_int = np.array(1).view(ThrowingInteger)
1014 assert_raises(TypeError, np.random.hypergeometric, throwing_int, 1, 1)
1015
1016 def test_vonmises(self):
1017 rng = random.RandomState(self.seed)
1018 actual = rng.vonmises(mu=1.23, kappa=1.54, size=(3, 2))
1019 desired = np.array([[2.28567572673902042, 2.89163838442285037],
1020 [0.38198375564286025, 2.57638023113890746],
1021 [1.19153771588353052, 1.83509849681825354]])
1022 assert_array_almost_equal(actual, desired, decimal=15)
1023
1024 def test_vonmises_small(self):
1025 # check infinite loop, gh-4720
1026 np.random.seed(self.seed)
1027 r = np.random.vonmises(mu=0., kappa=1.1e-8, size=10**6)
1028 np.testing.assert_(np.isfinite(r).all())
1029
1030 def test_wald(self):
1031 rng = random.RandomState(self.seed)
1032 actual = rng.wald(mean=1.23, scale=1.54, size=(3, 2))
1033 desired = np.array([[3.82935265715889983, 5.13125249184285526],
1034 [0.35045403618358717, 1.50832396872003538],
1035 [0.24124319895843183, 0.22031101461955038]])
1036 assert_array_almost_equal(actual, desired, decimal=14)
1037
1038 def test_weibull(self):
1039 rng = random.RandomState(self.seed)
1040 actual = rng.weibull(a=1.23, size=(3, 2))
1041 desired = np.array([[0.97097342648766727, 0.91422896443565516],
1042 [1.89517770034962929, 1.91414357960479564],
1043 [0.67057783752390987, 1.39494046635066793]])
1044 assert_array_almost_equal(actual, desired, decimal=15)
1045
1046 def test_weibull_0(self):
1047 np.random.seed(self.seed)
1048 assert_equal(np.random.weibull(a=0, size=12), np.zeros(12))
1049 assert_raises(ValueError, np.random.weibull, a=-0.)
1050
1051 def test_zipf(self):
1052 rng = random.RandomState(self.seed)
1053 actual = rng.zipf(a=1.23, size=(3, 2))
1054 desired = np.array([[66, 29],
1055 [1, 1],
1056 [3, 13]])
1057 assert_array_equal(actual, desired)
1058
1059
1060class TestBroadcast:
1061 # tests that functions that broadcast behave
1062 # correctly when presented with non-scalar arguments
1063 seed = 123456789
1064
1065 # TODO: Include test for randint once it can broadcast
1066 # Can steal the test written in PR #6938
1067
1068 def test_uniform(self):
1069 low = [0]
1070 high = [1]
1071 desired = np.array([0.53283302478975902,
1072 0.53413660089041659,
1073 0.50955303552646702])
1074
1075 rng = random.RandomState(self.seed)
1076 actual = rng.uniform(low * 3, high)
1077 assert_array_almost_equal(actual, desired, decimal=14)
1078
1079 rng = random.RandomState(self.seed)
1080 actual = rng.uniform(low, high * 3)
1081 assert_array_almost_equal(actual, desired, decimal=14)
1082
1083 def test_normal(self):
1084 loc = [0]
1085 scale = [1]
1086 bad_scale = [-1]
1087 desired = np.array([2.2129019979039612,
1088 2.1283977976520019,
1089 1.8417114045748335])
1090
1091 rng = random.RandomState(self.seed)
1092 actual = rng.normal(loc * 3, scale)
1093 assert_array_almost_equal(actual, desired, decimal=14)
1094 assert_raises(ValueError, rng.normal, loc * 3, bad_scale)
1095
1096 rng = random.RandomState(self.seed)
1097 actual = rng.normal(loc, scale * 3)
1098 assert_array_almost_equal(actual, desired, decimal=14)
1099 assert_raises(ValueError, rng.normal, loc, bad_scale * 3)
1100
1101 def test_beta(self):
1102 a = [1]
1103 b = [2]
1104 bad_a = [-1]
1105 bad_b = [-2]
1106 desired = np.array([0.19843558305989056,
1107 0.075230336409423643,
1108 0.24976865978980844])
1109
1110 rng = random.RandomState(self.seed)
1111 actual = rng.beta(a * 3, b)
1112 assert_array_almost_equal(actual, desired, decimal=14)
1113 assert_raises(ValueError, rng.beta, bad_a * 3, b)
1114 assert_raises(ValueError, rng.beta, a * 3, bad_b)
1115
1116 rng = random.RandomState(self.seed)
1117 actual = rng.beta(a, b * 3)
1118 assert_array_almost_equal(actual, desired, decimal=14)
1119 assert_raises(ValueError, rng.beta, bad_a, b * 3)
1120 assert_raises(ValueError, rng.beta, a, bad_b * 3)
1121
1122 def test_exponential(self):
1123 scale = [1]
1124 bad_scale = [-1]
1125 desired = np.array([0.76106853658845242,
1126 0.76386282278691653,
1127 0.71243813125891797])
1128
1129 rng = random.RandomState(self.seed)
1130 actual = rng.exponential(scale * 3)
1131 assert_array_almost_equal(actual, desired, decimal=14)
1132 assert_raises(ValueError, rng.exponential, bad_scale * 3)
1133
1134 def test_standard_gamma(self):
1135 shape = [1]
1136 bad_shape = [-1]
1137 desired = np.array([0.76106853658845242,
1138 0.76386282278691653,
1139 0.71243813125891797])
1140
1141 rng = random.RandomState(self.seed)
1142 actual = rng.standard_gamma(shape * 3)
1143 assert_array_almost_equal(actual, desired, decimal=14)
1144 assert_raises(ValueError, rng.standard_gamma, bad_shape * 3)
1145
1146 def test_gamma(self):
1147 shape = [1]
1148 scale = [2]
1149 bad_shape = [-1]
1150 bad_scale = [-2]
1151 desired = np.array([1.5221370731769048,
1152 1.5277256455738331,
1153 1.4248762625178359])
1154
1155 rng = random.RandomState(self.seed)
1156 actual = rng.gamma(shape * 3, scale)
1157 assert_array_almost_equal(actual, desired, decimal=14)
1158 assert_raises(ValueError, rng.gamma, bad_shape * 3, scale)
1159 assert_raises(ValueError, rng.gamma, shape * 3, bad_scale)
1160
1161 rng = random.RandomState(self.seed)
1162 actual = rng.gamma(shape, scale * 3)
1163 assert_array_almost_equal(actual, desired, decimal=14)
1164 assert_raises(ValueError, rng.gamma, bad_shape, scale * 3)
1165 assert_raises(ValueError, rng.gamma, shape, bad_scale * 3)
1166
1167 def test_f(self):
1168 dfnum = [1]
1169 dfden = [2]
1170 bad_dfnum = [-1]
1171 bad_dfden = [-2]
1172 desired = np.array([0.80038951638264799,
1173 0.86768719635363512,
1174 2.7251095168386801])
1175
1176 rng = random.RandomState(self.seed)
1177 actual = rng.f(dfnum * 3, dfden)
1178 assert_array_almost_equal(actual, desired, decimal=14)
1179 assert_raises(ValueError, rng.f, bad_dfnum * 3, dfden)
1180 assert_raises(ValueError, rng.f, dfnum * 3, bad_dfden)
1181
1182 rng = random.RandomState(self.seed)
1183 actual = rng.f(dfnum, dfden * 3)
1184 assert_array_almost_equal(actual, desired, decimal=14)
1185 assert_raises(ValueError, rng.f, bad_dfnum, dfden * 3)
1186 assert_raises(ValueError, rng.f, dfnum, bad_dfden * 3)
1187
1188 def test_noncentral_f(self):
1189 dfnum = [2]
1190 dfden = [3]
1191 nonc = [4]
1192 bad_dfnum = [0]
1193 bad_dfden = [-1]
1194 bad_nonc = [-2]
1195 desired = np.array([9.1393943263705211,
1196 13.025456344595602,
1197 8.8018098359100545])
1198
1199 rng = random.RandomState(self.seed)
1200 actual = rng.noncentral_f(dfnum * 3, dfden, nonc)