mirror of https://github.com/exaloop/codon.git
992 lines
40 KiB
Python
992 lines
40 KiB
Python
import numpy.random as rnd
|
|
from numpy import *
|
|
import numpy as np
|
|
|
|
@test
|
|
def test_MT19937_integers(seed, low, expected, high=None, size=None, e=False):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(low, int)
|
|
or isinstance(low, float)) and (high is None or isinstance(
|
|
high, int) or isinstance(high, float)):
|
|
assert gen.integers(low, high, endpoint=e) == expected
|
|
else:
|
|
assert (gen.integers(low, high, endpoint=e) == expected).all()
|
|
else:
|
|
assert (gen.integers(low, high, size, endpoint=e) == expected).all()
|
|
|
|
test_MT19937_integers(74, 5, 3)
|
|
test_MT19937_integers(74, 987.4, 706)
|
|
test_MT19937_integers(74, 98, 734, high=987)
|
|
test_MT19937_integers(74, 89, 64, e=True)
|
|
test_MT19937_integers(74, -1218, -277, high=98)
|
|
test_MT19937_integers(74, -5, np.array([37, 38, 38]), 55, size=3)
|
|
test_MT19937_integers(74, -5, np.array([38, 39, 39]), 55, size=3, e=True)
|
|
test_MT19937_integers(74, np.array([7, 49, 17]), np.array([57, 70, 61]), 78)
|
|
test_MT19937_integers(74, -99, np.array([26, 38, 45]), np.array([77, 89, 101]))
|
|
test_MT19937_integers(74, np.array([7, 49, 17]), np.array([57, 78, 77]),
|
|
np.array([77, 89, 101]))
|
|
|
|
@test
|
|
def test_MT19937_random(seed, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
assert gen.random() == expected
|
|
else:
|
|
assert (round(gen.random(size), 8) == round(expected, 8)).all()
|
|
|
|
test_MT19937_random(0, 0.47932306384132817)
|
|
test_MT19937_random(1, 0.24067553804036945)
|
|
test_MT19937_random(1234, 0.12038356302504949)
|
|
test_MT19937_random(
|
|
1234,
|
|
np.array([0.12038356, 0.40370142, 0.87770263, 0.95657880, 0.42646002]),
|
|
size=5)
|
|
test_MT19937_random(74,
|
|
np.array([[0.71552153, 0.72399061, 0.98011015],
|
|
[0.92823638, 0.81411241, 0.85174267]]),
|
|
size=(2, 3))
|
|
|
|
@test
|
|
def test_MT19937_choice(seed,
|
|
a,
|
|
expected,
|
|
size=None,
|
|
r=True,
|
|
p=None,
|
|
axis=0,
|
|
shuffle=True):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(a, int):
|
|
assert gen.choice(a, size, r, p, axis, shuffle) == expected
|
|
elif staticlen(a.shape) == 1:
|
|
assert gen.choice(a, size, r, p, axis, shuffle) == expected
|
|
else:
|
|
assert (round(gen.choice(a, size, r, p, axis, shuffle),
|
|
8) == expected).all()
|
|
else:
|
|
assert (round(gen.choice(a, size, r, p, axis, shuffle),
|
|
8) == expected).all()
|
|
|
|
test_MT19937_choice(
|
|
621,
|
|
np.array([
|
|
1.34, 2.15, 3.21, 4.78, 5.55, 6.42, 7.99, 8.31, 9.61, 10.75, 11.33,
|
|
12.93
|
|
]), np.array([9.61, 8.31, 1.34]), 3)
|
|
test_MT19937_choice(
|
|
318, np.array([5, 4, 2, 6, 7, 8, 2, 12, 1, 55, 33, 7, 78, 15, 43]), 5)
|
|
test_MT19937_choice(318, np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
|
|
np.array([12, 1, 11]), 3, False)
|
|
test_MT19937_choice(
|
|
4589,
|
|
np.array([
|
|
-1.34, -2.15, -3.21, -4.78, -5.55, -6.42, -7.99, -8.31, -9.61, -10.75,
|
|
-11.33, -12.93
|
|
]), -1.34)
|
|
test_MT19937_choice(318,
|
|
np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]),
|
|
np.array([[1, 2, 3], [10, 11, 12]]), 2)
|
|
test_MT19937_choice(74,
|
|
np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]),
|
|
np.array([7, 8, 9]))
|
|
test_MT19937_choice(74, 1, 0)
|
|
test_MT19937_choice(74, np.array([13, -4]), -4, p=np.array([0.3, 0.7]))
|
|
test_MT19937_choice(74,
|
|
np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]),
|
|
np.array([[3], [6], [9], [12]]),
|
|
axis=1)
|
|
test_MT19937_choice(74,
|
|
np.array([13, -4, 3, 18]),
|
|
-4,
|
|
p=np.array([0.5, 0.3, 0.1, 0.1]),
|
|
shuffle=True)
|
|
|
|
@test
|
|
def test_MT19937_bytes(seed, length, expected):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
check = gen.bytes(length) == expected
|
|
assert check
|
|
|
|
test_MT19937_bytes(555, 10, "\x93\x94\x84Ym\xca5\xa7\x0bi")
|
|
|
|
@test
|
|
def test_MT19937_shuffle(seed, x, expected, axis=0):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
gen.shuffle(x, axis)
|
|
assert (x == expected).all()
|
|
|
|
test_MT19937_shuffle(876, np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
|
|
np.array([9, 0, 5, 7, 4, 3, 1, 8, 6, 2]))
|
|
test_MT19937_shuffle(111, np.array([5.43, 6.56, 1.22, 4.3221, 7.88, 0.9352]),
|
|
np.array([1.22, 4.3221, 6.56, 0.9352, 5.43, 7.88]))
|
|
test_MT19937_shuffle(1234, np.array([3.14]), np.array([3.14]))
|
|
test_MT19937_shuffle(74,
|
|
np.arange(9).reshape((3, 3)),
|
|
np.array([[6, 7, 8], [3, 4, 5], [0, 1, 2]]))
|
|
test_MT19937_shuffle(74,
|
|
np.arange(9).reshape((3, 3)),
|
|
np.array([[2, 1, 0], [5, 4, 3], [8, 7, 6]]),
|
|
axis=1)
|
|
|
|
@test
|
|
def test_MT19937_permutation(seed, x, expected, axis=0):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
assert (gen.permutation(x, axis) == expected).all()
|
|
|
|
test_MT19937_permutation(12345, 10, np.array([6, 8, 0, 7, 9, 2, 5, 4, 1, 3]))
|
|
test_MT19937_permutation(1234,
|
|
np.array([1.124, 4.7532, 9.1246, 12.53243, 15.64324]),
|
|
np.array([1.124, 12.53243, 4.7532, 15.64324, 9.1246]))
|
|
test_MT19937_permutation(
|
|
4321,
|
|
np.arange(24).reshape(3, 8),
|
|
np.array([[0, 1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14, 15],
|
|
[16, 17, 18, 19, 20, 21, 22, 23]]))
|
|
test_MT19937_permutation(74,
|
|
np.arange(9).reshape((3, 3)),
|
|
np.array([[2, 1, 0], [5, 4, 3], [8, 7, 6]]),
|
|
axis=1)
|
|
|
|
@test
|
|
def test_MT19937_permuted(seed, x, expected, axis=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
arr = gen.permuted(x, axis)
|
|
assert (arr == expected).all()
|
|
|
|
test_MT19937_permuted(4321,
|
|
np.array([1.124, 4.7532, 9.1246, 12.53243, 15.64324]),
|
|
np.array([15.64324, 9.1246, 1.124, 12.53243, 4.7532]))
|
|
test_MT19937_permuted(
|
|
4321,
|
|
np.arange(24).reshape(3, 8),
|
|
np.array([[7, 8, 10, 2, 9, 15, 23, 20], [19, 17, 13, 21, 18, 16, 4, 5],
|
|
[11, 3, 1, 22, 0, 14, 12, 6]]))
|
|
|
|
@test
|
|
def test_MT19937_beta(seed, a, b, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(a, int) or isinstance(a, float)) and (isinstance(
|
|
b, int) or isinstance(b, float)):
|
|
assert gen.beta(a, b) == expected
|
|
else:
|
|
assert (round(gen.beta(a, b), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.beta(a, b, size), 8) == expected).all()
|
|
|
|
#test_MT19937_beta(4321, -7, 0, error)
|
|
test_MT19937_beta(4321, 0.2, 0.1, 0.001794143054409161)
|
|
test_MT19937_beta(4321, 10, 14, 0.44288329572745766)
|
|
test_MT19937_beta(4321, 167, 2041,
|
|
np.array([0.08210844, 0.07407015, 0.07356348, 0.07749650]),
|
|
4)
|
|
test_MT19937_beta(139, 14.32, 4, 0.498515830795026)
|
|
test_MT19937_beta(457, 12.87, 9.21, 0.5178223999023288)
|
|
test_MT19937_beta(
|
|
457, np.array([12.87, 1.32, 4.532, 1.34, 8.432]), 9.21,
|
|
np.array([0.51782240, 0.10097888, 0.38175823, 0.36792669, 0.48282513]))
|
|
test_MT19937_beta(
|
|
457, 32.14, np.array([9.21, 0.21, 14.32, 41.21, 5.55]),
|
|
np.array([[0.73639876, 1.00000000, 0.68338397, 0.53857496, 0.83560158]]))
|
|
test_MT19937_beta(
|
|
457, np.array([12.87, 1.32, 4.532, 1.34, 8.432]),
|
|
np.array([9.21, 0.21, 14.32, 41.21, 5.55]),
|
|
np.array([0.51782240, 0.99999999, 0.29636436, 0.10105227, 0.59638962]))
|
|
|
|
@test
|
|
def test_MT19937_binomial(seed, n, p, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(n, int) or isinstance(n, float)) and (isinstance(
|
|
p, int) or isinstance(p, float)):
|
|
assert gen.binomial(n, p) == expected
|
|
else:
|
|
assert (gen.binomial(n, p) == expected).all()
|
|
else:
|
|
assert (gen.binomial(n, p, size) == expected).all()
|
|
|
|
#test_MT19937_binomial(139, -2, .33, error)
|
|
test_MT19937_binomial(139, 28400, .66, 18590)
|
|
test_MT19937_binomial(139, 14.76, .33, 6)
|
|
test_MT19937_binomial(139, 0, .33, 0)
|
|
test_MT19937_binomial(139, 14, 0, 0)
|
|
test_MT19937_binomial(147, 10, .5, np.array([6, 6, 3, 5, 7, 5, 5, 6, 5, 3]),
|
|
10)
|
|
test_MT19937_binomial(457, np.array([12, 1, 4, 7, 8]), 0.11,
|
|
np.array([2, 0, 0, 0, 0]))
|
|
test_MT19937_binomial(457, 12, np.array([0.11, 0.21, 0.32, 0.43]),
|
|
np.array([2, 3, 1, 4]))
|
|
test_MT19937_binomial(457, np.array([12, 1, 4, 7, 8]),
|
|
np.array([0.11, 0.21, 0.32, 0.43, 0.55]),
|
|
np.array([2, 0, 0, 2, 5]))
|
|
|
|
@test
|
|
def test_MT19937_chisquare(seed, df, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(df, float) or isinstance(df, int)):
|
|
assert gen.chisquare(df) == expected
|
|
else:
|
|
assert (round(gen.chisquare(df), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.chisquare(df, size), 8) == expected).all()
|
|
|
|
test_MT19937_chisquare(457, 12.12, 10.371553390964028)
|
|
test_MT19937_chisquare(457, 24.12, np.array([21.88993555, 28.10914107]), 2)
|
|
test_MT19937_chisquare(
|
|
457, np.array([23, 42, 34, 17]),
|
|
np.array([20.80858708, 47.42164781, 32.29862709, 14.08026439]))
|
|
test_MT19937_chisquare(
|
|
457, np.array([274.23, 325.42, 352.34, 825.17]),
|
|
np.array([268.13692669, 341.31749251, 348.28803050, 807.81116202]))
|
|
|
|
@test
|
|
def test_MT19937_dirichlet(seed, alpha, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
assert (round(gen.dirichlet(alpha, size), 8) == round(expected, 8)).all()
|
|
|
|
test_MT19937_dirichlet(
|
|
457, np.array([278.23, 325.42, 352.34, 825.17]),
|
|
np.array([0.15451881, 0.18988989, 0.19714225, 0.45844905]))
|
|
test_MT19937_dirichlet(
|
|
874, np.array([10, 5, 3]),
|
|
np.array([[0.63510742, 0.22941463, 0.13547795],
|
|
[0.74168572, 0.20100343, 0.05731085]]), 2)
|
|
#test_MT19937_dirichlet(1234, np.array([]), np.array([]))
|
|
test_MT19937_dirichlet(74, np.array([0.01, 0.05]),
|
|
np.array([1.85187737e-12, 1.00000000]))
|
|
|
|
@test
|
|
def test_MT19937_exponential(seed, scale, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(scale, float) or isinstance(scale, int)):
|
|
assert gen.exponential(scale) == expected
|
|
else:
|
|
assert (round(gen.exponential(scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.exponential(scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_exponential(74, 1, 0.29730933531689413)
|
|
test_MT19937_exponential(874, 3, 1.3077665346601641)
|
|
test_MT19937_exponential(874, 724.952, 316.0226549449851)
|
|
test_MT19937_exponential(
|
|
874, np.array([278.23, 325.42, 352.34, 825.17]),
|
|
np.array([121.28662765, 1308.69597268, 1407.647810890, 156.18934242]))
|
|
test_MT19937_exponential(
|
|
874, 724.952,
|
|
np.array([
|
|
316.02265494, 2915.43778128, 2896.28511041, 137.21993791, 449.65873658,
|
|
462.39004499, 1267.56770807
|
|
]), 7)
|
|
|
|
@test
|
|
def test_MT19937_f(seed, dfnum, dfden, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(dfnum, float)
|
|
or isinstance(dfnum, int)) and (isinstance(dfden, float)
|
|
or isinstance(dfden, int)):
|
|
assert gen.f(dfnum, dfden) == expected
|
|
else:
|
|
assert (round(gen.f(dfnum, dfden), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.f(dfnum, dfden, size), 8) == expected).all()
|
|
|
|
test_MT19937_f(874, 12, 4.21, 1.6343383299954102)
|
|
test_MT19937_f(
|
|
874, np.array([14, 15, 16, 17, 18]), 4.21,
|
|
np.array([1.60433134, 0.33113465, 2.70993818, 1.30846860, 0.31543733]))
|
|
test_MT19937_f(
|
|
874, 2557, 0.92,
|
|
np.array([0.35240241, 0.35598113, 1.55704194, 1.06506043, 0.51375425]), 5)
|
|
test_MT19937_f(874, 7343, np.array([12.52, 0.92, 231.52]),
|
|
np.array([1.07913456, 0.35586940, 1.10156925]))
|
|
|
|
@test
|
|
def test_MT19937_gamma(seed, shape, expected, scale=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(shape, float)
|
|
or isinstance(shape, int)) and (isinstance(scale, float)
|
|
or isinstance(scale, int)):
|
|
assert gen.gamma(shape, scale) == expected
|
|
else:
|
|
assert (round(gen.gamma(shape, scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.gamma(shape, scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_gamma(318, 564, 579.9843506186213)
|
|
test_MT19937_gamma(318, 564, 3189.9139284024172, 5.5)
|
|
test_MT19937_gamma(318, 564, np.array([3189.91392840, 1295.02679157]),
|
|
np.array([5.5, 2.2]))
|
|
test_MT19937_gamma(
|
|
318, 564,
|
|
np.array([2391.52777079, 2427.25399922, 2330.71722926, 2310.71793516]),
|
|
4.123435, 4)
|
|
test_MT19937_gamma(
|
|
318, np.array([19, 17, 45, 52, 21]),
|
|
np.array(
|
|
[185.59130933, 181.36147656, 384.65049865, 432.13182218,
|
|
150.84772053]), 8.527)
|
|
test_MT19937_gamma(
|
|
318, np.array([19, 17, 45, 52, 21]),
|
|
np.array(
|
|
[23.94164891, 93.58396820, 90.21942035, 385.15326007, 174.60619229]),
|
|
np.array([1.1, 4.4, 2, 7.6, 9.87]))
|
|
|
|
@test
|
|
def test_MT19937_geometric(seed, p, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(p, float) or isinstance(p, int):
|
|
assert gen.geometric(p) == expected
|
|
else:
|
|
assert (gen.geometric(p) == expected).all()
|
|
else:
|
|
assert (gen.geometric(p, size) == expected).all()
|
|
|
|
test_MT19937_geometric(457, 0.35, 3)
|
|
test_MT19937_geometric(457, 0.2, 7)
|
|
test_MT19937_geometric(2000, 1, 1)
|
|
test_MT19937_geometric(12654, 0.5, np.array([1., 5., 3., 1.]), 4)
|
|
test_MT19937_geometric(12654, np.array([0.01, 0.6, 0.45, 0.33]),
|
|
np.array([53, 4, 4, 1]))
|
|
|
|
@test
|
|
def test_MT19937_gumbel(seed, expected, loc=0.0, scale=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(loc, float) or isinstance(loc, int)) and (isinstance(
|
|
scale, float) or isinstance(scale, int)):
|
|
assert gen.gumbel(loc, scale) == expected
|
|
else:
|
|
assert (round(gen.gumbel(loc, scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.gumbel(loc, scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_gumbel(1234, 2.0536230569636045)
|
|
test_MT19937_gumbel(1234, 14.053623056963605, 12)
|
|
test_MT19937_gumbel(1234, 250.54201294955973, scale=122)
|
|
test_MT19937_gumbel(1234,
|
|
np.array([2.05362306, 0.65968578, -0.74255606]),
|
|
size=3)
|
|
test_MT19937_gumbel(1234,
|
|
np.array(
|
|
[2.85362306, 1.82968578, -0.61255606, 264.30679443]),
|
|
loc=np.array([0.8, 1.17, 0.13, 265.45]))
|
|
test_MT19937_gumbel(1234,
|
|
np.array(
|
|
[24.23275207, 33.75612153, -44.64989592, -7.37367590]),
|
|
scale=np.array([11.8, 51.17, 60.13, 6.45]))
|
|
|
|
@test
|
|
def test_MT19937_hypergeometric(seed,
|
|
ngood,
|
|
nbad,
|
|
nsample,
|
|
expected,
|
|
size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(ngood, int) or isinstance(ngood, float)) and (
|
|
isinstance(nbad, int) or isinstance(nbad, float)) and (
|
|
isinstance(nsample, int) or isinstance(nsample, float)):
|
|
assert gen.hypergeometric(ngood, nbad, nsample) == expected
|
|
else:
|
|
assert (gen.hypergeometric(ngood, nbad, nsample) == expected).all()
|
|
else:
|
|
assert (gen.hypergeometric(ngood, nbad, nsample,
|
|
size) == expected).all()
|
|
|
|
test_MT19937_hypergeometric(1234, 11, 12, 9, 6)
|
|
test_MT19937_hypergeometric(1234, 100, 300, 200, 43)
|
|
#test_MT19937_hypergeometric(1234, 100.31, 300.55, 200.2, 43)
|
|
test_MT19937_hypergeometric(1234, 100, 300, np.array([200, 201, 222, 221]),
|
|
np.array([43, 55, 57, 60]))
|
|
test_MT19937_hypergeometric(1234, 100, np.array([301, 303, 304, 344, 355]),
|
|
200, np.array([43, 45, 48, 41, 44]))
|
|
test_MT19937_hypergeometric(1234, np.array([100, 111, 112, 122]), 300, 200,
|
|
np.array([43, 50, 53, 53]))
|
|
test_MT19937_hypergeometric(1234, 100, 700, 450, np.array([63, 61, 58, 61,
|
|
56]), 5)
|
|
|
|
@test
|
|
def test_MT19937_laplace(seed, expected, loc=0.0, scale=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(loc, float) or isinstance(loc, int)) and (isinstance(
|
|
scale, float) or isinstance(scale, int)):
|
|
assert gen.laplace(loc, scale) == expected
|
|
else:
|
|
assert (round(gen.laplace(loc, scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.laplace(loc, scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_laplace(1234, -1.4239250945926396)
|
|
test_MT19937_laplace(1234, 10.57607490540736, 12)
|
|
test_MT19937_laplace(1234, -173.71886154030204, scale=122)
|
|
test_MT19937_laplace(1234,
|
|
np.array([-1.42392509, -0.21393255, 1.40815252]),
|
|
size=3)
|
|
test_MT19937_laplace(1234,
|
|
np.array(
|
|
[-0.62392509, 0.95606745, 1.53815252, 267.89366033]),
|
|
loc=np.array([0.8, 1.17, 0.13, 265.45]))
|
|
test_MT19937_laplace(
|
|
1234,
|
|
np.array([-16.80231612, -10.94692881, 84.67221132, 15.76160913]),
|
|
scale=np.array([11.8, 51.17, 60.13, 6.45]))
|
|
|
|
@test
|
|
def test_MT19937_logistic(seed, expected, loc=0.0, scale=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(loc, float) or isinstance(loc, int)) and (isinstance(
|
|
scale, float) or isinstance(scale, int)):
|
|
assert gen.logistic(loc, scale) == expected
|
|
else:
|
|
assert (round(gen.logistic(loc, scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.logistic(loc, scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_logistic(1234, -1.9888029415511161)
|
|
test_MT19937_logistic(1234, 10.011197058448884, 12)
|
|
test_MT19937_logistic(1234, -242.63395886923618, scale=122)
|
|
test_MT19937_logistic(1234,
|
|
np.array([-1.98880294, -0.39006597, 1.97085227]),
|
|
size=3)
|
|
test_MT19937_logistic(1234,
|
|
np.array(
|
|
[-1.18880294, 0.77993403, 2.10085227, 268.54241540]),
|
|
loc=np.array([0.8, 1.17, 0.13, 265.45]))
|
|
test_MT19937_logistic(
|
|
1234,
|
|
np.array([-23.46787471, -19.95967576, 118.50734684, 19.94607935]),
|
|
scale=np.array([11.8, 51.17, 60.13, 6.45]))
|
|
|
|
@test
|
|
def test_MT19937_lognormal(seed, expected, mean=0.0, sigma=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(mean, float) or isinstance(mean, int)) and (isinstance(
|
|
sigma, float) or isinstance(sigma, int)):
|
|
assert gen.lognormal(mean, sigma) == expected
|
|
else:
|
|
assert (round(gen.lognormal(mean, sigma), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.lognormal(mean, sigma, size), 8) == expected).all()
|
|
|
|
test_MT19937_lognormal(1234, 7.733643068788345)
|
|
test_MT19937_lognormal(1234, 1258687.4645696718, 12)
|
|
test_MT19937_lognormal(1234, 59.809235115418005, sigma=2)
|
|
test_MT19937_lognormal(1234,
|
|
np.array([7.73364307, 0.81831089, 1.03314855]),
|
|
size=3)
|
|
test_MT19937_lognormal(
|
|
1234,
|
|
np.array([17.21153918, 2.63659168, 1.17657889, 756.94196432]),
|
|
mean=np.array([0.8, 1.17, 0.13, 5.45]))
|
|
test_MT19937_lognormal(1234,
|
|
np.array(
|
|
[39.72751712, 0.35464005, 1.00424843, 58.47145689]),
|
|
sigma=np.array([1.8, 5.17, 0.13, 3.45]))
|
|
|
|
@test
|
|
def test_MT19937_logseries(seed, p, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(p, float) or isinstance(p, int):
|
|
assert gen.logseries(p) == expected
|
|
else:
|
|
assert (gen.logseries(p) == expected).all()
|
|
else:
|
|
assert (gen.logseries(p, size) == expected).all()
|
|
|
|
test_MT19937_logseries(457, 0.35, 1)
|
|
test_MT19937_logseries(2000, 0, 1)
|
|
test_MT19937_logseries(457, 0.5, np.array([1., 1., 2., 1.]), 4)
|
|
test_MT19937_logseries(457, np.array([0.01, 0.6, 0.45, 0.33]),
|
|
np.array([1, 1, 2, 1]))
|
|
|
|
@test
|
|
def test_MT19937_multinomial(seed, n, pvals, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
assert (round(gen.multinomial(n, pvals, size), 8) == expected).all()
|
|
|
|
test_MT19937_multinomial(457, 20, [1 / 6.], np.array([20]))
|
|
test_MT19937_multinomial(457, 20.6, [1 / 6.], np.array([20]))
|
|
test_MT19937_multinomial(457, 20, [1 / 6.] * 6, np.array([4, 4, 1, 3, 4, 4]))
|
|
test_MT19937_multinomial(
|
|
457, 20, [1 / 6] * 6,
|
|
np.array([[4, 4, 1, 3, 4, 4], [4, 0, 4, 3, 6, 3], [4, 4, 5, 1, 1, 5]]), 3)
|
|
#test_MT19937_multinomial(457, 1, np.array([[.1, .5, .4 ], [.3, .7, .0]]), np.array([[0, 0, 1], [0, 1, 0]]))
|
|
#test_MT19937_multinomial(457, -1, [1/6.], error)
|
|
|
|
@test
|
|
def test_MT19937_multivariate_hypergeometric(seed,
|
|
colors,
|
|
nsample,
|
|
expected,
|
|
size=None,
|
|
method='marginals'):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
assert (gen.multivariate_hypergeometric(colors, nsample, size,
|
|
method) == expected).all()
|
|
|
|
test_MT19937_multivariate_hypergeometric(457, np.array([16, 8, 4]), 15,
|
|
np.array([10, 4, 1]))
|
|
test_MT19937_multivariate_hypergeometric(457,
|
|
np.array([16, 8, 4]),
|
|
15,
|
|
np.array([[10, 4, 1], [8, 5, 2],
|
|
[9, 4, 2]]),
|
|
size=3)
|
|
test_MT19937_multivariate_hypergeometric(457, np.array([16, 8, 4]), 0,
|
|
np.array([0, 0, 0]))
|
|
test_MT19937_multivariate_hypergeometric(457,
|
|
np.array([16, 8, 4]),
|
|
8,
|
|
np.array([4, 3, 1]),
|
|
method='count')
|
|
|
|
@test
|
|
def test_MT19937_multivariate_normal(seed,
|
|
mean,
|
|
cov,
|
|
expected,
|
|
size=None,
|
|
check_valid: Static[str] = 'warn',
|
|
tol: float = 1e-8,
|
|
m: Static[str] = 'svd'):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
assert (round(
|
|
gen.multivariate_normal(mean,
|
|
cov,
|
|
size,
|
|
check_valid=check_valid,
|
|
tol=tol,
|
|
method=m), 8) == expected).all()
|
|
|
|
test_MT19937_multivariate_normal(1234, (1, 2), np.array([[1, 0], [0, 1]]),
|
|
np.array([3.04558004, 1.79948705]))
|
|
test_MT19937_multivariate_normal(5432, (1, 2),
|
|
np.array([[1, 0], [0, 1]]),
|
|
np.array([0.16390254, 2.42265006]),
|
|
m='cholesky')
|
|
|
|
@test
|
|
def test_MT19937_negative_binomial(seed, n, p, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(n, int) or isinstance(n, float)) and (isinstance(
|
|
p, int) or isinstance(p, float)):
|
|
assert gen.negative_binomial(n, p) == expected
|
|
else:
|
|
assert (gen.negative_binomial(n, p) == expected).all()
|
|
else:
|
|
assert (gen.negative_binomial(n, p, size) == expected).all()
|
|
|
|
test_MT19937_negative_binomial(139, 28400, .66, 14541)
|
|
test_MT19937_negative_binomial(139, 14.76, .33, 21)
|
|
#test_MT19937_negative_binomial(139, 14, 0, error)
|
|
test_MT19937_negative_binomial(147, 10, .5,
|
|
np.array([6, 6, 11, 9, 8, 7, 10, 22, 4, 10]),
|
|
10)
|
|
test_MT19937_negative_binomial(457, np.array([12, 1, 4, 7, 8]), 0.11,
|
|
np.array([66, 1, 14, 70, 68]))
|
|
test_MT19937_negative_binomial(457, 12, np.array([0.11, 0.21, 0.32, 0.43]),
|
|
np.array([[66, 39, 41, 15]]))
|
|
|
|
@test
|
|
def test_MT19937_noncentral_chisquare(seed, df, nonc, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(df, int) or isinstance(df, float)) and (isinstance(
|
|
nonc, int) or isinstance(nonc, float)):
|
|
assert gen.noncentral_chisquare(df, nonc) == expected
|
|
else:
|
|
assert (round(gen.noncentral_chisquare(df, nonc),
|
|
8) == expected).all()
|
|
else:
|
|
assert (round(gen.noncentral_chisquare(df, nonc, size),
|
|
8) == expected).all()
|
|
|
|
test_MT19937_noncentral_chisquare(457, 0.1, 0.2, 0.004731999292935856)
|
|
test_MT19937_noncentral_chisquare(457, 5, 0, 3.681528279878184)
|
|
test_MT19937_noncentral_chisquare(457, 99, 7, 104.90202975815625)
|
|
test_MT19937_noncentral_chisquare(
|
|
457, 14.2, 0.5, np.array([13.21259789, 7.10349904, 15.26757211]), 3)
|
|
test_MT19937_noncentral_chisquare(
|
|
457, np.array([8, 7.1, 45.3]), 0.6,
|
|
np.array([7.53680531, 2.86873129, 44.87145655]))
|
|
test_MT19937_noncentral_chisquare(
|
|
457, 0.6, np.array([8, 7.1, 45.3]),
|
|
np.array([5.50303631, 0.12292794, 48.45712182]))
|
|
|
|
@test
|
|
def test_MT19937_noncentral_f(seed, dfnum, dfden, nonc, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(dfnum, float) or isinstance(dfnum, int)) and (
|
|
isinstance(dfden, int)
|
|
or isinstance(dfden, float)) and (isinstance(nonc, int)
|
|
or isinstance(nonc, float)):
|
|
assert gen.noncentral_f(dfnum, dfden, nonc) == expected
|
|
else:
|
|
assert (round(gen.noncentral_f(dfnum, dfden, nonc),
|
|
8) == expected).all()
|
|
else:
|
|
assert (round(gen.noncentral_f(dfnum, dfden, nonc, size),
|
|
8) == expected).all()
|
|
|
|
test_MT19937_noncentral_f(874, 3, 20, 3, 0.34619084015853513)
|
|
test_MT19937_noncentral_f(874, 3, 20, 0, 1.714196752567725)
|
|
test_MT19937_noncentral_f(
|
|
874, np.array([14, 15, 16, 17, 18]), 4.21, 6.7,
|
|
np.array([2.22094675, 1.17172906, 7.58260278, 0.82149275, 2.28171278]))
|
|
test_MT19937_noncentral_f(
|
|
874, 27, 5.92, 3.1,
|
|
np.array([1.58502318, 0.92155582, 3.77043692, 0.68717422, 1.64072948]), 5)
|
|
test_MT19937_noncentral_f(
|
|
874, 27, np.array([5.92, 8.13, 9.53, 33.14]), 3.1,
|
|
np.array([1.58502318, 0.89487268, 2.43982719, 0.92196298]))
|
|
test_MT19937_noncentral_f(
|
|
874, 743, 8.24, np.array([0.11, 0.21, 0.32, 0.43]),
|
|
np.array([1.20344619, 1.02049827, 3.17379438, 0.61622202]))
|
|
|
|
@test
|
|
def test_MT19937_normal(seed, expected, loc=0.0, scale=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(loc, float) or isinstance(loc, int)) and (isinstance(
|
|
scale, float) or isinstance(scale, int)):
|
|
assert gen.normal(loc, scale) == expected
|
|
else:
|
|
assert (round(gen.normal(loc, scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.normal(loc, scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_normal(1234, 2.0455800412005876)
|
|
test_MT19937_normal(1234, 14.045580041200587, 12)
|
|
test_MT19937_normal(1234, 249.56076502647167, scale=122)
|
|
test_MT19937_normal(1234,
|
|
np.array([2.04558004, -0.20051295, 0.03261098]),
|
|
size=3)
|
|
test_MT19937_normal(1234,
|
|
np.array([2.84558004, 0.96948705, 0.16261098,
|
|
26.62928659]),
|
|
loc=np.array([0.8, 1.17, 0.13, 25.45]))
|
|
test_MT19937_normal(1234,
|
|
np.array(
|
|
[24.13784449, -10.26024755, 1.96089830, 7.60639847]),
|
|
scale=np.array([11.8, 51.17, 60.13, 6.45]))
|
|
|
|
@test
|
|
def test_MT19937_pareto(seed, a, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(a, float) or isinstance(a, int):
|
|
assert gen.pareto(a) == expected
|
|
else:
|
|
assert (round(gen.pareto(a), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.pareto(a, size), 8) == expected).all()
|
|
|
|
test_MT19937_pareto(1234, 3, 0.08386598990600276)
|
|
test_MT19937_pareto(
|
|
1234, 5,
|
|
np.array([0.04950703, 0.11427519, 0.21520507, 0.44809618, 0.16192707]), 5)
|
|
test_MT19937_pareto(
|
|
1234, np.array([3, 13, 4, 23.2, 5.6]),
|
|
np.array([0.08386599, 0.04249510, 0.27588628, 0.08306523, 0.14339271]))
|
|
|
|
@test
|
|
def test_MT19937_poisson(seed, expected, lam=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(lam, float) or isinstance(lam, int):
|
|
assert gen.poisson(lam) == expected
|
|
else:
|
|
assert (round(gen.poisson(lam), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.poisson(lam, size), 8) == expected).all()
|
|
|
|
test_MT19937_poisson(1234, 0, 0)
|
|
test_MT19937_poisson(1234, 0)
|
|
test_MT19937_poisson(1234, 1, 3)
|
|
test_MT19937_poisson(1234, 9, 14.65)
|
|
test_MT19937_poisson(1234, np.array([27., 14., 17., 82., 30.]),
|
|
np.array([35.62, 9.23, 9.57, 76.79, 21.74]))
|
|
test_MT19937_poisson(1234, np.array([785., 818., 868., 839., 803.]), 824.14, 5)
|
|
|
|
@test
|
|
def test_MT19937_power(seed, a, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(a, float) or isinstance(a, int):
|
|
assert gen.power(a) == expected
|
|
else:
|
|
assert (round(gen.power(a), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.power(a, size), 8) == expected).all()
|
|
|
|
test_MT19937_power(1234, 1, 0.21463194364452776)
|
|
test_MT19937_power(1234, 45.11, 0.966462434390213)
|
|
test_MT19937_power(1234, 6, np.array([0.77377684, 0.86464152, 0.92407356]), 3)
|
|
test_MT19937_power(
|
|
1234, np.array([5.4, 1.1, 78, 19.34, 99999999999999]),
|
|
np.array(
|
|
array([0.75203784, 0.45234475, 0.99394429, 0.99120555, 1.00000000])))
|
|
|
|
@test
|
|
def test_MT19937_rayleigh(seed, expected, scale=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(scale, float) or isinstance(scale, int):
|
|
assert gen.rayleigh(scale) == expected
|
|
else:
|
|
assert (round(gen.rayleigh(scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.rayleigh(scale, size), 8) == expected).all()
|
|
|
|
#test_MT19937_rayleigh(1234, error, -1)
|
|
test_MT19937_rayleigh(1234, 0.6951299295551241)
|
|
test_MT19937_rayleigh(1234, 2.0853897886653723, 3)
|
|
test_MT19937_rayleigh(1234, 10.183653467982568, 14.65)
|
|
test_MT19937_rayleigh(1234,
|
|
np.array(
|
|
[0.69512993, 1.04021218, 1.39611191, 1.92418740]),
|
|
size=4)
|
|
test_MT19937_rayleigh(
|
|
1234,
|
|
np.array([3.75370162, 1.14423340, 108.89672861, 37.21378433, 68.84898931]),
|
|
np.array([5.4, 1.1, 78, 19.34, 56.2]))
|
|
|
|
@test
|
|
def test_MT19937_standard_cauchy(seed, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
assert gen.standard_cauchy() == expected
|
|
else:
|
|
assert (round(gen.standard_cauchy(size), 8) == round(expected,
|
|
8)).all()
|
|
|
|
test_MT19937_standard_cauchy(1234, -10.201735410135576)
|
|
test_MT19937_standard_cauchy(
|
|
1234, np.array([-10.20173541, 0.02765314, 1.39310640, 0.50990013]), 4)
|
|
|
|
@test
|
|
def test_MT19937_standard_exponential(seed, expected, size=None, m='zig'):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
assert gen.standard_exponential(method=m) == expected
|
|
else:
|
|
assert (round(gen.standard_exponential(size, method=m),
|
|
8) == expected).all()
|
|
|
|
test_MT19937_standard_exponential(1234, 0.24160280948165586)
|
|
test_MT19937_standard_exponential(
|
|
1234, np.array([0.24160281, 0.54102069, 0.97456423, 1.85124858]), 4)
|
|
test_MT19937_standard_exponential(1234, 0.1282693336014689, m='inv')
|
|
|
|
@test
|
|
def test_MT19937_standard_gamma(seed, shape, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(shape, float) or isinstance(shape, int):
|
|
assert gen.standard_gamma(shape) == expected
|
|
else:
|
|
assert (round(gen.standard_gamma(shape), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.standard_gamma(shape, size), 8) == expected).all()
|
|
|
|
test_MT19937_standard_gamma(318, 1, 0.0589214166795813)
|
|
test_MT19937_standard_gamma(1234, 0, 0)
|
|
test_MT19937_standard_gamma(1234, 0.5, 0.014492202246606063)
|
|
test_MT19937_standard_gamma(1234, 3, 7.59601798666233)
|
|
test_MT19937_standard_gamma(
|
|
1234, 0.5, np.array([0.01449220, 1.44979965, 0.18186815, 1.71465035]), 4)
|
|
test_MT19937_standard_gamma(
|
|
1234, np.array([4.5, 2, 7.7, 81.15]),
|
|
np.array([9.89229577, 1.70912275, 8.61357207, 77.06196796]))
|
|
|
|
@test
|
|
def test_MT19937_standard_normal(seed, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
assert gen.standard_normal(size) == expected
|
|
else:
|
|
assert (round(gen.standard_normal(size), 8) == expected).all()
|
|
|
|
test_MT19937_standard_normal(1234, 2.0455800412005876)
|
|
test_MT19937_standard_normal(1234,
|
|
np.array([2.04558004, -0.20051295, 0.03261098]),
|
|
3)
|
|
|
|
@test
|
|
def test_MT19937_standard_t(seed, df, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if isinstance(df, float) or isinstance(df, int):
|
|
assert gen.standard_t(df) == expected
|
|
else:
|
|
assert (round(gen.standard_t(df), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.standard_t(df, size), 8) == expected).all()
|
|
|
|
test_MT19937_standard_t(1234, 3, 2.5527064129505828)
|
|
test_MT19937_standard_t(1234, 1, 3.582953759233768)
|
|
test_MT19937_standard_t(1234, 0.5, 6.275754251724512)
|
|
test_MT19937_standard_t(1234, 0.5,
|
|
np.array([6.27575425, 3.24214707, -0.29526934]), 3)
|
|
test_MT19937_standard_t(1234, np.array([99, 5.6, 11.43]),
|
|
np.array([2.08220290, 1.10034819, -0.52927360]))
|
|
|
|
@test
|
|
def test_MT19937_triangular(seed, left, mode, right, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(left, int) or isinstance(left, float)) and (isinstance(
|
|
mode, int) or isinstance(mode, float)) and (isinstance(
|
|
right, int) or isinstance(right, float)):
|
|
assert gen.triangular(left, mode, right) == expected
|
|
else:
|
|
assert (round(gen.triangular(left, mode, right),
|
|
8) == expected).all()
|
|
else:
|
|
assert (round(gen.triangular(left, mode, right, size),
|
|
8) == expected).all()
|
|
|
|
test_MT19937_triangular(1234, -3, 0, 8, -1.006847326513437)
|
|
test_MT19937_triangular(1234, np.array([-1, -4.2, -3.2]), -0.2, 77,
|
|
np.array([4.22158056, 15.86096882, 49.48278983]))
|
|
test_MT19937_triangular(
|
|
1234, -4, np.array([0.1, 0.5, 3, 6, 7.9]), 8,
|
|
np.array([-1.56630501, 0.67423231, 5.29115477, 6.97916271, 3.80374854]))
|
|
test_MT19937_triangular(1234, -77, 0, np.array([0.1, 11, 789]),
|
|
np.array([-50.26647987, -24.69817576, 499.92800867]))
|
|
test_MT19937_triangular(
|
|
1234,
|
|
2,
|
|
10,
|
|
53,
|
|
np.array([9.00831604, 16.83810311, 36.62324385, 43.24178867]),
|
|
size=4)
|
|
|
|
@test
|
|
def test_MT19937_uniform(seed, expected, low=0.0, high=1.0, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
result = round(gen.uniform(low, high, size), 8)
|
|
if size is None:
|
|
if (isinstance(low, int) or isinstance(low, float)) and (isinstance(
|
|
high, int) or isinstance(high, float)):
|
|
assert result == round(expected, 8)
|
|
else:
|
|
assert (result == expected).all()
|
|
else:
|
|
assert (result == expected).all()
|
|
|
|
test_MT19937_uniform(1234, 6.203835630250495, 5, 15)
|
|
test_MT19937_uniform(1234, 0.20834520672254453, 0.1)
|
|
test_MT19937_uniform(1234, 14.686794689056038, high=122)
|
|
test_MT19937_uniform(1234,
|
|
np.array([0.12038356, 0.40370142, 0.87770263]),
|
|
size=3)
|
|
test_MT19937_uniform(1234,
|
|
np.array(
|
|
[5.76910691, 19.95545962, 40.23040240, 43.34999446]),
|
|
low=np.array([0.4, 3., 6., 7.]),
|
|
high=45.)
|
|
test_MT19937_uniform(
|
|
1234,
|
|
np.array([6.74147953, 6.45922271, 38.61891553, 2.96539428, 0.08529200]),
|
|
high=np.array([56., 16., 44., 3.1, 0.2]))
|
|
|
|
@test
|
|
def test_MT19937_vonmises(seed, mu, kappa, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(mu, float) or isinstance(mu, int)) and (isinstance(
|
|
kappa, float) or isinstance(kappa, int)):
|
|
assert gen.vonmises(mu, kappa) == expected
|
|
else:
|
|
assert (round(gen.vonmises(mu, kappa), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.vonmises(mu, kappa, size), 8) == expected).all()
|
|
|
|
test_MT19937_vonmises(1234, 0, 4, 0.09543421777776429)
|
|
test_MT19937_vonmises(1234, 0.1, 0.2, 0.412385001376804)
|
|
test_MT19937_vonmises(1234, -1, 0, -2.3852004191648746)
|
|
test_MT19937_vonmises(1234,
|
|
0,
|
|
5,
|
|
np.array([0.08543132, 0.21199714, 0.75964701]),
|
|
size=3)
|
|
test_MT19937_vonmises(
|
|
1234, np.array([43.09, 18.62, 42, 16.94]), 5,
|
|
np.array([-0.80686583, -0.01755878, -1.22265014, -2.50501149]))
|
|
test_MT19937_vonmises(
|
|
1234, 4, np.array([0, 0.1, 7.67, 99]),
|
|
np.array([-2.38520042, -1.10822682, -1.99926278, -2.42105600]))
|
|
|
|
@test
|
|
def test_MT19937_wald(seed, mean, scale, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(mean, float) or isinstance(mean, int)) and (isinstance(
|
|
scale, float) or isinstance(scale, int)):
|
|
assert gen.wald(mean, scale) == expected
|
|
else:
|
|
assert (round(gen.wald(mean, scale), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.wald(mean, scale, size), 8) == expected).all()
|
|
|
|
test_MT19937_wald(1234, 0.1, 0.1, 0.01661616443641617)
|
|
test_MT19937_wald(1234, 3, 2, 0.36791953972524594)
|
|
test_MT19937_wald(1234, 3, 2, np.array([0.36791954, 3.12223711, 1.77030450]),
|
|
3)
|
|
test_MT19937_wald(1234, np.array([0.1, 0.5, 1, 4]), 0.5,
|
|
np.array([0.04124719, 0.51657353, 0.54509668, 12.47886442]))
|
|
test_MT19937_wald(1234, 0.5, np.array([0.1, 0.5, 1, 4]),
|
|
np.array([0.02185479, 0.51657353, 0.36787436, 0.58084343]))
|
|
test_MT19937_wald(1234, np.array([0.1, 0.5, 1, 4]), np.array([3, 2, 1, 8]),
|
|
np.array([0.06898142, 0.50821948, 0.64901109, 5.39356830]))
|
|
|
|
@test
|
|
def test_MT19937_weibull(seed, a, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(a, float) or isinstance(a, int)):
|
|
assert gen.weibull(a) == expected
|
|
else:
|
|
assert (round(gen.weibull(a), 8) == expected).all()
|
|
else:
|
|
assert (round(gen.weibull(a, size), 8) == expected).all()
|
|
|
|
test_MT19937_weibull(1234, 0, 0)
|
|
test_MT19937_weibull(1234, 0.1, 6.776724055705368e-07)
|
|
test_MT19937_weibull(1234, 1, 0.24160280948165586)
|
|
test_MT19937_weibull(1234, 1, np.array([0.24160281, 0.54102069, 0.97456423]),
|
|
3)
|
|
test_MT19937_weibull(1234, np.array([17.8, 4.32]),
|
|
np.array([0.92329994, 0.86744900]))
|
|
|
|
@test
|
|
def test_MT19937_zipf(seed, a, expected, size=None):
|
|
gen = rnd.Generator(rnd.MT19937(seed))
|
|
if size is None:
|
|
if (isinstance(a, float) or isinstance(a, int)):
|
|
assert gen.zipf(a) == expected
|
|
else:
|
|
assert (gen.zipf(a) == expected).all()
|
|
else:
|
|
assert (gen.zipf(a, size) == expected).all()
|
|
|
|
test_MT19937_zipf(1234, 1.1, 3)
|
|
test_MT19937_zipf(1234, 3, 1)
|
|
test_MT19937_zipf(1234, 45, np.array([1, 1, 1]), 3)
|
|
test_MT19937_zipf(1234, np.array([17.8, 4.32]), np.array([1, 1]))
|