#!/usr/bin/env python # Copyright (c) 2017-2019, Intel Corporation # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are met: # # * Redistributions of source code must retain the above copyright notice, # this list of conditions and the following disclaimer. # * Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. # * Neither the name of Intel Corporation nor the names of its contributors # may be used to endorse or promote products derived from this software # without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" # AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. from typing import NamedTuple import numpy as np import mkl_random as rnd from numpy.testing import ( assert_, assert_raises, assert_equal, assert_warns, suppress_warnings) import sys import warnings import pytest def test_zero_scalar_seed(): evs_zero_seed = { 'MT19937' : 844, 'SFMT19937' : 857, 'WH' : 0, 'MT2203' : 890, 'MCG31' : 0, 'R250' : 229, 'MRG32K3A' : 0, 'MCG59' : 0 } for brng_algo in evs_zero_seed: s = rnd.RandomState(0, brng = brng_algo) assert_equal(s.get_state()[0], brng_algo) assert_equal(s.randint(1000), evs_zero_seed[brng_algo]) def test_max_scalar_seed(): evs_max_seed = { 'MT19937' : 635, 'SFMT19937' : 25, 'WH' : 100, 'MT2203' : 527, 'MCG31' : 0, 'R250' : 229, 'MRG32K3A' : 961, 'MCG59' : 0 } for brng_algo in evs_max_seed: s = rnd.RandomState(4294967295, brng = brng_algo) assert_equal(s.get_state()[0], brng_algo) assert_equal(s.randint(1000), evs_max_seed[brng_algo]) def test_array_seed(): s = rnd.RandomState(range(10), brng='MT19937') assert_equal(s.randint(1000), 410) s = rnd.RandomState(np.arange(10), brng='MT19937') assert_equal(s.randint(1000), 410) s = rnd.RandomState([0], brng='MT19937') assert_equal(s.randint(1000), 844) s = rnd.RandomState([4294967295], brng='MT19937') assert_equal(s.randint(1000), 635) def test_invalid_scalar_seed(): # seed must be an unsigned 32 bit integers pytest.raises(TypeError, rnd.RandomState, -0.5) pytest.raises(ValueError, rnd.RandomState, -1) def test_invalid_array_seed(): # seed must be an unsigned 32 bit integers pytest.raises(TypeError, rnd.RandomState, [-0.5]) pytest.raises(ValueError, rnd.RandomState, [-1]) pytest.raises(ValueError, rnd.RandomState, [4294967296]) pytest.raises(ValueError, rnd.RandomState, [1, 2, 4294967296]) pytest.raises(ValueError, rnd.RandomState, [1, -2, 4294967296]) def test_non_deterministic_brng(): rs = rnd.RandomState(brng='nondeterministic') v = rs.rand(10) assert isinstance(v, np.ndarray) v = rs.randint(0, 10) assert isinstance(v, int) def test_binomial_n_zero(): zeros = np.zeros(2, dtype='int32') for p in [0, .5, 1]: assert rnd.binomial(0, p) == 0 actual = rnd.binomial(zeros, p) np.testing.assert_allclose(actual, zeros) def test_binomial_p_is_nan(): # Issue #4571. pytest.raises(ValueError, rnd.binomial, 1, np.nan) def test_multinomial_basic(): rnd.multinomial(100, [0.2, 0.8]) def test_multinomial_zero_probability(): rnd.multinomial(100, [0.2, 0.8, 0.0, 0.0, 0.0]) def test_multinomial_int_negative_interval(): assert -5 <= rnd.randint(-5, -1) < -1 x = rnd.randint(-5, -1, 5) assert np.all(-5 <= x) assert np.all(x < -1) def test_size(): # gh-3173 p = [0.5, 0.5] assert_equal(rnd.multinomial(1, p, np.uint32(1)).shape, (1, 2)) assert_equal(rnd.multinomial(1, p, np.uint32(1)).shape, (1, 2)) assert_equal(rnd.multinomial(1, p, np.uint32(1)).shape, (1, 2)) assert_equal(rnd.multinomial(1, p, [2, 2]).shape, (2, 2, 2)) assert_equal(rnd.multinomial(1, p, (2, 2)).shape, (2, 2, 2)) assert_equal(rnd.multinomial(1, p, np.array((2, 2))).shape, (2, 2, 2)) pytest.raises(TypeError, rnd.multinomial, 1, p, np.float64(1)) class RngState(NamedTuple): seed: int prng: object state: object @pytest.fixture def rng_state(): seed = 1234567890 prng = rnd.RandomState(seed) state = prng.get_state() return RngState(seed, prng, state) def test_set_state_basic(rng_state): sample_ref = rng_state.prng.tomaxint(16) new_rng = rnd.RandomState() new_rng.set_state(rng_state.state) sample_from_new = new_rng.tomaxint(16) assert_equal(sample_ref, sample_from_new) def test_set_state_gaussian_reset(rng_state): # Make sure the cached every-other-Gaussian is reset. sample_ref = rng_state.prng.standard_normal(size=3) new_rng = rnd.RandomState() new_rng.set_state(rng_state.state) sample_from_new = new_rng.standard_normal(size=3) assert_equal(sample_ref, sample_from_new) def test_set_state_gaussian_reset_in_media_res(rng_state): # When the state is saved with a cached Gaussian, make sure the # cached Gaussian is restored. prng = rng_state.prng _ = prng.standard_normal() state_after_draw = prng.get_state() sample_ref = prng.standard_normal(size=3) new_rng = rnd.RandomState() new_rng.set_state(state_after_draw) sample_from_new = new_rng.standard_normal(size=3) assert_equal(sample_ref, sample_from_new) def test_set_state_backward_compatibility(rng_state): # Make sure we can accept old state tuples that do not have the # cached Gaussian value. if len(rng_state.state) == 5: state_old_format = rng_state.state[:-2] x1 = rng_state.prng.standard_normal(size=16) new_rng = rnd.RandomState() new_rng.set_state(state_old_format) x2 = new_rng.standard_normal(size=16) new_rng.set_state(rng_state.state) x3 = new_rng.standard_normal(size=16) assert_equal(x1, x2) assert_equal(x1, x3) def test_set_state_negative_binomial(rng_state): # Ensure that the negative binomial results take floating point # arguments without truncation. v = rng_state.prng.negative_binomial(0.5, 0.5) assert isinstance(v, int) class RandIntData(NamedTuple): rfunc : object itype : list @pytest.fixture def randint(): rfunc_method = rnd.randint integral_dtypes = [ np.bool_, np.int8, np.uint8, np.int16, np.uint16, np.int32, np.uint32, np.int64, np.uint64 ] return RandIntData(rfunc_method, integral_dtypes) def test_randint_unsupported_type(randint): pytest.raises(TypeError, randint.rfunc, 1, dtype=np.float64) def test_randint_bounds_checking(randint): for dt in randint.itype: lbnd = 0 if dt is np.bool_ else np.iinfo(dt).min ubnd = 2 if dt is np.bool_ else np.iinfo(dt).max + 1 pytest.raises(ValueError, randint.rfunc, lbnd - 1, ubnd, dtype=dt) pytest.raises(ValueError, randint.rfunc, lbnd, ubnd + 1, dtype=dt) pytest.raises(ValueError, randint.rfunc, ubnd, lbnd, dtype=dt) pytest.raises(ValueError, randint.rfunc, 1, 0, dtype=dt) def test_randint_rng_zero_and_extremes(randint): for dt in randint.itype: lbnd = 0 if dt is np.bool_ else np.iinfo(dt).min ubnd = 2 if dt is np.bool_ else np.iinfo(dt).max + 1 tgt = ubnd - 1 assert_equal(randint.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt) tgt = lbnd assert_equal(randint.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt) tgt = lbnd + ((ubnd - lbnd)//2) assert_equal(randint.rfunc(tgt, tgt + 1, size=1000, dtype=dt), tgt) def test_randint_in_bounds_fuzz(randint): # Don't use fixed seed rnd.seed() for dt in randint.itype[1:]: for ubnd in [4, 8, 16]: vals = randint.rfunc(2, ubnd, size=2**16, dtype=dt) assert_(vals.max() < ubnd) assert_(vals.min() >= 2) vals = randint.rfunc(0, 2, size=2**16, dtype='bool') assert (vals.max() < 2) assert (vals.min() >= 0) def test_randint_repeatability(randint): import hashlib # We use a md5 hash of generated sequences of 1000 samples # in the range [0, 6) for all but np.bool, where the range # is [0, 2). Hashes are for little endian numbers. tgt = {'bool': '4fee98a6885457da67c39331a9ec336f', 'int16': '80a5ff69c315ab6f80b03da1d570b656', 'int32': '15a3c379b6c7b0f296b162194eab68bc', 'int64': 'ea9875f9334c2775b00d4976b85a1458', 'int8': '0f56333af47de94930c799806158a274', 'uint16': '80a5ff69c315ab6f80b03da1d570b656', 'uint32': '15a3c379b6c7b0f296b162194eab68bc', 'uint64': 'ea9875f9334c2775b00d4976b85a1458', 'uint8': '0f56333af47de94930c799806158a274'} for dt in randint.itype[1:]: rnd.seed(1234, brng='MT19937') # view as little endian for hash if sys.byteorder == 'little': val = randint.rfunc(0, 6, size=1000, dtype=dt) else: val = randint.rfunc(0, 6, size=1000, dtype=dt).byteswap() res = hashlib.md5(val.view(np.int8)).hexdigest() assert tgt[np.dtype(dt).name] == res # bools do not depend on endianess rnd.seed(1234, brng='MT19937') val = randint.rfunc(0, 2, size=1000, dtype='bool').view(np.int8) res = hashlib.md5(val).hexdigest() assert (tgt[np.dtype('bool').name] == res) def test_randint_respect_dtype_singleton(randint): # See gh-7203 for dt in randint.itype: lbnd = 0 if dt is np.bool_ else np.iinfo(dt).min ubnd = 2 if dt is np.bool_ else np.iinfo(dt).max + 1 sample = randint.rfunc(lbnd, ubnd, dtype=dt) assert_equal(sample.dtype, np.dtype(dt)) for dt in (bool, int): lbnd = 0 if dt is bool else np.iinfo(np.dtype(dt)).min ubnd = 2 if dt is bool else np.iinfo(np.dtype(dt)).max + 1 # gh-7284: Ensure that we get Python data types sample = randint.rfunc(lbnd, ubnd, dtype=dt) assert not hasattr(sample, 'dtype') assert (type(sample) == dt) class RandomDistData(NamedTuple): seed : int brng : str @pytest.fixture def randomdist(): return RandomDistData(seed=1234567890, brng='SFMT19937') # Make sure the random distribution returns the correct value for a # given seed. Low value of decimal argument is intended, since functional # transformations's implementation or approximations thereof used to produce non-uniform # random variates can vary across platforms, yet be statistically indistinguishable to the end user, # that is no computationally feasible statistical experiment can detect the difference. def test_randomdist_rand(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.rand(3, 2) desired = np.array([[0.9838694715872407, 0.019142669625580311], [0.1767608025111258, 0.70966427633538842], [0.518550637178123, 0.98780936631374061]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_randn(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.randn(3, 2) desired = np.array([[2.1411609928913298, -2.0717866791744819], [-0.92778018318550248, 0.55240420724917727], [0.04651632135517459, 2.2510674226058036]]) np.testing.assert_allclose(actual, desired, atol=1e-10) def test_randomdist_randint(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.randint(-99, 99, size=(3, 2)) desired = np.array([[95, -96], [-65, 41], [3, 96]]) np.testing.assert_array_equal(actual, desired) def test_randomdist_random_integers(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) with suppress_warnings() as sup: w = sup.record(DeprecationWarning) actual = rnd.random_integers(-99, 99, size=(3, 2)) assert len(w) == 1 desired = np.array([[96, -96], [-64, 42], [4, 97]]) np.testing.assert_array_equal(actual, desired) def test_random_integers_max_int(): # Tests whether random_integers can generate the # maximum allowed Python int that can be converted # into a C long. Previous implementations of this # method have thrown an OverflowError when attempting # to generate this integer. with suppress_warnings() as sup: w = sup.record(DeprecationWarning) actual = rnd.random_integers(np.iinfo('l').max, np.iinfo('l').max) assert len(w) == 1 desired = np.iinfo('l').max np.testing.assert_equal(actual, desired) def test_random_integers_deprecated(): with warnings.catch_warnings(): warnings.simplefilter("error", DeprecationWarning) # DeprecationWarning raised with high == None assert_raises(DeprecationWarning, rnd.random_integers, np.iinfo('l').max) # DeprecationWarning raised with high != None assert_raises(DeprecationWarning, rnd.random_integers, np.iinfo('l').max, np.iinfo('l').max) def test_randomdist_random_sample(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.random_sample((3, 2)) desired = np.array([[0.9838694715872407, 0.01914266962558031], [0.1767608025111258, 0.7096642763353884], [0.518550637178123, 0.9878093663137406]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_choice_uniform_replace(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.choice(4, 4) desired = np.array([3, 0, 0, 2]) np.testing.assert_array_equal(actual, desired) def test_randomdist_choice_nonuniform_replace(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1]) desired = np.array([3, 0, 0, 1]) np.testing.assert_array_equal(actual, desired) def test_randomdist_choice_nonuniform_replace(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.choice(4, 4, p=[0.4, 0.4, 0.1, 0.1]) desired = np.array([3, 0, 0, 1]) np.testing.assert_array_equal(actual, desired) def test_randomdist_choice_uniform_noreplace(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.choice(4, 3, replace=False) desired = np.array([2, 1, 3]) np.testing.assert_array_equal(actual, desired) def test_randomdist_choice_nonuniform_noreplace(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.choice(4, 3, replace=False, p=[0.1, 0.3, 0.5, 0.1]) desired = np.array([3, 0, 1]) np.testing.assert_array_equal(actual, desired) def test_randomdist_choice_noninteger(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.choice(['a', 'b', 'c', 'd'], 4) desired = np.array(['d', 'a', 'a', 'c']) np.testing.assert_array_equal(actual, desired) def test_choice_exceptions(): sample = rnd.choice pytest.raises(ValueError, sample, -1, 3) pytest.raises(ValueError, sample, 3., 3) pytest.raises(ValueError, sample, [[1, 2], [3, 4]], 3) pytest.raises(ValueError, sample, [], 3) pytest.raises(ValueError, sample, [1, 2, 3, 4], 3, p=[[0.25, 0.25], [0.25, 0.25]]) pytest.raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4, 0.2]) pytest.raises(ValueError, sample, [1, 2], 3, p=[1.1, -0.1]) pytest.raises(ValueError, sample, [1, 2], 3, p=[0.4, 0.4]) pytest.raises(ValueError, sample, [1, 2, 3], 4, replace=False) pytest.raises(ValueError, sample, [1, 2, 3], 2, replace=False, p=[1, 0, 0]) def test_choice_return_shape(): p = [0.1, 0.9] # Check scalar assert np.isscalar(rnd.choice(2, replace=True)) assert np.isscalar(rnd.choice(2, replace=False)) assert np.isscalar(rnd.choice(2, replace=True, p=p)) assert np.isscalar(rnd.choice(2, replace=False, p=p)) assert np.isscalar(rnd.choice([1, 2], replace=True)) assert rnd.choice([None], replace=True) is None a = np.array([1, 2]) arr = np.empty(1, dtype=object) arr[0] = a assert rnd.choice(arr, replace=True) is a # Check 0-d array s = tuple() assert not np.isscalar(rnd.choice(2, s, replace=True)) assert not np.isscalar(rnd.choice(2, s, replace=False)) assert not np.isscalar(rnd.choice(2, s, replace=True, p=p)) assert not np.isscalar(rnd.choice(2, s, replace=False, p=p)) assert not np.isscalar(rnd.choice([1, 2], s, replace=True)) assert rnd.choice([None], s, replace=True).ndim == 0 a = np.array([1, 2]) arr = np.empty(1, dtype=object) arr[0] = a assert rnd.choice(arr, s, replace=True).item() is a # Check multi dimensional array s = (2, 3) p = [0.1, 0.1, 0.1, 0.1, 0.4, 0.2] assert_(rnd.choice(6, s, replace=True).shape, s) assert_(rnd.choice(6, s, replace=False).shape, s) assert_(rnd.choice(6, s, replace=True, p=p).shape, s) assert_(rnd.choice(6, s, replace=False, p=p).shape, s) assert_(rnd.choice(np.arange(6), s, replace=True).shape, s) def test_randomdist_bytes(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.bytes(10) desired = b'\xa4\xde\xde{\xb4\x88\xe6\x84*2' np.testing.assert_equal(actual, desired) def test_randomdist_shuffle(randomdist): # Test lists, arrays (of various dtypes), and multidimensional versions # of both, c-contiguous or not: for conv in [lambda x: np.array([]), lambda x: x, lambda x: np.asarray(x).astype(np.int8), lambda x: np.asarray(x).astype(np.float32), lambda x: np.asarray(x).astype(np.complex64), lambda x: np.asarray(x).astype(object), lambda x: [(i, i) for i in x], lambda x: np.asarray([[i, i] for i in x]), lambda x: np.vstack([x, x]).T, # gh-4270 lambda x: np.asarray([(i, i) for i in x], [("a", object, (1,)), ("b", np.int32, (1,))])]: rnd.seed(randomdist.seed, brng=randomdist.brng) alist = conv([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]) rnd.shuffle(alist) actual = alist desired = conv([9, 8, 5, 1, 6, 4, 7, 2, 3, 0]) np.testing.assert_array_equal(actual, desired) def test_shuffle_masked(): # gh-3263 a = np.ma.masked_values(np.reshape(range(20), (5,4)) % 3 - 1, -1) b = np.ma.masked_values(np.arange(20) % 3 - 1, -1) a_orig = a.copy() b_orig = b.copy() for i in range(50): rnd.shuffle(a) assert_equal( sorted(a.data[~a.mask]), sorted(a_orig.data[~a_orig.mask])) rnd.shuffle(b) assert_equal( sorted(b.data[~b.mask]), sorted(b_orig.data[~b_orig.mask])) def test_randomdist_beta(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.beta(.1, .9, size=(3, 2)) desired = np.array( [[0.9856952034381025, 4.35869375658114e-08], [0.0014230232791189966, 1.4981856288121975e-06], [1.426135763875603e-06, 4.5801786040477326e-07]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_binomial(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.binomial(100.123, .456, size=(3, 2)) desired = np.array([[43, 48], [55, 48], [46, 53]]) np.testing.assert_array_equal(actual, desired) def test_randomdist_chisquare(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.chisquare(50, size=(3, 2)) desired = np.array([[50.955833609920589, 50.133178918244099], [61.513615847062013, 50.757127871422448], [52.79816819717081, 49.973023331993552]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_dirichlet(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) alpha = np.array([51.72840233779265162, 39.74494232180943953]) actual = rnd.dirichlet(alpha, size=(3, 2)) desired = np.array([[[0.6332947001908874, 0.36670529980911254], [0.5376828907571894, 0.4623171092428107]], [[0.6835615930093024, 0.3164384069906976], [0.5452378139016114, 0.45476218609838875]], [[0.6498494402738553, 0.3501505597261446], [0.5622024400324822, 0.43779755996751785]]]) np.testing.assert_allclose(actual, desired, atol=4e-10, rtol=4e-10) def test_dirichlet_size(): # gh-3173 p = np.array([51.72840233779265162, 39.74494232180943953]) assert_equal(rnd.dirichlet(p, np.uint32(1)).shape, (1, 2)) assert_equal(rnd.dirichlet(p, np.uint32(1)).shape, (1, 2)) assert_equal(rnd.dirichlet(p, np.uint32(1)).shape, (1, 2)) assert_equal(rnd.dirichlet(p, [2, 2]).shape, (2, 2, 2)) assert_equal(rnd.dirichlet(p, (2, 2)).shape, (2, 2, 2)) assert_equal(rnd.dirichlet(p, np.array((2, 2))).shape, (2, 2, 2)) assert_raises(TypeError, rnd.dirichlet, p, np.float64(1)) def test_randomdist_exponential(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.exponential(1.1234, size=(3, 2)) desired = np.array([[0.01826877748252199, 4.4439855151117005], [1.9468048583654507, 0.38528493864979607], [0.7377565464231758, 0.013779117663987912]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_f(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.f(12, 77, size=(3, 2)) desired = np.array([[1.325076177478387, 0.8670927327120197], [2.1190792007836827, 0.9095296301824258], [1.4953697422236187, 0.9547125618834837]]) np.testing.assert_allclose(actual, desired, atol=1e-8, rtol=1e-9) def test_randomdist_gamma(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.gamma(5, 3, size=(3, 2)) desired = np.array([[15.073510060334929, 14.525495858042685], [22.73897210140115, 14.94044782480266], [16.327929995271095, 14.419692564592896]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdsit_geometric(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.geometric(.123456789, size=(3, 2)) desired = np.array([[0, 30], [13, 2], [4, 0]]) np.testing.assert_array_equal(actual, desired) def test_randomdist_gumbel(randomdist): rnd.seed(randomdist.seed, randomdist.brng) actual = rnd.gumbel(loc=.123456789, scale=2.0, size=(3, 2)) desired = np.array([[-8.114386462751979, 2.873840411460178], [1.2231161758452016, -2.0168070493213532], [-0.7175455966332102, -8.678464904504784]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_hypergeometric(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.hypergeometric(10.1, 5.5, 14, size=(3, 2)) desired = np.array([[10, 9], [9, 10], [9, 10]]) np.testing.assert_array_equal(actual, desired) # Test nbad = 0 actual = rnd.hypergeometric(5, 0, 3, size=4) desired = np.array([3, 3, 3, 3]) np.testing.assert_array_equal(actual, desired) actual = rnd.hypergeometric(15, 0, 12, size=4) desired = np.array([12, 12, 12, 12]) np.testing.assert_array_equal(actual, desired) # Test ngood = 0 actual = rnd.hypergeometric(0, 5, 3, size=4) desired = np.array([0, 0, 0, 0]) np.testing.assert_array_equal(actual, desired) actual = rnd.hypergeometric(0, 15, 12, size=4) desired = np.array([0, 0, 0, 0]) np.testing.assert_array_equal(actual, desired) def test_randomdist_laplace(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.laplace(loc=.123456789, scale=2.0, size=(3, 2)) desired = np.array([[0.15598087210935016, -3.3424589282252994], [-1.189978401356375, 3.0607925598732253], [0.0030946589024587745, 3.14795824463997]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_logistic(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.logistic(loc=.123456789, scale=2.0, size=(3, 2)) desired = np.array([[8.345015961402696, -7.749557532940552], [-2.9534419690278444, 1.910964962531448], [0.2719300361499433, 8.913100396613983]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_lognormal(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.lognormal(mean=.123456789, sigma=2.0, size=(3, 2)) desired = np.array([[81.92291750917155, 0.01795087229603931], [0.1769118704670423, 3.415299544410577], [1.2417099625339398, 102.0631392685238]]) np.testing.assert_allclose(actual, desired, atol=1e-6, rtol=1e-10) actual = rnd.lognormal(mean=.123456789, sigma=2.0, size=(3,2), method='Box-Muller2') desired = np.array([[0.2585388231094821, 0.43734953048924663], [26.050836228611697, 26.76266237820882], [0.24216420175675096, 0.2481945765083541]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_logseries(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.logseries(p=.923456789, size=(3, 2)) desired = np.array([[18, 1], [1, 1], [5, 19]]) np.testing.assert_array_equal(actual, desired) def test_randomdist_multinomial(randomdist): rs = rnd.RandomState(randomdist.seed, brng=randomdist.brng) actual = rs.multinomial(20, [1/6.]*6, size=(3, 2)) desired = np.full((3, 2), 20, dtype=actual.dtype) np.testing.assert_array_equal(actual.sum(axis=-1), desired) expected = np.array([ [[6, 2, 1, 3, 2, 6], [7, 5, 1, 2, 3, 2]], [[5, 1, 8, 3, 2, 1], [4, 6, 0, 4, 4, 2]], [[6, 3, 1, 4, 4, 2], [3, 2, 4, 2, 1, 8]]], actual.dtype) np.testing.assert_array_equal(actual, expected) def test_randomdist_multivariate_normal(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) mean = (.123456789, 10) # Hmm... not even symmetric. cov = [[1, 0], [1, 0]] size = (3, 2) actual = rnd.multivariate_normal(mean, cov, size) desired = np.array([[[-2.42282709811266, 10.0], [1.2267795840027274, 10.0]], [[0.06813924868067336, 10.0], [1.001190462507746, 10.0]], [[-1.74157261455869, 10.0], [1.0400952859037553, 10.0]]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) # Check for default size, was raising deprecation warning actual = rnd.multivariate_normal(mean, cov) desired = np.array([1.0579899448949994, 10.0]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) # Check that non positive-semidefinite covariance raises warning mean = [0, 0] cov = [[1, 1 + 1e-10], [1 + 1e-10, 1]] assert_warns(RuntimeWarning, rnd.multivariate_normal, mean, cov) def test_randomdist_multinormal_cholesky(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) mean = (.123456789, 10) # lower-triangular cholesky matrix chol_mat = [[1, 0], [-0.5, 1]] size = (3, 2) actual = rnd.multinormal_cholesky(mean, chol_mat, size, method='ICDF') desired = np.array([[[2.26461778189133, 6.857632824379853], [-0.8043233941855025, 11.01629429884193]], [[0.1699731103551746, 12.227809261928217], [-0.6146263106001378, 9.893801873973892]], [[1.691753328795276, 10.797627196240155], [-0.647341237129921, 9.626899489691816]]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_negative_binomial(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.negative_binomial(n=100, p=.12345, size=(3, 2)) desired = np.array([[667, 679], [677, 676], [779, 648]]) np.testing.assert_array_equal(actual, desired) def test_randomdist_noncentral_chisquare(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.noncentral_chisquare(df=5, nonc=5, size=(3, 2)) desired = np.array([[5.871334619375055, 8.756238913383225], [17.29576535176833, 3.9028417087862177], [5.1315133729432505, 9.942717979531027]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) actual = rnd.noncentral_chisquare(df=.5, nonc=.2, size=(3, 2)) desired = np.array([[0.0008971007339949436, 0.08948578998156566], [0.6721835871997511, 2.8892645287699352], [5.0858149962761007e-05, 1.7315797643658821]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_noncentral_f(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.noncentral_f(dfnum=5, dfden=2, nonc=1, size=(3, 2)) desired = np.array([[0.2216297348371284, 0.7632696724492449], [98.67664232828238, 0.9500319825372799], [0.3489618249246971, 1.5035633972571092]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_normal(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.normal(loc=.123456789, scale=2.0, size=(3, 2)) desired = np.array([[4.405778774782659, -4.020116569348963], [-1.732103577371005, 1.2282652034983546], [0.21648943171034918, 4.625591634211608]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.normal(loc=.123456789, scale=2.0, size=(3, 2), method="BoxMuller") desired = np.array([[0.16673479781277187, -3.4809986872165952], [-0.05193761082535492, 3.249201213154922], [-0.11915582299214138, 3.555636100927892]]) np.testing.assert_allclose(actual, desired, atol=1e-8, rtol=1e-8) rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.normal(loc=.123456789, scale=2.0, size=(3, 2), method="BoxMuller2") desired = np.array([[0.16673479781277187, 0.48153966449249175], [-3.4809986872165952, -0.8101190082826486], [-0.051937610825354905, 2.4088402362484342]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-7) def test_randomdist_pareto(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.pareto(a=.123456789, size=(3, 2)) desired = np.array( [[0.14079174875385214, 82372044085468.92], [1247881.6368437486, 15.086855668610944], [203.2638558933401, 0.10445383654349749]]) # For some reason on 32-bit x86 Ubuntu 12.10 the [1, 0] entry in this # matrix differs by 24 nulps. Discussion: # http://mail.scipy.org/pipermail/numpy-discussion/2012-September/063801.html # Consensus is that this is probably some gcc quirk that affects # rounding but not in any important way, so we just use a looser # tolerance on this test: np.testing.assert_array_almost_equal_nulp(actual, desired, nulp=30) def test_randomdist_poisson(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.poisson(lam=.123456789, size=(3, 2)) desired = np.array([[1, 0], [0, 0], [0, 1]]) np.testing.assert_array_equal(actual, desired) rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.poisson(lam=1234.56789, size=(3, 2)) desired = np.array([[1310, 1162], [1202, 1254], [1236, 1314]]) np.testing.assert_array_equal(actual, desired) def test_poisson_exceptions(): lambig = np.iinfo('l').max lamneg = -1 assert_raises(ValueError, rnd.poisson, lamneg) assert_raises(ValueError, rnd.poisson, [lamneg]*10) assert_raises(ValueError, rnd.poisson, lambig) assert_raises(ValueError, rnd.poisson, [lambig]*10) def test_randomdist_power(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.power(a=.123456789, size=(3, 2)) desired = np.array([[0.8765841803224415, 1.2140041091640163e-14], [8.013574117268635e-07, 0.06216255187464781], [0.004895628723087296, 0.9054248959192386]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_rayleigh(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.rayleigh(scale=10, size=(3, 2)) desired = np.array([[1.80344345931194, 28.127692489122378], [18.6169699930609, 8.282068232120208], [11.460520015934597, 1.5662406536967712]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_standard_cauchy(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.standard_cauchy(size=(3, 2)) desired = np.array([[19.716487700629912, -16.608240276131227], [-1.6117703817332278, 0.7739915895826882], [0.058344614106131, 26.09825325697747]]) np.testing.assert_allclose(actual, desired, atol=1e-9, rtol=1e-10) def test_randomdist_standard_exponential(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.standard_exponential(size=(3, 2)) desired = np.array([[0.016262041554675085, 3.955835423813157], [1.7329578586126497, 0.3429632710074738], [0.6567175951781875, 0.012265548926462446]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_standard_gamma(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.standard_gamma(shape=3, size=(3, 2)) desired = np.array([[2.939330965027084, 2.799606052259993], [4.988193705918075, 2.905305108691164], [3.2630929395548147, 2.772756340265377]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_standard_normal(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.standard_normal(size=(3, 2)) desired = np.array([[2.1411609928913298, -2.071786679174482], [-0.9277801831855025, 0.5524042072491773], [0.04651632135517459, 2.2510674226058036]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.standard_normal(size=(3, 2), method='BoxMuller2') desired = np.array([[0.021639004406385935, 0.17904143774624587], [-1.8022277381082976, -0.4667878986413243], [-0.08769719991267745, 1.1426917236242171]]) np.testing.assert_allclose(actual, desired, atol=1e-7, rtol=1e-10) def test_randomdist_standard_t(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.standard_t(df=10, size=(3, 2)) desired = np.array([[-0.783927044239963, 0.04762883516531178], [0.7624597987725193, -1.8045540288955506], [-1.2657694296239195, 0.307870906117017]]) np.testing.assert_allclose(actual, desired, atol=5e-10, rtol=5e-10) def test_randomdist_triangular(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.triangular(left=5.12, mode=10.23, right=20.34, size=(3, 2)) desired = np.array([[18.764540652669638, 6.340166306695037], [8.827752689522429, 13.65605077739865], [11.732872979633328, 18.970392754850423]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_randomdist_uniform(randomdist): rnd.seed(randomdist.seed, brng=randomdist.brng) actual = rnd.uniform(low=1.23, high=10.54, size=(3, 2)) desired = np.array([[10.38982478047721, 1.408218254214153], [2.8756430713785814, 7.836974412682466], [6.057706432128325, 10.426505200380925]]) np.testing.assert_allclose(actual, desired, atol=1e-10, rtol=1e-10) def test_uniform_range_bounds(): fmin = np.finfo('float').min fmax = np.finfo('float').max func = rnd.uniform np.testing.assert_raises(OverflowError, func, -np.inf, 0) np.testing.assert_raises(OverflowError, func, 0, np.inf) # this should not throw any error, since rng can be sampled as fmin*u + fmax*(1-u) # for 0