huangfu/DronePlanning
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

增加环绕侦察场景适配

Browse Source
This commit is contained in:
huangfu
2026-01-08 15:44:38 +08:00
parent 3eba1f962b
commit 10c5bb5a8a
5441 changed files with 40219 additions and 379695 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_direct.py
View File

@@ -572,6 +572,9 @@ class TestDefaultRNG:
assert rg2 is rg
assert rg2.bit_generator is bg
@pytest.mark.thread_unsafe(
reason="np.random.set_bit_generator affects global state"
)
def test_coercion_RandomState_Generator(self):
# use default_rng to coerce RandomState to Generator
rs = RandomState(1234)

4
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_extending.py
View File

@@ -57,6 +57,10 @@ else:
@pytest.mark.skipif(sysconfig.get_platform() == 'win-arm64',
reason='Meson unable to find MSVC linker on win-arm64')
@pytest.mark.slow
@pytest.mark.thread_unsafe(
reason="building cython code in a subprocess doesn't make sense to do in many "
"threads and sometimes crashes"
)
def test_cython(tmp_path):
import glob
# build the examples in a temporary directory

130
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_generator_mt19937.py
View File

@@ -1,6 +1,7 @@
import hashlib
import os.path
import sys
import warnings
import pytest
@@ -17,8 +18,6 @@ from numpy.testing import (
assert_equal,
assert_no_warnings,
assert_raises,
assert_warns,
suppress_warnings,
)
random = Generator(MT19937())
@@ -100,6 +99,24 @@ class TestBinomial:
# Issue #4571.
assert_raises(ValueError, random.binomial, 1, np.nan)
def test_p_extremely_small(self):
n = 50000000000
p = 5e-17
sample_size = 20000000
x = random.binomial(n, p, size=sample_size)
sample_mean = x.mean()
expected_mean = n * p
sigma = np.sqrt(n * p * (1 - p) / sample_size)
# Note: the parameters were chosen so that expected_mean - 6*sigma
# is a positive value. The first `assert` below validates that
# assumption (in case someone edits the parameters in the future).
# The second `assert` is the actual test.
low_bound = expected_mean - 6 * sigma
assert low_bound > 0, "bad test params: 6-sigma lower bound is negative"
test_msg = (f"sample mean {sample_mean} deviates from the expected mean "
f"{expected_mean} by more than 6*sigma")
assert abs(expected_mean - sample_mean) < 6 * sigma, test_msg
class TestMultinomial:
def test_basic(self):
@@ -158,8 +175,7 @@ class TestMultinomial:
class TestMultivariateHypergeometric:
def setup_method(self):
self.seed = 8675309
seed = 8675309
def test_argument_validation(self):
# Error cases...
@@ -291,37 +307,40 @@ class TestMultivariateHypergeometric:
class TestSetState:
def setup_method(self):
self.seed = 1234567890
self.rg = Generator(MT19937(self.seed))
self.bit_generator = self.rg.bit_generator
self.state = self.bit_generator.state
self.legacy_state = (self.state['bit_generator'],
self.state['state']['key'],
self.state['state']['pos'])
def _create_rng(self):
seed = 1234567890
rg = Generator(MT19937(seed))
bit_generator = rg.bit_generator
state = bit_generator.state
legacy_state = (state['bit_generator'],
state['state']['key'],
state['state']['pos'])
return rg, bit_generator, state
def test_gaussian_reset(self):
# Make sure the cached every-other-Gaussian is reset.
old = self.rg.standard_normal(size=3)
self.bit_generator.state = self.state
new = self.rg.standard_normal(size=3)
rg, bit_generator, state = self._create_rng()
old = rg.standard_normal(size=3)
bit_generator.state = state
new = rg.standard_normal(size=3)
assert_(np.all(old == new))
def test_gaussian_reset_in_media_res(self):
# When the state is saved with a cached Gaussian, make sure the
# cached Gaussian is restored.
self.rg.standard_normal()
state = self.bit_generator.state
old = self.rg.standard_normal(size=3)
self.bit_generator.state = state
new = self.rg.standard_normal(size=3)
rg, bit_generator, state = self._create_rng()
rg.standard_normal()
state = bit_generator.state
old = rg.standard_normal(size=3)
bit_generator.state = state
new = rg.standard_normal(size=3)
assert_(np.all(old == new))
def test_negative_binomial(self):
# Ensure that the negative binomial results take floating point
# arguments without truncation.
self.rg.negative_binomial(0.5, 0.5)
rg, _, _ = self._create_rng()
rg.negative_binomial(0.5, 0.5)
class TestIntegers:
@@ -719,9 +738,7 @@ class TestIntegers:
class TestRandomDist:
# Make sure the random distribution returns the correct value for a
# given seed
def setup_method(self):
self.seed = 1234567890
seed = 1234567890
def test_integers(self):
random = Generator(MT19937(self.seed))
@@ -1249,6 +1266,7 @@ class TestRandomDist:
assert_array_almost_equal(actual, expected, decimal=15)
@pytest.mark.slow
@pytest.mark.thread_unsafe(reason="crashes with low memory")
def test_dirichlet_moderately_small_alpha(self):
# Use alpha.max() < 0.1 to trigger stick breaking code path
alpha = np.array([0.02, 0.04, 0.03])
@@ -1463,8 +1481,8 @@ class TestRandomDist:
# Check that non positive-semidefinite covariance warns with
# RuntimeWarning
cov = [[1, 2], [2, 1]]
assert_warns(RuntimeWarning, random.multivariate_normal, mean, cov)
assert_warns(RuntimeWarning, random.multivariate_normal, mean, cov,
pytest.warns(RuntimeWarning, random.multivariate_normal, mean, cov)
pytest.warns(RuntimeWarning, random.multivariate_normal, mean, cov,
method='eigh')
assert_raises(LinAlgError, random.multivariate_normal, mean, cov,
method='cholesky')
@@ -1491,10 +1509,9 @@ class TestRandomDist:
method='cholesky')
cov = np.array([[1, 0.1], [0.1, 1]], dtype=np.float32)
with suppress_warnings() as sup:
with warnings.catch_warnings():
warnings.simplefilter("error")
random.multivariate_normal(mean, cov, method=method)
w = sup.record(RuntimeWarning)
assert len(w) == 0
mu = np.zeros(2)
cov = np.eye(2)
@@ -1888,8 +1905,7 @@ class TestRandomDist:
class TestBroadcast:
# tests that functions that broadcast behave
# correctly when presented with non-scalar arguments
def setup_method(self):
self.seed = 123456789
seed = 123456789
def test_uniform(self):
random = Generator(MT19937(self.seed))
@@ -2501,8 +2517,7 @@ class TestBroadcast:
@pytest.mark.skipif(IS_WASM, reason="can't start thread")
class TestThread:
# make sure each state produces the same sequence even in threads
def setup_method(self):
self.seeds = range(4)
seeds = range(4)
def check_function(self, function, sz):
from threading import Thread
@@ -2547,13 +2562,11 @@ class TestThread:
# See Issue #4263
class TestSingleEltArrayInput:
def setup_method(self):
self.argOne = np.array([2])
self.argTwo = np.array([3])
self.argThree = np.array([4])
self.tgtShape = (1,)
def _create_arrays(self):
return np.array([2]), np.array([3]), np.array([4]), (1,)
def test_one_arg_funcs(self):
argOne, _, _, tgtShape = self._create_arrays()
funcs = (random.exponential, random.standard_gamma,
random.chisquare, random.standard_t,
random.pareto, random.weibull,
@@ -2568,11 +2581,12 @@ class TestSingleEltArrayInput:
out = func(np.array([0.5]))
else:
out = func(self.argOne)
out = func(argOne)
assert_equal(out.shape, self.tgtShape)
assert_equal(out.shape, tgtShape)
def test_two_arg_funcs(self):
argOne, argTwo, _, tgtShape = self._create_arrays()
funcs = (random.uniform, random.normal,
random.beta, random.gamma,
random.f, random.noncentral_chisquare,
@@ -2588,18 +2602,19 @@ class TestSingleEltArrayInput:
argTwo = np.array([0.5])
else:
argTwo = self.argTwo
argTwo = argTwo
out = func(self.argOne, argTwo)
assert_equal(out.shape, self.tgtShape)
out = func(argOne, argTwo)
assert_equal(out.shape, tgtShape)
out = func(self.argOne[0], argTwo)
assert_equal(out.shape, self.tgtShape)
out = func(argOne[0], argTwo)
assert_equal(out.shape, tgtShape)
out = func(self.argOne, argTwo[0])
assert_equal(out.shape, self.tgtShape)
out = func(argOne, argTwo[0])
assert_equal(out.shape, tgtShape)
def test_integers(self, endpoint):
_, _, _, tgtShape = self._create_arrays()
itype = [np.bool, np.int8, np.uint8, np.int16, np.uint16,
np.int32, np.uint32, np.int64, np.uint64]
func = random.integers
@@ -2608,27 +2623,28 @@ class TestSingleEltArrayInput:
for dt in itype:
out = func(low, high, endpoint=endpoint, dtype=dt)
assert_equal(out.shape, self.tgtShape)
assert_equal(out.shape, tgtShape)
out = func(low[0], high, endpoint=endpoint, dtype=dt)
assert_equal(out.shape, self.tgtShape)
assert_equal(out.shape, tgtShape)
out = func(low, high[0], endpoint=endpoint, dtype=dt)
assert_equal(out.shape, self.tgtShape)
assert_equal(out.shape, tgtShape)
def test_three_arg_funcs(self):
argOne, argTwo, argThree, tgtShape = self._create_arrays()
funcs = [random.noncentral_f, random.triangular,
random.hypergeometric]
for func in funcs:
out = func(self.argOne, self.argTwo, self.argThree)
assert_equal(out.shape, self.tgtShape)
out = func(argOne, argTwo, argThree)
assert_equal(out.shape, tgtShape)
out = func(self.argOne[0], self.argTwo, self.argThree)
assert_equal(out.shape, self.tgtShape)
out = func(argOne[0], argTwo, argThree)
assert_equal(out.shape, tgtShape)
out = func(self.argOne, self.argTwo[0], self.argThree)
assert_equal(out.shape, self.tgtShape)
out = func(argOne, argTwo[0], argThree)
assert_equal(out.shape, tgtShape)
@pytest.mark.parametrize("config", JUMP_TEST_DATA)

64
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_generator_mt19937_regressions.py
View File

@@ -6,30 +6,32 @@ from numpy.testing import assert_, assert_array_equal
class TestRegression:
def setup_method(self):
self.mt19937 = Generator(MT19937(121263137472525314065))
def _create_generator(self):
return Generator(MT19937(121263137472525314065))
def test_vonmises_range(self):
# Make sure generated random variables are in [-pi, pi].
# Regression test for ticket #986.
mt19937 = self._create_generator()
for mu in np.linspace(-7., 7., 5):
r = self.mt19937.vonmises(mu, 1, 50)
r = mt19937.vonmises(mu, 1, 50)
assert_(np.all(r > -np.pi) and np.all(r <= np.pi))
def test_hypergeometric_range(self):
# Test for ticket #921
assert_(np.all(self.mt19937.hypergeometric(3, 18, 11, size=10) < 4))
assert_(np.all(self.mt19937.hypergeometric(18, 3, 11, size=10) > 0))
mt19937 = self._create_generator()
assert_(np.all(mt19937.hypergeometric(3, 18, 11, size=10) < 4))
assert_(np.all(mt19937.hypergeometric(18, 3, 11, size=10) > 0))
# Test for ticket #5623
args = (2**20 - 2, 2**20 - 2, 2**20 - 2) # Check for 32-bit systems
assert_(self.mt19937.hypergeometric(*args) > 0)
assert_(mt19937.hypergeometric(*args) > 0)
def test_logseries_convergence(self):
# Test for ticket #923
mt19937 = self._create_generator()
N = 1000
rvsn = self.mt19937.logseries(0.8, size=N)
rvsn = mt19937.logseries(0.8, size=N)
# these two frequency counts should be close to theoretical
# numbers with this large sample
# theoretical large N result is 0.49706795
@@ -66,34 +68,39 @@ class TestRegression:
# Test for multivariate_normal issue with 'size' argument.
# Check that the multivariate_normal size argument can be a
# numpy integer.
self.mt19937.multivariate_normal([0], [[0]], size=1)
self.mt19937.multivariate_normal([0], [[0]], size=np.int_(1))
self.mt19937.multivariate_normal([0], [[0]], size=np.int64(1))
mt19937 = self._create_generator()
mt19937.multivariate_normal([0], [[0]], size=1)
mt19937.multivariate_normal([0], [[0]], size=np.int_(1))
mt19937.multivariate_normal([0], [[0]], size=np.int64(1))
def test_beta_small_parameters(self):
# Test that beta with small a and b parameters does not produce
# NaNs due to roundoff errors causing 0 / 0, gh-5851
x = self.mt19937.beta(0.0001, 0.0001, size=100)
mt19937 = self._create_generator()
x = mt19937.beta(0.0001, 0.0001, size=100)
assert_(not np.any(np.isnan(x)), 'Nans in mt19937.beta')
def test_beta_very_small_parameters(self):
# gh-24203: beta would hang with very small parameters.
self.mt19937.beta(1e-49, 1e-40)
mt19937 = self._create_generator()
mt19937.beta(1e-49, 1e-40)
def test_beta_ridiculously_small_parameters(self):
# gh-24266: beta would generate nan when the parameters
# were subnormal or a small multiple of the smallest normal.
mt19937 = self._create_generator()
tiny = np.finfo(1.0).tiny
x = self.mt19937.beta(tiny / 32, tiny / 40, size=50)
x = mt19937.beta(tiny / 32, tiny / 40, size=50)
assert not np.any(np.isnan(x))
def test_beta_expected_zero_frequency(self):
# gh-24475: For small a and b (e.g. a=0.0025, b=0.0025), beta
# would generate too many zeros.
mt19937 = self._create_generator()
a = 0.0025
b = 0.0025
n = 1000000
x = self.mt19937.beta(a, b, size=n)
x = mt19937.beta(a, b, size=n)
nzeros = np.count_nonzero(x == 0)
# beta CDF at x = np.finfo(np.double).smallest_subnormal/2
# is p = 0.0776169083131899, e.g,
@@ -114,24 +121,26 @@ class TestRegression:
# The sum of probs should be 1.0 with some tolerance.
# For low precision dtypes the tolerance was too tight.
# See numpy github issue 6123.
mt19937 = self._create_generator()
a = [1, 2, 3]
counts = [4, 4, 2]
for dt in np.float16, np.float32, np.float64:
probs = np.array(counts, dtype=dt) / sum(counts)
c = self.mt19937.choice(a, p=probs)
c = mt19937.choice(a, p=probs)
assert_(c in a)
with pytest.raises(ValueError):
self.mt19937.choice(a, p=probs * 0.9)
mt19937.choice(a, p=probs * 0.9)
def test_shuffle_of_array_of_different_length_strings(self):
# Test that permuting an array of different length strings
# will not cause a segfault on garbage collection
# Tests gh-7710
mt19937 = self._create_generator()
a = np.array(['a', 'a' * 1000])
for _ in range(100):
self.mt19937.shuffle(a)
mt19937.shuffle(a)
# Force Garbage Collection - should not segfault.
import gc
@@ -141,10 +150,11 @@ class TestRegression:
# Test that permuting an array of objects will not cause
# a segfault on garbage collection.
# See gh-7719
mt19937 = self._create_generator()
a = np.array([np.arange(1), np.arange(4)], dtype=object)
for _ in range(1000):
self.mt19937.shuffle(a)
mt19937.shuffle(a)
# Force Garbage Collection - should not segfault.
import gc
@@ -174,10 +184,11 @@ class TestRegression:
assert_array_equal(m.__array__(), np.arange(5))
def test_gamma_0(self):
assert self.mt19937.standard_gamma(0.0) == 0.0
assert_array_equal(self.mt19937.standard_gamma([0.0]), 0.0)
mt19937 = self._create_generator()
assert mt19937.standard_gamma(0.0) == 0.0
assert_array_equal(mt19937.standard_gamma([0.0]), 0.0)
actual = self.mt19937.standard_gamma([0.0], dtype='float')
actual = mt19937.standard_gamma([0.0], dtype='float')
expected = np.array([0.], dtype=np.float32)
assert_array_equal(actual, expected)
@@ -185,21 +196,24 @@ class TestRegression:
# Regression test for gh-17007.
# When p = 1e-30, the probability that a sample will exceed 2**63-1
# is 0.9999999999907766, so we expect the result to be all 2**63-1.
assert_array_equal(self.mt19937.geometric(p=1e-30, size=3),
mt19937 = self._create_generator()
assert_array_equal(mt19937.geometric(p=1e-30, size=3),
np.iinfo(np.int64).max)
def test_zipf_large_parameter(self):
# Regression test for part of gh-9829: a call such as rng.zipf(10000)
# would hang.
mt19937 = self._create_generator()
n = 8
sample = self.mt19937.zipf(10000, size=n)
sample = mt19937.zipf(10000, size=n)
assert_array_equal(sample, np.ones(n, dtype=np.int64))
def test_zipf_a_near_1(self):
# Regression test for gh-9829: a call such as rng.zipf(1.0000000000001)
# would hang.
mt19937 = self._create_generator()
n = 100000
sample = self.mt19937.zipf(1.0000000000001, size=n)
sample = mt19937.zipf(1.0000000000001, size=n)
# Not much of a test, but let's do something more than verify that
# it doesn't hang. Certainly for a monotonically decreasing
# discrete distribution truncated to signed 64 bit integers, more

807
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_random.py
View File

File diff suppressed because it is too large Load Diff

967
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_randomstate.py
View File

File diff suppressed because it is too large Load Diff

30
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_randomstate_regression.py
View File

@@ -4,11 +4,7 @@ import pytest
import numpy as np
from numpy import random
from numpy.testing import (
assert_,
assert_array_equal,
assert_raises,
)
from numpy.testing import assert_, assert_array_equal, assert_raises
class TestRegression:
@@ -58,9 +54,9 @@ class TestRegression:
[(1, 1), (2, 2), (3, 3), None],
[1, (2, 2), (3, 3), None],
[(1, 1), 2, 3, None]]:
random.seed(12345)
rng = random.RandomState(12345)
shuffled = list(t)
random.shuffle(shuffled)
rng.shuffle(shuffled)
expected = np.array([t[0], t[3], t[1], t[2]], dtype=object)
assert_array_equal(np.array(shuffled, dtype=object), expected)
@@ -135,9 +131,9 @@ class TestRegression:
class N(np.ndarray):
pass
random.seed(1)
rng = random.RandomState(1)
orig = np.arange(3).view(N)
perm = random.permutation(orig)
perm = rng.permutation(orig)
assert_array_equal(perm, np.array([0, 2, 1]))
assert_array_equal(orig, np.arange(3).view(N))
@@ -147,9 +143,9 @@ class TestRegression:
def __array__(self, dtype=None, copy=None):
return self.a
random.seed(1)
rng = random.RandomState(1)
m = M()
perm = random.permutation(m)
perm = rng.permutation(m)
assert_array_equal(perm, np.array([2, 1, 4, 0, 3]))
assert_array_equal(m.__array__(), np.arange(5))
@@ -180,27 +176,27 @@ class TestRegression:
reason='Cannot test with 32-bit C long')
def test_randint_117(self):
# GH 14189
random.seed(0)
rng = random.RandomState(0)
expected = np.array([2357136044, 2546248239, 3071714933, 3626093760,
2588848963, 3684848379, 2340255427, 3638918503,
1819583497, 2678185683], dtype='int64')
actual = random.randint(2**32, size=10)
actual = rng.randint(2**32, size=10)
assert_array_equal(actual, expected)
def test_p_zero_stream(self):
# Regression test for gh-14522. Ensure that future versions
# generate the same variates as version 1.16.
np.random.seed(12345)
assert_array_equal(random.binomial(1, [0, 0.25, 0.5, 0.75, 1]),
rng = random.RandomState(12345)
assert_array_equal(rng.binomial(1, [0, 0.25, 0.5, 0.75, 1]),
[0, 0, 0, 1, 1])
def test_n_zero_stream(self):
# Regression test for gh-14522. Ensure that future versions
# generate the same variates as version 1.16.
np.random.seed(8675309)
rng = random.RandomState(8675309)
expected = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[3, 4, 2, 3, 3, 1, 5, 3, 1, 3]])
assert_array_equal(random.binomial([[0], [10]], 0.25, size=(2, 10)),
assert_array_equal(rng.binomial([[0], [10]], 0.25, size=(2, 10)),
expected)

45
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_regression.py
View File

@@ -1,12 +1,11 @@
import inspect
import sys
import pytest
import numpy as np
from numpy import random
from numpy.testing import (
assert_,
assert_array_equal,
assert_raises,
)
from numpy.testing import IS_PYPY, assert_, assert_array_equal, assert_raises
class TestRegression:
@@ -56,9 +55,9 @@ class TestRegression:
[(1, 1), (2, 2), (3, 3), None],
[1, (2, 2), (3, 3), None],
[(1, 1), 2, 3, None]]:
np.random.seed(12345)
rng = np.random.RandomState(12345)
shuffled = list(t)
random.shuffle(shuffled)
rng.shuffle(shuffled)
expected = np.array([t[0], t[3], t[1], t[2]], dtype=object)
assert_array_equal(np.array(shuffled, dtype=object), expected)
@@ -133,9 +132,9 @@ class TestRegression:
class N(np.ndarray):
pass
np.random.seed(1)
rng = np.random.RandomState(1)
orig = np.arange(3).view(N)
perm = np.random.permutation(orig)
perm = rng.permutation(orig)
assert_array_equal(perm, np.array([0, 2, 1]))
assert_array_equal(orig, np.arange(3).view(N))
@@ -145,8 +144,32 @@ class TestRegression:
def __array__(self, dtype=None, copy=None):
return self.a
np.random.seed(1)
rng = np.random.RandomState(1)
m = M()
perm = np.random.permutation(m)
perm = rng.permutation(m)
assert_array_equal(perm, np.array([2, 1, 4, 0, 3]))
assert_array_equal(m.__array__(), np.arange(5))
@pytest.mark.skipif(sys.flags.optimize == 2, reason="Python running -OO")
@pytest.mark.skipif(IS_PYPY, reason="PyPy does not modify tp_doc")
@pytest.mark.parametrize(
"cls",
[
random.Generator,
random.MT19937,
random.PCG64,
random.PCG64DXSM,
random.Philox,
random.RandomState,
random.SFC64,
random.BitGenerator,
random.SeedSequence,
random.bit_generator.SeedlessSeedSequence,
],
)
def test_inspect_signature(self, cls: type) -> None:
assert hasattr(cls, "__text_signature__")
try:
inspect.signature(cls)
except ValueError:
pytest.fail(f"invalid signature: {cls.__module__}.{cls.__qualname__}")

