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.
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.cp315-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,1637 @@
1
+ # SPDX-License-Identifier: MIT
2
+ """lib._nanfunctions_impl 兼容实现。
3
+
4
+ 包含:
5
+ - 内部助手 _nan_mask / _replace_nan / _divide_by_count(2.x 语义)
6
+ - Python 层逐 slice NaN 归约/分位数引擎(Rust 快路径不可用的场景:
7
+ 含 NaN、元组轴、keepdims/out、weighted、method 分位数等)
8
+ - 14 个 nanX 的 re-export shim(__all__ 与 对齐)
9
+ """
10
+ import builtins
11
+ import math
12
+ import warnings
13
+
14
+ __all__ = [
15
+ "nansum", "nanmax", "nanmin", "nanargmax", "nanargmin", "nanmean",
16
+ "nanmedian", "nanpercentile", "nanvar", "nanstd", "nanprod",
17
+ "nancumsum", "nancumprod", "nanquantile",
18
+ ]
19
+
20
+
21
+ def _rs():
22
+ import rsarray as _np
23
+ return _np
24
+
25
+
26
+ # ------------------------------------------------------------------ 基础工具
27
+
28
+ def _dt_kind(dt):
29
+ """dtype 对象或字符串 → 首字母 kind('i'/'f'/'c'/'O'...)。"""
30
+ if dt is None:
31
+ return ''
32
+ if isinstance(dt, str):
33
+ s = dt.lstrip('<>=|')
34
+ return s[:1] if s else ''
35
+ k = getattr(dt, 'kind', None)
36
+ return k if isinstance(k, str) else ''
37
+
38
+
39
+ def _prod(seq):
40
+ r = 1
41
+ for v in seq:
42
+ r *= v
43
+ return r
44
+
45
+
46
+ def _flat_list(data):
47
+ """嵌套列表 → 扁平 Python 值列表(C 序)。"""
48
+ out = []
49
+
50
+ def _rec(x):
51
+ if isinstance(x, (list, tuple)):
52
+ for v in x:
53
+ _rec(v)
54
+ else:
55
+ out.append(x)
56
+
57
+ _rec(data)
58
+ return out
59
+
60
+
61
+ def _list_shape(l):
62
+ """嵌套列表 → 形状元组;不规则/空返回 None。"""
63
+ if not isinstance(l, (list, tuple)):
64
+ return ()
65
+ if len(l) == 0:
66
+ return None
67
+ sub = [_list_shape(v) for v in l]
68
+ if any(s is None for s in sub):
69
+ return None
70
+ if all(s == sub[0] for s in sub):
71
+ return (len(l),) + sub[0]
72
+ return None
73
+
74
+
75
+ def _reshape_flat(flat, shape):
76
+ """扁平列表 → 嵌套列表(C 序);0-d 直接返回标量值。"""
77
+ shape = tuple(shape)
78
+ if not shape:
79
+ return flat[0] if flat else 0
80
+
81
+ def _build(idx, remaining):
82
+ if len(remaining) == 1:
83
+ n = remaining[0]
84
+ return list(flat[idx: idx + n])
85
+ n = remaining[0]
86
+ sub = _prod(remaining[1:])
87
+ return [_build(idx + i * sub, remaining[1:]) for i in range(n)]
88
+
89
+ return _build(0, shape)
90
+
91
+
92
+ def _normalize_axes(axis, ndim):
93
+ """axis None/int/tuple → 非负轴元组;越界 AxisError、重复 ValueError。"""
94
+ if axis is None:
95
+ return ()
96
+ if isinstance(axis, (list, tuple)):
97
+ axes = tuple(int(a) for a in axis)
98
+ else:
99
+ axes = (int(axis),)
100
+ rs = _rs()
101
+ seen = set()
102
+ norm = []
103
+ for ax in axes:
104
+ if not (-ndim <= ax < ndim):
105
+ raise rs.AxisError(f"axis {ax} is out of bounds for array of dimension {ndim}")
106
+ a = ax % ndim
107
+ if a in seen:
108
+ raise ValueError(f"repeated axis {ax} in reduction")
109
+ seen.add(a)
110
+ norm.append(a)
111
+ return tuple(norm)
112
+
113
+
114
+ def _reduce_axes(axis, nd):
115
+ """axis → 归约轴元组;None = 全归约(所有轴,数组语义)。"""
116
+ if axis is None:
117
+ return tuple(range(nd))
118
+ return _normalize_axes(axis, nd)
119
+
120
+
121
+ def _slices(flat, shape, axes, wflat=None):
122
+ """按 axes 切分 flat(C 序) 值 → 逐 slice yield (值列表, 权值列表|None)。"""
123
+ nd = len(shape)
124
+ strides = [1] * nd
125
+ for i in range(nd - 2, -1, -1):
126
+ strides[i] = strides[i + 1] * shape[i + 1]
127
+ axset = set(axes)
128
+ red_axes = sorted((i for i in range(nd) if i in axset), reverse=True)
129
+ keep = [i for i in range(nd) if i not in axset]
130
+ out_shape = [shape[i] for i in keep]
131
+ out_size = _prod(out_shape) if out_shape else 1
132
+ red_size = _prod(shape[i] for i in red_axes)
133
+ if not axes and _prod(shape) == 0:
134
+ # 全归约空数组: 单个空 slice(数组语义 → NaN + 告警)
135
+ yield [], None
136
+ return
137
+ for oi in range(out_size):
138
+ # 混合进制解码(C 序):低轴先取余,高轴取商
139
+ base = 0
140
+ rem = oi
141
+ for i in reversed(keep):
142
+ dim = shape[i]
143
+ step = rem % dim if dim else 0
144
+ rem = rem // dim if dim else 0
145
+ base += step * strides[i]
146
+ idxs = []
147
+ for ri in range(red_size):
148
+ idx = base
149
+ rem = ri
150
+ for i in reversed(red_axes):
151
+ dim = shape[i]
152
+ step = rem % dim if dim else 0
153
+ rem = rem // dim if dim else 0
154
+ idx += step * strides[i]
155
+ idxs.append(idx)
156
+ vals = [flat[i] for i in idxs]
157
+ if wflat is not None:
158
+ yield vals, [wflat[i] for i in idxs]
159
+ else:
160
+ yield vals, None
161
+
162
+
163
+ def _is_nan_v(v):
164
+ return v != v
165
+
166
+
167
+ def _ckey(v):
168
+ """complex 安全的排序/比较 key(按 (real, imag) 字典序)。"""
169
+ if isinstance(v, complex):
170
+ return (v.real, v.imag)
171
+ return (float(v), 0.0)
172
+
173
+
174
+ def _has_nan_arr(a):
175
+ """数组是否含 NaN(int/bool 恒 False)。"""
176
+ k = _dt_kind(getattr(a, '_dtype', None))
177
+ if k not in 'fc':
178
+ return False
179
+ rs = _rs()
180
+ v = rs.isnan(a).any()
181
+ try:
182
+ return bool(v)
183
+ except Exception:
184
+ return bool(v.tolist() if hasattr(v, 'tolist') else v)
185
+
186
+
187
+ # ------------------------------------------------------------------ 归约引擎
188
+
189
+ def _nan_slice_reduce(a, axis, reducer, empty_value=None, allnan_value=None,
190
+ track_ddof=False):
191
+ """逐 slice NaN 归约。
192
+ reducer(clean_vals) -> value;空 slice → empty_value(默认 NaN),
193
+ 全 NaN slice → allnan_value(默认 NaN)。
194
+ 返回 (flat_results, axes, n_empty, n_allnan, ddof_bad)——
195
+ 告警由调用方按各函数的 数组语义自行发出。
196
+ """
197
+ shape = tuple(a.shape)
198
+ nd = len(shape)
199
+ axes = _reduce_axes(axis, nd)
200
+ flat = _flat_list(a.tolist())
201
+ results = []
202
+ n_allnan = 0
203
+ n_empty = 0
204
+ ddof_bad = False
205
+ for vals, _ in _slices(flat, shape, axes):
206
+ if not vals:
207
+ results.append(empty_value if empty_value is not None else float('nan'))
208
+ n_empty += 1
209
+ continue
210
+ clean = [v for v in vals if not _is_nan_v(v)]
211
+ if not clean:
212
+ results.append(allnan_value if allnan_value is not None else float('nan'))
213
+ n_allnan += 1
214
+ continue
215
+ if track_ddof:
216
+ v, bad = reducer(clean)
217
+ if bad:
218
+ ddof_bad = True
219
+ results.append(v)
220
+ else:
221
+ results.append(reducer(clean))
222
+ return results, axes, n_empty, n_allnan, ddof_bad
223
+
224
+
225
+ def _wrap_result(results, axes, input_shape, keepdims, dtype, scalar=False):
226
+ """flat 结果 → 嵌套列表 → ndarray(keepdims 插入 1 维)。"""
227
+ rs = _rs()
228
+ axset = set(axes)
229
+ out_shape = [d for i, d in enumerate(input_shape) if i not in axset]
230
+ if keepdims:
231
+ shape = []
232
+ k = 0
233
+ for i in range(len(input_shape)):
234
+ if i in axset:
235
+ shape.append(1)
236
+ else:
237
+ shape.append(out_shape[k])
238
+ k += 1
239
+ shape = tuple(shape) if axes else tuple(input_shape)
240
+ else:
241
+ shape = tuple(out_shape)
242
+ nested = _reshape_flat(results, shape)
243
+ if scalar and not shape:
244
+ c = _rs().float64
245
+ try:
246
+ return c(nested)
247
+ except Exception:
248
+ return nested
249
+ return rs.array(nested, dtype=dtype)
250
+
251
+
252
+ def _apply_where(a, where):
253
+ """where=False 位置置 NaN(返回新数组)。"""
254
+ rs = _rs()
255
+ mask = where
256
+ if not (hasattr(mask, '_array') or isinstance(mask, (list, tuple))):
257
+ mask = rs.array(mask)
258
+ dt = getattr(a, '_dtype', 'float64')
259
+ fill = rs.full(tuple(a.shape), float('nan'), dtype=dt)
260
+ return rs.where(mask, a, fill)
261
+
262
+
263
+ # ------------------------------------------------------------------ reducer
264
+
265
+ def _cmin(vs):
266
+ return builtins.min(vs, key=_ckey)
267
+
268
+
269
+ def _cmax(vs):
270
+ return builtins.max(vs, key=_ckey)
271
+
272
+
273
+ def _mk_mean_reducer():
274
+ def red(vs):
275
+ return builtins.sum(vs, 0) / len(vs)
276
+ return red
277
+
278
+
279
+ def _mk_var_reducer(ddof):
280
+ def red(vs):
281
+ n = len(vs)
282
+ denom = n - ddof
283
+ if denom <= 0:
284
+ return float('nan'), True
285
+ m = builtins.sum(vs, 0) / n
286
+ s = builtins.sum(abs(v - m) ** 2 for v in vs)
287
+ r = s / denom
288
+ if isinstance(r, complex):
289
+ r = r.real
290
+ return float(r), False
291
+ return red
292
+
293
+
294
+ def _py_median(vs):
295
+ s = sorted(vs, key=_ckey)
296
+ n = len(s)
297
+ if n % 2 == 1:
298
+ return s[n // 2]
299
+ return (s[n // 2 - 1] + s[n // 2]) / 2
300
+
301
+
302
+ def _sum_reducer(vs):
303
+ return builtins.sum(vs, 0)
304
+
305
+
306
+ def _prod_reducer(vs):
307
+ r = 1
308
+ for v in vs:
309
+ r = r * v
310
+ return r
311
+
312
+
313
+ def _initial_min(a, initial):
314
+ rs = _rs()
315
+ if not hasattr(a, '_array'):
316
+ a = rs.array(a)
317
+ vals = [initial if _ckey(initial) < _ckey(v) else v
318
+ for v in _flat_list(a.tolist())]
319
+ return rs.array(_reshape_flat(vals, tuple(a.shape)),
320
+ dtype=getattr(a, '_dtype', 'float64'))
321
+
322
+
323
+ def _initial_max(a, initial):
324
+ rs = _rs()
325
+ if not hasattr(a, '_array'):
326
+ a = rs.array(a)
327
+ vals = [initial if _ckey(initial) > _ckey(v) else v
328
+ for v in _flat_list(a.tolist())]
329
+ return rs.array(_reshape_flat(vals, tuple(a.shape)),
330
+ dtype=getattr(a, '_dtype', 'float64'))
331
+
332
+
333
+ def _initial_sum(a, initial):
334
+ rs = _rs()
335
+ if not hasattr(a, '_array'):
336
+ a = rs.array(a)
337
+ return a + initial
338
+
339
+
340
+ def _initial_prod(a, initial):
341
+ rs = _rs()
342
+ if not hasattr(a, '_array'):
343
+ a = rs.array(a)
344
+ return a * initial
345
+
346
+
347
+ # ------------------------------------------------------------------ 分位数引擎
348
+
349
+ # 2.x 分位数 method 全集与"插值型"(参与结果 dtype 提升)子集
350
+ QUANTILE_METHODS = [
351
+ 'inverted_cdf', 'averaged_inverted_cdf', 'closest_observation',
352
+ 'interpolated_inverted_cdf', 'hazen', 'weibull', 'linear',
353
+ 'median_unbiased', 'normal_unbiased', 'nearest', 'lower', 'higher',
354
+ 'midpoint']
355
+ _INTERPOLATING_METHODS = [
356
+ 'averaged_inverted_cdf', 'interpolated_inverted_cdf', 'hazen', 'weibull',
357
+ 'linear', 'median_unbiased', 'normal_unbiased', 'midpoint']
358
+
359
+ _INT64_MIN = -9223372036854775808 # m8/M8 的 NaT 哨兵(int64 存储)
360
+
361
+
362
+ def _quantile_of(sorted_vals, q01, method, wsorted=None):
363
+ """已排序(无 NaN)实值列表 + q01∈[0,1] → float。
364
+
365
+ 实现 2.x 全部 13 个 method(虚指数公式按真实 2.5 逐点验证);
366
+ weights 仅支持 inverted_cdf(概念上按权重展开成重复观测再取无权重值)。
367
+ """
368
+ n = len(sorted_vals)
369
+ if n == 0:
370
+ return float('nan')
371
+ m = method or 'linear'
372
+ vs = sorted_vals
373
+ ws = None
374
+ if wsorted is not None:
375
+ vs, ws = wsorted
376
+ if ws is not None:
377
+ total = builtins.sum(ws)
378
+ if not (total > 0) or total != total or total == float('inf'):
379
+ raise ValueError("Weights included NaN, inf or were all zero")
380
+ # 重复观测语义:展开数组中 0-based 位置 = max(ceil(q*W), 1) - 1
381
+ pos = builtins.max(math.ceil(q01 * total), 1) - 1
382
+ c = 0.0
383
+ for v, w in zip(vs, ws):
384
+ c += w
385
+ if c > pos:
386
+ return float(v)
387
+ return float(vs[-1])
388
+ if m == 'inverted_cdf':
389
+ idx = builtins.max(0, builtins.min(math.ceil(q01 * n) - 1, n - 1))
390
+ return float(vs[idx])
391
+ if m == 'averaged_inverted_cdf':
392
+ k = q01 * n
393
+ if k == builtins.int(k) and 0 < k < n:
394
+ # q 恰在 CDF 跳变点:左右极限的均值
395
+ return float((vs[int(k) - 1] + vs[int(k)]) / 2.0)
396
+ idx = builtins.max(0, builtins.min(math.ceil(k) - 1, n - 1))
397
+ return float(vs[idx])
398
+ # 其余 method:统一"虚指数"(0-based 小数位置,clamp 到 [0, n-1])
399
+ if m == 'lower':
400
+ vidx = math.floor(q01 * (n - 1))
401
+ elif m == 'higher':
402
+ vidx = math.ceil(q01 * (n - 1))
403
+ elif m == 'nearest':
404
+ vidx = round(q01 * (n - 1)) # Python round = 银行家舍入(tie→even)
405
+ elif m == 'closest_observation':
406
+ # 2.x(#26656):tie 向"偶数阶统计量"——1-based 位置做
407
+ # half-even 舍入,等价于 round(q*n) - 1
408
+ vidx = round(q01 * n) - 1
409
+ elif m == 'midpoint':
410
+ vidx = 0.5 * (math.floor(q01 * (n - 1)) + math.ceil(q01 * (n - 1)))
411
+ elif m == 'linear':
412
+ vidx = q01 * (n - 1)
413
+ elif m == 'hazen':
414
+ vidx = q01 * n - 0.5
415
+ elif m == 'weibull':
416
+ vidx = q01 * (n + 1.0) - 1.0
417
+ elif m == 'median_unbiased':
418
+ vidx = q01 * (n + 1.0 / 3.0) - 2.0 / 3.0
419
+ elif m == 'normal_unbiased':
420
+ vidx = q01 * (n + 0.25) - 0.625
421
+ elif m == 'interpolated_inverted_cdf':
422
+ vidx = q01 * n - 1.0
423
+ else:
424
+ raise ValueError(f"method {m!r} is not a valid method")
425
+ vidx = builtins.min(builtins.max(vidx, 0), n - 1)
426
+ if m in ('lower', 'higher', 'nearest', 'closest_observation'):
427
+ return float(vs[int(vidx)])
428
+ lo = int(math.floor(vidx))
429
+ hi = builtins.min(lo + 1, n - 1)
430
+ frac = vidx - lo
431
+ return float(vs[lo] + (vs[hi] - vs[lo]) * frac)
432
+
433
+
434
+ def _percentile_engine(a, q, axis, keepdims, dtype, out=None, weights=None,
435
+ method='linear', nan_filter=True, scale=100.0,
436
+ sentinel=None, relabel=None):
437
+ """通用分位数引擎(Python 层,2.x 语义)。
438
+ q: 标量或列表/数组(percentile 用 0-100、quantile 用 0-1,由 scale 归一);
439
+ method: 见 QUANTILE_METHODS(加权仅 inverted_cdf,公共层校验);
440
+ weights: 与 a 同形状,或 1-D(长度 = 归约轴长 → 广播;
441
+ 多轴时 = 每 slice 展平长 → 逐 slice 使用);
442
+ sentinel: m8/M8 哨兵(NaT=int64 最小值)——slice 含哨兵/为空 → 哨兵结果,
443
+ 数值结果 round 为 int;relabel: 结果数组 _dtype 标签(如 'm8[D]');
444
+ 全归约 + 标量 q → rsarray 标量(带 .dtype、isscalar 为 True);
445
+ out 被填充并返回;输入为 ndarray 子类时结果保持子类。
446
+ """
447
+ rs = _rs()
448
+ shape = tuple(a.shape)
449
+ nd = len(shape)
450
+ axes = _reduce_axes(axis, nd)
451
+ flat = _flat_list(a.tolist())
452
+ # ---- weights:全形状或 1-D
453
+ wflat = None
454
+ w1d = None
455
+ red_size = _prod([shape[i] for i in axes]) if axes else 1
456
+ if weights is not None:
457
+ wsrc = weights if hasattr(weights, 'tolist') else rs.array(weights)
458
+ wlist = _flat_list(wsrc.tolist())
459
+ if len(wlist) == len(flat):
460
+ wflat = wlist
461
+ elif len(axes) == 1 and len(wlist) == shape[axes[0]]:
462
+ w1d = wlist
463
+ elif len(axes) > 1 and len(wlist) == red_size:
464
+ w1d = wlist
465
+ else:
466
+ raise ValueError(
467
+ "weights must be a 1-D array with the same length as the "
468
+ "reduction axis, or an array with the same shape as a")
469
+ if hasattr(q, 'ndim'):
470
+ qarr = q.ndim > 0
471
+ q_shape = tuple(q.shape) if qarr else ()
472
+ qvals = _flat_list(q.tolist()) if qarr else [q.tolist()]
473
+ elif isinstance(q, (list, tuple)):
474
+ qarr = True
475
+ q_shape = _list_shape(q) or (len(_flat_list(q)),)
476
+ qvals = _flat_list(q)
477
+ else:
478
+ qarr = False
479
+ q_shape = ()
480
+ qvals = [q]
481
+ qs = []
482
+ for v in qvals:
483
+ try:
484
+ fv = float(v) / scale
485
+ except TypeError:
486
+ raise TypeError(f"q must be a real scalar or array, not {type(v).__name__}")
487
+ if not (0.0 <= fv <= 1.0):
488
+ raise ValueError("percentiles must be in the range [0, 100] or "
489
+ "quantiles in the range [0, 1]")
490
+ qs.append(fv)
491
+ slice_list = list(_slices(flat, shape, axes, wflat))
492
+ results = []
493
+ n_allnan = 0
494
+ n_empty = 0
495
+ bad = float('nan') if sentinel is None else sentinel
496
+ multi = len(axes) > 1
497
+ for q01 in qs:
498
+ for oi, (vals, wlist) in enumerate(slice_list):
499
+ if not vals:
500
+ results.append(bad)
501
+ n_empty += 1
502
+ continue
503
+ if w1d is not None:
504
+ wl = list(w1d) if not multi else w1d[:len(vals)]
505
+ else:
506
+ wl = wlist
507
+ vw = list(builtins.zip(vals, wl)) if wl is not None \
508
+ else [(v, None) for v in vals]
509
+ if nan_filter:
510
+ vw = [p for p in vw if not _is_nan_v(p[0])]
511
+ if not vw:
512
+ results.append(bad)
513
+ n_allnan += 1
514
+ continue
515
+ else:
516
+ if any(_is_nan_v(p[0]) for p in vw) or (
517
+ sentinel is not None
518
+ and any(p[0] == sentinel for p in vw)):
519
+ results.append(bad)
520
+ continue
521
+ if wl is not None:
522
+ sv = sorted(vw, key=lambda p: _ckey(p[0]))
523
+ vs = [p[0] for p in sv]
524
+ ws = [p[1] for p in sv]
525
+ r = _quantile_of(vs, q01, method, (vs, ws))
526
+ else:
527
+ r = _quantile_of(sorted((p[0] for p in vw), key=_ckey),
528
+ q01, method)
529
+ results.append(builtins.int(round(r)) if sentinel is not None else r)
530
+ if n_allnan:
531
+ warnings.warn("All-NaN slice encountered", RuntimeWarning, stacklevel=5)
532
+ if n_empty:
533
+ warnings.warn("Percentile of empty slice", RuntimeWarning, stacklevel=5)
534
+ # 结果 shape: (nq, *red_shape);qarr=False 时去掉 q 维
535
+ axset = set(axes)
536
+ out_shape = [d for i, d in enumerate(shape) if i not in axset]
537
+ if keepdims:
538
+ red_shape = []
539
+ k = 0
540
+ for i in range(nd):
541
+ if i in axset:
542
+ red_shape.append(1)
543
+ else:
544
+ red_shape.append(out_shape[k])
545
+ k += 1
546
+ red_shape = tuple(red_shape)
547
+ else:
548
+ red_shape = tuple(out_shape)
549
+ out_q_shape = q_shape + red_shape
550
+ if sentinel is not None:
551
+ # m8/M8:int64 存储 + 标签;0-d 结果保持 0-d ndarray(.dtype 可查)
552
+ if not results and 0 in out_q_shape:
553
+ res = rs.zeros(out_q_shape, dtype='int64')
554
+ elif qarr:
555
+ res = rs.array(_reshape_flat(results, out_q_shape), dtype='int64')
556
+ elif not red_shape and len(results) == 1:
557
+ res = rs.array([results[0]], dtype='int64').reshape(())
558
+ else:
559
+ res = rs.array(_reshape_flat(results, red_shape), dtype='int64')
560
+ if relabel:
561
+ res._dtype = relabel
562
+ return res
563
+ if not results and 0 in out_q_shape:
564
+ res = rs.zeros(out_q_shape, dtype=dtype)
565
+ elif qarr:
566
+ res = rs.array(_reshape_flat(results, out_q_shape), dtype=dtype)
567
+ elif not red_shape and len(results) == 1:
568
+ # 全归约 + 标量 q → 标量(数组语义:带 .dtype 的 np.generic)
569
+ res = _scalar_of(dtype, results[0])
570
+ else:
571
+ res = rs.array(_reshape_flat(results, red_shape), dtype=dtype)
572
+ res = _keep_subclass(res, a)
573
+ if out is not None:
574
+ try:
575
+ rs.copyto(out, res)
576
+ except Exception:
577
+ out[...] = res
578
+ return out
579
+ return res
580
+
581
+
582
+ # ------------------------------------------------------------------ 结果 dtype 规则
583
+
584
+ def _mean_result_dtype(dt):
585
+ k = _dt_kind(dt)
586
+ return dt if k in 'ef' else 'float64'
587
+
588
+
589
+ def _varstd_result_dtype(dt):
590
+ k = _dt_kind(dt)
591
+ return dt if k in 'ef' else 'float64'
592
+
593
+
594
+ def _percentile_result_dtype(dt):
595
+ k = _dt_kind(dt)
596
+ return dt if k in 'ef' else 'float64'
597
+
598
+
599
+ # ------------------------------------------------------------------ 内部助手
600
+
601
+ def _nan_mask(a, out=None):
602
+ """float/complex → ~isnan 布尔掩码(可用值=True);其他类型 → Python True。
603
+ 给出 out 时写入并返回 out。"""
604
+ rs = _rs()
605
+ a = rs.asanyarray(a)
606
+ if _dt_kind(getattr(a, '_dtype', None)) not in 'fc':
607
+ # 数组语义:不可能含 NaN 的类型恒返回 Python True(即使给出 out)
608
+ if out is not None:
609
+ rs.copyto(out, True)
610
+ return True
611
+ y = ~rs.isnan(a)
612
+ if out is not None:
613
+ rs.copyto(out, y)
614
+ return out
615
+ return y
616
+
617
+
618
+ def _replace_nan(a, val):
619
+ """inexact → (NaN 替换后的拷贝, isnan 掩码);object → (拷贝, a!=a 掩码);
620
+ 其他 → (原对象, None)。"""
621
+ rs = _rs()
622
+ a = rs.asanyarray(a)
623
+ k = _dt_kind(getattr(a, '_dtype', None))
624
+ if k == 'O':
625
+ mask = rs.not_equal(a, a)
626
+ elif k in 'fc':
627
+ mask = rs.isnan(a)
628
+ else:
629
+ return a, None
630
+ if len(tuple(a.shape)) == 0:
631
+ # 0-d:布尔掩码 setitem 会抛 IndexError,按值判定后直接重建
632
+ v = _flat_list(a.tolist())[0]
633
+ try:
634
+ _c = complex(v)
635
+ _m = _c != _c
636
+ except Exception:
637
+ _m = (v is not None) and (v != v)
638
+ if _m:
639
+ b = rs.array([val], dtype=getattr(a, '_dtype', 'float64')).reshape(())
640
+ else:
641
+ b = rs.array(a, copy=True)
642
+ return b, mask
643
+ b = rs.array(a, copy=True)
644
+ b[mask] = val
645
+ return b, mask
646
+
647
+
648
+ def _divide_by_count(a, count, out=None):
649
+ """逐元素 a/count;读入安全——绝不原地改 a(out 缺省时新建)。"""
650
+ rs = _rs()
651
+ a = rs.asanyarray(a)
652
+ count = rs.asanyarray(count)
653
+ if out is None:
654
+ # out 形状须与 a 一致(0-d → 0-d),否则 rs.divide 形状广播错误
655
+ out = rs.empty(tuple(a.shape), dtype=getattr(a, '_dtype', 'float64'))
656
+ rs.divide(a, count, out=out)
657
+ return out
658
+
659
+
660
+ # ------------------------------------------------------------------ nanX 公共 API(2.x 签名)
661
+
662
+ def _as_nd(a):
663
+ rs = _rs()
664
+ return a if hasattr(a, '_array') else rs.array(a)
665
+
666
+
667
+ def _obj_delegate(a, name, **kw):
668
+ """object dtype 且 ndim<=1 → 委托标准函数。
669
+
670
+ 标准函数对 object 走 Rust 占位存储(结果恒 0.0/索引 0),NumberTypes
671
+ 的 O 用例以标准函数为 oracle,故此处保持一致;ndim>=2 仍用引擎读
672
+ _raw_data 真值(test_object_array 语义)。"""
673
+ from rsarray import statistics as _st
674
+ fn = getattr(_st, name, None)
675
+ if fn is None:
676
+ fn = getattr(_rs(), name)
677
+ return fn(a, **kw)
678
+
679
+
680
+ _CHAR_DTYPE = {'?': 'bool', 'b': 'bool', 'i': 'int32', 'l': 'int64', 'q': 'int64',
681
+ 'u': 'uint32', 'L': 'uint64', 'Q': 'uint64',
682
+ 'e': 'float16', 'f': 'float32', 'd': 'float64',
683
+ 'F': 'complex64', 'D': 'complex128', 'G': 'complex128'}
684
+
685
+
686
+ def _dtype_name(dtype):
687
+ """dtype 字符串/对象 → 规范名('float16'/'int64'/'object'…)。"""
688
+ # DType 对象:str() 是 "dtype('...')" 形式,直接取内部规范名
689
+ if not isinstance(dtype, str) and hasattr(dtype, '_typename'):
690
+ _tn = getattr(dtype, '_typename', None)
691
+ if isinstance(_tn, str) and _tn:
692
+ return _tn
693
+ s = str(dtype).lstrip('<>=|')
694
+ if len(s) == 1:
695
+ return _CHAR_DTYPE.get(s, 'float64')
696
+ return s
697
+
698
+
699
+ def _scalar_of(dtype, value):
700
+ """全归约单值 → rsarray 标量(带 .dtype/.ndim=0,isscalar 为 True)。"""
701
+ name = _dtype_name(dtype)
702
+ if name in ('object', 'string_'):
703
+ return value
704
+ try:
705
+ from rsarray import _SCALAR_CLASS_BY_DTYPE
706
+ cls = _SCALAR_CLASS_BY_DTYPE.get(name)
707
+ if cls is not None:
708
+ return cls(value)
709
+ except Exception:
710
+ pass
711
+ if name in ('int32', 'int64', 'uint32', 'uint64'):
712
+ return int(value)
713
+ if name == 'bool':
714
+ return bool(value)
715
+ return value
716
+
717
+
718
+ def _keep_subclass(result, src):
719
+ """输入为 ndarray 子类时结果保持同子类(归约保留子类语义)。"""
720
+ rs = _rs()
721
+ t = type(src)
722
+ if t is rs.ndarray:
723
+ return result
724
+ if not (isinstance(t, builtins.type) and issubclass(t, rs.ndarray)):
725
+ return result
726
+ if not hasattr(result, '_array'):
727
+ return result
728
+ try:
729
+ return t._wrap(result._array, _dtype=getattr(result, '_dtype', 'float64'))
730
+ except Exception:
731
+ return result
732
+
733
+
734
+ def _reduction_dtype(kind, dt):
735
+ """nan 归约结果 dtype(数组语义)。
736
+
737
+ minmax/sumprod:保留输入 dtype;mean/median:float/complex 保留精度,
738
+ 其余 float64;varstd:float 保留精度,其余 float64。
739
+ """
740
+ k = _dt_kind(dt)
741
+ if kind in ('minmax', 'sumprod'):
742
+ return dt
743
+ if kind == 'varstd':
744
+ # oracle 语义:var/std 结果恒 float64(complex 输入取实部)
745
+ return 'float64'
746
+ return dt if k in 'efc' else 'float64'
747
+
748
+
749
+ def _reduce_wrap(results, axes, shape, keepdims, dtype, out, src):
750
+ """flat 结果 → ndarray(keepdims 插 1 维)/ 全归约标量;
751
+ out 被填充并原样返回;输入子类被保留。"""
752
+ rs = _rs()
753
+ nd = len(shape)
754
+ axset = set(axes)
755
+ out_shape = [d for i, d in enumerate(shape) if i not in axset]
756
+ if keepdims:
757
+ shape_out = []
758
+ k = 0
759
+ for i in range(nd):
760
+ if i in axset:
761
+ shape_out.append(1)
762
+ else:
763
+ shape_out.append(out_shape[k])
764
+ k += 1
765
+ shape_out = tuple(shape_out)
766
+ else:
767
+ shape_out = tuple(out_shape)
768
+ if not shape_out and len(results) == 1:
769
+ res = _scalar_of(dtype, results[0])
770
+ # 数组语义:子类输入的全归约返回 0-d 子类 ndarray(非裸标量)
771
+ t = builtins.type(src)
772
+ if (isinstance(t, builtins.type) and issubclass(t, rs.ndarray)
773
+ and t is not rs.ndarray and out is None):
774
+ try:
775
+ res = rs.array([results[0]], dtype=dtype).reshape(()).view(t)
776
+ except Exception:
777
+ pass
778
+ else:
779
+ # 空结果 + 含 0 维:嵌套列表无法表达 0 维形状,直接 zeros 构造
780
+ if not results and 0 in shape_out:
781
+ res = rs.zeros(shape_out, dtype=dtype)
782
+ else:
783
+ res = rs.array(_reshape_flat(list(results), shape_out), dtype=dtype)
784
+ res = _keep_subclass(res, src)
785
+ if out is not None:
786
+ try:
787
+ rs.copyto(out, res)
788
+ except Exception:
789
+ out[...] = res
790
+ return out
791
+ return res
792
+
793
+
794
+ def _simple_fast(a, axis, out):
795
+ """Rust 快路径条件:ndarray(非子类)、axis None/int、ndim>=1、无 NaN、无 out。"""
796
+ rs = _rs()
797
+ if out is not None or type(a) is not rs.ndarray:
798
+ return False
799
+ if len(tuple(a.shape)) < 1:
800
+ return False
801
+ # 空数组走引擎:Rust 归约对空 slice 会 panic(median 减溢)或形状错误
802
+ try:
803
+ if int(getattr(a, 'size', 0) or 0) <= 0:
804
+ return False
805
+ except Exception:
806
+ return False
807
+ if not (axis is None or isinstance(axis, int)):
808
+ return False
809
+ if _has_nan_arr(a):
810
+ return False
811
+ return True
812
+
813
+
814
+ def _rs_reduce(fn, a, axis, keepdims, dtype):
815
+ """Rust 快路径:调 _core 归约并按指定 dtype 包装。"""
816
+ raw = fn(a._array, axis, keepdims)
817
+ return _rs().ndarray._wrap(raw, _dtype=dtype)
818
+
819
+
820
+ def _mk_std_reducer(ddof):
821
+ red = _mk_var_reducer(ddof)
822
+
823
+ def red2(vs):
824
+ v, bad = red(vs)
825
+ if bad or v != v:
826
+ return float('nan'), True if bad else False
827
+ return (math.sqrt(v) if v >= 0 else float('nan')), False
828
+ return red2
829
+
830
+
831
+ def nansum(a, axis=None, dtype=None, out=None, keepdims=False, initial=None,
832
+ where=True):
833
+ """忽略 NaN 求和(Rust 快路径 / Python 逐 slice 归约)。"""
834
+ rs = _rs()
835
+ a = _as_nd(a)
836
+ dt = getattr(a, '_dtype', 'float64')
837
+ if dtype is not None and _dt_kind(dtype) not in 'efdcgciubOFGD':
838
+ raise TypeError(f"data type {dtype!r} is not supported by nansum")
839
+ res_dt = dtype if dtype is not None else dt
840
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
841
+ return _obj_delegate(a, 'sum', axis=axis, dtype=dtype, out=out,
842
+ keepdims=keepdims, initial=initial, where=where)
843
+ if where is True and initial is None and _simple_fast(a, axis, out):
844
+ import rsarray.num_core as _core
845
+ return _rs_reduce(_core.nansum, a, axis, keepdims, res_dt)
846
+ if where is not True:
847
+ a = _apply_where(a, where)
848
+ ident = initial if initial is not None else 0.0
849
+ if initial is not None:
850
+ red = lambda vs: builtins.sum(vs, initial)
851
+ else:
852
+ red = lambda vs: builtins.sum(vs, 0)
853
+ results, axes, _, _, _ = _nan_slice_reduce(a, axis, red,
854
+ empty_value=ident,
855
+ allnan_value=ident)
856
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, res_dt, out, a)
857
+
858
+
859
+ def nanprod(a, axis=None, dtype=None, out=None, keepdims=False, initial=None,
860
+ where=True):
861
+ """忽略 NaN 求积(Rust 快路径 / Python 逐 slice 归约)。"""
862
+ rs = _rs()
863
+ a = _as_nd(a)
864
+ dt = getattr(a, '_dtype', 'float64')
865
+ if dtype is not None and _dt_kind(dtype) not in 'efdcgciubOFGD':
866
+ raise TypeError(f"data type {dtype!r} is not supported by nanprod")
867
+ res_dt = dtype if dtype is not None else dt
868
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
869
+ return _obj_delegate(a, 'prod', axis=axis, dtype=dtype, out=out,
870
+ keepdims=keepdims, initial=initial, where=where)
871
+ if where is True and initial is None and _simple_fast(a, axis, out):
872
+ import rsarray.num_core as _core
873
+ return _rs_reduce(_core.nanprod, a, axis, keepdims, res_dt)
874
+ if where is not True:
875
+ a = _apply_where(a, where)
876
+ ident = initial if initial is not None else 1.0
877
+ if initial is not None:
878
+ def red(vs):
879
+ r = initial
880
+ for v in vs:
881
+ r = r * v
882
+ return r
883
+ else:
884
+ red = _prod_reducer
885
+ results, axes, _, _, _ = _nan_slice_reduce(a, axis, red,
886
+ empty_value=ident,
887
+ allnan_value=ident)
888
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, res_dt, out, a)
889
+
890
+
891
+ def _check_reduce_out(a, axis, out, op):
892
+ """ufunc.reduce 语义:out 形状须与归约结果兼容,否则 ValueError
893
+ (错误信息与 "reduction operation <op> ..." 一致,memmap 快路径测试依赖)。"""
894
+ if out is None:
895
+ return
896
+ oshape = tuple(getattr(out, 'shape', ()))
897
+ ashape = tuple(getattr(a, 'shape', ()))
898
+ if axis is None:
899
+ ok = (oshape == () or oshape == ashape)
900
+ elif isinstance(axis, int):
901
+ _axn = (axis % len(ashape),) if ashape else ()
902
+ exp = tuple(d for i, d in enumerate(ashape) if i not in _axn)
903
+ ok = (oshape == exp or oshape == ashape or oshape == ())
904
+ else:
905
+ ok = (oshape == ashape or oshape == ())
906
+ if not ok:
907
+ raise ValueError(
908
+ f"reduction operation {op} has output operand with shape "
909
+ f"{oshape} where input shape {ashape} was expected")
910
+
911
+
912
+ def nanmax(a, axis=None, out=None, keepdims=False, initial=None, where=True):
913
+ """忽略 NaN 求最大值(全 NaN slice → NaN + 单次警告)。"""
914
+ rs = _rs()
915
+ a = _as_nd(a)
916
+ dt = getattr(a, '_dtype', 'float64')
917
+ _check_reduce_out(a, axis, out, 'fmax')
918
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
919
+ return _obj_delegate(a, 'max', axis=axis, out=out,
920
+ keepdims=keepdims, initial=initial, where=where)
921
+ if where is True and initial is None and _simple_fast(a, axis, out):
922
+ import rsarray.num_core as _core
923
+ return _rs_reduce(_core.nanmax, a, axis, keepdims, dt)
924
+ if where is not True:
925
+ a = _apply_where(a, where)
926
+ if initial is not None:
927
+ def red(vs):
928
+ vals = list(vs) + [initial]
929
+ return builtins.max(vals, key=_ckey)
930
+ allnan_v = initial
931
+ else:
932
+ red = _cmax
933
+ allnan_v = float('nan')
934
+ results, axes, _, n_allnan, _ = _nan_slice_reduce(
935
+ a, axis, red, empty_value=float('inf'), allnan_value=allnan_v)
936
+ if n_allnan and initial is None:
937
+ warnings.warn("All-NaN slice encountered", RuntimeWarning, stacklevel=4)
938
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, dt, out, a)
939
+
940
+
941
+ def nanmin(a, axis=None, out=None, keepdims=False, initial=None, where=True):
942
+ """忽略 NaN 求最小值(全 NaN slice → NaN + 单次警告)。"""
943
+ rs = _rs()
944
+ a = _as_nd(a)
945
+ dt = getattr(a, '_dtype', 'float64')
946
+ _check_reduce_out(a, axis, out, 'fmin')
947
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
948
+ return _obj_delegate(a, 'min', axis=axis, out=out,
949
+ keepdims=keepdims, initial=initial, where=where)
950
+ if where is True and initial is None and _simple_fast(a, axis, out):
951
+ import rsarray.num_core as _core
952
+ return _rs_reduce(_core.nanmin, a, axis, keepdims, dt)
953
+ if where is not True:
954
+ a = _apply_where(a, where)
955
+ if initial is not None:
956
+ def red(vs):
957
+ vals = list(vs) + [initial]
958
+ return builtins.min(vals, key=_ckey)
959
+ allnan_v = initial
960
+ else:
961
+ red = _cmin
962
+ allnan_v = float('nan')
963
+ results, axes, _, n_allnan, _ = _nan_slice_reduce(
964
+ a, axis, red, empty_value=float('-inf'), allnan_value=allnan_v)
965
+ if n_allnan and initial is None:
966
+ warnings.warn("All-NaN slice encountered", RuntimeWarning, stacklevel=4)
967
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, dt, out, a)
968
+
969
+
970
+ def nanmean(a, axis=None, dtype=None, out=None, keepdims=False, where=True):
971
+ """忽略 NaN 求均值(空/全 NaN → NaN + "Mean of empty slice")。"""
972
+ rs = _rs()
973
+ a = _as_nd(a)
974
+ dt = getattr(a, '_dtype', 'float64')
975
+ if dtype is not None and _dt_kind(dtype) not in 'efgdcFDG':
976
+ raise TypeError(f"data type {dtype!r} not inexact")
977
+ if dtype is not None and _dt_kind(dtype) in 'cFDG':
978
+ # 复数 dtype:委托标准 mean(dtype 语义与 oracle 完全一致)
979
+ from rsarray import statistics as _st
980
+ return _st.mean(a, axis=axis, dtype=dtype, out=out, keepdims=keepdims,
981
+ where=where)
982
+ res_dt = dtype if dtype is not None else _reduction_dtype('mean', dt)
983
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
984
+ return _obj_delegate(a, 'mean', axis=axis, dtype=dtype, out=out,
985
+ keepdims=keepdims, where=where)
986
+ if where is True and _simple_fast(a, axis, out):
987
+ import rsarray.num_core as _core
988
+ return _rs_reduce(_core.nanmean, a, axis, keepdims, res_dt)
989
+ if where is not True:
990
+ a = _apply_where(a, where)
991
+ results, axes, n_empty, n_allnan, _ = _nan_slice_reduce(a, axis,
992
+ _mk_mean_reducer())
993
+ if n_empty or n_allnan:
994
+ warnings.warn("Mean of empty slice", RuntimeWarning, stacklevel=4)
995
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, res_dt, out, a)
996
+
997
+
998
+ def _nan_var_std_given_mean(a, mean, axis, keepdims, ddof, want_std, out):
999
+ """nanvar/nanstd(mean=...) 路径:信任给定均值,仅干净值参与计算
1000
+ (masked 语义:count 排除 NaN,NaN 位置零贡献)。"""
1001
+ import builtins as _bi
1002
+ rs = _rs()
1003
+ a = _as_nd(a)
1004
+ dt = getattr(a, '_dtype', 'float64')
1005
+ res_dt = _reduction_dtype('varstd', dt)
1006
+ # 必须在原始数组上判 NaN(替换后的 0.0 会被误判为干净值)
1007
+ shape = tuple(a.shape)
1008
+ nd = len(shape)
1009
+
1010
+ def _clean(v):
1011
+ try:
1012
+ c = complex(v)
1013
+ except Exception:
1014
+ return None
1015
+ return None if c != c else c
1016
+
1017
+ def _mval(m):
1018
+ try:
1019
+ return complex(m)
1020
+ except Exception:
1021
+ return m
1022
+
1023
+ def _unravel(idx, dims):
1024
+ mi = []
1025
+ for dm in reversed(dims):
1026
+ mi.append(idx % dm)
1027
+ idx //= dm
1028
+ return list(reversed(mi))
1029
+
1030
+ def _cidx(mi, shp):
1031
+ c = 0
1032
+ for m, s in zip(mi, shp):
1033
+ c = c * s + m
1034
+ return c
1035
+
1036
+ if hasattr(mean, 'tolist'):
1037
+ mshape = tuple(mean.shape)
1038
+ mflat = _flat_list(mean.tolist())
1039
+ else:
1040
+ mshape = ()
1041
+ mflat = [mean]
1042
+
1043
+ if axis is None:
1044
+ vals = [c for c in map(_clean, _flat_list(a.tolist())) if c is not None]
1045
+ m = _mval(mflat[0])
1046
+ n = len(vals) - ddof
1047
+ if n <= 0 or not vals:
1048
+ s = float('nan')
1049
+ else:
1050
+ s = _bi.sum(abs(v - m) ** 2 for v in vals) / n
1051
+ v = s ** 0.5 if want_std else s
1052
+ return _reduce_wrap([v], tuple(range(nd)), shape, keepdims, res_dt,
1053
+ out, a)
1054
+ ai = axis if axis >= 0 else axis + nd
1055
+ dims = list(shape)
1056
+ d = dims[ai]
1057
+ inner = 1
1058
+ for j in range(ai + 1, nd):
1059
+ inner *= dims[j]
1060
+ flat = _flat_list(a.tolist())
1061
+ out_shape = dims[:ai] + dims[ai + 1:]
1062
+ out_size = 1
1063
+ for s in out_shape:
1064
+ out_size *= s
1065
+ results = []
1066
+ for oi in range(out_size):
1067
+ # 输出网格逐元素:slice = a[omi, k, imi](k 沿轴方向,非轴内维)
1068
+ omi = _unravel(oi // inner, dims[:ai]) if dims[:ai] else []
1069
+ imi = _unravel(oi % inner, dims[ai + 1:]) if dims[ai + 1:] else []
1070
+ if len(mshape) == nd:
1071
+ midx = _cidx(omi + [0] + imi, mshape)
1072
+ elif mshape:
1073
+ midx = _cidx(omi + imi, mshape)
1074
+ else:
1075
+ midx = 0
1076
+ m = _mval(mflat[midx])
1077
+ vals = []
1078
+ for kk in range(d):
1079
+ c = _clean(flat[_cidx(omi + [kk] + imi, shape)])
1080
+ if c is not None:
1081
+ vals.append(c)
1082
+ n = len(vals) - ddof
1083
+ if n <= 0 or not vals:
1084
+ s = float('nan')
1085
+ else:
1086
+ s = _bi.sum(abs(v - m) ** 2 for v in vals) / n
1087
+ results.append(s ** 0.5 if want_std else s)
1088
+ return _reduce_wrap(results, (ai,), shape, keepdims, res_dt, out, a)
1089
+
1090
+
1091
+ def nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False,
1092
+ where=True, correction=None, mean=None):
1093
+ """忽略 NaN 求方差(ddof/correction 互斥;mean= 走信任均值路径)。"""
1094
+ rs = _rs()
1095
+ a = _as_nd(a)
1096
+ dt = getattr(a, '_dtype', 'float64')
1097
+ if dtype is not None and _dt_kind(dtype) not in 'efgdcFDG':
1098
+ raise TypeError(f"data type {dtype!r} not inexact")
1099
+ if correction is not None:
1100
+ if ddof != 0:
1101
+ raise ValueError(
1102
+ "ddof and correction can't be provided simultaneously.")
1103
+ ddof = correction
1104
+ if mean is not None:
1105
+ return _nan_var_std_given_mean(a, mean, axis, keepdims, ddof,
1106
+ False, out)
1107
+ if dtype is not None and _dt_kind(dtype) in 'cFDG':
1108
+ # 复数 dtype:委托标准 var(dtype 语义与 oracle 完全一致)
1109
+ from rsarray import statistics as _st
1110
+ return _st.var(a, axis=axis, dtype=dtype, out=out, ddof=ddof,
1111
+ keepdims=keepdims, where=where)
1112
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
1113
+ return _obj_delegate(a, 'var', axis=axis, dtype=dtype, out=out,
1114
+ ddof=ddof, keepdims=keepdims, where=where)
1115
+ res_dt = dtype if dtype is not None else _reduction_dtype('varstd', dt)
1116
+ if where is True and _simple_fast(a, axis, out):
1117
+ import rsarray.num_core as _core
1118
+ raw = _core.nanvar(a._array, axis, float(ddof), keepdims)
1119
+ return _keep_subclass(_rs().ndarray._wrap(raw, _dtype=res_dt), a)
1120
+ if where is not True:
1121
+ a = _apply_where(a, where)
1122
+ results, axes, n_empty, n_allnan, ddof_bad = _nan_slice_reduce(
1123
+ a, axis, _mk_var_reducer(ddof), track_ddof=True)
1124
+ if n_empty or n_allnan:
1125
+ warnings.warn("Mean of empty slice", RuntimeWarning, stacklevel=4)
1126
+ if ddof_bad:
1127
+ warnings.warn("Degrees of freedom <= 0 for slice.", RuntimeWarning,
1128
+ stacklevel=4)
1129
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, res_dt, out, a)
1130
+
1131
+
1132
+ def nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False,
1133
+ where=True, correction=None, mean=None):
1134
+ """忽略 NaN 求标准差(ddof/correction 互斥;mean= 走信任均值路径)。"""
1135
+ rs = _rs()
1136
+ a = _as_nd(a)
1137
+ dt = getattr(a, '_dtype', 'float64')
1138
+ if dtype is not None and _dt_kind(dtype) not in 'efgdcFDG':
1139
+ raise TypeError(f"data type {dtype!r} not inexact")
1140
+ if correction is not None:
1141
+ if ddof != 0:
1142
+ raise ValueError(
1143
+ "ddof and correction can't be provided simultaneously.")
1144
+ ddof = correction
1145
+ if mean is not None:
1146
+ return _nan_var_std_given_mean(a, mean, axis, keepdims, ddof,
1147
+ True, out)
1148
+ if dtype is not None and _dt_kind(dtype) in 'cFDG':
1149
+ # 复数 dtype:委托标准 std(dtype 语义与 oracle 完全一致)
1150
+ from rsarray import statistics as _st
1151
+ return _st.std(a, axis=axis, dtype=dtype, out=out, ddof=ddof,
1152
+ keepdims=keepdims, where=where)
1153
+ if _dt_kind(dt) == 'o' and len(tuple(a.shape)) <= 1:
1154
+ return _obj_delegate(a, 'std', axis=axis, dtype=dtype, out=out,
1155
+ ddof=ddof, keepdims=keepdims, where=where)
1156
+ res_dt = dtype if dtype is not None else _reduction_dtype('varstd', dt)
1157
+ if where is True and _simple_fast(a, axis, out):
1158
+ import rsarray.num_core as _core
1159
+ raw = _core.nanstd(a._array, axis, float(ddof), keepdims)
1160
+ return _keep_subclass(_rs().ndarray._wrap(raw, _dtype=res_dt), a)
1161
+ if where is not True:
1162
+ a = _apply_where(a, where)
1163
+ results, axes, n_empty, n_allnan, ddof_bad = _nan_slice_reduce(
1164
+ a, axis, _mk_std_reducer(ddof), track_ddof=True)
1165
+ if n_empty or n_allnan:
1166
+ warnings.warn("Mean of empty slice", RuntimeWarning, stacklevel=4)
1167
+ if ddof_bad:
1168
+ warnings.warn("Degrees of freedom <= 0 for slice.", RuntimeWarning,
1169
+ stacklevel=4)
1170
+ return _reduce_wrap(results, axes, tuple(a.shape), keepdims, res_dt, out, a)
1171
+
1172
+
1173
+ def nanargmax(a, axis=None, out=None, keepdims=False):
1174
+ """忽略 NaN 的最大值索引(全 NaN slice / 空序列 → ValueError)。"""
1175
+ rs = _rs()
1176
+ a = _as_nd(a)
1177
+ shape = tuple(a.shape)
1178
+ if _dt_kind(getattr(a, '_dtype', 'float64')) == 'o' and len(shape) <= 1:
1179
+ return _obj_delegate(a, 'argmax', axis=axis, out=out, keepdims=keepdims)
1180
+ nd = len(shape)
1181
+ axes = _reduce_axes(axis, nd)
1182
+ flat = _flat_list(a.tolist())
1183
+ results = []
1184
+ n_empty = 0
1185
+ n_allnan = 0
1186
+ for vals, _ in _slices(flat, shape, axes):
1187
+ if not vals:
1188
+ n_empty += 1
1189
+ results.append(0)
1190
+ continue
1191
+ best_i = None
1192
+ best_v = None
1193
+ for i, v in enumerate(vals):
1194
+ if _is_nan_v(v):
1195
+ continue
1196
+ if best_v is None or _ckey(v) > _ckey(best_v):
1197
+ best_i, best_v = i, v
1198
+ if best_v is None:
1199
+ n_allnan += 1
1200
+ results.append(0)
1201
+ else:
1202
+ results.append(best_i)
1203
+ if n_allnan:
1204
+ raise ValueError("All-NaN slice encountered")
1205
+ if n_empty:
1206
+ raise ValueError("attempt to get argmax of an empty sequence")
1207
+ res = _reduce_wrap(results, axes, shape, keepdims, 'int64', out, a)
1208
+ return res
1209
+
1210
+
1211
+ def nanargmin(a, axis=None, out=None, keepdims=False):
1212
+ """忽略 NaN 的最小值索引(全 NaN slice / 空序列 → ValueError)。"""
1213
+ rs = _rs()
1214
+ a = _as_nd(a)
1215
+ shape = tuple(a.shape)
1216
+ if _dt_kind(getattr(a, '_dtype', 'float64')) == 'o' and len(shape) <= 1:
1217
+ return _obj_delegate(a, 'argmin', axis=axis, out=out, keepdims=keepdims)
1218
+ nd = len(shape)
1219
+ axes = _reduce_axes(axis, nd)
1220
+ flat = _flat_list(a.tolist())
1221
+ results = []
1222
+ n_empty = 0
1223
+ n_allnan = 0
1224
+ for vals, _ in _slices(flat, shape, axes):
1225
+ if not vals:
1226
+ n_empty += 1
1227
+ results.append(0)
1228
+ continue
1229
+ best_i = None
1230
+ best_v = None
1231
+ for i, v in enumerate(vals):
1232
+ if _is_nan_v(v):
1233
+ continue
1234
+ if best_v is None or _ckey(v) < _ckey(best_v):
1235
+ best_i, best_v = i, v
1236
+ if best_v is None:
1237
+ n_allnan += 1
1238
+ results.append(0)
1239
+ else:
1240
+ results.append(best_i)
1241
+ if n_allnan:
1242
+ raise ValueError("All-NaN slice encountered")
1243
+ if n_empty:
1244
+ raise ValueError("attempt to get argmin of an empty sequence")
1245
+ return _reduce_wrap(results, axes, shape, keepdims, 'int64', out, a)
1246
+
1247
+
1248
+ def nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=False):
1249
+ """忽略 NaN 的中位数(全 NaN slice → NaN + 逐 slice 警告)。
1250
+ 0-d:返回保持输入 dtype 的 0-d ndarray(与标准 median 0-d 短路一致)。"""
1251
+ rs = _rs()
1252
+ a = _as_nd(a)
1253
+ dt = getattr(a, '_dtype', 'float64')
1254
+ k = _dt_kind(dt)
1255
+ shape = tuple(a.shape)
1256
+ if k == 'o' and len(shape) <= 1:
1257
+ from rsarray import statistics as _st
1258
+ return _st.median(a, axis=axis, out=out, keepdims=keepdims)
1259
+ # 0-d 与标准 median 一致:float/complex 保留精度,其余 float64
1260
+ #(int 输入 0-d 也转 float64,与 _median_py 的 res_dt 规则对齐)
1261
+ res_dt = (dt if k in 'efc' else 'float64') if len(shape) == 0 \
1262
+ else _reduction_dtype('median', dt)
1263
+ if _simple_fast(a, axis, out):
1264
+ from rsarray import statistics as _st
1265
+ return _st.median(a, axis=axis, out=out, keepdims=keepdims)
1266
+ results, axes, n_empty, n_allnan, _ = _nan_slice_reduce(a, axis, _py_median)
1267
+ if n_allnan:
1268
+ for _ in range(n_allnan):
1269
+ warnings.warn("All-NaN slice encountered", RuntimeWarning, stacklevel=4)
1270
+ if n_empty:
1271
+ warnings.warn("Mean of empty slice", RuntimeWarning, stacklevel=4)
1272
+ if len(shape) == 0 and out is None:
1273
+ # 0-d 结果须为 0-d ndarray(标准 median 0-d 短路同款),非裸标量
1274
+ try:
1275
+ return rs.array([results[0]], dtype=res_dt).reshape(())
1276
+ except Exception:
1277
+ pass
1278
+ return _reduce_wrap(results, axes, shape, keepdims, res_dt, out, a)
1279
+
1280
+
1281
+ def _validate_method(method):
1282
+ """2.x 报错:"<m> is not a valid method. Use one of: 'inverted_cdf', ..."""
1283
+ m = getattr(method, 'value', method)
1284
+ if m not in QUANTILE_METHODS:
1285
+ use = ', '.join("'%s'" % x for x in QUANTILE_METHODS)
1286
+ raise ValueError(f"{m} is not a valid method. Use one of: {use}")
1287
+ return m
1288
+
1289
+
1290
+ def _frac_type():
1291
+ from fractions import Fraction
1292
+ return Fraction
1293
+
1294
+
1295
+ def _promote_float(base, other):
1296
+ """float 家族 dtype 提升(f16<f32<f64<f80);非 float 基底按对方 float 提升。"""
1297
+ order = {'float16': 0, 'float32': 1, 'float64': 2, 'longdouble': 3}
1298
+ if base in order and other in order:
1299
+ return base if order[base] >= order[other] else other
1300
+ if base in order:
1301
+ return base
1302
+ if other in order:
1303
+ return other
1304
+ return 'float64'
1305
+
1306
+
1307
+ def _m8_label_of(dt):
1308
+ """dtype 字符串/DType 的 m8[X]/M8[X] 标签(无则 None)。"""
1309
+ if dt is None:
1310
+ return None
1311
+ s = dt if isinstance(dt, str) else str(dt)
1312
+ t = s.lstrip('<>=|')
1313
+ if (len(t) > 4 and t[1] == '8' and t[2] == '[' and t[-1] == ']'
1314
+ and t[0] in 'Mm' and t[3:-1].isalpha()):
1315
+ return t
1316
+ return None
1317
+
1318
+
1319
+ def _q_values(q, scale):
1320
+ """q → (Python 数值列表, 数组 q 的 float 提升 dtype|None, 是否全 0/1, 是否数组)。
1321
+ 校验范围并按 scale 给出 2.x 精确报错信息。"""
1322
+ msg = ("Percentiles must be in the range [0, 100]" if scale > 1
1323
+ else "Quantiles must be in the range [0, 1]")
1324
+ promote = None
1325
+ if isinstance(q, (list, tuple)):
1326
+ qvals = _flat_list(q)
1327
+ qarr = True
1328
+ elif builtins.type(q) in (int, float, bool) or isinstance(q, _frac_type()):
1329
+ # 纯 Python 标量:NEP50 不参与提升
1330
+ qvals = [q]
1331
+ qarr = False
1332
+ else:
1333
+ # rsarray ndarray / 数值标量(有 .dtype):参与提升
1334
+ _dtq = getattr(q, '_dtype', None) or getattr(q, 'dtype', None)
1335
+ qk = _dt_kind(_dtq)
1336
+ if qk in 'efd':
1337
+ promote = _dtype_name(_dtq)
1338
+ qarr = getattr(q, 'ndim', 0) > 0
1339
+ qvals = _flat_list(q.tolist()) if qarr else [q.tolist()]
1340
+ exact01 = True
1341
+ for v in qvals:
1342
+ try:
1343
+ fv = float(v) / scale
1344
+ except (TypeError, ValueError):
1345
+ raise ValueError(msg)
1346
+ if fv != fv or not (0.0 <= fv <= 1.0):
1347
+ raise ValueError(msg)
1348
+ if fv not in (0.0, 1.0):
1349
+ exact01 = False
1350
+ return qvals, promote, exact01, qarr
1351
+
1352
+
1353
+ def _frac_quantile(vs, qf, method):
1354
+ """Fraction 精确分位数(vs 已排序 Fraction 列表,qf ∈ [0,1] 精确值)。"""
1355
+ from fractions import Fraction as _Frac
1356
+ n = len(vs)
1357
+ if n == 0:
1358
+ return _Frac(0)
1359
+ m = method or 'linear'
1360
+ if m == 'inverted_cdf':
1361
+ idx = builtins.max(0, builtins.min(math.ceil(qf * n) - 1, n - 1))
1362
+ return vs[idx]
1363
+ if m == 'averaged_inverted_cdf':
1364
+ k = qf * n
1365
+ if k.denominator == 1 and 0 < k < n:
1366
+ return (vs[k - 1] + vs[k]) / 2
1367
+ idx = builtins.max(0, builtins.min(math.ceil(k) - 1, n - 1))
1368
+ return vs[idx]
1369
+ if m == 'lower':
1370
+ vidx = math.floor(qf * (n - 1))
1371
+ elif m == 'higher':
1372
+ vidx = math.ceil(qf * (n - 1))
1373
+ elif m == 'nearest':
1374
+ # Fraction 精确 half-even(Python round 对 Fraction 是精确 tie→even)
1375
+ vidx = round(qf * (n - 1))
1376
+ elif m == 'closest_observation':
1377
+ # 1-based 位置 half-even(#26656):round(q*n) - 1
1378
+ vidx = round(qf * n) - 1
1379
+ elif m == 'midpoint':
1380
+ vidx = _Frac(math.floor(qf * (n - 1))
1381
+ + math.ceil(qf * (n - 1)), 2)
1382
+ elif m == 'linear':
1383
+ vidx = qf * (n - 1)
1384
+ elif m == 'hazen':
1385
+ vidx = qf * n - _Frac(1, 2)
1386
+ elif m == 'weibull':
1387
+ vidx = qf * (n + 1) - 1
1388
+ elif m == 'median_unbiased':
1389
+ vidx = qf * (n + _Frac(1, 3)) - _Frac(2, 3)
1390
+ elif m == 'normal_unbiased':
1391
+ vidx = qf * (n + _Frac(1, 4)) - _Frac(5, 8)
1392
+ elif m == 'interpolated_inverted_cdf':
1393
+ vidx = qf * n - 1
1394
+ else:
1395
+ raise ValueError(f"method {m!r} is not a valid method")
1396
+ vidx = builtins.min(builtins.max(vidx, 0), n - 1)
1397
+ if m in ('lower', 'higher', 'nearest', 'closest_observation'):
1398
+ return vs[vidx]
1399
+ lo = math.floor(vidx)
1400
+ hi = builtins.min(lo + 1, n - 1)
1401
+ frac = vidx - lo
1402
+ return vs[lo] + (vs[hi] - vs[lo]) * frac
1403
+
1404
+
1405
+ def _percentile_public(a, q, axis, out, overwrite_input, method, keepdims,
1406
+ weights, nan_filter, scale):
1407
+ m = _validate_method(method)
1408
+ a = _as_nd(a)
1409
+ dt = getattr(a, '_dtype', 'float64')
1410
+ k = _dt_kind(dt).lower()
1411
+ if k == 'c':
1412
+ raise TypeError(
1413
+ "is unable to avoid using the complex type with the "
1414
+ "current version of the 'inplace-sort' used in the "
1415
+ "'nanpercentile' function. Please make sure to cast your "
1416
+ "input array to a real type before calling this function.")
1417
+ # ---- weights 校验(仅 inverted_cdf;非负)
1418
+ if weights is not None:
1419
+ if m != 'inverted_cdf':
1420
+ raise ValueError("Only method 'inverted_cdf' supports weights")
1421
+ wsrc = weights if hasattr(weights, 'tolist') else _rs().array(weights)
1422
+ for w in _flat_list(wsrc.tolist()):
1423
+ if w < 0:
1424
+ raise ValueError("Weights must be non-negative")
1425
+ # ---- m8/M8:int64 哨兵路径
1426
+ m8s = _m8_label_of(dt)
1427
+ if m8s is not None:
1428
+ return _percentile_engine(a, q, axis, keepdims, 'int64', out=out,
1429
+ weights=weights, method=m, nan_filter=nan_filter,
1430
+ scale=scale, sentinel=_INT64_MIN, relabel=m8s)
1431
+ qvals, promote, exact01, qarr = _q_values(q, scale)
1432
+ if isinstance(q, (list, tuple)):
1433
+ q_shape = _list_shape(q) or (len(qvals),)
1434
+ elif qarr and hasattr(q, 'shape'):
1435
+ q_shape = tuple(q.shape)
1436
+ else:
1437
+ q_shape = ()
1438
+
1439
+ def _frac_results(vs):
1440
+ _Frac = _frac_type()
1441
+ n = len(vs)
1442
+ res = []
1443
+ for qv in qvals:
1444
+ fqv = float(qv) / scale
1445
+ if isinstance(qv, _Frac):
1446
+ res.append(_frac_quantile(vs, _Frac(qv) / _Frac(int(scale)), m))
1447
+ elif m in _INTERPOLATING_METHODS and fqv not in (0.0, 1.0):
1448
+ # 浮点 q + 插值 method:float 结果(数组语义)
1449
+ res.append(_quantile_of([float(x) for x in vs], fqv, m))
1450
+ elif m == 'averaged_inverted_cdf':
1451
+ kx = fqv * n
1452
+ if kx == builtins.int(kx) and 0 < kx < n:
1453
+ res.append((vs[int(kx) - 1] + vs[int(kk)]) / 2)
1454
+ else:
1455
+ idx = builtins.max(0, builtins.min(math.ceil(kx) - 1, n - 1))
1456
+ res.append(vs[idx])
1457
+ else:
1458
+ # 精确 0/1 或离散 method:保留原对象(Fraction 恒等性)
1459
+ if fqv == 0.0:
1460
+ res.append(vs[0])
1461
+ elif fqv == 1.0:
1462
+ res.append(vs[n - 1])
1463
+ else:
1464
+ res.append(vs[_sel_idx(fqv, n, m)])
1465
+ return res
1466
+
1467
+ def _frac_out(results):
1468
+ rs = _rs()
1469
+ if qarr:
1470
+ r = rs.array(results, dtype='object')
1471
+ if q_shape and int(getattr(r, 'size', 0) or 0) == _prod(q_shape):
1472
+ r = r.reshape(q_shape)
1473
+ return r
1474
+ return results[0]
1475
+
1476
+ # ---- Fraction 精确路径(object 输入 + Fraction q,全归约)
1477
+ if k == 'o' and axis is None:
1478
+ flat = _flat_list(a.tolist())
1479
+ if flat and all(isinstance(v, _frac_type()) for v in flat):
1480
+ return _frac_out(_frac_results(sorted(flat)))
1481
+ # ---- int/bool 输入 + Fraction q:数组语义——插值算术保持 Fraction
1482
+ #(q=Fraction(1), [1,2] → Fraction(2);Fraction(.5) → Fraction(3,2))
1483
+ if (k in 'iu?b' and axis is None and weights is None
1484
+ and any(isinstance(qv, _frac_type()) for qv in qvals)):
1485
+ vals0 = _flat_list(a.tolist())
1486
+ if vals0 and all(isinstance(v, (int, bool)) for v in vals0):
1487
+ return _frac_out(_frac_results(sorted(vals0)))
1488
+ # ---- 结果 dtype 规则(2.x)
1489
+ interp = m in _INTERPOLATING_METHODS
1490
+ if k in 'ef':
1491
+ res_dt = _dtype_name(dt)
1492
+ elif k in 'iu?b':
1493
+ res_dt = _dtype_name(dt) if (not interp or exact01) else 'float64'
1494
+ else:
1495
+ res_dt = 'float64'
1496
+ if promote is not None:
1497
+ res_dt = _promote_float(res_dt, promote)
1498
+ return _percentile_engine(a, q, axis, keepdims, res_dt, out=out,
1499
+ weights=weights, method=m,
1500
+ nan_filter=nan_filter, scale=scale)
1501
+
1502
+
1503
+ def _sel_idx(fqv, n, m):
1504
+ """离散 method 的选择索引(0-based,clamp);非离散返回 None。"""
1505
+ if m == 'inverted_cdf':
1506
+ return builtins.max(0, builtins.min(math.ceil(fqv * n) - 1, n - 1))
1507
+ if m == 'lower':
1508
+ return builtins.min(builtins.max(math.floor(fqv * (n - 1)), 0), n - 1)
1509
+ if m == 'higher':
1510
+ return builtins.min(builtins.max(math.ceil(fqv * (n - 1)), 0), n - 1)
1511
+ if m == 'nearest':
1512
+ return builtins.min(builtins.max(round(fqv * (n - 1)), 0), n - 1)
1513
+ if m == 'closest_observation':
1514
+ return builtins.min(builtins.max(round(fqv * n) - 1, 0), n - 1)
1515
+ return None
1516
+
1517
+
1518
+ def _median_py(a, axis, out, keepdims):
1519
+ """纯 Python 中位数(2.x 语义;任意 dtype/axis 形状,消除 Rust
1520
+ _core.median 的 f64/2D 限制与空 slice 减溢 abort)。
1521
+ NaN/NaT 传染 slice;空 slice → NaN + 两条 RuntimeWarning;
1522
+ m8/M8 在 int64 存储上计算(NaT=INT64_MIN),结果重贴标签;
1523
+ 结果 dtype:float 保精度,其余 float64;子类/keepdims/out 保留。
1524
+ """
1525
+ rs = _rs()
1526
+ a = _as_nd(a)
1527
+ dt = getattr(a, '_dtype', 'float64')
1528
+ k = _dt_kind(dt)
1529
+ shape = tuple(a.shape)
1530
+ nd = len(shape)
1531
+ axes = _reduce_axes(axis, nd)
1532
+ flat = _flat_list(a.tolist())
1533
+ m8s = _m8_label_of(dt)
1534
+ sentinel = _INT64_MIN if m8s else None
1535
+ results = []
1536
+ n_empty = 0
1537
+ for vals, _wl in _slices(flat, shape, axes):
1538
+ if not vals:
1539
+ results.append(sentinel if sentinel is not None else float('nan'))
1540
+ n_empty += 1
1541
+ continue
1542
+ if any(_is_nan_v(v) for v in vals) or (
1543
+ sentinel is not None and any(v == sentinel for v in vals)):
1544
+ results.append(sentinel if sentinel is not None else float('nan'))
1545
+ continue
1546
+ vs = sorted(vals, key=_ckey)
1547
+ n = len(vs)
1548
+ r = vs[n // 2] if n % 2 == 1 else (vs[n // 2 - 1] + vs[n // 2]) / 2
1549
+ results.append(builtins.int(round(r)) if sentinel is not None else r)
1550
+ if n_empty:
1551
+ warnings.warn("Mean of empty slice", RuntimeWarning, stacklevel=4)
1552
+ warnings.warn("invalid value encountered in scalar divide",
1553
+ RuntimeWarning, stacklevel=4)
1554
+ if m8s:
1555
+ axset = set(axes)
1556
+ out_shape = [d for i, d in enumerate(shape) if i not in axset]
1557
+ if keepdims:
1558
+ red = []
1559
+ kk = 0
1560
+ for i in range(nd):
1561
+ if i in axset:
1562
+ red.append(1)
1563
+ else:
1564
+ red.append(out_shape[kk])
1565
+ kk += 1
1566
+ red = tuple(red)
1567
+ else:
1568
+ red = tuple(out_shape)
1569
+ if not red:
1570
+ res = rs.array([results[0]], dtype='int64').reshape(())
1571
+ elif not results and 0 in red:
1572
+ res = rs.zeros(red, dtype='int64')
1573
+ else:
1574
+ res = rs.array(_reshape_flat(list(results), red), dtype='int64')
1575
+ res._dtype = m8s
1576
+ if out is not None:
1577
+ try:
1578
+ rs.copyto(out, res)
1579
+ except Exception:
1580
+ out[...] = res
1581
+ return out
1582
+ return res
1583
+ # complex 保留自身 dtype(数组语义:median(c64) → c64;float64(c) 会
1584
+ # 抛 TypeError 退化裸值)
1585
+ res_dt = _dtype_name(dt) if k in 'efc' else 'float64'
1586
+ return _reduce_wrap(results, axes, shape, keepdims, res_dt, out, a)
1587
+
1588
+
1589
+ def nanpercentile(a, q, axis=None, out=None, overwrite_input=False,
1590
+ method='linear', keepdims=False, weights=None,
1591
+ interpolation=None):
1592
+ """忽略 NaN 的百分位数(q ∈ [0,100];支持 method/weights/元组轴/keepdims/out)。"""
1593
+ if interpolation is not None:
1594
+ if method == 'linear':
1595
+ method = interpolation
1596
+ else:
1597
+ raise ValueError(
1598
+ "interpolation and method cannot be used simultaneously")
1599
+ return _percentile_public(a, q, axis, out, overwrite_input, method,
1600
+ keepdims, weights, nan_filter=True, scale=100.0)
1601
+
1602
+
1603
+ def nanquantile(a, q, axis=None, out=None, method='linear', keepdims=False,
1604
+ weights=None, interpolation=None):
1605
+ """忽略 NaN 的分位数(q ∈ [0,1];支持 method/weights/元组轴/keepdims/out)。"""
1606
+ if interpolation is not None:
1607
+ if method == 'linear':
1608
+ method = interpolation
1609
+ else:
1610
+ raise ValueError(
1611
+ "interpolation and method cannot be used simultaneously")
1612
+ return _percentile_public(a, q, axis, out, None, method, keepdims,
1613
+ weights, nan_filter=True, scale=1.0)
1614
+
1615
+
1616
+ def _nancum_impl(a, axis, dtype, out, is_prod):
1617
+ """忽略 NaN 的累积和/积(实现:NaN → 0/1 替换后委托标准
1618
+ cumsum/cumprod 内核——与标准结果逐位一致、标注规则天然一致)。"""
1619
+ rs = _rs()
1620
+ a = _as_nd(a)
1621
+ ident = 1.0 if is_prod else 0.0
1622
+ b, _mask = _replace_nan(a, ident)
1623
+ func = rs.cumprod if is_prod else rs.cumsum
1624
+ res = func(b, axis=axis, dtype=dtype, out=out)
1625
+ if out is not None:
1626
+ return res
1627
+ return _keep_subclass(res, a)
1628
+
1629
+
1630
+ def nancumsum(a, axis=None, dtype=None, out=None):
1631
+ """忽略 NaN 的累积和(NaN 视为 0)。"""
1632
+ return _nancum_impl(a, axis, dtype, out, False)
1633
+
1634
+
1635
+ def nancumprod(a, axis=None, dtype=None, out=None):
1636
+ """忽略 NaN 的累积积(NaN 视为 1)。"""
1637
+ return _nancum_impl(a, axis, dtype, out, True)