Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1import sys
2import warnings
4import pytest
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)
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)
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)
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)
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])
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]])
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)
68 def test_p_is_nan(self):
69 # Issue #4571.
70 assert_raises(ValueError, random.binomial, 1, np.nan)
73class TestMultinomial:
74 def test_basic(self):
75 random.multinomial(100, [0.2, 0.8])
77 def test_zero_probability(self):
78 random.multinomial(100, [0.2, 0.8, 0.0, 0.0, 0.0])
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))
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))
97 assert_raises(TypeError, np.random.multinomial, 1, p,
98 float(1))
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]]))
107class TestSetState:
108 def _create_rng(self):
109 seed = 1234567890
110 prng = random.RandomState(seed)
111 state = prng.get_state()
112 return prng, state
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))
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))
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))
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))
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)
159 def test_set_invalid_state(self):
160 # gh-25402
161 prng, _ = self._create_rng()
162 with pytest.raises(IndexError):
163 prng.set_state(())
166class TestRandint:
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]
172 def test_unsupported_type(self):
173 rng = random.RandomState()
174 assert_raises(TypeError, rng.randint, 1, dtype=float)
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)
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
192 tgt = ubnd - 1
193 assert_equal(rng.randint(tgt, tgt + 1, size=1000, dtype=dt), tgt)
195 tgt = lbnd
196 assert_equal(rng.randint(tgt, tgt + 1, size=1000, dtype=dt), tgt)
198 tgt = (lbnd + ubnd) // 2
199 assert_equal(rng.randint(tgt, tgt + 1, size=1000, dtype=dt), tgt)
201 def test_full_range(self):
202 # Test for ticket #1690
203 rng = random.RandomState()
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
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))
216 def test_in_bounds_fuzz(self):
217 # Don't use fixed seed
218 rng = random.RandomState()
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)
226 vals = rng.randint(0, 2, size=2**16, dtype=np.bool)
228 assert_(vals.max() < 2)
229 assert_(vals.min() >= 0)
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
246 for dt in self.itype[1:]:
247 rng = random.RandomState(1234)
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()
255 res = hashlib.sha256(val.view(np.int8)).hexdigest()
256 assert_(tgt[np.dtype(dt).name] == res)
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)
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`.
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)
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)
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
294 sample = rng.randint(lbnd, ubnd, dtype=dt)
295 assert_equal(sample.dtype, np.dtype(dt))
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
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)
308class TestRandomDist:
309 # Make sure the random distribution returns the correct value for a
310 # given seed
311 seed = 1234567890
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)
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)
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)
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)
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)
356 desired = np.iinfo('l').max
357 assert_equal(actual, desired)
359 def test_random_integers_deprecated(self):
360 with warnings.catch_warnings():
361 warnings.simplefilter("error", DeprecationWarning)
363 # DeprecationWarning raised with high == None
364 assert_raises(DeprecationWarning,
365 np.random.random_integers,
366 np.iinfo('l').max)
368 # DeprecationWarning raised with high != None
369 assert_raises(DeprecationWarning,
370 np.random.random_integers,
371 np.iinfo('l').max, np.iinfo('l').max)
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)
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)
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)
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)
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)
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)
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])
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)
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)
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)
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)
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)
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)
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)
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]))
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
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
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)
553 # The array was created fine, and did not modify any objects:
554 assert all(id(i) in item_ids for i in arr)
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)
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])
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)
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)
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)
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)
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)
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))
633 assert_raises(TypeError, np.random.dirichlet, p, float(1))
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)
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]]))
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)
654 def test_exponential_0(self):
655 assert_equal(np.random.exponential(scale=0), 0)
656 assert_raises(ValueError, np.random.exponential, scale=-0.)
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)
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)
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.)
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)
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)
694 def test_gumbel_0(self):
695 assert_equal(np.random.gumbel(scale=0), 0)
696 assert_raises(ValueError, np.random.gumbel, scale=-0.)
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)
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)
711 actual = rng.hypergeometric(15, 0, 12, size=4)
712 desired = np.array([12, 12, 12, 12])
713 assert_array_equal(actual, desired)
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)
720 actual = rng.hypergeometric(0, 15, 12, size=4)
721 desired = np.array([0, 0, 0, 0])
722 assert_array_equal(actual, desired)
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)
732 def test_laplace_0(self):
733 assert_equal(np.random.laplace(scale=0), 0)
734 assert_raises(ValueError, np.random.laplace, scale=-0.)
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)
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)
752 def test_lognormal_0(self):
753 assert_equal(np.random.lognormal(sigma=0), 1)
754 assert_raises(ValueError, np.random.lognormal, sigma=-0.)
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)
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)
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]]])
788 assert_array_almost_equal(actual, desired, decimal=15)
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)
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)
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')
805 # and that it raises with RuntimeWarning check_valid='raises'
806 assert_raises(ValueError, rng.multivariate_normal, mean, cov,
807 check_valid='raise')
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)
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)
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)
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)
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)
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)
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)
860 def test_normal_0(self):
861 assert_equal(np.random.normal(scale=0), 0)
862 assert_raises(ValueError, np.random.normal, scale=-0.)
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)
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)
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)
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)
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)
911 def test_rayleigh_0(self):
912 assert_equal(np.random.rayleigh(scale=0), 0)
913 assert_raises(ValueError, np.random.rayleigh, scale=-0.)
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)
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)
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)
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.)
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)
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)
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)
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)
976 def test_uniform_range_bounds(self):
977 fmin = np.finfo('float').min
978 fmax = np.finfo('float').max
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])
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)
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
999 class ThrowingFloat(np.ndarray):
1000 def __float__(self):
1001 raise TypeError
1003 throwing_float = np.array(1.0).view(ThrowingFloat)
1004 assert_raises(TypeError, np.random.uniform, throwing_float,
1005 throwing_float)
1007 class ThrowingInteger(np.ndarray):
1008 def __int__(self):
1009 raise TypeError
1011 __index__ = __int__
1013 throwing_int = np.array(1).view(ThrowingInteger)
1014 assert_raises(TypeError, np.random.hypergeometric, throwing_int, 1, 1)
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)
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())
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)
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)
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.)
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)
1060class TestBroadcast:
1061 # tests that functions that broadcast behave
1062 # correctly when presented with non-scalar arguments
1063 seed = 123456789
1065 # TODO: Include test for randint once it can broadcast
1066 # Can steal the test written in PR #6938
1068 def test_uniform(self):
1069 low = [0]
1070 high = [1]
1071 desired = np.array([0.53283302478975902,
1072 0.53413660089041659,
1073 0.50955303552646702])
1075 rng = random.RandomState(self.seed)
1076 actual = rng.uniform(low * 3, high)
1077 assert_array_almost_equal(actual, desired, decimal=14)
1079 rng = random.RandomState(self.seed)
1080 actual = rng.uniform(low, high * 3)
1081 assert_array_almost_equal(actual, desired, decimal=14)
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])
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)
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)
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])
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)
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)
1122 def test_exponential(self):
1123 scale = [1]
1124 bad_scale = [-1]
1125 desired = np.array([0.76106853658845242,
1126 0.76386282278691653,
1127 0.71243813125891797])
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)
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])
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)
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])
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)
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)
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])
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)
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)
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])
1199 rng = random.RandomState(self.seed)
1200 actual = rng.noncentral_f(dfnum * 3, dfden, nonc)
1201 assert_array_almost_equal(actual, desired, decimal=14)
1202 assert_raises(ValueError, rng.noncentral_f, bad_dfnum * 3, dfden, nonc)
1203 assert_raises(ValueError, rng.noncentral_f, dfnum * 3, bad_dfden, nonc)
1204 assert_raises(ValueError, rng.noncentral_f, dfnum * 3, dfden, bad_nonc)
1206 rng = random.RandomState(self.seed)
1207 actual = rng.noncentral_f(dfnum, dfden * 3, nonc)
1208 assert_array_almost_equal(actual, desired, decimal=14)
1209 assert_raises(ValueError, rng.noncentral_f, bad_dfnum, dfden * 3, nonc)
1210 assert_raises(ValueError, rng.noncentral_f, dfnum, bad_dfden * 3, nonc)
1211 assert_raises(ValueError, rng.noncentral_f, dfnum, dfden * 3, bad_nonc)
1213 rng = random.RandomState(self.seed)
1214 actual = rng.noncentral_f(dfnum, dfden, nonc * 3)
1215 assert_array_almost_equal(actual, desired, decimal=14)
1216 assert_raises(ValueError, rng.noncentral_f, bad_dfnum, dfden, nonc * 3)
1217 assert_raises(ValueError, rng.noncentral_f, dfnum, bad_dfden, nonc * 3)
1218 assert_raises(ValueError, rng.noncentral_f, dfnum, dfden, bad_nonc * 3)
1220 def test_noncentral_f_small_df(self):
1221 rng = random.RandomState(self.seed)
1222 desired = np.array([6.869638627492048, 0.785880199263955])
1223 actual = rng.noncentral_f(0.9, 0.9, 2, size=2)
1224 assert_array_almost_equal(actual, desired, decimal=14)
1226 def test_chisquare(self):
1227 df = [1]
1228 bad_df = [-1]
1229 desired = np.array([0.57022801133088286,
1230 0.51947702108840776,
1231 0.1320969254923558])
1233 rng = random.RandomState(self.seed)
1234 actual = rng.chisquare(df * 3)
1235 assert_array_almost_equal(actual, desired, decimal=14)
1236 assert_raises(ValueError, rng.chisquare, bad_df * 3)
1238 def test_noncentral_chisquare(self):
1239 df = [1]
1240 nonc = [2]
1241 bad_df = [-1]
1242 bad_nonc = [-2]
1243 desired = np.array([9.0015599467913763,
1244 4.5804135049718742,
1245 6.0872302432834564])
1247 rng = random.RandomState(self.seed)
1248 actual = rng.noncentral_chisquare(df * 3, nonc)
1249 assert_array_almost_equal(actual, desired, decimal=14)
1250 assert_raises(ValueError, rng.noncentral_chisquare, bad_df * 3, nonc)
1251 assert_raises(ValueError, rng.noncentral_chisquare, df * 3, bad_nonc)
1253 rng = random.RandomState(self.seed)
1254 actual = rng.noncentral_chisquare(df, nonc * 3)
1255 assert_array_almost_equal(actual, desired, decimal=14)
1256 assert_raises(ValueError, rng.noncentral_chisquare, bad_df, nonc * 3)
1257 assert_raises(ValueError, rng.noncentral_chisquare, df, bad_nonc * 3)
1259 def test_standard_t(self):
1260 df = [1]
1261 bad_df = [-1]
1262 desired = np.array([3.0702872575217643,
1263 5.8560725167361607,
1264 1.0274791436474273])
1266 rng = random.RandomState(self.seed)
1267 actual = rng.standard_t(df * 3)
1268 assert_array_almost_equal(actual, desired, decimal=14)
1269 assert_raises(ValueError, rng.standard_t, bad_df * 3)
1271 def test_vonmises(self):
1272 mu = [2]
1273 kappa = [1]
1274 bad_kappa = [-1]
1275 desired = np.array([2.9883443664201312,
1276 -2.7064099483995943,
1277 -1.8672476700665914])
1279 rng = random.RandomState(self.seed)
1280 actual = rng.vonmises(mu * 3, kappa)
1281 assert_array_almost_equal(actual, desired, decimal=14)
1282 assert_raises(ValueError, rng.vonmises, mu * 3, bad_kappa)
1284 rng = random.RandomState(self.seed)
1285 actual = rng.vonmises(mu, kappa * 3)
1286 assert_array_almost_equal(actual, desired, decimal=14)
1287 assert_raises(ValueError, rng.vonmises, mu, bad_kappa * 3)
1289 def test_pareto(self):
1290 a = [1]
1291 bad_a = [-1]
1292 desired = np.array([1.1405622680198362,
1293 1.1465519762044529,
1294 1.0389564467453547])
1296 rng = random.RandomState(self.seed)
1297 actual = rng.pareto(a * 3)
1298 assert_array_almost_equal(actual, desired, decimal=14)
1299 assert_raises(ValueError, rng.pareto, bad_a * 3)
1301 def test_weibull(self):
1302 a = [1]
1303 bad_a = [-1]
1304 desired = np.array([0.76106853658845242,
1305 0.76386282278691653,
1306 0.71243813125891797])
1308 rng = random.RandomState(self.seed)
1309 actual = rng.weibull(a * 3)
1310 assert_array_almost_equal(actual, desired, decimal=14)
1311 assert_raises(ValueError, rng.weibull, bad_a * 3)
1313 def test_power(self):
1314 a = [1]
1315 bad_a = [-1]
1316 desired = np.array([0.53283302478975902,
1317 0.53413660089041659,
1318 0.50955303552646702])
1320 rng = random.RandomState(self.seed)
1321 actual = rng.power(a * 3)
1322 assert_array_almost_equal(actual, desired, decimal=14)
1323 assert_raises(ValueError, rng.power, bad_a * 3)
1325 def test_laplace(self):
1326 loc = [0]
1327 scale = [1]
1328 bad_scale = [-1]
1329 desired = np.array([0.067921356028507157,
1330 0.070715642226971326,
1331 0.019290950698972624])
1333 rng = random.RandomState(self.seed)
1334 actual = rng.laplace(loc * 3, scale)
1335 assert_array_almost_equal(actual, desired, decimal=14)
1336 assert_raises(ValueError, rng.laplace, loc * 3, bad_scale)
1338 rng = random.RandomState(self.seed)
1339 actual = rng.laplace(loc, scale * 3)
1340 assert_array_almost_equal(actual, desired, decimal=14)
1341 assert_raises(ValueError, rng.laplace, loc, bad_scale * 3)
1343 def test_gumbel(self):
1344 loc = [0]
1345 scale = [1]
1346 bad_scale = [-1]
1347 desired = np.array([0.2730318639556768,
1348 0.26936705726291116,
1349 0.33906220393037939])
1351 rng = random.RandomState(self.seed)
1352 actual = rng.gumbel(loc * 3, scale)
1353 assert_array_almost_equal(actual, desired, decimal=14)
1354 assert_raises(ValueError, rng.gumbel, loc * 3, bad_scale)
1356 rng = random.RandomState(self.seed)
1357 actual = rng.gumbel(loc, scale * 3)
1358 assert_array_almost_equal(actual, desired, decimal=14)
1359 assert_raises(ValueError, rng.gumbel, loc, bad_scale * 3)
1361 def test_logistic(self):
1362 loc = [0]
1363 scale = [1]
1364 bad_scale = [-1]
1365 desired = np.array([0.13152135837586171,
1366 0.13675915696285773,
1367 0.038216792802833396])
1369 rng = random.RandomState(self.seed)
1370 actual = rng.logistic(loc * 3, scale)
1371 assert_array_almost_equal(actual, desired, decimal=14)
1372 assert_raises(ValueError, rng.logistic, loc * 3, bad_scale)
1374 rng = random.RandomState(self.seed)
1375 actual = rng.logistic(loc, scale * 3)
1376 assert_array_almost_equal(actual, desired, decimal=14)
1377 assert_raises(ValueError, rng.logistic, loc, bad_scale * 3)
1379 def test_lognormal(self):
1380 mean = [0]
1381 sigma = [1]
1382 bad_sigma = [-1]
1383 desired = np.array([9.1422086044848427,
1384 8.4013952870126261,
1385 6.3073234116578671])
1387 rng = random.RandomState(self.seed)
1388 actual = rng.lognormal(mean * 3, sigma)
1389 assert_array_almost_equal(actual, desired, decimal=14)
1390 assert_raises(ValueError, rng.lognormal, mean * 3, bad_sigma)
1392 rng = random.RandomState(self.seed)
1393 actual = rng.lognormal(mean, sigma * 3)
1394 assert_array_almost_equal(actual, desired, decimal=14)
1395 assert_raises(ValueError, rng.lognormal, mean, bad_sigma * 3)
1397 def test_rayleigh(self):
1398 scale = [1]
1399 bad_scale = [-1]
1400 desired = np.array([1.2337491937897689,
1401 1.2360119924878694,
1402 1.1936818095781789])
1404 rng = random.RandomState(self.seed)
1405 actual = rng.rayleigh(scale * 3)
1406 assert_array_almost_equal(actual, desired, decimal=14)
1407 assert_raises(ValueError, rng.rayleigh, bad_scale * 3)
1409 def test_wald(self):
1410 mean = [0.5]
1411 scale = [1]
1412 bad_mean = [0]
1413 bad_scale = [-2]
1414 desired = np.array([0.11873681120271318,
1415 0.12450084820795027,
1416 0.9096122728408238])
1418 rng = random.RandomState(self.seed)
1419 actual = rng.wald(mean * 3, scale)
1420 assert_array_almost_equal(actual, desired, decimal=14)
1421 assert_raises(ValueError, rng.wald, bad_mean * 3, scale)
1422 assert_raises(ValueError, rng.wald, mean * 3, bad_scale)
1424 rng = random.RandomState(self.seed)
1425 actual = rng.wald(mean, scale * 3)
1426 assert_array_almost_equal(actual, desired, decimal=14)
1427 assert_raises(ValueError, rng.wald, bad_mean, scale * 3)
1428 assert_raises(ValueError, rng.wald, mean, bad_scale * 3)
1429 assert_raises(ValueError, rng.wald, 0.0, 1)
1430 assert_raises(ValueError, rng.wald, 0.5, 0.0)
1432 def test_triangular(self):
1433 left = [1]
1434 right = [3]
1435 mode = [2]
1436 bad_left_one = [3]
1437 bad_mode_one = [4]
1438 bad_left_two, bad_mode_two = right * 2
1439 desired = np.array([2.03339048710429,
1440 2.0347400359389356,
1441 2.0095991069536208])
1443 rng = random.RandomState(self.seed)
1444 actual = rng.triangular(left * 3, mode, right)
1445 assert_array_almost_equal(actual, desired, decimal=14)
1446 assert_raises(ValueError, rng.triangular, bad_left_one * 3, mode, right)
1447 assert_raises(ValueError, rng.triangular, left * 3, bad_mode_one, right)
1448 assert_raises(ValueError, rng.triangular, bad_left_two * 3, bad_mode_two,
1449 right)
1451 rng = random.RandomState(self.seed)
1452 actual = rng.triangular(left, mode * 3, right)
1453 assert_array_almost_equal(actual, desired, decimal=14)
1454 assert_raises(ValueError, rng.triangular, bad_left_one, mode * 3, right)
1455 assert_raises(ValueError, rng.triangular, left, bad_mode_one * 3, right)
1456 assert_raises(ValueError, rng.triangular, bad_left_two, bad_mode_two * 3,
1457 right)
1459 rng = random.RandomState(self.seed)
1460 actual = rng.triangular(left, mode, right * 3)
1461 assert_array_almost_equal(actual, desired, decimal=14)
1462 assert_raises(ValueError, rng.triangular, bad_left_one, mode, right * 3)
1463 assert_raises(ValueError, rng.triangular, left, bad_mode_one, right * 3)
1464 assert_raises(ValueError, rng.triangular, bad_left_two, bad_mode_two,
1465 right * 3)
1467 def test_binomial(self):
1468 n = [1]
1469 p = [0.5]
1470 bad_n = [-1]
1471 bad_p_one = [-1]
1472 bad_p_two = [1.5]
1473 desired = np.array([1, 1, 1])
1475 rng = random.RandomState(self.seed)
1476 actual = rng.binomial(n * 3, p)
1477 assert_array_equal(actual, desired)
1478 assert_raises(ValueError, rng.binomial, bad_n * 3, p)
1479 assert_raises(ValueError, rng.binomial, n * 3, bad_p_one)
1480 assert_raises(ValueError, rng.binomial, n * 3, bad_p_two)
1482 rng = random.RandomState(self.seed)
1483 actual = rng.binomial(n, p * 3)
1484 assert_array_equal(actual, desired)
1485 assert_raises(ValueError, rng.binomial, bad_n, p * 3)
1486 assert_raises(ValueError, rng.binomial, n, bad_p_one * 3)
1487 assert_raises(ValueError, rng.binomial, n, bad_p_two * 3)
1489 def test_negative_binomial(self):
1490 n = [1]
1491 p = [0.5]
1492 bad_n = [-1]
1493 bad_p_one = [-1]
1494 bad_p_two = [1.5]
1495 desired = np.array([1, 0, 1])
1497 rng = random.RandomState(self.seed)
1498 actual = rng.negative_binomial(n * 3, p)
1499 assert_array_equal(actual, desired)
1500 assert_raises(ValueError, rng.negative_binomial, bad_n * 3, p)
1501 assert_raises(ValueError, rng.negative_binomial, n * 3, bad_p_one)
1502 assert_raises(ValueError, rng.negative_binomial, n * 3, bad_p_two)
1504 rng = random.RandomState(self.seed)
1505 actual = rng.negative_binomial(n, p * 3)
1506 assert_array_equal(actual, desired)
1507 assert_raises(ValueError, rng.negative_binomial, bad_n, p * 3)
1508 assert_raises(ValueError, rng.negative_binomial, n, bad_p_one * 3)
1509 assert_raises(ValueError, rng.negative_binomial, n, bad_p_two * 3)
1511 def test_poisson(self):
1512 max_lam = np.random.RandomState()._poisson_lam_max
1514 lam = [1]
1515 bad_lam_one = [-1]
1516 bad_lam_two = [max_lam * 2]
1517 desired = np.array([1, 1, 0])
1519 rng = random.RandomState(self.seed)
1520 actual = rng.poisson(lam * 3)
1521 assert_array_equal(actual, desired)
1522 assert_raises(ValueError, rng.poisson, bad_lam_one * 3)
1523 assert_raises(ValueError, rng.poisson, bad_lam_two * 3)
1525 def test_zipf(self):
1526 a = [2]
1527 bad_a = [0]
1528 desired = np.array([2, 2, 1])
1530 rng = random.RandomState(self.seed)
1531 actual = rng.zipf(a * 3)
1532 assert_array_equal(actual, desired)
1533 assert_raises(ValueError, rng.zipf, bad_a * 3)
1534 with np.errstate(invalid='ignore'):
1535 assert_raises(ValueError, rng.zipf, np.nan)
1536 assert_raises(ValueError, rng.zipf, [0, 0, np.nan])
1538 def test_geometric(self):
1539 p = [0.5]
1540 bad_p_one = [-1]
1541 bad_p_two = [1.5]
1542 desired = np.array([2, 2, 2])
1544 rng = random.RandomState(self.seed)
1545 actual = rng.geometric(p * 3)
1546 assert_array_equal(actual, desired)
1547 assert_raises(ValueError, rng.geometric, bad_p_one * 3)
1548 assert_raises(ValueError, rng.geometric, bad_p_two * 3)
1550 def test_hypergeometric(self):
1551 ngood = [1]
1552 nbad = [2]
1553 nsample = [2]
1554 bad_ngood = [-1]
1555 bad_nbad = [-2]
1556 bad_nsample_one = [0]
1557 bad_nsample_two = [4]
1558 desired = np.array([1, 1, 1])
1560 rng = random.RandomState(self.seed)
1561 actual = rng.hypergeometric(ngood * 3, nbad, nsample)
1562 assert_array_equal(actual, desired)
1563 assert_raises(ValueError, rng.hypergeometric, bad_ngood * 3, nbad, nsample)
1564 assert_raises(ValueError, rng.hypergeometric, ngood * 3, bad_nbad, nsample)
1565 assert_raises(ValueError, rng.hypergeometric, ngood * 3, nbad, bad_nsample_one)
1566 assert_raises(ValueError, rng.hypergeometric, ngood * 3, nbad, bad_nsample_two)
1568 rng = random.RandomState(self.seed)
1569 actual = rng.hypergeometric(ngood, nbad * 3, nsample)
1570 assert_array_equal(actual, desired)
1571 assert_raises(ValueError, rng.hypergeometric, bad_ngood, nbad * 3, nsample)
1572 assert_raises(ValueError, rng.hypergeometric, ngood, bad_nbad * 3, nsample)
1573 assert_raises(ValueError, rng.hypergeometric, ngood, nbad * 3, bad_nsample_one)
1574 assert_raises(ValueError, rng.hypergeometric, ngood, nbad * 3, bad_nsample_two)
1576 rng = random.RandomState(self.seed)
1577 actual = rng.hypergeometric(ngood, nbad, nsample * 3)
1578 assert_array_equal(actual, desired)
1579 assert_raises(ValueError, rng.hypergeometric, bad_ngood, nbad, nsample * 3)
1580 assert_raises(ValueError, rng.hypergeometric, ngood, bad_nbad, nsample * 3)
1581 assert_raises(ValueError, rng.hypergeometric, ngood, nbad, bad_nsample_one * 3)
1582 assert_raises(ValueError, rng.hypergeometric, ngood, nbad, bad_nsample_two * 3)
1584 def test_logseries(self):
1585 p = [0.5]
1586 bad_p_one = [2]
1587 bad_p_two = [-1]
1588 desired = np.array([1, 1, 1])
1590 rng = random.RandomState(self.seed)
1591 actual = rng.logseries(p * 3)
1592 assert_array_equal(actual, desired)
1593 assert_raises(ValueError, rng.logseries, bad_p_one * 3)
1594 assert_raises(ValueError, rng.logseries, bad_p_two * 3)
1597@pytest.mark.skipif(IS_WASM, reason="can't start thread")
1598class TestThread:
1599 # make sure each state produces the same sequence even in threads
1600 seeds = range(4)
1602 def check_function(self, function, sz):
1603 from threading import Thread
1605 out1 = np.empty((len(self.seeds),) + sz)
1606 out2 = np.empty((len(self.seeds),) + sz)
1608 # threaded generation
1609 t = [Thread(target=function, args=(np.random.RandomState(s), o))
1610 for s, o in zip(self.seeds, out1)]
1611 [x.start() for x in t]
1612 [x.join() for x in t]
1614 # the same serial
1615 for s, o in zip(self.seeds, out2):
1616 function(np.random.RandomState(s), o)
1618 # these platforms change x87 fpu precision mode in threads
1619 if np.intp().dtype.itemsize == 4 and sys.platform == "win32":
1620 assert_array_almost_equal(out1, out2)
1621 else:
1622 assert_array_equal(out1, out2)
1624 def test_normal(self):
1625 def gen_random(state, out):
1626 out[...] = state.normal(size=10000)
1627 self.check_function(gen_random, sz=(10000,))
1629 def test_exp(self):
1630 def gen_random(state, out):
1631 out[...] = state.exponential(scale=np.ones((100, 1000)))
1632 self.check_function(gen_random, sz=(100, 1000))
1634 def test_multinomial(self):
1635 def gen_random(state, out):
1636 out[...] = state.multinomial(10, [1 / 6.] * 6, size=10000)
1637 self.check_function(gen_random, sz=(10000, 6))
1640# See Issue #4263
1641class TestSingleEltArrayInput:
1642 def _create_arrays(self):
1643 return np.array([2]), np.array([3]), np.array([4]), (1,)
1645 def test_one_arg_funcs(self):
1646 argOne, _, _, tgtShape = self._create_arrays()
1647 funcs = (np.random.exponential, np.random.standard_gamma,
1648 np.random.chisquare, np.random.standard_t,
1649 np.random.pareto, np.random.weibull,
1650 np.random.power, np.random.rayleigh,
1651 np.random.poisson, np.random.zipf,
1652 np.random.geometric, np.random.logseries)
1654 probfuncs = (np.random.geometric, np.random.logseries)
1656 for func in funcs:
1657 if func in probfuncs: # p < 1.0
1658 out = func(np.array([0.5]))
1660 else:
1661 out = func(argOne)
1663 assert_equal(out.shape, tgtShape)
1665 def test_two_arg_funcs(self):
1666 argOne, argTwo, _, tgtShape = self._create_arrays()
1667 funcs = (np.random.uniform, np.random.normal,
1668 np.random.beta, np.random.gamma,
1669 np.random.f, np.random.noncentral_chisquare,
1670 np.random.vonmises, np.random.laplace,
1671 np.random.gumbel, np.random.logistic,
1672 np.random.lognormal, np.random.wald,
1673 np.random.binomial, np.random.negative_binomial)
1675 probfuncs = (np.random.binomial, np.random.negative_binomial)
1677 for func in funcs:
1678 if func in probfuncs: # p <= 1
1679 argTwo = np.array([0.5])
1681 else:
1682 argTwo = argTwo
1684 out = func(argOne, argTwo)
1685 assert_equal(out.shape, tgtShape)
1687 out = func(argOne[0], argTwo)
1688 assert_equal(out.shape, tgtShape)
1690 out = func(argOne, argTwo[0])
1691 assert_equal(out.shape, tgtShape)
1693 def test_randint(self):
1694 _, _, _, tgtShape = self._create_arrays()
1695 itype = [bool, np.int8, np.uint8, np.int16, np.uint16,
1696 np.int32, np.uint32, np.int64, np.uint64]
1697 func = np.random.randint
1698 high = np.array([1])
1699 low = np.array([0])
1701 for dt in itype:
1702 out = func(low, high, dtype=dt)
1703 assert_equal(out.shape, tgtShape)
1705 out = func(low[0], high, dtype=dt)
1706 assert_equal(out.shape, tgtShape)
1708 out = func(low, high[0], dtype=dt)
1709 assert_equal(out.shape, tgtShape)
1711 def test_three_arg_funcs(self):
1712 argOne, argTwo, argThree, tgtShape = self._create_arrays()
1713 funcs = [np.random.noncentral_f, np.random.triangular,
1714 np.random.hypergeometric]
1716 for func in funcs:
1717 out = func(argOne, argTwo, argThree)
1718 assert_equal(out.shape, tgtShape)
1720 out = func(argOne[0], argTwo, argThree)
1721 assert_equal(out.shape, tgtShape)
1723 out = func(argOne, argTwo[0], argThree)
1724 assert_equal(out.shape, tgtShape)