rsarray 1.2.10__cp315-cp315-win_amd64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- rsarray/__init__.py +12028 -0
- rsarray/_core/__init__.py +213 -0
- rsarray/_core/_exceptions.py +83 -0
- rsarray/_core/_internal.py +331 -0
- rsarray/_core/_multiarray_tests.py +129 -0
- rsarray/_core/_multiarray_umath.py +121 -0
- rsarray/_core/_rational_tests.py +52 -0
- rsarray/_core/arrayprint.py +36 -0
- rsarray/_core/fromnumeric.py +31 -0
- rsarray/_core/function_base.py +84 -0
- rsarray/_core/multiarray.py +385 -0
- rsarray/_core/numeric.py +28 -0
- rsarray/_core/numerictypes.py +233 -0
- rsarray/_core/records.py +14 -0
- rsarray/_core/shape_base.py +23 -0
- rsarray/_core/strings.py +78 -0
- rsarray/_core/umath.py +176 -0
- rsarray/_dtypes.py +1229 -0
- rsarray/_extra.py +6621 -0
- rsarray/_typing.py +24 -0
- rsarray/array_methods.py +1224 -0
- rsarray/array_ops.py +1585 -0
- rsarray/char.py +1590 -0
- rsarray/exceptions.py +45 -0
- rsarray/fft/__init__.py +231 -0
- rsarray/io.py +453 -0
- rsarray/lib/__init__.py +102 -0
- rsarray/lib/_function_base_impl.py +37 -0
- rsarray/lib/_index_tricks_impl.py +98 -0
- rsarray/lib/_nanfunctions_impl.py +1637 -0
- rsarray/lib/_stride_tricks_impl.py +110 -0
- rsarray/lib/recfunctions.py +1222 -0
- rsarray/lib/stride_tricks.py +106 -0
- rsarray/linalg/__init__.py +2603 -0
- rsarray/linalg/_linalg.py +91 -0
- rsarray/linalg/_pylinalg.py +1008 -0
- rsarray/linalg/lapack_lite.py +13 -0
- rsarray/ma/__init__.py +92 -0
- rsarray/ma/core.py +1385 -0
- rsarray/ma/extras.py +711 -0
- rsarray/ma/mrecords.py +144 -0
- rsarray/math_functions.py +965 -0
- rsarray/matlib.py +67 -0
- rsarray/num_core.cp315-win_amd64.pyd +0 -0
- rsarray/polynomial/__init__.py +148 -0
- rsarray/polynomial/_npcompat.py +721 -0
- rsarray/polynomial/polynomial.py +1082 -0
- rsarray/random/__init__.py +2266 -0
- rsarray/random/_distributions.py +773 -0
- rsarray/rec.py +207 -0
- rsarray/statistics.py +1360 -0
- rsarray/strings.py +349 -0
- rsarray/typing/__init__.py +26 -0
- rsarray-1.2.10.dist-info/METADATA +280 -0
- rsarray-1.2.10.dist-info/RECORD +59 -0
- rsarray-1.2.10.dist-info/WHEEL +4 -0
- rsarray-1.2.10.dist-info/licenses/LICENSE +21 -0
- rsarray-1.2.10.dist-info/licenses/NOTICE +7 -0
- rsarray-1.2.10.dist-info/sboms/rsarray.cyclonedx.json +2789 -0
|
@@ -0,0 +1,2266 @@
|
|
|
1
|
+
# SPDX-License-Identifier: MIT
|
|
2
|
+
"""rsarray.random - 随机数生成模块"""
|
|
3
|
+
|
|
4
|
+
import rsarray.num_core as _core
|
|
5
|
+
import random as _py_random
|
|
6
|
+
import rsarray as np
|
|
7
|
+
|
|
8
|
+
from ._distributions import Samplers, _POISSON_LAM_MAX, _broadcast_shapes, _zeta
|
|
9
|
+
|
|
10
|
+
|
|
11
|
+
# _core.random.Generator may be Python's built-in typing.Generator, not a
|
|
12
|
+
# real RNG. Provide a working fallback.
|
|
13
|
+
if not hasattr(_core.random.Generator, 'integers'):
|
|
14
|
+
class _PyGenerator:
|
|
15
|
+
"""Python-based random number generator fallback."""
|
|
16
|
+
|
|
17
|
+
def __init__(self, seed=None):
|
|
18
|
+
self._rng = _py_random.Random(seed)
|
|
19
|
+
|
|
20
|
+
def integers(self, low, high=None, size=None, dtype=None, endpoint=False):
|
|
21
|
+
if high is None:
|
|
22
|
+
low, high = 0, low
|
|
23
|
+
if size is None:
|
|
24
|
+
return self._rng.randint(low, high)
|
|
25
|
+
return np.asarray([self._rng.randint(low, high) for _ in range(size)])
|
|
26
|
+
|
|
27
|
+
def uniform(self, low=0.0, high=1.0, size=None):
|
|
28
|
+
import rsarray as np
|
|
29
|
+
if size is None:
|
|
30
|
+
return self._rng.uniform(low, high)
|
|
31
|
+
return np.asarray([self._rng.uniform(low, high) for _ in range(size)])
|
|
32
|
+
|
|
33
|
+
def normal(self, loc=0.0, scale=1.0, size=None):
|
|
34
|
+
import rsarray as np
|
|
35
|
+
if size is None:
|
|
36
|
+
return self._rng.gauss(loc, scale)
|
|
37
|
+
return np.asarray([self._rng.gauss(loc, scale) for _ in range(size)])
|
|
38
|
+
|
|
39
|
+
def random(self, size=None):
|
|
40
|
+
import rsarray as np
|
|
41
|
+
if size is None:
|
|
42
|
+
return self._rng.random()
|
|
43
|
+
return np.asarray([self._rng.random() for _ in range(size)])
|
|
44
|
+
|
|
45
|
+
def standard_normal(self, size=None):
|
|
46
|
+
return self.normal(0.0, 1.0, size)
|
|
47
|
+
|
|
48
|
+
def vonmises(self, kappa, size=None):
|
|
49
|
+
import rsarray as np
|
|
50
|
+
import math
|
|
51
|
+
if size is None:
|
|
52
|
+
size = ()
|
|
53
|
+
n_samples = int(np.prod(size)) if isinstance(size, tuple) else int(size)
|
|
54
|
+
result = []
|
|
55
|
+
for _ in range(n_samples):
|
|
56
|
+
while True:
|
|
57
|
+
u1 = self._rng.random()
|
|
58
|
+
u2 = self._rng.random()
|
|
59
|
+
z = math.cos(math.pi * u1)
|
|
60
|
+
if u2 < math.exp(kappa * (z - 1)):
|
|
61
|
+
break
|
|
62
|
+
angle = math.acos(max(-1.0, min(1.0, z)))
|
|
63
|
+
if self._rng.random() < 0.5:
|
|
64
|
+
angle = -angle
|
|
65
|
+
result.append(angle)
|
|
66
|
+
return np.asarray(result).reshape(size)
|
|
67
|
+
|
|
68
|
+
def multinomial(self, n, pvals, size=None):
|
|
69
|
+
import rsarray as np
|
|
70
|
+
# Simple categorical sampling
|
|
71
|
+
pvals = np.asarray(pvals)
|
|
72
|
+
pvals = pvals / pvals.sum()
|
|
73
|
+
cdf = np.cumsum(pvals)
|
|
74
|
+
if size is None:
|
|
75
|
+
size = ()
|
|
76
|
+
result = []
|
|
77
|
+
for _ in range(np.prod(size) if isinstance(size, tuple) else size):
|
|
78
|
+
u = self._rng.random()
|
|
79
|
+
idx = int(cdf.searchsorted(u))
|
|
80
|
+
result.append(idx)
|
|
81
|
+
return np.asarray(result).reshape(size)
|
|
82
|
+
|
|
83
|
+
_core.random.Generator = _PyGenerator
|
|
84
|
+
|
|
85
|
+
|
|
86
|
+
class _MT19937:
|
|
87
|
+
"""Minimal stand-in for 's MT19937 bit generator.
|
|
88
|
+
|
|
89
|
+
Only the attributes that downstream code (e.g. rsscipy's ``_util``)
|
|
90
|
+
inspects are provided: ``_seed_seq`` and ``state``.
|
|
91
|
+
"""
|
|
92
|
+
|
|
93
|
+
def __init__(self, seed=None):
|
|
94
|
+
self._seed_seq = None
|
|
95
|
+
self._seed = seed
|
|
96
|
+
|
|
97
|
+
@property
|
|
98
|
+
def state(self):
|
|
99
|
+
return {'bit_generator': 'MT19937', 'state': {'key': [0]}, 'pos': 0}
|
|
100
|
+
|
|
101
|
+
def spawn(self, n_children):
|
|
102
|
+
return [type(self)(None) for _ in range(n_children)]
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
def _is_arraylike(v):
|
|
106
|
+
return isinstance(v, (list, tuple, np.ndarray)) or hasattr(v, 'shape')
|
|
107
|
+
|
|
108
|
+
|
|
109
|
+
def _norm_size(size):
|
|
110
|
+
if size is None:
|
|
111
|
+
return ()
|
|
112
|
+
if isinstance(size, float):
|
|
113
|
+
raise TypeError("size must be an integer or tuple of integers")
|
|
114
|
+
if isinstance(size, (list, tuple)):
|
|
115
|
+
return tuple(int(x) for x in size)
|
|
116
|
+
if _is_arraylike(size):
|
|
117
|
+
return tuple(int(x) for x in np.asarray(size).ravel().tolist())
|
|
118
|
+
return (int(size),)
|
|
119
|
+
|
|
120
|
+
|
|
121
|
+
def _sample_dist(sampler, name, params, size, int_dist=False):
|
|
122
|
+
"""按 数组语义:数组参数广播 → 前置 size → 逐点采样 → 封装
|
|
123
|
+
(标量 or ndarray)。params 为采样器位置参数序列(标量或数组)。"""
|
|
124
|
+
param_vals = []
|
|
125
|
+
arrs = []
|
|
126
|
+
for p in params:
|
|
127
|
+
if _is_arraylike(p):
|
|
128
|
+
pa = np.asarray(p)
|
|
129
|
+
if pa.ndim == 0:
|
|
130
|
+
# 0-d:以 __float__/__int__ 提取标量,子类覆盖须被尊重
|
|
131
|
+
# (test_scalar_exception_propagation);整数分布的整数 dtype
|
|
132
|
+
# 参数走 __int__(尊重 __index__ 覆盖),浮点参数保持 float
|
|
133
|
+
_dt = str(pa.dtype)
|
|
134
|
+
if int_dist and _dt not in ('float16', 'float32', 'float64',
|
|
135
|
+
'complex64', 'complex128'):
|
|
136
|
+
param_vals.append(('s', int(p)))
|
|
137
|
+
else:
|
|
138
|
+
param_vals.append(('s', float(p)))
|
|
139
|
+
continue
|
|
140
|
+
a = np.asarray(pa, dtype='float64')
|
|
141
|
+
param_vals.append(('a', a))
|
|
142
|
+
arrs.append(a)
|
|
143
|
+
else:
|
|
144
|
+
param_vals.append(('s', float(p)))
|
|
145
|
+
ssize = _norm_size(size)
|
|
146
|
+
if arrs:
|
|
147
|
+
bcast = np.broadcast_arrays(*arrs)
|
|
148
|
+
bshape = tuple(bcast[0].shape)
|
|
149
|
+
# 数组语义:size 与参数广播形一起(右对齐)广播,结果须等于 size
|
|
150
|
+
# (test_n_zero_stream:binomial([[0],[10]], .25, size=(2,10)) → (2,10));
|
|
151
|
+
# 不兼容时 _broadcast_shapes 抛 ValueError(与标准语义一致)。
|
|
152
|
+
bshape = _broadcast_shapes(ssize, bshape)
|
|
153
|
+
# 每个参数数组扩到最终形状(如 (2,1) → (2,10)),否则扁平索引错位。
|
|
154
|
+
bcast = [np.broadcast_to(b, bshape) for b in bcast]
|
|
155
|
+
idx = 0
|
|
156
|
+
flat_params = []
|
|
157
|
+
for kind, p in param_vals:
|
|
158
|
+
if kind == 's':
|
|
159
|
+
flat_params.append(('s', p))
|
|
160
|
+
else:
|
|
161
|
+
flat_params.append(('a', bcast[idx].ravel().tolist()))
|
|
162
|
+
idx += 1
|
|
163
|
+
else:
|
|
164
|
+
bshape = ()
|
|
165
|
+
flat_params = param_vals
|
|
166
|
+
out_shape = ssize + bshape if not arrs else bshape
|
|
167
|
+
total = 1
|
|
168
|
+
for d in out_shape:
|
|
169
|
+
total *= d
|
|
170
|
+
bn = 1
|
|
171
|
+
for d in bshape:
|
|
172
|
+
bn *= d
|
|
173
|
+
fn = getattr(sampler, name)
|
|
174
|
+
res = []
|
|
175
|
+
for i in range(total):
|
|
176
|
+
bidx = i % bn
|
|
177
|
+
vals = [d if k == 's' else d[bidx] for k, d in flat_params]
|
|
178
|
+
res.append(fn(*vals))
|
|
179
|
+
if out_shape == ():
|
|
180
|
+
return int(res[0]) if int_dist else res[0]
|
|
181
|
+
return np.asarray(res, dtype='int64' if int_dist else 'float64').reshape(out_shape)
|
|
182
|
+
|
|
183
|
+
|
|
184
|
+
def _multinomial_impl(sampler, n, pvals, size):
|
|
185
|
+
"""legacy multinomial:d-1 次 legacy_random_binomial 循环 + 余数
|
|
186
|
+
(legacy-distributions.c L621-644),与 binomial() 共享同一 binomial 缓存。"""
|
|
187
|
+
if isinstance(pvals, (str, bytes)):
|
|
188
|
+
raise TypeError("pvals must be a 1-d sequence")
|
|
189
|
+
parr = np.asarray(pvals, dtype='float64')
|
|
190
|
+
if parr.ndim == 0:
|
|
191
|
+
raise TypeError("pvals must be a 1-d sequence")
|
|
192
|
+
if parr.ndim != 1:
|
|
193
|
+
raise ValueError("pvals must be a 1-d sequence")
|
|
194
|
+
d = int(parr.size)
|
|
195
|
+
pix = parr.ravel().tolist()
|
|
196
|
+
# CONS_BOUNDED_0_1:只拒绝 x<0 或 x>1(NaN 放行,由 binomial 捕获)
|
|
197
|
+
for pv in pix:
|
|
198
|
+
if pv < 0.0 or pv > 1.0:
|
|
199
|
+
raise ValueError("pvals < 0, pvals > 1 or pvals contains NaNs")
|
|
200
|
+
# sum(pvals[:-1]) > 1.0(末元素视为剩余概率,不参与求和)
|
|
201
|
+
if d and sum(pix[:-1]) > (1.0 + 1e-12):
|
|
202
|
+
raise ValueError("sum(pvals[:-1]) > 1.0")
|
|
203
|
+
if size is None:
|
|
204
|
+
shape = (d,)
|
|
205
|
+
else:
|
|
206
|
+
shape = _norm_size(size) + (d,)
|
|
207
|
+
ni = int(n)
|
|
208
|
+
if ni < 0:
|
|
209
|
+
raise ValueError("n must be non-negative")
|
|
210
|
+
if d == 0:
|
|
211
|
+
return np.zeros(shape, dtype='int64')
|
|
212
|
+
sz = 1
|
|
213
|
+
for _dd in shape:
|
|
214
|
+
sz *= _dd
|
|
215
|
+
niter = sz // d if d else 0
|
|
216
|
+
out = []
|
|
217
|
+
for _i in range(niter):
|
|
218
|
+
dn = ni
|
|
219
|
+
row = [0] * d
|
|
220
|
+
remaining_p = 1.0
|
|
221
|
+
for j in range(d - 1):
|
|
222
|
+
row[j] = int(sampler.binomial(dn, pix[j] / remaining_p))
|
|
223
|
+
dn -= row[j]
|
|
224
|
+
if dn <= 0:
|
|
225
|
+
break
|
|
226
|
+
remaining_p -= pix[j]
|
|
227
|
+
if dn > 0:
|
|
228
|
+
row[d - 1] = dn
|
|
229
|
+
out.extend(row)
|
|
230
|
+
return np.asarray(out, dtype='int64').reshape(shape)
|
|
231
|
+
|
|
232
|
+
|
|
233
|
+
# legacy 分布名 → Samplers 方法名(uniform/normal/standard_normal 走 Rust 内核,
|
|
234
|
+
# 不在此列,保持既有流不变)
|
|
235
|
+
_RS_DIST_DISPATCH = {
|
|
236
|
+
'beta': 'beta',
|
|
237
|
+
'binomial': 'binomial',
|
|
238
|
+
'chisquare': 'chisquare',
|
|
239
|
+
'exponential': 'exponential',
|
|
240
|
+
'f': 'f',
|
|
241
|
+
'gamma': 'gamma',
|
|
242
|
+
'geometric': 'geometric',
|
|
243
|
+
'gumbel': 'gumbel',
|
|
244
|
+
'hypergeometric': 'hypergeometric',
|
|
245
|
+
'laplace': 'laplace',
|
|
246
|
+
'logistic': 'logistic',
|
|
247
|
+
'lognormal': 'lognormal',
|
|
248
|
+
'logseries': 'logseries',
|
|
249
|
+
'negative_binomial': 'negative_binomial',
|
|
250
|
+
'noncentral_chisquare': 'noncentral_chisquare',
|
|
251
|
+
'noncentral_f': 'noncentral_f',
|
|
252
|
+
'pareto': 'pareto',
|
|
253
|
+
'poisson': 'poisson',
|
|
254
|
+
'power': 'power',
|
|
255
|
+
'rayleigh': 'rayleigh',
|
|
256
|
+
'standard_cauchy': 'standard_cauchy',
|
|
257
|
+
'standard_exponential': 'standard_exponential',
|
|
258
|
+
'standard_gamma': 'standard_gamma',
|
|
259
|
+
'standard_t': 'standard_t',
|
|
260
|
+
't': 'standard_t',
|
|
261
|
+
'triangular': 'triangular',
|
|
262
|
+
'triangle': 'triangular',
|
|
263
|
+
'weibull': 'weibull',
|
|
264
|
+
'wald': 'wald',
|
|
265
|
+
'zipf': 'zipf',
|
|
266
|
+
}
|
|
267
|
+
_RS_INT_DISTS = {'binomial', 'geometric', 'hypergeometric', 'logseries',
|
|
268
|
+
'negative_binomial', 'poisson', 'zipf'}
|
|
269
|
+
|
|
270
|
+
# 每个分布的规范位置参数名(用于把关键字参数映射到正确槽位)
|
|
271
|
+
_RS_DIST_PARAMS = {
|
|
272
|
+
'beta': ('a', 'b'),
|
|
273
|
+
'binomial': ('n', 'p'),
|
|
274
|
+
'chisquare': ('df',),
|
|
275
|
+
'exponential': ('scale',),
|
|
276
|
+
'f': ('dfnum', 'dfden'),
|
|
277
|
+
'gamma': ('shape', 'scale'),
|
|
278
|
+
'geometric': ('p',),
|
|
279
|
+
'gumbel': ('loc', 'scale'),
|
|
280
|
+
'hypergeometric': ('ngood', 'nbad', 'nsample'),
|
|
281
|
+
'laplace': ('loc', 'scale'),
|
|
282
|
+
'logistic': ('loc', 'scale'),
|
|
283
|
+
'lognormal': ('mean', 'sigma'),
|
|
284
|
+
'logseries': ('p',),
|
|
285
|
+
'negative_binomial': ('n', 'p'),
|
|
286
|
+
'noncentral_chisquare': ('df', 'nonc'),
|
|
287
|
+
'noncentral_f': ('dfnum', 'dfden', 'nonc'),
|
|
288
|
+
'pareto': ('a',),
|
|
289
|
+
'poisson': ('lam',),
|
|
290
|
+
'power': ('a',),
|
|
291
|
+
'rayleigh': ('scale',),
|
|
292
|
+
'standard_cauchy': (),
|
|
293
|
+
'standard_exponential': (),
|
|
294
|
+
'standard_gamma': ('shape',),
|
|
295
|
+
'standard_t': ('df',),
|
|
296
|
+
't': ('df',),
|
|
297
|
+
'triangular': ('left', 'mode', 'right'),
|
|
298
|
+
'triangle': ('left', 'mode', 'right'),
|
|
299
|
+
'weibull': ('a',),
|
|
300
|
+
'wald': ('mean', 'scale'),
|
|
301
|
+
'zipf': ('a',),
|
|
302
|
+
}
|
|
303
|
+
|
|
304
|
+
# legacy 分布缺省参数(与 mtrand 签名一致,参数缺失时填充)
|
|
305
|
+
_RS_DIST_DEFAULTS = {
|
|
306
|
+
('exponential', 'scale'): 1.0,
|
|
307
|
+
('gamma', 'shape'): 1.0, ('gamma', 'scale'): 1.0,
|
|
308
|
+
('gumbel', 'loc'): 0.0, ('gumbel', 'scale'): 1.0,
|
|
309
|
+
('laplace', 'loc'): 0.0, ('laplace', 'scale'): 1.0,
|
|
310
|
+
('logistic', 'loc'): 0.0, ('logistic', 'scale'): 1.0,
|
|
311
|
+
('lognormal', 'mean'): 0.0, ('lognormal', 'sigma'): 1.0,
|
|
312
|
+
('poisson', 'lam'): 1.0,
|
|
313
|
+
('rayleigh', 'scale'): 1.0,
|
|
314
|
+
('triangular', 'left'): 0.0, ('triangular', 'mode'): 0.5,
|
|
315
|
+
('triangular', 'right'): 1.0,
|
|
316
|
+
('triangle', 'left'): 0.0, ('triangle', 'mode'): 0.5,
|
|
317
|
+
('triangle', 'right'): 1.0,
|
|
318
|
+
}
|
|
319
|
+
|
|
320
|
+
_MISSING = object()
|
|
321
|
+
|
|
322
|
+
|
|
323
|
+
def _fold_seed(seed):
|
|
324
|
+
"""任意 Python 种子 → Rust 可接受的 u64(新 API Generator 用,宽松)。"""
|
|
325
|
+
if seed is None:
|
|
326
|
+
return None
|
|
327
|
+
if isinstance(seed, _SeedSequence):
|
|
328
|
+
seed = seed.entropy
|
|
329
|
+
if not isinstance(seed, int) and hasattr(seed, 'item'):
|
|
330
|
+
seed = int(seed)
|
|
331
|
+
if not isinstance(seed, int):
|
|
332
|
+
if isinstance(seed, (list, tuple)):
|
|
333
|
+
acc = 0
|
|
334
|
+
for x in seed:
|
|
335
|
+
acc = (acc * 1000003 + int(x)) & ((1 << 64) - 1)
|
|
336
|
+
seed = acc
|
|
337
|
+
else:
|
|
338
|
+
try:
|
|
339
|
+
seed = int(seed)
|
|
340
|
+
except (TypeError, ValueError):
|
|
341
|
+
raise TypeError(f"cannot convert {type(seed).__name__} to a seed")
|
|
342
|
+
return seed & ((1 << 64) - 1)
|
|
343
|
+
|
|
344
|
+
|
|
345
|
+
def _legacy_validate_seed(seed):
|
|
346
|
+
"""legacy RandomState 种子校验(严格)。
|
|
347
|
+
|
|
348
|
+
合法:None、单个 [0, 2**32) 整数、1-d 非空整数数组(元素同范围)。
|
|
349
|
+
越界/非整数 → ValueError/TypeError,与 对齐。
|
|
350
|
+
返回:None / int(标量种子)/ list[int](array 种子——对其走
|
|
351
|
+
mt19937_init_by_array,不折叠为标量;0-d 整数数组按标量处理)。
|
|
352
|
+
"""
|
|
353
|
+
if seed is None:
|
|
354
|
+
return None
|
|
355
|
+
if isinstance(seed, _SeedSequence):
|
|
356
|
+
seed = seed.entropy
|
|
357
|
+
if isinstance(seed, int) and not isinstance(seed, bool):
|
|
358
|
+
if seed < 0 or seed >= 2 ** 32:
|
|
359
|
+
raise ValueError("Seed must be in [0, 2**32)")
|
|
360
|
+
return seed
|
|
361
|
+
if isinstance(seed, float) or isinstance(seed, bool):
|
|
362
|
+
raise TypeError("Seed must be a non-negative integer")
|
|
363
|
+
if not isinstance(seed, (list, tuple, np.ndarray)) and hasattr(seed, 'item'):
|
|
364
|
+
try:
|
|
365
|
+
iv = int(seed)
|
|
366
|
+
except (TypeError, ValueError):
|
|
367
|
+
raise TypeError("Seed must be a non-negative integer")
|
|
368
|
+
if iv < 0 or iv >= 2 ** 32:
|
|
369
|
+
raise ValueError("Seed must be in [0, 2**32)")
|
|
370
|
+
return iv
|
|
371
|
+
try:
|
|
372
|
+
arr = np.asarray(seed)
|
|
373
|
+
except Exception:
|
|
374
|
+
raise TypeError("Seed must be a non-negative integer or array of integers")
|
|
375
|
+
if arr.ndim == 0:
|
|
376
|
+
# 数组语义:squeeze 后 0-d 整数数组按标量种子处理(operator.index 路径)
|
|
377
|
+
v = arr.ravel().tolist()[0]
|
|
378
|
+
if isinstance(v, float):
|
|
379
|
+
raise TypeError("Seed must be a non-negative integer")
|
|
380
|
+
iv = int(v)
|
|
381
|
+
if iv != v:
|
|
382
|
+
raise TypeError("Seed must be a non-negative integer")
|
|
383
|
+
if iv < 0 or iv >= 2 ** 32:
|
|
384
|
+
raise ValueError("Seed must be in [0, 2**32)")
|
|
385
|
+
return iv
|
|
386
|
+
if arr.ndim != 1:
|
|
387
|
+
raise ValueError("Seed must be a 1-d array of integers or None")
|
|
388
|
+
if arr.size == 0:
|
|
389
|
+
raise ValueError("Seed must be a non-empty array or None")
|
|
390
|
+
out = []
|
|
391
|
+
for v in arr.ravel().tolist():
|
|
392
|
+
if isinstance(v, float):
|
|
393
|
+
raise TypeError("Seed elements must be integers")
|
|
394
|
+
try:
|
|
395
|
+
iv = int(v)
|
|
396
|
+
except (TypeError, ValueError):
|
|
397
|
+
raise TypeError("Seed elements must be integers")
|
|
398
|
+
if iv != v:
|
|
399
|
+
raise TypeError("Seed elements must be integers")
|
|
400
|
+
if iv < 0 or iv >= 2 ** 32:
|
|
401
|
+
raise ValueError("Seed elements must be in [0, 2**32)")
|
|
402
|
+
out.append(iv)
|
|
403
|
+
return out
|
|
404
|
+
|
|
405
|
+
|
|
406
|
+
def _parse_int_dtype(name):
|
|
407
|
+
"""'int32'/'i4'/'uint64'/'u8'/'bool'/'int' → ('int'|'uint', bits) / ('bool', None)。"""
|
|
408
|
+
name = name.strip()
|
|
409
|
+
if name in ('bool', '?'):
|
|
410
|
+
return 'bool', None
|
|
411
|
+
if name in ('int', 'l', 'long'):
|
|
412
|
+
return 'int', 64
|
|
413
|
+
if name.startswith('uint') and name[4:].isdigit():
|
|
414
|
+
return 'uint', int(name[4:])
|
|
415
|
+
if name.startswith('int') and name[3:].isdigit():
|
|
416
|
+
return 'int', int(name[3:])
|
|
417
|
+
# 单字母+数字简写是字节数(i4 = int32 / u8 = uint64),须 ×8 换成位宽
|
|
418
|
+
if name.startswith('u') and name[1:].isdigit():
|
|
419
|
+
return 'uint', int(name[1:]) * 8
|
|
420
|
+
if name.startswith('i') and name[1:].isdigit():
|
|
421
|
+
return 'int', int(name[1:]) * 8
|
|
422
|
+
return None
|
|
423
|
+
|
|
424
|
+
|
|
425
|
+
def _python_shuffle(next_j, x, axis=0, warn_1d_object=False):
|
|
426
|
+
"""Fisher-Yates 洗牌:list / ndarray(含 object/结构化/memoryview)。
|
|
427
|
+
|
|
428
|
+
next_j(i) 用 legacy rk_interval(掩码拒绝)抽 j ∈ [0, i],与
|
|
429
|
+
random_interval 流逐位一致(int(next_u()*(i+1)) 缩放不匹配)。
|
|
430
|
+
object 数组逐元素搬运 Python 对象引用(不复制,保持对象身份);
|
|
431
|
+
数值数组按行搬运(行 view 需 copy 后再写回)。
|
|
432
|
+
"""
|
|
433
|
+
if isinstance(x, list):
|
|
434
|
+
n = len(x)
|
|
435
|
+
for i in range(n - 1, 0, -1):
|
|
436
|
+
j = next_j(i)
|
|
437
|
+
x[i], x[j] = x[j], x[i]
|
|
438
|
+
return
|
|
439
|
+
# MaskedArray(纯 Python 对象,非 ndarray 子类):data/mask 行同步交换
|
|
440
|
+
# (gh-3263)。MA.__setitem__ 走数值 cast 无法写入 MA 行;mask getter 每次
|
|
441
|
+
# 重建临时数组(_mask 是扁平 list),须交换后经 mask setter 写回。
|
|
442
|
+
import rsarray.ma.core as _macore
|
|
443
|
+
if isinstance(x, _macore.MaskedArray):
|
|
444
|
+
d, m = x.data, x.mask
|
|
445
|
+
n = d.shape[0]
|
|
446
|
+
for i in range(n - 1, 0, -1):
|
|
447
|
+
j = next_j(i)
|
|
448
|
+
if j == i:
|
|
449
|
+
continue
|
|
450
|
+
di, dj = d[i].copy(), d[j].copy()
|
|
451
|
+
mi, mj = m[i].copy(), m[j].copy()
|
|
452
|
+
d[i], d[j] = dj, di
|
|
453
|
+
m[i], m[j] = mj, mi
|
|
454
|
+
x.mask = m
|
|
455
|
+
return
|
|
456
|
+
if hasattr(x, 'shape'):
|
|
457
|
+
if hasattr(x, 'flags') and not x.flags.writeable:
|
|
458
|
+
raise ValueError("read-only array -- cannot shuffle in-place")
|
|
459
|
+
is_obj = False
|
|
460
|
+
try:
|
|
461
|
+
is_obj = str(x.dtype).strip() == 'object'
|
|
462
|
+
except Exception:
|
|
463
|
+
pass
|
|
464
|
+
if warn_1d_object and is_obj and len(x.shape) == 1:
|
|
465
|
+
import warnings
|
|
466
|
+
warnings.warn(
|
|
467
|
+
"Shuffling a one dimensional array of objects is a common "
|
|
468
|
+
"use case, but the result is a new array of the shuffled "
|
|
469
|
+
"objects; use a list instead.", UserWarning, stacklevel=3)
|
|
470
|
+
n = x.shape[0]
|
|
471
|
+
for i in range(n - 1, 0, -1):
|
|
472
|
+
j = next_j(i)
|
|
473
|
+
if j == i:
|
|
474
|
+
continue
|
|
475
|
+
el = x[i]
|
|
476
|
+
tmp = el if (is_obj or not hasattr(el, 'copy')) else el.copy()
|
|
477
|
+
x[i] = x[j]
|
|
478
|
+
x[j] = tmp
|
|
479
|
+
return
|
|
480
|
+
import warnings
|
|
481
|
+
warnings.warn(
|
|
482
|
+
f"you are shuffling a '{type(x).__name__}' object, which is "
|
|
483
|
+
"treated as a sequence by rsarray.random.shuffle", UserWarning,
|
|
484
|
+
stacklevel=3)
|
|
485
|
+
n = len(x)
|
|
486
|
+
for i in range(n - 1, 0, -1):
|
|
487
|
+
j = next_j(i)
|
|
488
|
+
x[i], x[j] = x[j], x[i]
|
|
489
|
+
|
|
490
|
+
|
|
491
|
+
class _MT19937Legacy:
|
|
492
|
+
"""legacy ``RandomState`` 的 MT19937 位级一致流。
|
|
493
|
+
|
|
494
|
+
种子算法 = 标准 MT19937:标量种子走 ``init_genrand``;array 种子走
|
|
495
|
+
``mt19937_init_by_array``(``_legacy_seeding`` 语义,已与
|
|
496
|
+
2.5.4 逐位对照:RandomState(range(10)) / [0] / [4294967295]
|
|
497
|
+
的 randint(1000) = 468/973/265)。
|
|
498
|
+
uniform = ``res53``(两个 32 位输出合成 53 位 double);
|
|
499
|
+
randint = ``rk_interval``(掩码拒绝采样,无偏)。
|
|
500
|
+
"""
|
|
501
|
+
__slots__ = ('_mt', '_mti', '_gauss_cache')
|
|
502
|
+
|
|
503
|
+
def _init_state(self, seed):
|
|
504
|
+
if seed is None:
|
|
505
|
+
import time
|
|
506
|
+
seed = (time.time_ns() ^ id(self)) & 0xffffffff
|
|
507
|
+
if isinstance(seed, (list, tuple)):
|
|
508
|
+
self._init_by_array(seed)
|
|
509
|
+
return
|
|
510
|
+
seed = int(seed) & 0xffffffff
|
|
511
|
+
mt = [0] * 624
|
|
512
|
+
mt[0] = seed
|
|
513
|
+
for i in range(1, 624):
|
|
514
|
+
mt[i] = (1812433253 * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i) & 0xffffffff
|
|
515
|
+
self._mt = mt
|
|
516
|
+
self._mti = 624
|
|
517
|
+
self._gauss_cache = None
|
|
518
|
+
|
|
519
|
+
def _init_by_array(self, key):
|
|
520
|
+
"""``mt19937_init_by_array``(legacy array 种子)。
|
|
521
|
+
|
|
522
|
+
常量与 MT19937 参考实现一致:
|
|
523
|
+
init_genrand(19650218) + 1664525 / 1566083941 两轮非线性扰动。
|
|
524
|
+
"""
|
|
525
|
+
key = [int(k) & 0xffffffff for k in key]
|
|
526
|
+
key_len = len(key)
|
|
527
|
+
mt = [0] * 624
|
|
528
|
+
mt[0] = 19650218
|
|
529
|
+
for i in range(1, 624):
|
|
530
|
+
mt[i] = (1812433253 * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i) & 0xffffffff
|
|
531
|
+
i, j = 1, 0
|
|
532
|
+
k = 624 if 624 > key_len else key_len
|
|
533
|
+
for _ in range(k):
|
|
534
|
+
mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >> 30)) * 1664525)) + key[j] + j
|
|
535
|
+
mt[i] &= 0xffffffff
|
|
536
|
+
i += 1
|
|
537
|
+
j += 1
|
|
538
|
+
if i >= 624:
|
|
539
|
+
mt[0] = mt[623]
|
|
540
|
+
i = 1
|
|
541
|
+
if j >= key_len:
|
|
542
|
+
j = 0
|
|
543
|
+
for _ in range(623, 0, -1):
|
|
544
|
+
mt[i] = (mt[i] ^ ((mt[i - 1] ^ (mt[i - 1] >> 30)) * 1566083941)) - i
|
|
545
|
+
mt[i] &= 0xffffffff
|
|
546
|
+
i += 1
|
|
547
|
+
if i >= 624:
|
|
548
|
+
mt[0] = mt[623]
|
|
549
|
+
i = 1
|
|
550
|
+
mt[0] = 0x80000000
|
|
551
|
+
self._mt = mt
|
|
552
|
+
self._mti = 624
|
|
553
|
+
self._gauss_cache = None
|
|
554
|
+
|
|
555
|
+
def __init__(self, seed):
|
|
556
|
+
self._init_state(seed)
|
|
557
|
+
|
|
558
|
+
def reseed(self, seed):
|
|
559
|
+
self._init_state(seed)
|
|
560
|
+
|
|
561
|
+
def _twist(self):
|
|
562
|
+
mt = self._mt
|
|
563
|
+
for i in range(624):
|
|
564
|
+
y = (mt[i] & 0x80000000) + (mt[(i + 1) % 624] & 0x7fffffff)
|
|
565
|
+
v = mt[(i + 397) % 624] ^ (y >> 1)
|
|
566
|
+
if y & 1:
|
|
567
|
+
v ^= 0x9908b0df
|
|
568
|
+
mt[i] = v & 0xffffffff
|
|
569
|
+
self._mti = 0
|
|
570
|
+
|
|
571
|
+
def u32(self):
|
|
572
|
+
if self._mti >= 624:
|
|
573
|
+
self._twist()
|
|
574
|
+
x = self._mt[self._mti]
|
|
575
|
+
self._mti += 1
|
|
576
|
+
x ^= (x >> 11)
|
|
577
|
+
x ^= (x << 7) & 0x9d2c5680
|
|
578
|
+
x ^= (x << 15) & 0xefc60000
|
|
579
|
+
x ^= (x >> 18)
|
|
580
|
+
return x & 0xffffffff
|
|
581
|
+
|
|
582
|
+
def random_sample(self):
|
|
583
|
+
a = self.u32() >> 5
|
|
584
|
+
b = self.u32() >> 6
|
|
585
|
+
return (a * 67108864.0 + b) * (1.0 / 9007199254740992.0)
|
|
586
|
+
|
|
587
|
+
def interval(self, maxv):
|
|
588
|
+
"""``rk_interval(maxv)``:返回 [0, maxv] 的无偏整数。"""
|
|
589
|
+
if maxv == 0:
|
|
590
|
+
return 0
|
|
591
|
+
mask = (1 << maxv.bit_length()) - 1
|
|
592
|
+
while True:
|
|
593
|
+
v = self.u32() & mask
|
|
594
|
+
if v <= maxv:
|
|
595
|
+
return v
|
|
596
|
+
|
|
597
|
+
def _gen_mask(self, maxv):
|
|
598
|
+
"""``gen_mask``:最小位掩码 ≥ maxv(顶位以下全置 1)。"""
|
|
599
|
+
mask = maxv
|
|
600
|
+
mask |= mask >> 1
|
|
601
|
+
mask |= mask >> 2
|
|
602
|
+
mask |= mask >> 4
|
|
603
|
+
mask |= mask >> 8
|
|
604
|
+
mask |= mask >> 16
|
|
605
|
+
mask |= mask >> 32
|
|
606
|
+
return mask
|
|
607
|
+
|
|
608
|
+
def intervals_u8(self, rngs):
|
|
609
|
+
"""legacy _rand_uint8 掩码路径(distributions.c
|
|
610
|
+
random_buffered_bounded_uint8):每 32-bit 字出 4 个 8-bit 值(LSB
|
|
611
|
+
起)、掩码拒绝;单次 randint 调用内 buf 跨元素共享,跨调用全新
|
|
612
|
+
(中为函数局部变量)。rngs: 逐元素闭包上界(hi-1-lo)。"""
|
|
613
|
+
buf = 0
|
|
614
|
+
bcnt = 0
|
|
615
|
+
out = []
|
|
616
|
+
for rng in rngs:
|
|
617
|
+
if rng == 0:
|
|
618
|
+
out.append(0)
|
|
619
|
+
continue
|
|
620
|
+
mask = self._gen_mask(rng)
|
|
621
|
+
while True:
|
|
622
|
+
if bcnt == 0:
|
|
623
|
+
buf = self.u32()
|
|
624
|
+
bcnt = 3
|
|
625
|
+
else:
|
|
626
|
+
buf >>= 8
|
|
627
|
+
bcnt -= 1
|
|
628
|
+
val = buf & 0xFF & mask
|
|
629
|
+
if val <= rng:
|
|
630
|
+
break
|
|
631
|
+
out.append(val)
|
|
632
|
+
return out
|
|
633
|
+
|
|
634
|
+
def intervals_u16(self, rngs):
|
|
635
|
+
"""legacy _rand_uint16 掩码路径:每 32-bit 字出 2 个 16-bit
|
|
636
|
+
值(低半字先)、掩码拒绝;buf 语义同 intervals_u8。"""
|
|
637
|
+
buf = 0
|
|
638
|
+
bcnt = 0
|
|
639
|
+
out = []
|
|
640
|
+
for rng in rngs:
|
|
641
|
+
if rng == 0:
|
|
642
|
+
out.append(0)
|
|
643
|
+
continue
|
|
644
|
+
mask = self._gen_mask(rng)
|
|
645
|
+
while True:
|
|
646
|
+
if bcnt == 0:
|
|
647
|
+
buf = self.u32()
|
|
648
|
+
bcnt = 1
|
|
649
|
+
else:
|
|
650
|
+
buf >>= 16
|
|
651
|
+
bcnt -= 1
|
|
652
|
+
val = buf & 0xFFFF & mask
|
|
653
|
+
if val <= rng:
|
|
654
|
+
break
|
|
655
|
+
out.append(val)
|
|
656
|
+
return out
|
|
657
|
+
|
|
658
|
+
def intervals_bool(self, rngs):
|
|
659
|
+
"""legacy _rand_bool(buffered_bounded_bool):每 32-bit 字出
|
|
660
|
+
32 个 bit(LSB 起)、无拒绝;rng==0 元素不消耗随机数。"""
|
|
661
|
+
buf = 0
|
|
662
|
+
bcnt = 0
|
|
663
|
+
out = []
|
|
664
|
+
for rng in rngs:
|
|
665
|
+
if rng == 0:
|
|
666
|
+
out.append(0)
|
|
667
|
+
continue
|
|
668
|
+
if bcnt == 0:
|
|
669
|
+
buf = self.u32()
|
|
670
|
+
bcnt = 31
|
|
671
|
+
else:
|
|
672
|
+
buf >>= 1
|
|
673
|
+
bcnt -= 1
|
|
674
|
+
out.append(1 if (buf & 1) else 0)
|
|
675
|
+
return out
|
|
676
|
+
|
|
677
|
+
def standard_normal(self):
|
|
678
|
+
"""legacy ``rk_gauss``(极坐标 Box-Muller,带缓存)。
|
|
679
|
+
|
|
680
|
+
先返回 v2*r(第二个 res53 对应值),缓存 v1*r(第一个),
|
|
681
|
+
与 逐位一致(小 size 与标量已验证;大 size 有 C/Python 位级差)。
|
|
682
|
+
"""
|
|
683
|
+
if self._gauss_cache is not None:
|
|
684
|
+
x = self._gauss_cache
|
|
685
|
+
self._gauss_cache = None
|
|
686
|
+
return x
|
|
687
|
+
import math
|
|
688
|
+
while True:
|
|
689
|
+
v1 = 2.0 * self.random_sample() - 1.0
|
|
690
|
+
v2 = 2.0 * self.random_sample() - 1.0
|
|
691
|
+
s = v1 * v1 + v2 * v2
|
|
692
|
+
if 0.0 < s < 1.0:
|
|
693
|
+
break
|
|
694
|
+
r = math.sqrt(-2.0 * math.log(s) / s)
|
|
695
|
+
self._gauss_cache = v1 * r
|
|
696
|
+
return v2 * r
|
|
697
|
+
|
|
698
|
+
|
|
699
|
+
class _PCG64LegacyStream(_MT19937Legacy):
|
|
700
|
+
"""适配器:legacy RandomState 流走 PCG64 位生成器。
|
|
701
|
+
|
|
702
|
+
复用 _MT19937Legacy 全部消费模式(res53 double、rk_interval、
|
|
703
|
+
buffered randint、polar normal),仅把 uint32 源换成 PCG64 next32
|
|
704
|
+
(含 uinteger 缓存)——与 ``RandomState(PCG64())`` 的位级
|
|
705
|
+
流消费一致(legacy 分布一律经 next32 的 res53 double 取流)。
|
|
706
|
+
"""
|
|
707
|
+
__slots__ = ('_bg',)
|
|
708
|
+
|
|
709
|
+
def __init__(self, bg):
|
|
710
|
+
self._bg = bg
|
|
711
|
+
# 不走父类 __init__(那会初始化 MT 状态);_mt/_mti 仅作
|
|
712
|
+
# get_state/set_state 闭包的兜底(bg 路径实际走 PCG64 state dict)
|
|
713
|
+
self._mt = []
|
|
714
|
+
self._mti = 0
|
|
715
|
+
self._gauss_cache = None
|
|
716
|
+
|
|
717
|
+
def u32(self):
|
|
718
|
+
return self._bg.next32()
|
|
719
|
+
|
|
720
|
+
def random_sample(self):
|
|
721
|
+
# generic 位生成器:uint64_to_double(n) = (n >> 11) / 2^53
|
|
722
|
+
# (取高 53 位,非 MT 的 res53 移位法)
|
|
723
|
+
return (self._bg.next64() >> 11) * (1.0 / 9007199254740992.0)
|
|
724
|
+
|
|
725
|
+
def reseed(self, seed):
|
|
726
|
+
# —非 MT 位生成器上 RandomState.seed 委托 bit_generator.seed
|
|
727
|
+
self._bg.seed(seed)
|
|
728
|
+
|
|
729
|
+
|
|
730
|
+
class _RandomStateWrapper:
|
|
731
|
+
"""Python wrapper around the core RandomState.
|
|
732
|
+
|
|
733
|
+
Adds the legacy attributes SciPy expects (``_bit_generator``) and
|
|
734
|
+
distributions the Rust core does not implement (``multivariate_normal``
|
|
735
|
+
以及 _distributions 补齐的完整 legacy 分布集)。
|
|
736
|
+
"""
|
|
737
|
+
|
|
738
|
+
def __init__(self, seed=None):
|
|
739
|
+
if isinstance(seed, PCG64):
|
|
740
|
+
# 新 API 位生成器:legacy 分布走 PCG64 流(位级兼容
|
|
741
|
+
# RandomState(bg))
|
|
742
|
+
self._bg = seed
|
|
743
|
+
self._seed = None
|
|
744
|
+
self._mt = _PCG64LegacyStream(seed)
|
|
745
|
+
self._sampler = Samplers(self._next_u, self._next_normal)
|
|
746
|
+
# Rust 核流仅作未处理属性(如 randn)的回退,不属 legacy 流
|
|
747
|
+
self._inner = _core.random.RandomState(0)
|
|
748
|
+
return
|
|
749
|
+
seed = _legacy_validate_seed(seed)
|
|
750
|
+
self._seed = seed
|
|
751
|
+
self._mt = _MT19937Legacy(seed)
|
|
752
|
+
self._sampler = Samplers(self._next_u, self._next_normal)
|
|
753
|
+
# Rust 核流(ChaCha8)只收 u64 标量种子;array 种子折叠处理。
|
|
754
|
+
# legacy 分布全在 _mt 上,_inner 仅供未处理属性回退。
|
|
755
|
+
self._inner = _core.random.RandomState(_fold_seed(seed))
|
|
756
|
+
|
|
757
|
+
def __deepcopy__(self, memo):
|
|
758
|
+
# The Rust core object is not picklable. Re-seed from the original
|
|
759
|
+
# seed so the copy is independent of (and initially identical to)
|
|
760
|
+
# this wrapper, matching standard deepcopy semantics for unused
|
|
761
|
+
# generators.
|
|
762
|
+
return _RandomStateWrapper(self._seed)
|
|
763
|
+
|
|
764
|
+
def __copy__(self, memo=None):
|
|
765
|
+
return _RandomStateWrapper(self._seed)
|
|
766
|
+
|
|
767
|
+
def _rs_f64(self, vals):
|
|
768
|
+
"""确保输出是带 _dtype 的正规 rsarray ndarray(Rust 原生对象转换)。"""
|
|
769
|
+
import rsarray as _np
|
|
770
|
+
if hasattr(vals, 'tolist') and not hasattr(vals, '_dtype'):
|
|
771
|
+
vals = vals.tolist()
|
|
772
|
+
return _np.asarray(vals, dtype='float64')
|
|
773
|
+
|
|
774
|
+
def rand(self, *args):
|
|
775
|
+
"""生成均匀分布的随机数(MT19937 res53 流)。"""
|
|
776
|
+
# 兼容 rand((2,3)) / rand([2,3]) 单容器参数(视为 shape)
|
|
777
|
+
if len(args) == 1 and isinstance(args[0], (tuple, list)):
|
|
778
|
+
args = tuple(int(d) for d in args[0])
|
|
779
|
+
shape = tuple(int(d) for d in args) if args else (1,)
|
|
780
|
+
total = 1
|
|
781
|
+
for d in shape:
|
|
782
|
+
total *= d
|
|
783
|
+
vals = [self._mt.random_sample() for _ in range(total)]
|
|
784
|
+
return self._rs_f64(vals).reshape(shape)
|
|
785
|
+
|
|
786
|
+
def random(self, *args, **kwargs):
|
|
787
|
+
"""legacy random_sample:[0,1) 均匀(MT19937 res53)。"""
|
|
788
|
+
if not args and 'size' in kwargs:
|
|
789
|
+
size = kwargs['size']
|
|
790
|
+
elif len(args) == 1:
|
|
791
|
+
size = args[0]
|
|
792
|
+
elif args:
|
|
793
|
+
size = args
|
|
794
|
+
else:
|
|
795
|
+
size = None
|
|
796
|
+
if size is None:
|
|
797
|
+
return self._mt.random_sample()
|
|
798
|
+
if isinstance(size, tuple):
|
|
799
|
+
return self.rand(*size)
|
|
800
|
+
return self.rand(int(size))
|
|
801
|
+
|
|
802
|
+
def random_sample(self, size=None):
|
|
803
|
+
"""legacy random_sample:[0,1) 均匀(MT19937 res53)。"""
|
|
804
|
+
return self.random(size)
|
|
805
|
+
|
|
806
|
+
def randn(self, *args):
|
|
807
|
+
"""生成标准正态分布的随机数。"""
|
|
808
|
+
return self._rs_f64(self._inner.randn(1) if not args
|
|
809
|
+
else self._inner.randn(*args))
|
|
810
|
+
|
|
811
|
+
def _next_u(self):
|
|
812
|
+
return self._mt.random_sample()
|
|
813
|
+
|
|
814
|
+
def _next_normal(self):
|
|
815
|
+
# MT19937 Box-Muller(legacy rk_gauss,带缓存)
|
|
816
|
+
return self._mt.standard_normal()
|
|
817
|
+
|
|
818
|
+
def normal(self, *args, **kwargs):
|
|
819
|
+
"""正态分布(MT19937 Box-Muller,legacy rk_gauss 流)。"""
|
|
820
|
+
import rsarray as _np
|
|
821
|
+
dtype = kwargs.pop('dtype', None)
|
|
822
|
+
size = kwargs.pop('size', None)
|
|
823
|
+
loc = kwargs.pop('loc', None)
|
|
824
|
+
scale = kwargs.pop('scale', None)
|
|
825
|
+
if len(args) >= 1 and loc is None:
|
|
826
|
+
loc = args[0]
|
|
827
|
+
if len(args) >= 2 and scale is None:
|
|
828
|
+
scale = args[1]
|
|
829
|
+
if len(args) >= 3 and size is None:
|
|
830
|
+
size = args[2]
|
|
831
|
+
loc = 0.0 if loc is None else loc
|
|
832
|
+
scale = 1.0 if scale is None else scale
|
|
833
|
+
|
|
834
|
+
def _is_seq(x):
|
|
835
|
+
try:
|
|
836
|
+
len(x)
|
|
837
|
+
except (TypeError, AttributeError):
|
|
838
|
+
return False
|
|
839
|
+
return not isinstance(x, (str, bytes))
|
|
840
|
+
|
|
841
|
+
if _is_seq(loc) or _is_seq(scale):
|
|
842
|
+
# 广播路径:loc/scale 为序列,按 1 维广播规则
|
|
843
|
+
def _flat(x):
|
|
844
|
+
if hasattr(x, 'tolist'):
|
|
845
|
+
x = x.tolist()
|
|
846
|
+
if isinstance(x, (list, tuple)):
|
|
847
|
+
return list(x)
|
|
848
|
+
return [float(x)]
|
|
849
|
+
loc_f = _flat(loc)
|
|
850
|
+
scale_f = _flat(scale)
|
|
851
|
+
if len(loc_f) == 1 and len(scale_f) != 1:
|
|
852
|
+
loc_f = loc_f * len(scale_f)
|
|
853
|
+
elif len(scale_f) == 1 and len(loc_f) != 1:
|
|
854
|
+
scale_f = scale_f * len(loc_f)
|
|
855
|
+
if any(s < 0.0 for s in scale_f):
|
|
856
|
+
raise ValueError("scale < 0")
|
|
857
|
+
z = [self._next_normal() for _ in range(len(loc_f))]
|
|
858
|
+
vals = [loc_f[i] + scale_f[i] * z[i] for i in range(len(loc_f))]
|
|
859
|
+
result = _np.asarray(vals, dtype='float64')
|
|
860
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
861
|
+
result = result.astype(dtype)
|
|
862
|
+
return result
|
|
863
|
+
|
|
864
|
+
# 标量路径
|
|
865
|
+
loc = float(loc)
|
|
866
|
+
scale = float(scale)
|
|
867
|
+
if scale < 0.0:
|
|
868
|
+
raise ValueError("scale < 0")
|
|
869
|
+
if size is None:
|
|
870
|
+
val = loc if scale == 0.0 else loc + scale * self._next_normal()
|
|
871
|
+
return val
|
|
872
|
+
if isinstance(size, (tuple, list)):
|
|
873
|
+
shape = tuple(int(d) for d in size)
|
|
874
|
+
else:
|
|
875
|
+
shape = (int(size),)
|
|
876
|
+
n = 1
|
|
877
|
+
for d in shape:
|
|
878
|
+
n *= d
|
|
879
|
+
if n == 0:
|
|
880
|
+
# 空尺寸:直接以目标形状建空数组(reshape 空 (0,) 到含 0
|
|
881
|
+
# 的高维形状可能失败,不能依赖它)
|
|
882
|
+
result = _np.zeros(shape, dtype='float64')
|
|
883
|
+
else:
|
|
884
|
+
if scale == 0.0:
|
|
885
|
+
vals = [loc] * n
|
|
886
|
+
else:
|
|
887
|
+
vals = [loc + scale * self._next_normal() for _ in range(n)]
|
|
888
|
+
result = _np.asarray(vals, dtype='float64')
|
|
889
|
+
if len(shape) > 1:
|
|
890
|
+
result = result.reshape(shape)
|
|
891
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
892
|
+
result = result.astype(dtype)
|
|
893
|
+
return result
|
|
894
|
+
|
|
895
|
+
def standard_normal(self, size=None, **kwargs):
|
|
896
|
+
"""标准正态分布(MT19937 Box-Muller)。"""
|
|
897
|
+
dtype = kwargs.pop('dtype', None)
|
|
898
|
+
return self.normal(0.0, 1.0, size=size, dtype=dtype)
|
|
899
|
+
|
|
900
|
+
def randn(self, *args):
|
|
901
|
+
"""标准正态分布 randn(d0, d1, ..., dn)(MT19937 Box-Muller)。"""
|
|
902
|
+
return self.normal(0.0, 1.0, size=(args if args else None))
|
|
903
|
+
|
|
904
|
+
def uniform(self, low=0.0, high=1.0, size=None, dtype=None):
|
|
905
|
+
"""均匀分布(MT19937 res53,legacy;low/high 支持广播)。"""
|
|
906
|
+
result = self._sample_dist('uniform', (low, high), size)
|
|
907
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
908
|
+
result = result.astype(dtype)
|
|
909
|
+
return result
|
|
910
|
+
|
|
911
|
+
def __getattr__(self, name):
|
|
912
|
+
if name == 'multivariate_normal':
|
|
913
|
+
def mvn(mean, cov, size=None, check_valid='warn', tol=1e-8):
|
|
914
|
+
return _mvn_sample(self._next_normal, mean, cov, size,
|
|
915
|
+
check_valid=check_valid, tol=tol)
|
|
916
|
+
return mvn
|
|
917
|
+
if name == 'choice':
|
|
918
|
+
def choice(a, size=None, replace=True, p=None):
|
|
919
|
+
# legacy mtrand.choice:uniform replace 用 randint
|
|
920
|
+
# (掩码拒绝);uniform noreplace 用 permutation;weighted
|
|
921
|
+
# replace 用 cdf.searchsorted(right);weighted noreplace 是
|
|
922
|
+
# “批量抽取 + 置零 + 首次出现去重”循环(mtrand.pyx L1030-1049)。
|
|
923
|
+
a_arr = np.asarray(a)
|
|
924
|
+
if a_arr.ndim == 0:
|
|
925
|
+
# rsarray 0-d item() 恒为 float(f64 存储),用 dtype 判定整数性
|
|
926
|
+
dt = str(a_arr.dtype)
|
|
927
|
+
if dt not in ('bool', 'int64', 'int32', 'int16', 'int8',
|
|
928
|
+
'uint64', 'uint32', 'uint16', 'uint8'):
|
|
929
|
+
raise ValueError(
|
|
930
|
+
"a must be 1-dimensional or an integer")
|
|
931
|
+
pop = int(a_arr.item())
|
|
932
|
+
arr0 = None
|
|
933
|
+
elif a_arr.ndim != 1:
|
|
934
|
+
raise ValueError("a must be 1-dimensional")
|
|
935
|
+
else:
|
|
936
|
+
arr0 = a_arr
|
|
937
|
+
pop = a_arr.shape[0]
|
|
938
|
+
|
|
939
|
+
def _sz_prod(sz):
|
|
940
|
+
if sz is None:
|
|
941
|
+
return 1
|
|
942
|
+
if isinstance(sz, (tuple, list)):
|
|
943
|
+
r = 1
|
|
944
|
+
for d in sz:
|
|
945
|
+
r *= int(d)
|
|
946
|
+
return r
|
|
947
|
+
return int(sz)
|
|
948
|
+
|
|
949
|
+
if pop <= 0 and _sz_prod(size) != 0:
|
|
950
|
+
if arr0 is None:
|
|
951
|
+
raise ValueError(
|
|
952
|
+
"a must be greater than 0 unless no samples "
|
|
953
|
+
"are taken")
|
|
954
|
+
raise ValueError(
|
|
955
|
+
"'a' cannot be empty unless no samples are taken")
|
|
956
|
+
|
|
957
|
+
if p is not None:
|
|
958
|
+
parr = np.asarray(p, dtype='float64')
|
|
959
|
+
if parr.ndim != 1:
|
|
960
|
+
raise ValueError("'p' must be 1-dimensional")
|
|
961
|
+
if parr.shape[0] != pop:
|
|
962
|
+
raise ValueError("'a' and 'p' must have same size")
|
|
963
|
+
pl = parr.ravel().tolist()
|
|
964
|
+
if str(parr.dtype) != 'float64' or any(
|
|
965
|
+
not isinstance(v, (int, float)) for v in pl):
|
|
966
|
+
# 把 None 等无法转 float 的项按 NaN 处理
|
|
967
|
+
raise ValueError("probabilities contain NaN")
|
|
968
|
+
for v in pl:
|
|
969
|
+
if v != v:
|
|
970
|
+
raise ValueError("probabilities contain NaN")
|
|
971
|
+
for v in pl:
|
|
972
|
+
if v < 0:
|
|
973
|
+
raise ValueError(
|
|
974
|
+
"probabilities are not non-negative")
|
|
975
|
+
if abs(sum(pl) - 1.0) > 1.4901161193847656e-08:
|
|
976
|
+
raise ValueError("probabilities do not sum to 1")
|
|
977
|
+
|
|
978
|
+
is_scalar = size is None
|
|
979
|
+
if is_scalar:
|
|
980
|
+
shape = ()
|
|
981
|
+
nsize = 1
|
|
982
|
+
else:
|
|
983
|
+
if isinstance(size, (tuple, list)):
|
|
984
|
+
shape = tuple(int(d) for d in size)
|
|
985
|
+
else:
|
|
986
|
+
shape = (int(size),)
|
|
987
|
+
nsize = 1
|
|
988
|
+
for d in shape:
|
|
989
|
+
nsize *= d
|
|
990
|
+
|
|
991
|
+
def _ss_right(cdf, u):
|
|
992
|
+
# cdf.searchsorted(u, side='right'):首个 cdf[i] > u 的 i
|
|
993
|
+
for i in range(len(cdf)):
|
|
994
|
+
if cdf[i] > u:
|
|
995
|
+
return i
|
|
996
|
+
return len(cdf) - 1
|
|
997
|
+
|
|
998
|
+
def _norm_cdf(probs):
|
|
999
|
+
total = 0.0
|
|
1000
|
+
for v in probs:
|
|
1001
|
+
total += v
|
|
1002
|
+
cum = np.cumsum(np.asarray(probs, dtype='float64')) \
|
|
1003
|
+
.ravel().tolist()
|
|
1004
|
+
return [c / total for c in cum]
|
|
1005
|
+
|
|
1006
|
+
if replace:
|
|
1007
|
+
if p is not None:
|
|
1008
|
+
cdf = _norm_cdf(pl)
|
|
1009
|
+
out = [_ss_right(cdf, self._next_u())
|
|
1010
|
+
for _ in range(nsize)]
|
|
1011
|
+
else:
|
|
1012
|
+
# randint(0, pop, size=shape):rk_interval 掩码拒绝
|
|
1013
|
+
out = [self._mt.interval(pop - 1)
|
|
1014
|
+
for _ in range(nsize)]
|
|
1015
|
+
else:
|
|
1016
|
+
if nsize > pop:
|
|
1017
|
+
raise ValueError(
|
|
1018
|
+
"Cannot take a larger sample than population "
|
|
1019
|
+
"when 'replace=False'")
|
|
1020
|
+
if nsize < 0:
|
|
1021
|
+
raise ValueError(
|
|
1022
|
+
"Negative dimensions are not allowed")
|
|
1023
|
+
if p is not None:
|
|
1024
|
+
if sum(1 for v in pl if v > 0) < nsize:
|
|
1025
|
+
raise ValueError(
|
|
1026
|
+
"Fewer non-zero entries in p than size")
|
|
1027
|
+
pcur = list(pl)
|
|
1028
|
+
found = []
|
|
1029
|
+
while len(found) < nsize:
|
|
1030
|
+
x = [self._next_u()
|
|
1031
|
+
for _ in range(nsize - len(found))]
|
|
1032
|
+
if found:
|
|
1033
|
+
for f in found:
|
|
1034
|
+
pcur[f] = 0.0
|
|
1035
|
+
cdf = _norm_cdf(pcur)
|
|
1036
|
+
for v in (_ss_right(cdf, u) for u in x):
|
|
1037
|
+
if v not in found:
|
|
1038
|
+
found.append(v)
|
|
1039
|
+
out = found
|
|
1040
|
+
else:
|
|
1041
|
+
# permutation(pop)[:nsize]:Fisher-Yates + interval
|
|
1042
|
+
idx = list(range(pop))
|
|
1043
|
+
for i in range(pop - 1, 0, -1):
|
|
1044
|
+
j = self._mt.interval(i)
|
|
1045
|
+
idx[i], idx[j] = idx[j], idx[i]
|
|
1046
|
+
out = idx[:nsize]
|
|
1047
|
+
|
|
1048
|
+
if is_scalar:
|
|
1049
|
+
if arr0 is None:
|
|
1050
|
+
return out[0]
|
|
1051
|
+
if str(arr0.dtype) == 'object':
|
|
1052
|
+
return arr0[out[0]]
|
|
1053
|
+
return arr0.ravel().tolist()[out[0]]
|
|
1054
|
+
if nsize == 0:
|
|
1055
|
+
if arr0 is None:
|
|
1056
|
+
return np.zeros(shape, dtype='int64')
|
|
1057
|
+
return np.empty(shape, dtype=arr0.dtype)
|
|
1058
|
+
if arr0 is None:
|
|
1059
|
+
res = np.asarray(out)
|
|
1060
|
+
elif str(arr0.dtype) == 'object':
|
|
1061
|
+
# 直接 getitem 保持对象引用身份(ravel/tolist 会转换值)
|
|
1062
|
+
res = np.array([arr0[i] for i in out], dtype='object')
|
|
1063
|
+
else:
|
|
1064
|
+
res = np.take(arr0, np.asarray(out))
|
|
1065
|
+
return res.reshape(shape)
|
|
1066
|
+
return choice
|
|
1067
|
+
if name == 'permutation':
|
|
1068
|
+
def permutation(x):
|
|
1069
|
+
# legacy:int → 洗乱 arange(n);array → 洗乱副本
|
|
1070
|
+
# (仅第一轴)。Fisher-Yates + interval,与 逐位一致。
|
|
1071
|
+
if isinstance(x, int):
|
|
1072
|
+
n = x
|
|
1073
|
+
idx = list(range(n))
|
|
1074
|
+
for i in range(n - 1, 0, -1):
|
|
1075
|
+
j = self._mt.interval(i)
|
|
1076
|
+
idx[i], idx[j] = idx[j], idx[i]
|
|
1077
|
+
if n == 0:
|
|
1078
|
+
return np.zeros(0, dtype='int64')
|
|
1079
|
+
return np.asarray(idx)
|
|
1080
|
+
arr = np.asarray(x)
|
|
1081
|
+
if arr.ndim < 1:
|
|
1082
|
+
raise IndexError(
|
|
1083
|
+
"x must be an integer or at least 1-dimensional")
|
|
1084
|
+
n = arr.shape[0]
|
|
1085
|
+
idx = list(range(n))
|
|
1086
|
+
for i in range(n - 1, 0, -1):
|
|
1087
|
+
j = self._mt.interval(i)
|
|
1088
|
+
idx[i], idx[j] = idx[j], idx[i]
|
|
1089
|
+
if n == 0:
|
|
1090
|
+
return np.empty(arr.shape, dtype=arr.dtype)
|
|
1091
|
+
return np.take(arr, np.asarray(idx))
|
|
1092
|
+
return permutation
|
|
1093
|
+
if name == 'get_state':
|
|
1094
|
+
def get_state():
|
|
1095
|
+
# —非 MT 位生成器返回 bg 的 state dict
|
|
1096
|
+
if '_bg' in self.__dict__:
|
|
1097
|
+
return self._bg.state
|
|
1098
|
+
# legacy 布局: ('MT19937', keys[624], pos, has_gauss, cached)
|
|
1099
|
+
mt = self._mt
|
|
1100
|
+
keys = list(mt._mt)
|
|
1101
|
+
pos = mt._mti
|
|
1102
|
+
has_gauss = 1 if mt._gauss_cache is not None else 0
|
|
1103
|
+
cached = mt._gauss_cache if mt._gauss_cache is not None else 0.0
|
|
1104
|
+
return ('MT19937', keys, pos, has_gauss, cached)
|
|
1105
|
+
return get_state
|
|
1106
|
+
if name == 'set_state':
|
|
1107
|
+
def set_state(state):
|
|
1108
|
+
# —非 MT 位生成器设 bg 的 state dict
|
|
1109
|
+
if '_bg' in self.__dict__:
|
|
1110
|
+
self._bg.state = state
|
|
1111
|
+
return
|
|
1112
|
+
# 恢复完整 MT19937 缓冲 + 位置 + 高斯缓存(legacy,逐位精确)。
|
|
1113
|
+
# 兼容 3 元素旧格式(无 has_gauss/cached)。
|
|
1114
|
+
keys = [int(k) & 0xffffffff for k in state[1]]
|
|
1115
|
+
pos = int(state[2])
|
|
1116
|
+
self._mt._mt = keys
|
|
1117
|
+
self._mt._mti = pos
|
|
1118
|
+
if len(state) >= 5 and state[3]:
|
|
1119
|
+
self._mt._gauss_cache = float(state[4])
|
|
1120
|
+
else:
|
|
1121
|
+
self._mt._gauss_cache = None
|
|
1122
|
+
return set_state
|
|
1123
|
+
if name == 'standard_normal':
|
|
1124
|
+
def standard_normal(size=None):
|
|
1125
|
+
return self._inner.randn(*( (size,) if isinstance(size, int)
|
|
1126
|
+
else tuple(size) if size else (1,)))
|
|
1127
|
+
return standard_normal
|
|
1128
|
+
if name == 'multinomial':
|
|
1129
|
+
def multinomial(n, pvals, size=None):
|
|
1130
|
+
return self._multinomial_impl(n, pvals, size)
|
|
1131
|
+
return multinomial
|
|
1132
|
+
if name == 'dirichlet':
|
|
1133
|
+
def dirichlet(alpha, size=None):
|
|
1134
|
+
return self._dirichlet_impl(alpha, size)
|
|
1135
|
+
return dirichlet
|
|
1136
|
+
if name == 'vonmises':
|
|
1137
|
+
def vonmises(*args, **kwargs):
|
|
1138
|
+
return self._vonmises_impl(*args, **kwargs)
|
|
1139
|
+
return vonmises
|
|
1140
|
+
if name in _RS_DIST_DISPATCH:
|
|
1141
|
+
_sampler_name = _RS_DIST_DISPATCH[name]
|
|
1142
|
+
_int = name in _RS_INT_DISTS
|
|
1143
|
+
def _dist_method(*args, _sampler_name=_sampler_name, _int=_int,
|
|
1144
|
+
**kwargs):
|
|
1145
|
+
return self._dist_call(_sampler_name, args, kwargs, _int)
|
|
1146
|
+
return _dist_method
|
|
1147
|
+
return getattr(self._inner, name)
|
|
1148
|
+
|
|
1149
|
+
def _dist_call(self, sampler_name, args, kwargs, int_dist):
|
|
1150
|
+
"""位置 + 关键字参数 → 规范顺序;size 取 kwargs 或多余位置参数。"""
|
|
1151
|
+
names = _RS_DIST_PARAMS.get(sampler_name, ())
|
|
1152
|
+
size = kwargs.pop('size', None)
|
|
1153
|
+
pos = list(args)
|
|
1154
|
+
if size is None and len(pos) > len(names):
|
|
1155
|
+
extra = pos[len(names):]
|
|
1156
|
+
pos = pos[:len(names)]
|
|
1157
|
+
size = tuple(extra) if len(extra) > 1 else extra[0]
|
|
1158
|
+
vals = list(pos)
|
|
1159
|
+
for i, nm in enumerate(names):
|
|
1160
|
+
while len(vals) <= i:
|
|
1161
|
+
vals.append(_MISSING)
|
|
1162
|
+
if vals[i] is _MISSING and nm in kwargs:
|
|
1163
|
+
vals[i] = kwargs.pop(nm)
|
|
1164
|
+
for i, nm in enumerate(names):
|
|
1165
|
+
if vals[i] is _MISSING:
|
|
1166
|
+
vals[i] = _RS_DIST_DEFAULTS.get((sampler_name, nm))
|
|
1167
|
+
while vals and vals[-1] is _MISSING:
|
|
1168
|
+
vals.pop()
|
|
1169
|
+
for v in vals:
|
|
1170
|
+
if v is _MISSING:
|
|
1171
|
+
raise TypeError(f"missing required argument for {sampler_name}")
|
|
1172
|
+
if kwargs:
|
|
1173
|
+
raise TypeError(
|
|
1174
|
+
f"unexpected keyword argument {next(iter(kwargs))!r}")
|
|
1175
|
+
return self._sample_dist(sampler_name, tuple(vals), size,
|
|
1176
|
+
int_dist=int_dist)
|
|
1177
|
+
|
|
1178
|
+
# ------------------------------------------------------------------
|
|
1179
|
+
# 纯 Python 补齐的 legacy 方法(统计正确;逐位兼容流需 MT19937 内核)
|
|
1180
|
+
# ------------------------------------------------------------------
|
|
1181
|
+
def _sample_dist(self, name, params, size, int_dist=False):
|
|
1182
|
+
return _sample_dist(self._sampler, name, params, size, int_dist)
|
|
1183
|
+
|
|
1184
|
+
def _multinomial_impl(self, n, pvals, size):
|
|
1185
|
+
return _multinomial_impl(self._sampler, n, pvals, size)
|
|
1186
|
+
|
|
1187
|
+
def _dirichlet_impl(self, alpha, size):
|
|
1188
|
+
if isinstance(alpha, (str, bytes)) or (
|
|
1189
|
+
not isinstance(alpha, (list, tuple, np.ndarray))
|
|
1190
|
+
and not hasattr(alpha, 'shape')):
|
|
1191
|
+
alpha = [float(alpha)]
|
|
1192
|
+
arr = np.asarray(alpha, dtype='float64')
|
|
1193
|
+
if arr.ndim != 1:
|
|
1194
|
+
raise ValueError("alpha must be a 1-d sequence")
|
|
1195
|
+
a_list = arr.ravel().tolist()
|
|
1196
|
+
k = len(a_list)
|
|
1197
|
+
ssize = _norm_size(size)
|
|
1198
|
+
out_shape = ssize + (k,)
|
|
1199
|
+
total = 1
|
|
1200
|
+
for d in ssize:
|
|
1201
|
+
total *= d
|
|
1202
|
+
res = []
|
|
1203
|
+
for _ in range(total):
|
|
1204
|
+
res.extend(self._sampler.dirichlet(a_list))
|
|
1205
|
+
if out_shape == ():
|
|
1206
|
+
return res
|
|
1207
|
+
return np.asarray(res, dtype='float64').reshape(out_shape)
|
|
1208
|
+
|
|
1209
|
+
def _vonmises_impl(self, *args, **kwargs):
|
|
1210
|
+
"""legacy API:vonmises(mu=0.0, kappa=1.0, size=None);
|
|
1211
|
+
位置参数按 (mu, kappa, [size]) 顺序,mu/kappa 支持数组广播。"""
|
|
1212
|
+
size = kwargs.pop('size', None)
|
|
1213
|
+
mu = kwargs.pop('mu', None)
|
|
1214
|
+
kappa = kwargs.pop('kappa', None)
|
|
1215
|
+
if args:
|
|
1216
|
+
if mu is None:
|
|
1217
|
+
mu = args[0]
|
|
1218
|
+
if len(args) >= 2 and kappa is None:
|
|
1219
|
+
kappa = args[1]
|
|
1220
|
+
if len(args) >= 3 and size is None:
|
|
1221
|
+
size = args[2]
|
|
1222
|
+
if kappa is None:
|
|
1223
|
+
raise TypeError("kappa is required")
|
|
1224
|
+
if kwargs:
|
|
1225
|
+
raise TypeError(
|
|
1226
|
+
f"unexpected keyword argument {next(iter(kwargs))!r}")
|
|
1227
|
+
mu_a = np.asarray(0.0 if mu is None else mu, dtype='float64')
|
|
1228
|
+
k_a = np.asarray(kappa, dtype='float64')
|
|
1229
|
+
# CONS_NON_NEGATIVE:负 kappa → ValueError(NaN 放行到采样器)
|
|
1230
|
+
if any(k < 0.0 for k in k_a.ravel().tolist()):
|
|
1231
|
+
raise ValueError("kappa must be non-negative")
|
|
1232
|
+
mu_b, k_b = np.broadcast_arrays(mu_a, k_a)
|
|
1233
|
+
bshape = tuple(mu_b.shape)
|
|
1234
|
+
ssize = _norm_size(size)
|
|
1235
|
+
if bshape:
|
|
1236
|
+
# 数组语义:size 与参数广播形一起(右对齐)广播;不兼容时
|
|
1237
|
+
# ValueError(与 _sample_dist 同一规则,已实测对齐)
|
|
1238
|
+
bshape = _broadcast_shapes(ssize, bshape)
|
|
1239
|
+
mu_b = np.broadcast_to(mu_b, bshape)
|
|
1240
|
+
k_b = np.broadcast_to(k_b, bshape)
|
|
1241
|
+
out_shape = bshape if bshape else ssize
|
|
1242
|
+
mflat = mu_b.ravel().tolist()
|
|
1243
|
+
kflat = k_b.ravel().tolist()
|
|
1244
|
+
bn = 1
|
|
1245
|
+
for d in bshape:
|
|
1246
|
+
bn *= d
|
|
1247
|
+
total = 1
|
|
1248
|
+
for d in out_shape:
|
|
1249
|
+
total *= d
|
|
1250
|
+
if total == 0:
|
|
1251
|
+
return np.empty(out_shape)
|
|
1252
|
+
res = [self._sampler.vonmises(mflat[i % bn], kflat[i % bn])
|
|
1253
|
+
for i in range(total)]
|
|
1254
|
+
return np.asarray(res, dtype='float64').reshape(out_shape)
|
|
1255
|
+
|
|
1256
|
+
def randint(self, low, high=None, size=None, dtype='int64', endpoint=False):
|
|
1257
|
+
if high is None:
|
|
1258
|
+
low, high = 0, int(low)
|
|
1259
|
+
# dtype 解析:兼容 'int32'/'i4'/'uint64'/'u8'/Python 类型;
|
|
1260
|
+
# 非原生字节序('>i4' 等)按 数组语义发 DeprecationWarning。
|
|
1261
|
+
raw = str(dtype)
|
|
1262
|
+
if any(ch in raw for ch in '<>=|'):
|
|
1263
|
+
import warnings
|
|
1264
|
+
warnings.warn("non-native byteorder is not supported",
|
|
1265
|
+
DeprecationWarning)
|
|
1266
|
+
name = raw.lstrip('<>=| ')
|
|
1267
|
+
parsed = _parse_int_dtype(name)
|
|
1268
|
+
if parsed is None:
|
|
1269
|
+
name = str(np.dtype(dtype)).lstrip('<>=| ')
|
|
1270
|
+
parsed = _parse_int_dtype(name)
|
|
1271
|
+
if parsed is None:
|
|
1272
|
+
raise TypeError(f"dtype {dtype!r} is not a valid integer dtype")
|
|
1273
|
+
kind, bits = parsed
|
|
1274
|
+
is_bool = (kind == 'bool')
|
|
1275
|
+
signed = (kind == 'int')
|
|
1276
|
+
if is_bool:
|
|
1277
|
+
dmin, dmax = 0, 1
|
|
1278
|
+
else:
|
|
1279
|
+
dmin = 0 if not signed else -(1 << (bits - 1))
|
|
1280
|
+
dmax = (1 << (bits - 1)) - 1 if signed else (1 << bits) - 1
|
|
1281
|
+
# low/high 可为标量或数组(按 数组语义广播)。
|
|
1282
|
+
# 0-d 标量(rsarray 标量 / 0-d 数组)走 int() 取精确值:asarray 路径
|
|
1283
|
+
# 在 f64 2^63 边界丢精度(int64.max → 2^63 → tolist 环绕成 -2^63),
|
|
1284
|
+
# 而 int() 对标量返回精确值。无 ndim 属性的 list 等仍走 asarray 路径。
|
|
1285
|
+
def _is_scalar0(x):
|
|
1286
|
+
return _is_arraylike(x) and getattr(x, 'ndim', None) == 0
|
|
1287
|
+
lo_arr = _is_arraylike(low) and not _is_scalar0(low)
|
|
1288
|
+
hi_arr = _is_arraylike(high) and not _is_scalar0(high)
|
|
1289
|
+
if lo_arr or hi_arr:
|
|
1290
|
+
la = np.asarray(low, dtype='int64') if lo_arr else np.asarray(low)
|
|
1291
|
+
ha = np.asarray(high, dtype='int64') if hi_arr else np.asarray(high)
|
|
1292
|
+
la, ha = np.broadcast_arrays(la, ha)
|
|
1293
|
+
los = la.ravel().tolist()
|
|
1294
|
+
his = ha.ravel().tolist()
|
|
1295
|
+
bshape = tuple(la.shape)
|
|
1296
|
+
else:
|
|
1297
|
+
los = [int(low)]
|
|
1298
|
+
his = [int(high)]
|
|
1299
|
+
bshape = ()
|
|
1300
|
+
ssize = _norm_size(size)
|
|
1301
|
+
out_shape = ssize + bshape
|
|
1302
|
+
total = 1
|
|
1303
|
+
for d in out_shape:
|
|
1304
|
+
total *= d
|
|
1305
|
+
# 数组语义:零长度 size 直接短路(不做 low/high 校验,
|
|
1306
|
+
# randint(0, -10, size=0) → shape (0,))
|
|
1307
|
+
if total == 0:
|
|
1308
|
+
return np.zeros(out_shape, dtype=name)
|
|
1309
|
+
# 检查结果值域宽度是否放得进 dtype(数组语义:high 本身可越 dtype
|
|
1310
|
+
# 上界,如 randint(2**63-1, 2**63, dtype='int64')——int64/uint64 无
|
|
1311
|
+
# 公共整数超集,按值域宽度判,不按 high 判)
|
|
1312
|
+
maxwidth = dmax - dmin + 1 if dmax >= dmin else 0
|
|
1313
|
+
for lo, hi in zip(los, his):
|
|
1314
|
+
if hi <= lo or hi - lo > maxwidth:
|
|
1315
|
+
raise ValueError(
|
|
1316
|
+
f"low/high ({lo}, {hi}) out of range for dtype {name}")
|
|
1317
|
+
|
|
1318
|
+
bn = 1
|
|
1319
|
+
for d in bshape:
|
|
1320
|
+
bn *= d
|
|
1321
|
+
# legacy randint 按宽度采样(_bounded_integers 掩码路径,
|
|
1322
|
+
# distributions.c):u8=4 值/字、u16=2 值/字、bool=32 bit/字
|
|
1323
|
+
# (均 LSB 起 + 掩码拒绝),u32/u64=1 字/值(interval,无偏拒绝)。
|
|
1324
|
+
# 同宽度 signed 与 unsigned 流相同(仅二补体重解释);单次调用内
|
|
1325
|
+
# buf 跨元素共享、跨调用全新。
|
|
1326
|
+
rngs = [his[i % bn] - 1 - los[i % bn] for i in range(total)]
|
|
1327
|
+
if is_bool:
|
|
1328
|
+
uint_vals = self._mt.intervals_bool(rngs)
|
|
1329
|
+
elif bits == 8:
|
|
1330
|
+
uint_vals = self._mt.intervals_u8(rngs)
|
|
1331
|
+
elif bits == 16:
|
|
1332
|
+
uint_vals = self._mt.intervals_u16(rngs)
|
|
1333
|
+
else:
|
|
1334
|
+
uint_vals = [self._mt.interval(r) for r in rngs]
|
|
1335
|
+
vals = [los[i % bn] + v for i, v in enumerate(uint_vals)]
|
|
1336
|
+
if total == 1 and ssize == () and bshape == ():
|
|
1337
|
+
v = vals[0]
|
|
1338
|
+
# 显式 Python 类型 → 返回 Python 标量(无 .dtype)
|
|
1339
|
+
if dtype is bool:
|
|
1340
|
+
return bool(v)
|
|
1341
|
+
if dtype is int:
|
|
1342
|
+
return v
|
|
1343
|
+
if is_bool:
|
|
1344
|
+
return np.asarray(1 if v else 0, dtype='bool')
|
|
1345
|
+
if signed and bits < 64:
|
|
1346
|
+
m = 1 << bits
|
|
1347
|
+
v = ((v + (1 << (bits - 1))) % m) - (1 << (bits - 1))
|
|
1348
|
+
return np.asarray(v, dtype=name)
|
|
1349
|
+
if is_bool:
|
|
1350
|
+
arr = np.asarray([1 if v else 0 for v in vals], dtype='bool')
|
|
1351
|
+
elif signed and bits < 64:
|
|
1352
|
+
m = 1 << bits
|
|
1353
|
+
vals = [((v + (1 << (bits - 1))) % m) - (1 << (bits - 1))
|
|
1354
|
+
for v in vals]
|
|
1355
|
+
arr = np.asarray(vals, dtype='int64').astype(name)
|
|
1356
|
+
elif signed:
|
|
1357
|
+
arr = np.asarray(vals, dtype='int64')
|
|
1358
|
+
else:
|
|
1359
|
+
if bits < 64:
|
|
1360
|
+
m = 1 << bits
|
|
1361
|
+
vals = [v % m for v in vals]
|
|
1362
|
+
arr = np.asarray(vals, dtype='uint64' if bits == 64 else 'int64')
|
|
1363
|
+
if bits < 64:
|
|
1364
|
+
arr = arr.astype(name)
|
|
1365
|
+
return arr.reshape(out_shape)
|
|
1366
|
+
|
|
1367
|
+
def random_integers(self, low, high=None, size=None):
|
|
1368
|
+
import warnings
|
|
1369
|
+
warnings.warn("random_integers is deprecated; use randint instead",
|
|
1370
|
+
DeprecationWarning)
|
|
1371
|
+
if high is None:
|
|
1372
|
+
high = low
|
|
1373
|
+
return self.randint(low, high + 1, size=size)
|
|
1374
|
+
|
|
1375
|
+
def bytes(self, length=4):
|
|
1376
|
+
# legacy:randint(0, 2**32, size=n_uint32, dtype='uint32')
|
|
1377
|
+
# 的原生(小端)字节串截断——直接取 u32 流,非 res53 缩放。
|
|
1378
|
+
n = int(length)
|
|
1379
|
+
n_uint32 = (n - 1) // 4 + 1
|
|
1380
|
+
return b''.join(self._mt.interval(0xffffffff).to_bytes(4, 'little')
|
|
1381
|
+
for _ in range(n_uint32))[:n]
|
|
1382
|
+
|
|
1383
|
+
def tomaxint(self, type='int32'):
|
|
1384
|
+
import re
|
|
1385
|
+
m = re.match(r'[<>=|]?int(\d+)', str(type))
|
|
1386
|
+
bits = int(m.group(1)) if m else 32
|
|
1387
|
+
return (1 << (bits - 1)) - 1
|
|
1388
|
+
|
|
1389
|
+
def shuffle(self, x, axis=0):
|
|
1390
|
+
if axis != 0 and hasattr(x, 'shape'):
|
|
1391
|
+
x = np.moveaxis(x, axis, 0)
|
|
1392
|
+
_python_shuffle(lambda i: self._mt.interval(i), x, 0,
|
|
1393
|
+
warn_1d_object=True)
|
|
1394
|
+
|
|
1395
|
+
def seed(self, s=None):
|
|
1396
|
+
s = _legacy_validate_seed(s)
|
|
1397
|
+
self._seed = s
|
|
1398
|
+
self._mt.reseed(s)
|
|
1399
|
+
self._inner = _core.random.RandomState(_fold_seed(s))
|
|
1400
|
+
|
|
1401
|
+
@property
|
|
1402
|
+
def _bit_generator(self):
|
|
1403
|
+
return _MT19937(None)
|
|
1404
|
+
|
|
1405
|
+
@property
|
|
1406
|
+
def _poisson_lam_max(self):
|
|
1407
|
+
"""Knuth 采样上限;超过后切换正态近似(测试读取此常数)。"""
|
|
1408
|
+
return _POISSON_LAM_MAX
|
|
1409
|
+
|
|
1410
|
+
|
|
1411
|
+
def _mvn_sample(next_standard_normal, mean, cov, size,
|
|
1412
|
+
check_valid='warn', tol=1e-8):
|
|
1413
|
+
"""Draw multivariate normal samples via the SVD factor of ``cov``."""
|
|
1414
|
+
import rsarray as np
|
|
1415
|
+
mean = np.asarray(mean, dtype='float64').reshape(-1).tolist()
|
|
1416
|
+
cov = np.asarray(cov, dtype='float64')
|
|
1417
|
+
d = len(mean)
|
|
1418
|
+
_, s, vt = np.linalg.svd(cov, full_matrices=False)
|
|
1419
|
+
s_arr = np.asarray(s, dtype='float64')
|
|
1420
|
+
if s_arr.ndim == 2:
|
|
1421
|
+
# rsarray svd 对 2x2 返回 2D 对角矩阵(非常规)→ 取对角线奇异值
|
|
1422
|
+
s_vals = [s_arr[i, i] for i in range(min(s_arr.shape))]
|
|
1423
|
+
else:
|
|
1424
|
+
s_vals = s_arr.ravel().tolist()
|
|
1425
|
+
sl = [max(float(x), 0.0) ** 0.5 for x in s_vals]
|
|
1426
|
+
vtl = [[float(x) for x in row] for row in vt.tolist()]
|
|
1427
|
+
if check_valid != 'ignore':
|
|
1428
|
+
# 数组语义(mtrand.pyx):psd = allclose(V·diag(s)·Vt, cov,
|
|
1429
|
+
# rtol=tol, atol=tol);非对称/非半正定时 V≠U,重构与 cov 偏离。
|
|
1430
|
+
if check_valid not in ('warn', 'raise'):
|
|
1431
|
+
raise ValueError(
|
|
1432
|
+
"check_valid must equal 'warn', 'raise', or 'ignore'")
|
|
1433
|
+
_covf = cov.reshape(-1).tolist()
|
|
1434
|
+
_psd = True
|
|
1435
|
+
for _a in range(d):
|
|
1436
|
+
for _c in range(d):
|
|
1437
|
+
_acc = 0.0
|
|
1438
|
+
for _b in range(d):
|
|
1439
|
+
_acc += vtl[_b][_a] * s_vals[_b] * vtl[_b][_c]
|
|
1440
|
+
_ref = _covf[_a * d + _c]
|
|
1441
|
+
if abs(_acc - _ref) > tol + tol * abs(_ref):
|
|
1442
|
+
_psd = False
|
|
1443
|
+
break
|
|
1444
|
+
if not _psd:
|
|
1445
|
+
break
|
|
1446
|
+
if not _psd:
|
|
1447
|
+
if check_valid == 'warn':
|
|
1448
|
+
import warnings
|
|
1449
|
+
warnings.warn(
|
|
1450
|
+
"covariance is not symmetric positive-semidefinite.",
|
|
1451
|
+
RuntimeWarning)
|
|
1452
|
+
else:
|
|
1453
|
+
raise ValueError(
|
|
1454
|
+
"covariance is not symmetric positive-semidefinite.")
|
|
1455
|
+
shape = _norm_size(size)
|
|
1456
|
+
n = int(np.prod(shape)) if shape else 1
|
|
1457
|
+
out = []
|
|
1458
|
+
for _ in range(n):
|
|
1459
|
+
z = [next_standard_normal() for _ in range(d)]
|
|
1460
|
+
row = []
|
|
1461
|
+
for i in range(d):
|
|
1462
|
+
acc = mean[i]
|
|
1463
|
+
for j in range(d):
|
|
1464
|
+
acc += vtl[j][i] * sl[j] * z[j]
|
|
1465
|
+
row.append(acc)
|
|
1466
|
+
out.append(row)
|
|
1467
|
+
return np.asarray(out).reshape(shape + (d,))
|
|
1468
|
+
|
|
1469
|
+
|
|
1470
|
+
def _coerce_size_arg(args, kwargs):
|
|
1471
|
+
"""size 参数数组化 → int/tuple(接受 array-like size,Rust 后端不接受)。"""
|
|
1472
|
+
|
|
1473
|
+
def _conv(v):
|
|
1474
|
+
if isinstance(v, bool) or isinstance(v, int):
|
|
1475
|
+
return v
|
|
1476
|
+
if isinstance(v, (tuple, list)):
|
|
1477
|
+
return tuple(int(x) for x in v)
|
|
1478
|
+
try:
|
|
1479
|
+
arr = np.asarray(v)
|
|
1480
|
+
if arr.ndim == 0:
|
|
1481
|
+
return int(arr.item())
|
|
1482
|
+
return tuple(int(x) for x in arr.reshape((-1,)).tolist())
|
|
1483
|
+
except Exception:
|
|
1484
|
+
return v
|
|
1485
|
+
|
|
1486
|
+
out_args = list(args)
|
|
1487
|
+
if out_args:
|
|
1488
|
+
out_args[0] = _conv(out_args[0])
|
|
1489
|
+
if 'size' in kwargs:
|
|
1490
|
+
kwargs['size'] = _conv(kwargs['size'])
|
|
1491
|
+
return tuple(out_args), kwargs
|
|
1492
|
+
|
|
1493
|
+
|
|
1494
|
+
class _WrappedGenerator:
|
|
1495
|
+
"""Generator 的薄包装,把核心返回的数组提升为 rsarray 数组。
|
|
1496
|
+
|
|
1497
|
+
核心生成器(`_core.random.Generator`)返回的是 Rust 侧的 `ndarray`,它和
|
|
1498
|
+
`rsarray.ndarray` 不是同一个类:后者才有那些补齐了 数组语义的 Python 层
|
|
1499
|
+
方法。差别最明显的是 `astype` —— 核心版只接受字符串,而 数组语义要求也能
|
|
1500
|
+
吃 `dtype` 实例,因此诸如
|
|
1501
|
+
|
|
1502
|
+
a = rng.random(shape).astype(np.dtype('float64'))
|
|
1503
|
+
|
|
1504
|
+
的写法(约定 scipy 测试里到处在用)在裸核心对象上会直接报错。
|
|
1505
|
+
|
|
1506
|
+
这里只做一件事:转发所有属性,并把方法返回值里的核心数组换成 `rsarray.ndarray`。
|
|
1507
|
+
"""
|
|
1508
|
+
|
|
1509
|
+
__slots__ = ('_inner', '_seed', '_pcg')
|
|
1510
|
+
|
|
1511
|
+
def __init__(self, inner=None):
|
|
1512
|
+
# Accept -style construction: Generator(seed) or Generator()
|
|
1513
|
+
self._seed = inner
|
|
1514
|
+
self._pcg = None
|
|
1515
|
+
if isinstance(inner, _WrappedGenerator):
|
|
1516
|
+
self._seed = inner._seed
|
|
1517
|
+
inner = inner._inner
|
|
1518
|
+
if isinstance(inner, PCG64):
|
|
1519
|
+
# copy 保留位生成器(—Generator 拷贝共享 BitGenerator)
|
|
1520
|
+
self._pcg = inner
|
|
1521
|
+
inner = 0
|
|
1522
|
+
elif isinstance(inner, PCG64):
|
|
1523
|
+
# Generator(bit_generator):shuffle/permutation 走 PCG64 精确
|
|
1524
|
+
# 流;其余分布保持 Rust 核(见类 docstring 的既有差距说明)
|
|
1525
|
+
self._pcg = inner
|
|
1526
|
+
self._seed = inner
|
|
1527
|
+
inner = 0
|
|
1528
|
+
elif not hasattr(inner, 'random'):
|
|
1529
|
+
try:
|
|
1530
|
+
inner = _core.random.Generator(inner)
|
|
1531
|
+
except OverflowError:
|
|
1532
|
+
# accepts arbitrarily large seeds (SeedSequence);
|
|
1533
|
+
# fold them into the range the core understands.
|
|
1534
|
+
inner = _core.random.Generator(int(inner) % (2**63))
|
|
1535
|
+
self._inner = inner
|
|
1536
|
+
if self._pcg is None and self._seed is not None and \
|
|
1537
|
+
isinstance(self._seed, (int, list, tuple, range)):
|
|
1538
|
+
# default_rng(seed):洗牌需位级兼容 数组的 PCG64 流
|
|
1539
|
+
# (SeedSequence → pcg64_srandom_r)
|
|
1540
|
+
self._pcg = PCG64(self._seed)
|
|
1541
|
+
|
|
1542
|
+
def __deepcopy__(self, memo):
|
|
1543
|
+
return _WrappedGenerator(self._seed)
|
|
1544
|
+
|
|
1545
|
+
def __copy__(self):
|
|
1546
|
+
return _WrappedGenerator(self._seed)
|
|
1547
|
+
|
|
1548
|
+
def _u(self):
|
|
1549
|
+
"""One uniform float in [0, 1) from the inner generator."""
|
|
1550
|
+
v = self._inner.random()
|
|
1551
|
+
if hasattr(v, 'item'):
|
|
1552
|
+
v = v.item()
|
|
1553
|
+
return float(v)
|
|
1554
|
+
|
|
1555
|
+
def shuffle(self, x, axis=0):
|
|
1556
|
+
"""新 API 洗牌:object 数组不告警、保持对象身份。
|
|
1557
|
+
|
|
1558
|
+
有 PCG64 流时按 Generator.random_interval(64 位流拒绝
|
|
1559
|
+
抽样,j ∈ [0, i])逐位精确;否则回退 Rust 核 integers(StdRng
|
|
1560
|
+
流,与 不位级兼容,见类 docstring)。
|
|
1561
|
+
"""
|
|
1562
|
+
if axis != 0 and hasattr(x, 'shape'):
|
|
1563
|
+
x = np.moveaxis(x, axis, 0)
|
|
1564
|
+
if self._pcg is not None:
|
|
1565
|
+
bg = self._pcg
|
|
1566
|
+
|
|
1567
|
+
def next_j(i):
|
|
1568
|
+
# random_interval(distributions.c):掩码拒绝 + uint32 流
|
|
1569
|
+
if i == 0:
|
|
1570
|
+
return 0
|
|
1571
|
+
mask = i
|
|
1572
|
+
mask |= mask >> 1
|
|
1573
|
+
mask |= mask >> 2
|
|
1574
|
+
mask |= mask >> 4
|
|
1575
|
+
mask |= mask >> 8
|
|
1576
|
+
mask |= mask >> 16
|
|
1577
|
+
mask |= mask >> 32
|
|
1578
|
+
if i <= 0xffffffff:
|
|
1579
|
+
while True:
|
|
1580
|
+
v = bg.next32() & mask
|
|
1581
|
+
if v <= i:
|
|
1582
|
+
return v
|
|
1583
|
+
else:
|
|
1584
|
+
while True:
|
|
1585
|
+
v = bg.next64() & mask
|
|
1586
|
+
if v <= i:
|
|
1587
|
+
return v
|
|
1588
|
+
else:
|
|
1589
|
+
def next_j(i):
|
|
1590
|
+
v = self._inner.integers(0, i + 1)
|
|
1591
|
+
if hasattr(v, 'item'):
|
|
1592
|
+
v = v.item()
|
|
1593
|
+
return int(v)
|
|
1594
|
+
_python_shuffle(next_j, x, 0)
|
|
1595
|
+
|
|
1596
|
+
def _make_choice(self):
|
|
1597
|
+
"""-compatible ``choice`` (the Rust core only takes array `a`
|
|
1598
|
+
and no ``p``; int populations and weights are handled here)."""
|
|
1599
|
+
def choice(a, size=None, replace=True, p=None):
|
|
1600
|
+
import rsarray as np
|
|
1601
|
+
if hasattr(a, 'shape') or isinstance(a, (list, tuple)):
|
|
1602
|
+
values = np.asarray(a)
|
|
1603
|
+
pop = values.shape[0] if values.ndim > 0 else values.size
|
|
1604
|
+
else:
|
|
1605
|
+
values = None
|
|
1606
|
+
pop = int(a)
|
|
1607
|
+
if size is None:
|
|
1608
|
+
sz_shape = ()
|
|
1609
|
+
n = 1
|
|
1610
|
+
elif isinstance(size, (int,)):
|
|
1611
|
+
sz_shape = (int(size),)
|
|
1612
|
+
n = int(size)
|
|
1613
|
+
else:
|
|
1614
|
+
sz_shape = tuple(int(x) for x in size)
|
|
1615
|
+
n = 1
|
|
1616
|
+
for x in sz_shape:
|
|
1617
|
+
n *= x
|
|
1618
|
+
if not replace and pop < n:
|
|
1619
|
+
raise ValueError(
|
|
1620
|
+
"Cannot take a larger sample than population when "
|
|
1621
|
+
"'replace=false'")
|
|
1622
|
+
if p is not None:
|
|
1623
|
+
pw = np.asarray(p, dtype='float64').reshape(-1).tolist()
|
|
1624
|
+
total = float(sum(pw))
|
|
1625
|
+
cum = []
|
|
1626
|
+
acc = 0.0
|
|
1627
|
+
for x in pw:
|
|
1628
|
+
acc += float(x) / total
|
|
1629
|
+
cum.append(acc)
|
|
1630
|
+
cum[-1] = 1.0
|
|
1631
|
+
|
|
1632
|
+
def draw():
|
|
1633
|
+
u = self._u()
|
|
1634
|
+
for i, c in enumerate(cum):
|
|
1635
|
+
if u <= c:
|
|
1636
|
+
return i
|
|
1637
|
+
return len(cum) - 1
|
|
1638
|
+
else:
|
|
1639
|
+
def draw():
|
|
1640
|
+
return int(self._u() * pop)
|
|
1641
|
+
idx = [draw() for _ in range(n)]
|
|
1642
|
+
if not replace:
|
|
1643
|
+
seen = set()
|
|
1644
|
+
fixed = []
|
|
1645
|
+
for v in idx:
|
|
1646
|
+
while v in seen:
|
|
1647
|
+
v = draw()
|
|
1648
|
+
seen.add(v)
|
|
1649
|
+
fixed.append(v)
|
|
1650
|
+
idx = fixed
|
|
1651
|
+
if values is None:
|
|
1652
|
+
res = np.asarray(idx)
|
|
1653
|
+
else:
|
|
1654
|
+
res = np.take(values, np.asarray(idx))
|
|
1655
|
+
if size is None:
|
|
1656
|
+
return res.reshape(sz_shape)[()]
|
|
1657
|
+
return res.reshape(sz_shape)
|
|
1658
|
+
return choice
|
|
1659
|
+
|
|
1660
|
+
def _make_shuffle(self):
|
|
1661
|
+
"""-compatible in-place ``shuffle`` (the Rust core only accepts
|
|
1662
|
+
its own ndarray type, so shuffle at the Python layer)."""
|
|
1663
|
+
def shuffle(x, axis=0):
|
|
1664
|
+
import rsarray as np
|
|
1665
|
+
arr = x if axis == 0 else np.moveaxis(x, axis, 0)
|
|
1666
|
+
n = arr.shape[0]
|
|
1667
|
+
for i in range(n - 1, 0, -1):
|
|
1668
|
+
j = int(self.integers(i + 1))
|
|
1669
|
+
if j == i:
|
|
1670
|
+
continue
|
|
1671
|
+
tmp = arr[i].copy()
|
|
1672
|
+
arr[i] = arr[j]
|
|
1673
|
+
arr[j] = tmp
|
|
1674
|
+
return shuffle
|
|
1675
|
+
|
|
1676
|
+
def __getattr__(self, name):
|
|
1677
|
+
if name == 'choice':
|
|
1678
|
+
return self._make_choice()
|
|
1679
|
+
if name == 'shuffle':
|
|
1680
|
+
return self._make_shuffle()
|
|
1681
|
+
attr = getattr(self._inner, name, None)
|
|
1682
|
+
if attr is None:
|
|
1683
|
+
# Fallback for methods not available on the inner generator
|
|
1684
|
+
if name == 'vonmises':
|
|
1685
|
+
def vonmises_wrapper(kappa, size=None, mu=0.0, dtype=None):
|
|
1686
|
+
import rsarray as np
|
|
1687
|
+
import math
|
|
1688
|
+
# Broadcast mu/kappa to a common shape, then optionally to
|
|
1689
|
+
# ``size``. This lets callers pass array parameters (as
|
|
1690
|
+
# rsscipy's distribution layer does) as well as scalars.
|
|
1691
|
+
mu_b, kappa_b = np.broadcast_arrays(
|
|
1692
|
+
np.asarray(mu, dtype='float64'),
|
|
1693
|
+
np.asarray(kappa, dtype='float64'))
|
|
1694
|
+
if size is None:
|
|
1695
|
+
shape = tuple(mu_b.shape)
|
|
1696
|
+
else:
|
|
1697
|
+
shape = (tuple(size) if isinstance(size, (tuple, list))
|
|
1698
|
+
else (int(size),))
|
|
1699
|
+
mu_b = np.broadcast_to(mu_b, shape)
|
|
1700
|
+
kappa_b = np.broadcast_to(kappa_b, shape)
|
|
1701
|
+
flat_mu = mu_b.reshape(-1).tolist()
|
|
1702
|
+
flat_k = kappa_b.reshape(-1).tolist()
|
|
1703
|
+
result = []
|
|
1704
|
+
for m, k in zip(flat_mu, flat_k):
|
|
1705
|
+
m = float(m)
|
|
1706
|
+
k = float(k)
|
|
1707
|
+
while True:
|
|
1708
|
+
u1 = self._inner.random().item()
|
|
1709
|
+
u2 = self._inner.random().item()
|
|
1710
|
+
z = math.cos(math.pi * u1)
|
|
1711
|
+
if u2 < math.exp(k * (z - 1)):
|
|
1712
|
+
break
|
|
1713
|
+
angle = math.acos(max(-1.0, min(1.0, z)))
|
|
1714
|
+
if self._inner.random().item() < 0.5:
|
|
1715
|
+
angle = -angle
|
|
1716
|
+
result.append(m + angle)
|
|
1717
|
+
result_arr = np.asarray(result).reshape(shape)
|
|
1718
|
+
if dtype is not None and hasattr(result_arr, 'astype'):
|
|
1719
|
+
result_arr = result_arr.astype(dtype)
|
|
1720
|
+
return result_arr
|
|
1721
|
+
return vonmises_wrapper
|
|
1722
|
+
if name == 'multivariate_normal':
|
|
1723
|
+
def mvn_wrapper(mean, cov, size=None):
|
|
1724
|
+
def _std_normal():
|
|
1725
|
+
v = self._inner.standard_normal()
|
|
1726
|
+
if hasattr(v, 'item'):
|
|
1727
|
+
v = v.item()
|
|
1728
|
+
return float(v)
|
|
1729
|
+
return _mvn_sample(_std_normal, mean, cov, size)
|
|
1730
|
+
return mvn_wrapper
|
|
1731
|
+
if name == 'permutation':
|
|
1732
|
+
def permutation_wrapper(x, axis=0):
|
|
1733
|
+
import rsarray as np
|
|
1734
|
+
arr = np.asarray(x)
|
|
1735
|
+
idx = self._inner.permutation(arr.shape[axis])
|
|
1736
|
+
return np.take(arr, idx, axis=axis)
|
|
1737
|
+
return permutation_wrapper
|
|
1738
|
+
if name == 'permutated':
|
|
1739
|
+
def permutated_wrapper(x, axis=0, *args, **kwargs):
|
|
1740
|
+
import rsarray as np
|
|
1741
|
+
arr = np.asarray(x)
|
|
1742
|
+
idx = self._inner.permutation(arr.shape[axis])
|
|
1743
|
+
return np.take(arr, idx, axis=axis)
|
|
1744
|
+
return permutated_wrapper
|
|
1745
|
+
raise AttributeError(f"'{type(self._inner).__name__}' object has no attribute '{name}'")
|
|
1746
|
+
if callable(attr):
|
|
1747
|
+
def wrapper(*args, **kwargs):
|
|
1748
|
+
# Strip dtype from kwargs - rsarray core doesn't support it
|
|
1749
|
+
dtype = kwargs.pop('dtype', None)
|
|
1750
|
+
result = attr(*args, **kwargs)
|
|
1751
|
+
import rsarray as np
|
|
1752
|
+
# Wrap builtins.ndarray results into rsarray ndarray
|
|
1753
|
+
if type(result).__module__ == 'builtins' and type(result).__name__ == 'ndarray':
|
|
1754
|
+
result = np.asarray(result)
|
|
1755
|
+
# Convert dtype if specified
|
|
1756
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
1757
|
+
result = result.astype(dtype)
|
|
1758
|
+
return result
|
|
1759
|
+
return wrapper
|
|
1760
|
+
return attr
|
|
1761
|
+
|
|
1762
|
+
def _convert(self, value):
|
|
1763
|
+
if type(value).__module__ == 'builtins' and \
|
|
1764
|
+
type(value).__name__ == 'ndarray':
|
|
1765
|
+
# `_core.ndarray`:Rust 侧类型,包一层即可获得 Python 层 API。
|
|
1766
|
+
import rsarray as np
|
|
1767
|
+
return np.asarray(value)
|
|
1768
|
+
return value
|
|
1769
|
+
|
|
1770
|
+
def random(self, *args, **kwargs):
|
|
1771
|
+
dtype = kwargs.pop('dtype', None)
|
|
1772
|
+
args, kwargs = _coerce_size_arg(args, kwargs)
|
|
1773
|
+
# Rust Generator.random 不接受位置 size,统一改走 size= 关键字
|
|
1774
|
+
if args:
|
|
1775
|
+
kwargs.setdefault('size', args[0])
|
|
1776
|
+
args = args[1:]
|
|
1777
|
+
result = self._convert(self._inner.random(*args, **kwargs))
|
|
1778
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
1779
|
+
result = result.astype(dtype)
|
|
1780
|
+
return result
|
|
1781
|
+
|
|
1782
|
+
def standard_normal(self, *args, **kwargs):
|
|
1783
|
+
dtype = kwargs.pop('dtype', None)
|
|
1784
|
+
result = self._convert(self._inner.standard_normal(*args, **kwargs))
|
|
1785
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
1786
|
+
result = result.astype(dtype)
|
|
1787
|
+
return result
|
|
1788
|
+
|
|
1789
|
+
def normal(self, *args, **kwargs):
|
|
1790
|
+
dtype = kwargs.pop('dtype', None)
|
|
1791
|
+
result = self._convert(self._inner.normal(*args, **kwargs))
|
|
1792
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
1793
|
+
result = result.astype(dtype)
|
|
1794
|
+
return result
|
|
1795
|
+
|
|
1796
|
+
def uniform(self, *args, **kwargs):
|
|
1797
|
+
dtype = kwargs.pop('dtype', None)
|
|
1798
|
+
result = self._convert(self._inner.uniform(*args, **kwargs))
|
|
1799
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
1800
|
+
result = result.astype(dtype)
|
|
1801
|
+
return result
|
|
1802
|
+
|
|
1803
|
+
def integers(self, *args, **kwargs):
|
|
1804
|
+
dtype = kwargs.pop('dtype', None)
|
|
1805
|
+
result = self._convert(self._inner.integers(*args, **kwargs))
|
|
1806
|
+
if dtype is not None and hasattr(result, 'astype'):
|
|
1807
|
+
result = result.astype(dtype)
|
|
1808
|
+
return result
|
|
1809
|
+
|
|
1810
|
+
def multinomial(self, n, pvals, size=None):
|
|
1811
|
+
import rsarray as np
|
|
1812
|
+
pvals = np.asarray(pvals, dtype=float)
|
|
1813
|
+
pvals = pvals / pvals.sum()
|
|
1814
|
+
cdf = np.cumsum(pvals)
|
|
1815
|
+
if size is None:
|
|
1816
|
+
size = ()
|
|
1817
|
+
n_samples = int(np.prod(size)) if isinstance(size, tuple) else int(size)
|
|
1818
|
+
# Count occurrences of each category
|
|
1819
|
+
result = np.zeros(len(pvals), dtype=int)
|
|
1820
|
+
for _ in range(n_samples):
|
|
1821
|
+
u = float(np.asarray(self._inner.random()).tolist())
|
|
1822
|
+
if isinstance(u, list):
|
|
1823
|
+
u = u[0]
|
|
1824
|
+
idx = int(np.asarray(cdf).searchsorted(u) if hasattr(cdf, 'searchsorted') else 0)
|
|
1825
|
+
idx = min(idx, len(pvals) - 1)
|
|
1826
|
+
result[idx] += 1
|
|
1827
|
+
return np.asarray(result)
|
|
1828
|
+
|
|
1829
|
+
def permuted(self, x, axis=0, *args, **kwargs):
|
|
1830
|
+
import rsarray as np
|
|
1831
|
+
arr = np.asarray(x)
|
|
1832
|
+
idx = self._inner.permutation(arr.shape[axis])
|
|
1833
|
+
return np.take(arr, idx, axis=axis)
|
|
1834
|
+
|
|
1835
|
+
|
|
1836
|
+
class mtrand_module:
|
|
1837
|
+
"""mtrand 模块,提供全局随机数生成器"""
|
|
1838
|
+
def __init__(self):
|
|
1839
|
+
self._rand = _RandomStateWrapper(None)
|
|
1840
|
+
|
|
1841
|
+
def __getattr__(self, name):
|
|
1842
|
+
# np.random.mtrand.<分布>/方法 全部委托给 legacy RandomState
|
|
1843
|
+
return getattr(self._rand, name)
|
|
1844
|
+
|
|
1845
|
+
|
|
1846
|
+
class _SeedSequence:
|
|
1847
|
+
"""random.SeedSequence 纯 Python 位级兼容移植。
|
|
1848
|
+
|
|
1849
|
+
算法 = O'Neill seed_seq 的修订版:4×uint32 池,hashmix(INIT_A/MULT_A)
|
|
1850
|
+
填充 +
|
|
1851
|
+
全混合,generate_state 走 INIT_B/MULT_B 流。常量与调用顺序与
|
|
1852
|
+
2.5.4 逐位一致(SeedSequence(42).generate_state(4) =
|
|
1853
|
+
[3444837047, 2669555309, 2046530742, 3581440988],10 组官方
|
|
1854
|
+
参考向量全部吻合)。
|
|
1855
|
+
"""
|
|
1856
|
+
|
|
1857
|
+
DEFAULT_POOL_SIZE = 4
|
|
1858
|
+
_MASK32 = 0xFFFFFFFF
|
|
1859
|
+
_INIT_A = 0x43B0D7E5
|
|
1860
|
+
_MULT_A = 0x931E8875
|
|
1861
|
+
_INIT_B = 0x8B51F9DD
|
|
1862
|
+
_MULT_B = 0x58F38DED
|
|
1863
|
+
_MIX_MULT_L = 0xCA01F9DD
|
|
1864
|
+
_MIX_MULT_R = 0x4973F715
|
|
1865
|
+
|
|
1866
|
+
def __init__(self, entropy=None, spawn_key=(),
|
|
1867
|
+
pool_size=DEFAULT_POOL_SIZE, n_children_spawned=0):
|
|
1868
|
+
if pool_size < self.DEFAULT_POOL_SIZE:
|
|
1869
|
+
raise ValueError("The size of the entropy pool should be at least "
|
|
1870
|
+
f"{self.DEFAULT_POOL_SIZE}")
|
|
1871
|
+
if entropy is None:
|
|
1872
|
+
# —secrets.randbits(pool_size * 32)(OS 熵)
|
|
1873
|
+
entropy = _py_random.SystemRandom().getrandbits(pool_size * 32)
|
|
1874
|
+
elif not isinstance(entropy, (int, list, tuple, range)):
|
|
1875
|
+
raise TypeError('SeedSequence expects int or sequence of ints for '
|
|
1876
|
+
f'entropy not {entropy}')
|
|
1877
|
+
self.entropy = entropy
|
|
1878
|
+
self.spawn_key = tuple(spawn_key)
|
|
1879
|
+
self.pool_size = pool_size
|
|
1880
|
+
self.n_children_spawned = n_children_spawned
|
|
1881
|
+
self.pool = [0] * pool_size
|
|
1882
|
+
self._mix_entropy(self.pool, self._assembled_entropy())
|
|
1883
|
+
|
|
1884
|
+
@property
|
|
1885
|
+
def state(self):
|
|
1886
|
+
return {'entropy': self.entropy, 'spawn_key': self.spawn_key,
|
|
1887
|
+
'pool_size': self.pool_size,
|
|
1888
|
+
'n_children_spawned': self.n_children_spawned}
|
|
1889
|
+
|
|
1890
|
+
def _assembled_entropy(self):
|
|
1891
|
+
run = self._coerce(self.entropy)
|
|
1892
|
+
spawn = self._coerce(self.spawn_key) if len(self.spawn_key) else []
|
|
1893
|
+
if spawn and len(run) < self.pool_size:
|
|
1894
|
+
# 1.19+(gh-16539):带 spawn_key 时先把 entropy
|
|
1895
|
+
# 补零到 pool_size,避免与 spawn key 冲突
|
|
1896
|
+
run = run + [0] * (self.pool_size - len(run))
|
|
1897
|
+
return run + spawn
|
|
1898
|
+
|
|
1899
|
+
@classmethod
|
|
1900
|
+
def _coerce(cls, x):
|
|
1901
|
+
"""``_coerce_to_uint32_array``:int/str/序列 → uint32 字。"""
|
|
1902
|
+
if isinstance(x, str):
|
|
1903
|
+
if x.startswith('0x'):
|
|
1904
|
+
x = int(x, base=16)
|
|
1905
|
+
elif x and all(c in '0123456789' for c in x):
|
|
1906
|
+
x = int(x)
|
|
1907
|
+
else:
|
|
1908
|
+
raise ValueError("unrecognized seed string")
|
|
1909
|
+
if isinstance(x, int):
|
|
1910
|
+
if x < 0:
|
|
1911
|
+
raise ValueError("expected non-negative integer")
|
|
1912
|
+
if x == 0:
|
|
1913
|
+
return [0]
|
|
1914
|
+
words = []
|
|
1915
|
+
while x > 0:
|
|
1916
|
+
words.append(x & cls._MASK32)
|
|
1917
|
+
x //= 2 ** 32
|
|
1918
|
+
return words
|
|
1919
|
+
if isinstance(x, float):
|
|
1920
|
+
raise TypeError('seed must be integer')
|
|
1921
|
+
if len(x) == 0:
|
|
1922
|
+
return []
|
|
1923
|
+
out = []
|
|
1924
|
+
for v in x:
|
|
1925
|
+
if hasattr(v, '__len__') and not isinstance(v, str):
|
|
1926
|
+
raise TypeError("SeedSequence does not accept nested sequences.")
|
|
1927
|
+
out.extend(cls._coerce(v))
|
|
1928
|
+
return out
|
|
1929
|
+
|
|
1930
|
+
def _mix_entropy(self, mixer, entropy_array):
|
|
1931
|
+
"""``SeedSequence.mix_entropy``:hashmix 填充 + 全混合。
|
|
1932
|
+
|
|
1933
|
+
hash_const 是跨全部 hashmix 调用共享推进的可变值,调用顺序
|
|
1934
|
+
与 完全一致(位级兼容的关键)。
|
|
1935
|
+
"""
|
|
1936
|
+
hc = self._INIT_A
|
|
1937
|
+
|
|
1938
|
+
def hm(value):
|
|
1939
|
+
nonlocal hc
|
|
1940
|
+
value ^= hc
|
|
1941
|
+
hc = (hc * self._MULT_A) & self._MASK32
|
|
1942
|
+
value = (value * hc) & self._MASK32
|
|
1943
|
+
value ^= value >> 16
|
|
1944
|
+
return value & self._MASK32
|
|
1945
|
+
|
|
1946
|
+
def mx(a, b):
|
|
1947
|
+
r = (self._MIX_MULT_L * a - self._MIX_MULT_R * b) & self._MASK32
|
|
1948
|
+
r ^= r >> 16
|
|
1949
|
+
return r & self._MASK32
|
|
1950
|
+
|
|
1951
|
+
# 阶段 1:entropy 不足 pool 位时用 0 继续 hash
|
|
1952
|
+
for i in range(len(mixer)):
|
|
1953
|
+
mixer[i] = hm(entropy_array[i] if i < len(entropy_array) else 0)
|
|
1954
|
+
# 阶段 2:全混合(后位影响前位)
|
|
1955
|
+
for i_src in range(len(mixer)):
|
|
1956
|
+
for i_dst in range(len(mixer)):
|
|
1957
|
+
if i_src != i_dst:
|
|
1958
|
+
mixer[i_dst] = mx(mixer[i_dst], hm(mixer[i_src]))
|
|
1959
|
+
# 阶段 3:剩余 entropy 逐字与各 pool 位混合
|
|
1960
|
+
for i_src in range(len(mixer), len(entropy_array)):
|
|
1961
|
+
for i_dst in range(len(mixer)):
|
|
1962
|
+
mixer[i_dst] = mx(mixer[i_dst], hm(entropy_array[i_src]))
|
|
1963
|
+
|
|
1964
|
+
def generate_state(self, n_words, dtype='uint32'):
|
|
1965
|
+
"""``SeedSequence.generate_state``:INIT_B/MULT_B 流输出。
|
|
1966
|
+
|
|
1967
|
+
dtype 为 uint64 时按对打包(小端:前字为低 32 位)。
|
|
1968
|
+
"""
|
|
1969
|
+
if str(dtype).endswith('64'):
|
|
1970
|
+
n_words *= 2
|
|
1971
|
+
hc = self._INIT_B
|
|
1972
|
+
out = []
|
|
1973
|
+
for i in range(n_words):
|
|
1974
|
+
v = self.pool[i % len(self.pool)]
|
|
1975
|
+
v ^= hc
|
|
1976
|
+
hc = (hc * self._MULT_B) & self._MASK32
|
|
1977
|
+
v = (v * hc) & self._MASK32
|
|
1978
|
+
v ^= v >> 16
|
|
1979
|
+
out.append(v & self._MASK32)
|
|
1980
|
+
if str(dtype).endswith('64'):
|
|
1981
|
+
out = [out[i] | (out[i + 1] << 32) for i in range(0, len(out), 2)]
|
|
1982
|
+
return out
|
|
1983
|
+
|
|
1984
|
+
|
|
1985
|
+
class PCG64:
|
|
1986
|
+
"""random.PCG64 纯 Python 位级兼容移植(PCG XSL-RR-128-64)。
|
|
1987
|
+
|
|
1988
|
+
状态 = (128-bit state, 128-bit inc) + uint32 缓存(has_uint32/
|
|
1989
|
+
uinteger,legacy RandomState 的 res53 double 流消费)。种子链与
|
|
1990
|
+
一致:SeedSequence(seed).generate_state(4, uint64) →
|
|
1991
|
+
initstate/inc → pcg_setseq_128_srandom_r
|
|
1992
|
+
(state=0; inc=(seq<<1)|1; step; state+=initstate; step)。
|
|
1993
|
+
"""
|
|
1994
|
+
|
|
1995
|
+
_MASK128 = (1 << 128) - 1
|
|
1996
|
+
_MASK64 = (1 << 64) - 1
|
|
1997
|
+
# pcg64.h: PCG_DEFAULT_MULTIPLIER_128
|
|
1998
|
+
_MULT128 = (2549297995355413924 << 64) | 4865540595714422341
|
|
1999
|
+
|
|
2000
|
+
def __init__(self, seed=None):
|
|
2001
|
+
self._state = 0
|
|
2002
|
+
self._inc = 0
|
|
2003
|
+
self._has_uint32 = 0
|
|
2004
|
+
self._uinteger = 0
|
|
2005
|
+
self._seed_seq = None
|
|
2006
|
+
self.seed(seed)
|
|
2007
|
+
|
|
2008
|
+
def seed(self, seed=None):
|
|
2009
|
+
"""重新播种(``PCG64.seed``)。"""
|
|
2010
|
+
ss = _SeedSequence(seed)
|
|
2011
|
+
self._seed_seq = ss
|
|
2012
|
+
val = ss.generate_state(4, 'uint64')
|
|
2013
|
+
initstate = (val[0] << 64) | val[1]
|
|
2014
|
+
initseq = (val[2] << 64) | val[3]
|
|
2015
|
+
self._state = 0
|
|
2016
|
+
self._inc = ((initseq << 1) | 1) & self._MASK128
|
|
2017
|
+
self._step()
|
|
2018
|
+
self._state = (self._state + initstate) & self._MASK128
|
|
2019
|
+
self._step()
|
|
2020
|
+
self._has_uint32 = 0
|
|
2021
|
+
self._uinteger = 0
|
|
2022
|
+
return self
|
|
2023
|
+
|
|
2024
|
+
def _step(self):
|
|
2025
|
+
self._state = (self._state * self._MULT128 + self._inc) & self._MASK128
|
|
2026
|
+
|
|
2027
|
+
def next64(self):
|
|
2028
|
+
"""一个 64 位输出(先步进后输出,XSL-RR)。"""
|
|
2029
|
+
self._step()
|
|
2030
|
+
hi = self._state >> 64
|
|
2031
|
+
lo = self._state & self._MASK64
|
|
2032
|
+
x = hi ^ lo
|
|
2033
|
+
rot = (self._state >> 122) & 63
|
|
2034
|
+
return ((x >> rot) | (x << ((-rot) & 63))) & self._MASK64
|
|
2035
|
+
|
|
2036
|
+
def next32(self):
|
|
2037
|
+
"""32 位输出,带 uinteger 缓存(对应 state 的 has_uint32 字段)。"""
|
|
2038
|
+
if self._has_uint32:
|
|
2039
|
+
self._has_uint32 = 0
|
|
2040
|
+
return self._uinteger
|
|
2041
|
+
n = self.next64()
|
|
2042
|
+
self._has_uint32 = 1
|
|
2043
|
+
self._uinteger = n >> 32
|
|
2044
|
+
return n & 0xFFFFFFFF
|
|
2045
|
+
|
|
2046
|
+
@property
|
|
2047
|
+
def state(self):
|
|
2048
|
+
"""``PCG64.state`` get:dict(state/inc 为 128-bit 整数)。"""
|
|
2049
|
+
return {'bit_generator': 'PCG64',
|
|
2050
|
+
'state': {'state': self._state, 'inc': self._inc},
|
|
2051
|
+
'has_uint32': self._has_uint32,
|
|
2052
|
+
'uinteger': self._uinteger}
|
|
2053
|
+
|
|
2054
|
+
@state.setter
|
|
2055
|
+
def state(self, value):
|
|
2056
|
+
if not isinstance(value, dict):
|
|
2057
|
+
raise TypeError('state must be a dict')
|
|
2058
|
+
if value.get('bit_generator', '') != 'PCG64':
|
|
2059
|
+
raise ValueError('state must be for a PCG64 RNG')
|
|
2060
|
+
self._state = int(value['state']['state']) & self._MASK128
|
|
2061
|
+
self._inc = int(value['state']['inc']) & self._MASK128
|
|
2062
|
+
self._has_uint32 = int(value['has_uint32'])
|
|
2063
|
+
self._uinteger = int(value['uinteger']) & 0xFFFFFFFF
|
|
2064
|
+
|
|
2065
|
+
def __repr__(self):
|
|
2066
|
+
return f'PCG64(seed={self._seed_seq.entropy!r})'
|
|
2067
|
+
|
|
2068
|
+
|
|
2069
|
+
class random_module:
|
|
2070
|
+
"""随机数生成模块"""
|
|
2071
|
+
|
|
2072
|
+
def __init__(self):
|
|
2073
|
+
self._random = _core.random
|
|
2074
|
+
self.mtrand = mtrand_module()
|
|
2075
|
+
|
|
2076
|
+
@property
|
|
2077
|
+
def Generator(self):
|
|
2078
|
+
# Expose the wrapper class so ``isinstance(x, np.random.Generator)``
|
|
2079
|
+
# works for generators produced by ``default_rng``.
|
|
2080
|
+
return _WrappedGenerator
|
|
2081
|
+
|
|
2082
|
+
@property
|
|
2083
|
+
def RandomState(self):
|
|
2084
|
+
return _RandomStateWrapper
|
|
2085
|
+
|
|
2086
|
+
@property
|
|
2087
|
+
def SeedSequence(self):
|
|
2088
|
+
return _SeedSequence
|
|
2089
|
+
|
|
2090
|
+
@property
|
|
2091
|
+
def PCG64(self):
|
|
2092
|
+
return PCG64
|
|
2093
|
+
|
|
2094
|
+
@property
|
|
2095
|
+
def BitGenerator(self):
|
|
2096
|
+
return _MT19937
|
|
2097
|
+
|
|
2098
|
+
def default_rng(self, seed=None):
|
|
2099
|
+
"""创建默认的随机数生成器(新 API)。
|
|
2100
|
+
|
|
2101
|
+
参数:
|
|
2102
|
+
seed: 随机种子。
|
|
2103
|
+
|
|
2104
|
+
返回:
|
|
2105
|
+
Generator: 随机数生成器。
|
|
2106
|
+
"""
|
|
2107
|
+
# If seed is already a wrapped generator, return it directly
|
|
2108
|
+
if isinstance(seed, _WrappedGenerator):
|
|
2109
|
+
return seed
|
|
2110
|
+
return _WrappedGenerator(seed)
|
|
2111
|
+
|
|
2112
|
+
def seed(self, s):
|
|
2113
|
+
"""设置随机种子。"""
|
|
2114
|
+
return self._random.seed(s)
|
|
2115
|
+
|
|
2116
|
+
def _rand_arr(self, vals):
|
|
2117
|
+
"""确保输出是带 _dtype 的正规 rsarray ndarray(Rust 原生对象转换)。"""
|
|
2118
|
+
from ..__init__ import ndarray
|
|
2119
|
+
if hasattr(vals, 'tolist') and not hasattr(vals, '_dtype'):
|
|
2120
|
+
vals = vals.tolist()
|
|
2121
|
+
return ndarray(vals)
|
|
2122
|
+
|
|
2123
|
+
def rand(self, *args):
|
|
2124
|
+
"""生成均匀分布的随机数。"""
|
|
2125
|
+
if len(args) == 0:
|
|
2126
|
+
return self._rand_arr(self._random.rand(1))
|
|
2127
|
+
return self._rand_arr(self._random.rand(*args))
|
|
2128
|
+
|
|
2129
|
+
def _fix_rand_shape(self, arr, shape):
|
|
2130
|
+
"""Rust randn/normal 空尺寸会折叠成 (0,),按请求形状还原。"""
|
|
2131
|
+
if tuple(getattr(arr, 'shape', ())) != shape:
|
|
2132
|
+
total = 1
|
|
2133
|
+
for d in shape:
|
|
2134
|
+
total *= d
|
|
2135
|
+
if getattr(arr, 'size', None) == total:
|
|
2136
|
+
arr = arr.reshape(shape)
|
|
2137
|
+
return arr
|
|
2138
|
+
|
|
2139
|
+
def randn(self, *args):
|
|
2140
|
+
"""生成标准正态分布的随机数。"""
|
|
2141
|
+
if len(args) == 0:
|
|
2142
|
+
return self._rand_arr(self._random.randn(1))
|
|
2143
|
+
shape = tuple(int(d) for d in args)
|
|
2144
|
+
return self._fix_rand_shape(
|
|
2145
|
+
self._rand_arr(self._random.randn(*args)), shape)
|
|
2146
|
+
|
|
2147
|
+
def randint(self, low, high=None, size=None):
|
|
2148
|
+
"""生成整数随机数。"""
|
|
2149
|
+
from ..__init__ import ndarray
|
|
2150
|
+
return ndarray._wrap(self._random.randint(low, high, size), "int64")
|
|
2151
|
+
|
|
2152
|
+
def uniform(self, low=0.0, high=1.0, size=None):
|
|
2153
|
+
"""生成均匀分布的随机数。"""
|
|
2154
|
+
from ..__init__ import ndarray
|
|
2155
|
+
return ndarray(self._random.uniform(low, high, size))
|
|
2156
|
+
|
|
2157
|
+
def random(self, size=None):
|
|
2158
|
+
"""生成 [0.0, 1.0) 区间均匀分布的随机数。"""
|
|
2159
|
+
from ..__init__ import ndarray
|
|
2160
|
+
return ndarray(self._random.uniform(0.0, 1.0, size))
|
|
2161
|
+
|
|
2162
|
+
def normal(self, loc=0.0, scale=1.0, size=None):
|
|
2163
|
+
"""生成正态分布的随机数。"""
|
|
2164
|
+
from ..__init__ import ndarray
|
|
2165
|
+
if size is None:
|
|
2166
|
+
size = 1
|
|
2167
|
+
shape = size if isinstance(size, tuple) else tuple(size) \
|
|
2168
|
+
if isinstance(size, list) else (size,)
|
|
2169
|
+
return self._fix_rand_shape(
|
|
2170
|
+
ndarray(self._random.normal(loc, scale, size)), tuple(shape))
|
|
2171
|
+
|
|
2172
|
+
def randn_like(self, a):
|
|
2173
|
+
"""生成与输入数组形状相同的标准正态分布随机数。"""
|
|
2174
|
+
from ..__init__ import ndarray
|
|
2175
|
+
arr = ndarray(a)
|
|
2176
|
+
return self._fix_rand_shape(
|
|
2177
|
+
ndarray(self._random.randn(*arr.shape)), tuple(arr.shape))
|
|
2178
|
+
|
|
2179
|
+
def rand_like(self, a):
|
|
2180
|
+
"""生成与输入数组形状相同的均匀分布随机数。"""
|
|
2181
|
+
from ..__init__ import ndarray
|
|
2182
|
+
arr = ndarray(a)
|
|
2183
|
+
return ndarray(self._random.rand(*arr.shape))
|
|
2184
|
+
|
|
2185
|
+
|
|
2186
|
+
# ---------------------------------------------------------------------------
|
|
2187
|
+
# 兼容的模块级 API:里 ``np.random`` 是模块,``from random
|
|
2188
|
+
# import rand`` 是合法用法。以下模块级函数绑定同一个默认实例,且
|
|
2189
|
+
# ``rsarray.random``(见 python/rsarray/__init__.py)指向本模块本身,
|
|
2190
|
+
# 两种访问形式共享同一份全局状态。
|
|
2191
|
+
# ---------------------------------------------------------------------------
|
|
2192
|
+
_default_rng = random_module()
|
|
2193
|
+
Generator = _default_rng.Generator
|
|
2194
|
+
RandomState = _default_rng.RandomState
|
|
2195
|
+
SeedSequence = _default_rng.SeedSequence
|
|
2196
|
+
BitGenerator = _default_rng.BitGenerator
|
|
2197
|
+
mtrand = _default_rng.mtrand
|
|
2198
|
+
default_rng = _default_rng.default_rng
|
|
2199
|
+
|
|
2200
|
+
def rand(*args):
|
|
2201
|
+
# MT19937 全局流(与 randint/uniform 共用 _get_legacy_state)
|
|
2202
|
+
return _get_legacy_state().rand(*args)
|
|
2203
|
+
|
|
2204
|
+
randn = _default_rng.randn
|
|
2205
|
+
|
|
2206
|
+
def random(*args, **kwargs):
|
|
2207
|
+
# legacy random_sample:MT19937 全局流
|
|
2208
|
+
return _get_legacy_state().random(*args, **kwargs)
|
|
2209
|
+
|
|
2210
|
+
random_sample = random
|
|
2211
|
+
randn_like = _default_rng.randn_like
|
|
2212
|
+
rand_like = _default_rng.rand_like
|
|
2213
|
+
|
|
2214
|
+
_legacy_state = None
|
|
2215
|
+
|
|
2216
|
+
|
|
2217
|
+
def _get_legacy_state():
|
|
2218
|
+
global _legacy_state
|
|
2219
|
+
if _legacy_state is None:
|
|
2220
|
+
_legacy_state = _RandomStateWrapper(None)
|
|
2221
|
+
return _legacy_state
|
|
2222
|
+
|
|
2223
|
+
|
|
2224
|
+
def seed(s=None):
|
|
2225
|
+
"""设置全局随机种子(legacy 状态 + Rust 全局流,共享)。"""
|
|
2226
|
+
s = _legacy_validate_seed(s)
|
|
2227
|
+
if s is not None:
|
|
2228
|
+
try:
|
|
2229
|
+
_default_rng._random.seed(_fold_seed(s))
|
|
2230
|
+
except Exception:
|
|
2231
|
+
pass
|
|
2232
|
+
_get_legacy_state().seed(s)
|
|
2233
|
+
|
|
2234
|
+
|
|
2235
|
+
def randint(low, high=None, size=None, dtype='int64'):
|
|
2236
|
+
"""legacy randint:完整 dtype 语义(校验/边界/位宽截断)。"""
|
|
2237
|
+
return _get_legacy_state().randint(low, high, size=size, dtype=dtype)
|
|
2238
|
+
|
|
2239
|
+
|
|
2240
|
+
def uniform(low=0.0, high=1.0, size=None):
|
|
2241
|
+
return _get_legacy_state()._sample_dist('uniform', (low, high), size)
|
|
2242
|
+
|
|
2243
|
+
|
|
2244
|
+
def normal(loc=0.0, scale=1.0, size=None):
|
|
2245
|
+
return _get_legacy_state()._sample_dist('normal', (loc, scale), size)
|
|
2246
|
+
|
|
2247
|
+
|
|
2248
|
+
_legacy_func_cache = {}
|
|
2249
|
+
|
|
2250
|
+
|
|
2251
|
+
def __getattr__(name):
|
|
2252
|
+
"""PEP 562:补齐遗留 np.random.* 函数名(分布/permutation/shuffle 等)。
|
|
2253
|
+
|
|
2254
|
+
结果缓存:保证 ``np.random.geometric in (np.random.geometric,)`` 之类的
|
|
2255
|
+
函数身份比较成立(tests 用 ``func in probfuncs`` 判定)。
|
|
2256
|
+
"""
|
|
2257
|
+
if name in _RS_DIST_DISPATCH or name in (
|
|
2258
|
+
'multinomial', 'dirichlet', 'vonmises', 'permutation', 'shuffle',
|
|
2259
|
+
'choice', 'multivariate_normal', 'random_integers', 'bytes',
|
|
2260
|
+
'tomaxint', 'standard_normal'):
|
|
2261
|
+
f = _legacy_func_cache.get(name)
|
|
2262
|
+
if f is None:
|
|
2263
|
+
f = getattr(_get_legacy_state(), name)
|
|
2264
|
+
_legacy_func_cache[name] = f
|
|
2265
|
+
return f
|
|
2266
|
+
raise AttributeError(f"module 'rsarray.random' has no attribute {name!r}")
|