537
backend_service/venv/lib/python3.13/site-packages/numpy/random/tests/test_smoke.py
View File

@@ -1,4 +1,5 @@
import pickle
from dataclasses import dataclass
from functools import partial
import pytest
@@ -7,12 +8,8 @@ import numpy as np
from numpy.random import MT19937, PCG64, PCG64DXSM, SFC64, Generator, Philox
from numpy.testing import assert_, assert_array_equal, assert_equal
@pytest.fixture(scope='module',
params=(np.bool, np.int8, np.int16, np.int32, np.int64,
np.uint8, np.uint16, np.uint32, np.uint64))
def dtype(request):
return request.param
DTYPES_BOOL_INT_UINT = (np.bool, np.int8, np.int16, np.int32, np.int64,
np.uint8, np.uint16, np.uint32, np.uint64)
def params_0(f):
@@ -92,403 +89,459 @@ def warmup(rg, n=None):
rg.random(n, dtype=np.float32)
@dataclass
class RNGData:
bit_generator: type[np.random.BitGenerator]
advance: int
seed: list[int]
rg: Generator
seed_vector_bits: int
class RNG:
@classmethod
def setup_class(cls):
def _create_rng(cls):
# Overridden in test classes. Place holder to silence IDE noise
cls.bit_generator = PCG64
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
@classmethod
def _extra_setup(cls):
cls.vec_1d = np.arange(2.0, 102.0)
cls.vec_2d = np.arange(2.0, 102.0)[None, :]
cls.mat = np.arange(2.0, 102.0, 0.01).reshape((100, 100))
cls.seed_error = TypeError
def _reset_state(self):
self.rg.bit_generator.state = self.initial_state
bit_generator = PCG64
advance = None
seed = [12345]
rg = Generator(bit_generator(*seed))
seed_vector_bits = 64
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
def test_init(self):
rg = Generator(self.bit_generator())
state = rg.bit_generator.state
rg.standard_normal(1)
rg.standard_normal(1)
rg.bit_generator.state = state
new_state = rg.bit_generator.state
data = self._create_rng()
data.rg = Generator(data.bit_generator())
state = data.rg.bit_generator.state
data.rg.standard_normal(1)
data.rg.standard_normal(1)
data.rg.bit_generator.state = state
new_state = data.rg.bit_generator.state
assert_(comp_state(state, new_state))
def test_advance(self):
state = self.rg.bit_generator.state
if hasattr(self.rg.bit_generator, 'advance'):
self.rg.bit_generator.advance(self.advance)
assert_(not comp_state(state, self.rg.bit_generator.state))
data = self._create_rng()
state = data.rg.bit_generator.state
if hasattr(data.rg.bit_generator, 'advance'):
data.rg.bit_generator.advance(data.advance)
assert_(not comp_state(state, data.rg.bit_generator.state))
else:
bitgen_name = self.rg.bit_generator.__class__.__name__
bitgen_name = data.rg.bit_generator.__class__.__name__
pytest.skip(f'Advance is not supported by {bitgen_name}')
def test_jump(self):
state = self.rg.bit_generator.state
if hasattr(self.rg.bit_generator, 'jumped'):
bit_gen2 = self.rg.bit_generator.jumped()
rg = self._create_rng().rg
state = rg.bit_generator.state
if hasattr(rg.bit_generator, 'jumped'):
bit_gen2 = rg.bit_generator.jumped()
jumped_state = bit_gen2.state
assert_(not comp_state(state, jumped_state))
self.rg.random(2 * 3 * 5 * 7 * 11 * 13 * 17)
self.rg.bit_generator.state = state
bit_gen3 = self.rg.bit_generator.jumped()
rg.random(2 * 3 * 5 * 7 * 11 * 13 * 17)
rg.bit_generator.state = state
bit_gen3 = rg.bit_generator.jumped()
rejumped_state = bit_gen3.state
assert_(comp_state(jumped_state, rejumped_state))
else:
bitgen_name = self.rg.bit_generator.__class__.__name__
bitgen_name = rg.bit_generator.__class__.__name__
if bitgen_name not in ('SFC64',):
raise AttributeError(f'no "jumped" in {bitgen_name}')
pytest.skip(f'Jump is not supported by {bitgen_name}')
def test_uniform(self):
r = self.rg.uniform(-1.0, 0.0, size=10)
rg = self._create_rng().rg
r = rg.uniform(-1.0, 0.0, size=10)
assert_(len(r) == 10)
assert_((r > -1).all())
assert_((r <= 0).all())
def test_uniform_array(self):
r = self.rg.uniform(np.array([-1.0] * 10), 0.0, size=10)
rg = self._create_rng().rg
r = rg.uniform(np.array([-1.0] * 10), 0.0, size=10)
assert_(len(r) == 10)
assert_((r > -1).all())
assert_((r <= 0).all())
r = self.rg.uniform(np.array([-1.0] * 10),
r = rg.uniform(np.array([-1.0] * 10),
np.array([0.0] * 10), size=10)
assert_(len(r) == 10)
assert_((r > -1).all())
assert_((r <= 0).all())
r = self.rg.uniform(-1.0, np.array([0.0] * 10), size=10)
r = rg.uniform(-1.0, np.array([0.0] * 10), size=10)
assert_(len(r) == 10)
assert_((r > -1).all())
assert_((r <= 0).all())
def test_random(self):
assert_(len(self.rg.random(10)) == 10)
params_0(self.rg.random)
rg = self._create_rng().rg
assert_(len(rg.random(10)) == 10)
params_0(rg.random)
def test_standard_normal_zig(self):
assert_(len(self.rg.standard_normal(10)) == 10)
rg = self._create_rng().rg
assert_(len(rg.standard_normal(10)) == 10)
def test_standard_normal(self):
assert_(len(self.rg.standard_normal(10)) == 10)
params_0(self.rg.standard_normal)
rg = self._create_rng().rg
assert_(len(rg.standard_normal(10)) == 10)
params_0(rg.standard_normal)
def test_standard_gamma(self):
assert_(len(self.rg.standard_gamma(10, 10)) == 10)
assert_(len(self.rg.standard_gamma(np.array([10] * 10), 10)) == 10)
params_1(self.rg.standard_gamma)
rg = self._create_rng().rg
assert_(len(rg.standard_gamma(10, 10)) == 10)
assert_(len(rg.standard_gamma(np.array([10] * 10), 10)) == 10)
params_1(rg.standard_gamma)
def test_standard_exponential(self):
assert_(len(self.rg.standard_exponential(10)) == 10)
params_0(self.rg.standard_exponential)
rg = self._create_rng().rg
assert_(len(rg.standard_exponential(10)) == 10)
params_0(rg.standard_exponential)
def test_standard_exponential_float(self):
randoms = self.rg.standard_exponential(10, dtype='float32')
rg = self._create_rng().rg
randoms = rg.standard_exponential(10, dtype='float32')
assert_(len(randoms) == 10)
assert randoms.dtype == np.float32
params_0(partial(self.rg.standard_exponential, dtype='float32'))
params_0(partial(rg.standard_exponential, dtype='float32'))
def test_standard_exponential_float_log(self):
randoms = self.rg.standard_exponential(10, dtype='float32',
rg = self._create_rng().rg
randoms = rg.standard_exponential(10, dtype='float32',
method='inv')
assert_(len(randoms) == 10)
assert randoms.dtype == np.float32
params_0(partial(self.rg.standard_exponential, dtype='float32',
params_0(partial(rg.standard_exponential, dtype='float32',
method='inv'))
def test_standard_cauchy(self):
assert_(len(self.rg.standard_cauchy(10)) == 10)
params_0(self.rg.standard_cauchy)
rg = self._create_rng().rg
assert_(len(rg.standard_cauchy(10)) == 10)
params_0(rg.standard_cauchy)
def test_standard_t(self):
assert_(len(self.rg.standard_t(10, 10)) == 10)
params_1(self.rg.standard_t)
rg = self._create_rng().rg
assert_(len(rg.standard_t(10, 10)) == 10)
params_1(rg.standard_t)
def test_binomial(self):
assert_(self.rg.binomial(10, .5) >= 0)
assert_(self.rg.binomial(1000, .5) >= 0)
rg = self._create_rng().rg
assert_(rg.binomial(10, .5) >= 0)
assert_(rg.binomial(1000, .5) >= 0)
def test_reset_state(self):
state = self.rg.bit_generator.state
int_1 = self.rg.integers(2**31)
self.rg.bit_generator.state = state
int_2 = self.rg.integers(2**31)
rg = self._create_rng().rg
state = rg.bit_generator.state
int_1 = rg.integers(2**31)
rg.bit_generator.state = state
int_2 = rg.integers(2**31)
assert_(int_1 == int_2)
def test_entropy_init(self):
rg = Generator(self.bit_generator())
rg2 = Generator(self.bit_generator())
bit_generator = self._create_rng().bit_generator
rg = Generator(bit_generator())
rg2 = Generator(bit_generator())
assert_(not comp_state(rg.bit_generator.state,
rg2.bit_generator.state))
def test_seed(self):
rg = Generator(self.bit_generator(*self.seed))
rg2 = Generator(self.bit_generator(*self.seed))
data = self._create_rng()
rg = Generator(data.bit_generator(*data.seed))
rg2 = Generator(data.bit_generator(*data.seed))
rg.random()
rg2.random()
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_reset_state_gauss(self):
rg = Generator(self.bit_generator(*self.seed))
data = self._create_rng()
rg = Generator(data.bit_generator(*data.seed))
rg.standard_normal()
state = rg.bit_generator.state
n1 = rg.standard_normal(size=10)
rg2 = Generator(self.bit_generator())
rg2 = Generator(data.bit_generator())
rg2.bit_generator.state = state
n2 = rg2.standard_normal(size=10)
assert_array_equal(n1, n2)
def test_reset_state_uint32(self):
rg = Generator(self.bit_generator(*self.seed))
data = self._create_rng()
rg = Generator(data.bit_generator(*data.seed))
rg.integers(0, 2 ** 24, 120, dtype=np.uint32)
state = rg.bit_generator.state
n1 = rg.integers(0, 2 ** 24, 10, dtype=np.uint32)
rg2 = Generator(self.bit_generator())
rg2 = Generator(data.bit_generator())
rg2.bit_generator.state = state
n2 = rg2.integers(0, 2 ** 24, 10, dtype=np.uint32)
assert_array_equal(n1, n2)
def test_reset_state_float(self):
rg = Generator(self.bit_generator(*self.seed))
data = self._create_rng()
rg = Generator(data.bit_generator(*data.seed))
rg.random(dtype='float32')
state = rg.bit_generator.state
n1 = rg.random(size=10, dtype='float32')
rg2 = Generator(self.bit_generator())
rg2 = Generator(data.bit_generator())
rg2.bit_generator.state = state
n2 = rg2.random(size=10, dtype='float32')
assert_((n1 == n2).all())
def test_shuffle(self):
rg = self._create_rng().rg
original = np.arange(200, 0, -1)
permuted = self.rg.permutation(original)
permuted = rg.permutation(original)
assert_((original != permuted).any())
def test_permutation(self):
rg = self._create_rng().rg
original = np.arange(200, 0, -1)
permuted = self.rg.permutation(original)
permuted = rg.permutation(original)
assert_((original != permuted).any())
def test_beta(self):
vals = self.rg.beta(2.0, 2.0, 10)
rg = self._create_rng().rg
vals = rg.beta(2.0, 2.0, 10)
assert_(len(vals) == 10)
vals = self.rg.beta(np.array([2.0] * 10), 2.0)
vals = rg.beta(np.array([2.0] * 10), 2.0)
assert_(len(vals) == 10)
vals = self.rg.beta(2.0, np.array([2.0] * 10))
vals = rg.beta(2.0, np.array([2.0] * 10))
assert_(len(vals) == 10)
vals = self.rg.beta(np.array([2.0] * 10), np.array([2.0] * 10))
vals = rg.beta(np.array([2.0] * 10), np.array([2.0] * 10))
assert_(len(vals) == 10)
vals = self.rg.beta(np.array([2.0] * 10), np.array([[2.0]] * 10))
vals = rg.beta(np.array([2.0] * 10), np.array([[2.0]] * 10))
assert_(vals.shape == (10, 10))
def test_bytes(self):
vals = self.rg.bytes(10)
rg = self._create_rng().rg
vals = rg.bytes(10)
assert_(len(vals) == 10)
def test_chisquare(self):
vals = self.rg.chisquare(2.0, 10)
rg = self._create_rng().rg
vals = rg.chisquare(2.0, 10)
assert_(len(vals) == 10)
params_1(self.rg.chisquare)
params_1(rg.chisquare)
def test_exponential(self):
vals = self.rg.exponential(2.0, 10)
rg = self._create_rng().rg
vals = rg.exponential(2.0, 10)
assert_(len(vals) == 10)
params_1(self.rg.exponential)
params_1(rg.exponential)
def test_f(self):
vals = self.rg.f(3, 1000, 10)
rg = self._create_rng().rg
vals = rg.f(3, 1000, 10)
assert_(len(vals) == 10)
def test_gamma(self):
vals = self.rg.gamma(3, 2, 10)
rg = self._create_rng().rg
vals = rg.gamma(3, 2, 10)
assert_(len(vals) == 10)
def test_geometric(self):
vals = self.rg.geometric(0.5, 10)
rg = self._create_rng().rg
vals = rg.geometric(0.5, 10)
assert_(len(vals) == 10)
params_1(self.rg.exponential, bounded=True)
params_1(rg.exponential, bounded=True)
def test_gumbel(self):
vals = self.rg.gumbel(2.0, 2.0, 10)
rg = self._create_rng().rg
vals = rg.gumbel(2.0, 2.0, 10)
assert_(len(vals) == 10)
def test_laplace(self):
vals = self.rg.laplace(2.0, 2.0, 10)
rg = self._create_rng().rg
vals = rg.laplace(2.0, 2.0, 10)
assert_(len(vals) == 10)
def test_logitic(self):
vals = self.rg.logistic(2.0, 2.0, 10)
rg = self._create_rng().rg
vals = rg.logistic(2.0, 2.0, 10)
assert_(len(vals) == 10)
def test_logseries(self):
vals = self.rg.logseries(0.5, 10)
rg = self._create_rng().rg
vals = rg.logseries(0.5, 10)
assert_(len(vals) == 10)
def test_negative_binomial(self):
vals = self.rg.negative_binomial(10, 0.2, 10)
rg = self._create_rng().rg
vals = rg.negative_binomial(10, 0.2, 10)
assert_(len(vals) == 10)
def test_noncentral_chisquare(self):
vals = self.rg.noncentral_chisquare(10, 2, 10)
rg = self._create_rng().rg
vals = rg.noncentral_chisquare(10, 2, 10)
assert_(len(vals) == 10)
def test_noncentral_f(self):
vals = self.rg.noncentral_f(3, 1000, 2, 10)
rg = self._create_rng().rg
vals = rg.noncentral_f(3, 1000, 2, 10)
assert_(len(vals) == 10)
vals = self.rg.noncentral_f(np.array([3] * 10), 1000, 2)
vals = rg.noncentral_f(np.array([3] * 10), 1000, 2)
assert_(len(vals) == 10)
vals = self.rg.noncentral_f(3, np.array([1000] * 10), 2)
vals = rg.noncentral_f(3, np.array([1000] * 10), 2)
assert_(len(vals) == 10)
vals = self.rg.noncentral_f(3, 1000, np.array([2] * 10))
vals = rg.noncentral_f(3, 1000, np.array([2] * 10))
assert_(len(vals) == 10)
def test_normal(self):
vals = self.rg.normal(10, 0.2, 10)
rg = self._create_rng().rg
vals = rg.normal(10, 0.2, 10)
assert_(len(vals) == 10)
def test_pareto(self):
vals = self.rg.pareto(3.0, 10)
rg = self._create_rng().rg
vals = rg.pareto(3.0, 10)
assert_(len(vals) == 10)
def test_poisson(self):
vals = self.rg.poisson(10, 10)
rg = self._create_rng().rg
vals = rg.poisson(10, 10)
assert_(len(vals) == 10)
vals = self.rg.poisson(np.array([10] * 10))
vals = rg.poisson(np.array([10] * 10))
assert_(len(vals) == 10)
params_1(self.rg.poisson)
params_1(rg.poisson)
def test_power(self):
vals = self.rg.power(0.2, 10)
rg = self._create_rng().rg
vals = rg.power(0.2, 10)
assert_(len(vals) == 10)
def test_integers(self):
vals = self.rg.integers(10, 20, 10)
rg = self._create_rng().rg
vals = rg.integers(10, 20, 10)
assert_(len(vals) == 10)
def test_rayleigh(self):
vals = self.rg.rayleigh(0.2, 10)
rg = self._create_rng().rg
vals = rg.rayleigh(0.2, 10)
assert_(len(vals) == 10)
params_1(self.rg.rayleigh, bounded=True)
params_1(rg.rayleigh, bounded=True)
def test_vonmises(self):
vals = self.rg.vonmises(10, 0.2, 10)
rg = self._create_rng().rg
vals = rg.vonmises(10, 0.2, 10)
assert_(len(vals) == 10)
def test_wald(self):
vals = self.rg.wald(1.0, 1.0, 10)
rg = self._create_rng().rg
vals = rg.wald(1.0, 1.0, 10)
assert_(len(vals) == 10)
def test_weibull(self):
vals = self.rg.weibull(1.0, 10)
rg = self._create_rng().rg
vals = rg.weibull(1.0, 10)
assert_(len(vals) == 10)
def test_zipf(self):
vals = self.rg.zipf(10, 10)
rg = self._create_rng().rg
vec_1d = np.arange(2.0, 102.0)
vec_2d = np.arange(2.0, 102.0)[None, :]
mat = np.arange(2.0, 102.0, 0.01).reshape((100, 100))
vals = rg.zipf(10, 10)
assert_(len(vals) == 10)
vals = self.rg.zipf(self.vec_1d)
vals = rg.zipf(vec_1d)
assert_(len(vals) == 100)
vals = self.rg.zipf(self.vec_2d)
vals = rg.zipf(vec_2d)
assert_(vals.shape == (1, 100))
vals = self.rg.zipf(self.mat)
vals = rg.zipf(mat)
assert_(vals.shape == (100, 100))
def test_hypergeometric(self):
vals = self.rg.hypergeometric(25, 25, 20)
rg = self._create_rng().rg
vals = rg.hypergeometric(25, 25, 20)
assert_(np.isscalar(vals))
vals = self.rg.hypergeometric(np.array([25] * 10), 25, 20)
vals = rg.hypergeometric(np.array([25] * 10), 25, 20)
assert_(vals.shape == (10,))
def test_triangular(self):
vals = self.rg.triangular(-5, 0, 5)
rg = self._create_rng().rg
vals = rg.triangular(-5, 0, 5)
assert_(np.isscalar(vals))
vals = self.rg.triangular(-5, np.array([0] * 10), 5)
vals = rg.triangular(-5, np.array([0] * 10), 5)
assert_(vals.shape == (10,))
def test_multivariate_normal(self):
rg = self._create_rng().rg
mean = [0, 0]
cov = [[1, 0], [0, 100]] # diagonal covariance
x = self.rg.multivariate_normal(mean, cov, 5000)
x = rg.multivariate_normal(mean, cov, 5000)
assert_(x.shape == (5000, 2))
x_zig = self.rg.multivariate_normal(mean, cov, 5000)
x_zig = rg.multivariate_normal(mean, cov, 5000)
assert_(x.shape == (5000, 2))
x_inv = self.rg.multivariate_normal(mean, cov, 5000)
x_inv = rg.multivariate_normal(mean, cov, 5000)
assert_(x.shape == (5000, 2))
assert_((x_zig != x_inv).any())
def test_multinomial(self):
vals = self.rg.multinomial(100, [1.0 / 3, 2.0 / 3])
rg = self._create_rng().rg
vals = rg.multinomial(100, [1.0 / 3, 2.0 / 3])
assert_(vals.shape == (2,))
vals = self.rg.multinomial(100, [1.0 / 3, 2.0 / 3], size=10)
vals = rg.multinomial(100, [1.0 / 3, 2.0 / 3], size=10)
assert_(vals.shape == (10, 2))
def test_dirichlet(self):
s = self.rg.dirichlet((10, 5, 3), 20)
rg = self._create_rng().rg
s = rg.dirichlet((10, 5, 3), 20)
assert_(s.shape == (20, 3))
def test_pickle(self):
pick = pickle.dumps(self.rg)
rg = self._create_rng().rg
pick = pickle.dumps(rg)
unpick = pickle.loads(pick)
assert_(type(self.rg) == type(unpick))
assert_(comp_state(self.rg.bit_generator.state,
assert_(type(rg) == type(unpick))
assert_(comp_state(rg.bit_generator.state,
unpick.bit_generator.state))
pick = pickle.dumps(self.rg)
pick = pickle.dumps(rg)
unpick = pickle.loads(pick)
assert_(type(self.rg) == type(unpick))
assert_(comp_state(self.rg.bit_generator.state,
assert_(type(rg) == type(unpick))
assert_(comp_state(rg.bit_generator.state,
unpick.bit_generator.state))
def test_seed_array(self):
if self.seed_vector_bits is None:
bitgen_name = self.bit_generator.__name__
data = self._create_rng()
if data.seed_vector_bits is None:
bitgen_name = data.bit_generator.__name__
pytest.skip(f'Vector seeding is not supported by {bitgen_name}')
if self.seed_vector_bits == 32:
if data.seed_vector_bits == 32:
dtype = np.uint32
else:
dtype = np.uint64
seed = np.array([1], dtype=dtype)
bg = self.bit_generator(seed)
bg = data.bit_generator(seed)
state1 = bg.state
bg = self.bit_generator(1)
bg = data.bit_generator(1)
state2 = bg.state
assert_(comp_state(state1, state2))
seed = np.arange(4, dtype=dtype)
bg = self.bit_generator(seed)
bg = data.bit_generator(seed)
state1 = bg.state
bg = self.bit_generator(seed[0])
bg = data.bit_generator(seed[0])
state2 = bg.state
assert_(not comp_state(state1, state2))
seed = np.arange(1500, dtype=dtype)
bg = self.bit_generator(seed)
bg = data.bit_generator(seed)
state1 = bg.state
bg = self.bit_generator(seed[0])
bg = data.bit_generator(seed[0])
state2 = bg.state
assert_(not comp_state(state1, state2))
seed = 2 ** np.mod(np.arange(1500, dtype=dtype),
self.seed_vector_bits - 1) + 1
bg = self.bit_generator(seed)
data.seed_vector_bits - 1) + 1
bg = data.bit_generator(seed)
state1 = bg.state
bg = self.bit_generator(seed[0])
bg = data.bit_generator(seed[0])
state2 = bg.state
assert_(not comp_state(state1, state2))
def test_uniform_float(self):
rg = Generator(self.bit_generator(12345))
bit_generator = self._create_rng().bit_generator
rg = Generator(bit_generator(12345))
warmup(rg)
state = rg.bit_generator.state
r1 = rg.random(11, dtype=np.float32)
rg2 = Generator(self.bit_generator())
rg2 = Generator(bit_generator())
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.random(11, dtype=np.float32)
@@ -497,11 +550,12 @@ class RNG:
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_gamma_floats(self):
rg = Generator(self.bit_generator())
bit_generator = self._create_rng().bit_generator
rg = Generator(bit_generator())
warmup(rg)
state = rg.bit_generator.state
r1 = rg.standard_gamma(4.0, 11, dtype=np.float32)
rg2 = Generator(self.bit_generator())
rg2 = Generator(bit_generator())
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.standard_gamma(4.0, 11, dtype=np.float32)
@@ -510,11 +564,12 @@ class RNG:
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_normal_floats(self):
rg = Generator(self.bit_generator())
bit_generator = self._create_rng().bit_generator
rg = Generator(bit_generator())
warmup(rg)
state = rg.bit_generator.state
r1 = rg.standard_normal(11, dtype=np.float32)
rg2 = Generator(self.bit_generator())
rg2 = Generator(bit_generator())
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.standard_normal(11, dtype=np.float32)
@@ -523,11 +578,12 @@ class RNG:
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_normal_zig_floats(self):
rg = Generator(self.bit_generator())
bit_generator = self._create_rng().bit_generator
rg = Generator(bit_generator())
warmup(rg)
state = rg.bit_generator.state
r1 = rg.standard_normal(11, dtype=np.float32)
rg2 = Generator(self.bit_generator())
rg2 = Generator(bit_generator())
warmup(rg2)
rg2.bit_generator.state = state
r2 = rg2.standard_normal(11, dtype=np.float32)
@@ -536,7 +592,7 @@ class RNG:
assert_(comp_state(rg.bit_generator.state, rg2.bit_generator.state))
def test_output_fill(self):
rg = self.rg
rg = self._create_rng().rg
state = rg.bit_generator.state
size = (31, 7, 97)
existing = np.empty(size)
@@ -558,7 +614,7 @@ class RNG:
assert_equal(direct, existing)
def test_output_filling_uniform(self):
rg = self.rg
rg = self._create_rng().rg
state = rg.bit_generator.state
size = (31, 7, 97)
existing = np.empty(size)
@@ -576,7 +632,7 @@ class RNG:
assert_equal(direct, existing)
def test_output_filling_exponential(self):
rg = self.rg
rg = self._create_rng().rg
state = rg.bit_generator.state
size = (31, 7, 97)
existing = np.empty(size)
@@ -594,7 +650,7 @@ class RNG:
assert_equal(direct, existing)
def test_output_filling_gamma(self):
rg = self.rg
rg = self._create_rng().rg
state = rg.bit_generator.state
size = (31, 7, 97)
existing = np.zeros(size)
@@ -612,7 +668,7 @@ class RNG:
assert_equal(direct, existing)
def test_output_filling_gamma_broadcast(self):
rg = self.rg
rg = self._create_rng().rg
state = rg.bit_generator.state
size = (31, 7, 97)
mu = np.arange(97.0) + 1.0
@@ -631,7 +687,7 @@ class RNG:
assert_equal(direct, existing)
def test_output_fill_error(self):
rg = self.rg
rg = self._create_rng().rg
size = (31, 7, 97)
existing = np.empty(size)
with pytest.raises(TypeError):
@@ -653,7 +709,14 @@ class RNG:
with pytest.raises(ValueError):
rg.standard_gamma(1.0, out=existing[::3])
@pytest.mark.parametrize("dtype", DTYPES_BOOL_INT_UINT)
def test_integers_broadcast(self, dtype):
rg = self._create_rng().rg
initial_state = rg.bit_generator.state
def reset_state(rng):
rng.bit_generator.state = initial_state
if dtype == np.bool:
upper = 2
lower = 0
@@ -661,45 +724,50 @@ class RNG:
info = np.iinfo(dtype)
upper = int(info.max) + 1
lower = info.min
self._reset_state()
a = self.rg.integers(lower, [upper] * 10, dtype=dtype)
self._reset_state()
b = self.rg.integers([lower] * 10, upper, dtype=dtype)
reset_state(rg)
rg.bit_generator.state = initial_state
a = rg.integers(lower, [upper] * 10, dtype=dtype)
reset_state(rg)
b = rg.integers([lower] * 10, upper, dtype=dtype)
assert_equal(a, b)
self._reset_state()
c = self.rg.integers(lower, upper, size=10, dtype=dtype)
reset_state(rg)
c = rg.integers(lower, upper, size=10, dtype=dtype)
assert_equal(a, c)
self._reset_state()
d = self.rg.integers(np.array(
reset_state(rg)
d = rg.integers(np.array(
[lower] * 10), np.array([upper], dtype=object), size=10,
dtype=dtype)
assert_equal(a, d)
self._reset_state()
e = self.rg.integers(
reset_state(rg)
e = rg.integers(
np.array([lower] * 10), np.array([upper] * 10), size=10,
dtype=dtype)
assert_equal(a, e)
self._reset_state()
a = self.rg.integers(0, upper, size=10, dtype=dtype)
self._reset_state()
b = self.rg.integers([upper] * 10, dtype=dtype)
reset_state(rg)
a = rg.integers(0, upper, size=10, dtype=dtype)
reset_state(rg)
b = rg.integers([upper] * 10, dtype=dtype)
assert_equal(a, b)
@pytest.mark.parametrize("dtype", DTYPES_BOOL_INT_UINT)
def test_integers_numpy(self, dtype):
rg = self._create_rng().rg
high = np.array([1])
low = np.array([0])
out = self.rg.integers(low, high, dtype=dtype)
out = rg.integers(low, high, dtype=dtype)
assert out.shape == (1,)
out = self.rg.integers(low[0], high, dtype=dtype)
out = rg.integers(low[0], high, dtype=dtype)
assert out.shape == (1,)
out = self.rg.integers(low, high[0], dtype=dtype)
out = rg.integers(low, high[0], dtype=dtype)
assert out.shape == (1,)
@pytest.mark.parametrize("dtype", DTYPES_BOOL_INT_UINT)
def test_integers_broadcast_errors(self, dtype):
rg = self._create_rng().rg
if dtype == np.bool:
upper = 2
lower = 0
@@ -708,102 +776,97 @@ class RNG:
upper = int(info.max) + 1
lower = info.min
with pytest.raises(ValueError):
self.rg.integers(lower, [upper + 1] * 10, dtype=dtype)
rg.integers(lower, [upper + 1] * 10, dtype=dtype)
with pytest.raises(ValueError):
self.rg.integers(lower - 1, [upper] * 10, dtype=dtype)
rg.integers(lower - 1, [upper] * 10, dtype=dtype)
with pytest.raises(ValueError):
self.rg.integers([lower - 1], [upper] * 10, dtype=dtype)
rg.integers([lower - 1], [upper] * 10, dtype=dtype)
with pytest.raises(ValueError):
self.rg.integers([0], [0], dtype=dtype)
rg.integers([0], [0], dtype=dtype)
class TestMT19937(RNG):
@classmethod
def setup_class(cls):
cls.bit_generator = MT19937
cls.advance = None
cls.seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 32
cls._extra_setup()
cls.seed_error = ValueError
def _create_rng(cls):
bit_generator = MT19937
advance = None
seed = [2 ** 21 + 2 ** 16 + 2 ** 5 + 1]
rg = Generator(bit_generator(*seed))
seed_vector_bits = 32
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
def test_numpy_state(self):
rg = self._create_rng().rg
nprg = np.random.RandomState()
nprg.standard_normal(99)
state = nprg.get_state()
self.rg.bit_generator.state = state
state2 = self.rg.bit_generator.state
rg.bit_generator.state = state
state2 = rg.bit_generator.state
assert_((state[1] == state2['state']['key']).all())
assert_(state[2] == state2['state']['pos'])
class TestPhilox(RNG):
@classmethod
def setup_class(cls):
cls.bit_generator = Philox
cls.advance = 2**63 + 2**31 + 2**15 + 1
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def _create_rng(cls):
bit_generator = Philox
advance = 2**63 + 2**31 + 2**15 + 1
seed = [12345]
rg = Generator(bit_generator(*seed))
seed_vector_bits = 64
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
class TestSFC64(RNG):
@classmethod
def setup_class(cls):
cls.bit_generator = SFC64
cls.advance = None
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 192
cls._extra_setup()
def _create_rng(cls):
bit_generator = SFC64
advance = None
seed = [12345]
rg = Generator(bit_generator(*seed))
seed_vector_bits = 192
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
class TestPCG64(RNG):
@classmethod
def setup_class(cls):
cls.bit_generator = PCG64
cls.advance = 2**63 + 2**31 + 2**15 + 1
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def _create_rng(cls):
bit_generator = PCG64
advance = 2**63 + 2**31 + 2**15 + 1
seed = [12345]
rg = Generator(bit_generator(*seed))
seed_vector_bits = 64
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
class TestPCG64DXSM(RNG):
@classmethod
def setup_class(cls):
cls.bit_generator = PCG64DXSM
cls.advance = 2**63 + 2**31 + 2**15 + 1
cls.seed = [12345]
cls.rg = Generator(cls.bit_generator(*cls.seed))
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
def _create_rng(cls):
bit_generator = PCG64DXSM
advance = 2**63 + 2**31 + 2**15 + 1
seed = [12345]
rg = Generator(bit_generator(*seed))
seed_vector_bits = 64
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
class TestDefaultRNG(RNG):
@classmethod
def setup_class(cls):
def _create_rng(cls):
# This will duplicate some tests that directly instantiate a fresh
# Generator(), but that's okay.
cls.bit_generator = PCG64
cls.advance = 2**63 + 2**31 + 2**15 + 1
cls.seed = [12345]
cls.rg = np.random.default_rng(*cls.seed)
cls.initial_state = cls.rg.bit_generator.state
cls.seed_vector_bits = 64
cls._extra_setup()
bit_generator = PCG64
advance = 2**63 + 2**31 + 2**15 + 1
seed = [12345]
rg = np.random.default_rng(*seed)
seed_vector_bits = 64
return RNGData(bit_generator, advance, seed, rg, seed_vector_bits)
def test_default_is_pcg64(self):
# In order to change the default BitGenerator, we'll go through
# a deprecation cycle to move to a different function.
assert_(isinstance(self.rg.bit_generator, PCG64))
rg = self._create_rng().rg
assert_(isinstance(rg.bit_generator, PCG64))
def test_seed(self):
np.random.default_rng()