rsarray 1.2.10__cp313-cp313-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.
Files changed (59) hide show
  1. rsarray/__init__.py +12028 -0
  2. rsarray/_core/__init__.py +213 -0
  3. rsarray/_core/_exceptions.py +83 -0
  4. rsarray/_core/_internal.py +331 -0
  5. rsarray/_core/_multiarray_tests.py +129 -0
  6. rsarray/_core/_multiarray_umath.py +121 -0
  7. rsarray/_core/_rational_tests.py +52 -0
  8. rsarray/_core/arrayprint.py +36 -0
  9. rsarray/_core/fromnumeric.py +31 -0
  10. rsarray/_core/function_base.py +84 -0
  11. rsarray/_core/multiarray.py +385 -0
  12. rsarray/_core/numeric.py +28 -0
  13. rsarray/_core/numerictypes.py +233 -0
  14. rsarray/_core/records.py +14 -0
  15. rsarray/_core/shape_base.py +23 -0
  16. rsarray/_core/strings.py +78 -0
  17. rsarray/_core/umath.py +176 -0
  18. rsarray/_dtypes.py +1229 -0
  19. rsarray/_extra.py +6621 -0
  20. rsarray/_typing.py +24 -0
  21. rsarray/array_methods.py +1224 -0
  22. rsarray/array_ops.py +1585 -0
  23. rsarray/char.py +1590 -0
  24. rsarray/exceptions.py +45 -0
  25. rsarray/fft/__init__.py +231 -0
  26. rsarray/io.py +453 -0
  27. rsarray/lib/__init__.py +102 -0
  28. rsarray/lib/_function_base_impl.py +37 -0
  29. rsarray/lib/_index_tricks_impl.py +98 -0
  30. rsarray/lib/_nanfunctions_impl.py +1637 -0
  31. rsarray/lib/_stride_tricks_impl.py +110 -0
  32. rsarray/lib/recfunctions.py +1222 -0
  33. rsarray/lib/stride_tricks.py +106 -0
  34. rsarray/linalg/__init__.py +2603 -0
  35. rsarray/linalg/_linalg.py +91 -0
  36. rsarray/linalg/_pylinalg.py +1008 -0
  37. rsarray/linalg/lapack_lite.py +13 -0
  38. rsarray/ma/__init__.py +92 -0
  39. rsarray/ma/core.py +1385 -0
  40. rsarray/ma/extras.py +711 -0
  41. rsarray/ma/mrecords.py +144 -0
  42. rsarray/math_functions.py +965 -0
  43. rsarray/matlib.py +67 -0
  44. rsarray/num_core.cp313-win_amd64.pyd +0 -0
  45. rsarray/polynomial/__init__.py +148 -0
  46. rsarray/polynomial/_npcompat.py +721 -0
  47. rsarray/polynomial/polynomial.py +1082 -0
  48. rsarray/random/__init__.py +2266 -0
  49. rsarray/random/_distributions.py +773 -0
  50. rsarray/rec.py +207 -0
  51. rsarray/statistics.py +1360 -0
  52. rsarray/strings.py +349 -0
  53. rsarray/typing/__init__.py +26 -0
  54. rsarray-1.2.10.dist-info/METADATA +280 -0
  55. rsarray-1.2.10.dist-info/RECORD +59 -0
  56. rsarray-1.2.10.dist-info/WHEEL +4 -0
  57. rsarray-1.2.10.dist-info/licenses/LICENSE +21 -0
  58. rsarray-1.2.10.dist-info/licenses/NOTICE +7 -0
  59. 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}")