rsarray 1.2.10__cp315-cp315-win_amd64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- rsarray/__init__.py +12028 -0
- rsarray/_core/__init__.py +213 -0
- rsarray/_core/_exceptions.py +83 -0
- rsarray/_core/_internal.py +331 -0
- rsarray/_core/_multiarray_tests.py +129 -0
- rsarray/_core/_multiarray_umath.py +121 -0
- rsarray/_core/_rational_tests.py +52 -0
- rsarray/_core/arrayprint.py +36 -0
- rsarray/_core/fromnumeric.py +31 -0
- rsarray/_core/function_base.py +84 -0
- rsarray/_core/multiarray.py +385 -0
- rsarray/_core/numeric.py +28 -0
- rsarray/_core/numerictypes.py +233 -0
- rsarray/_core/records.py +14 -0
- rsarray/_core/shape_base.py +23 -0
- rsarray/_core/strings.py +78 -0
- rsarray/_core/umath.py +176 -0
- rsarray/_dtypes.py +1229 -0
- rsarray/_extra.py +6621 -0
- rsarray/_typing.py +24 -0
- rsarray/array_methods.py +1224 -0
- rsarray/array_ops.py +1585 -0
- rsarray/char.py +1590 -0
- rsarray/exceptions.py +45 -0
- rsarray/fft/__init__.py +231 -0
- rsarray/io.py +453 -0
- rsarray/lib/__init__.py +102 -0
- rsarray/lib/_function_base_impl.py +37 -0
- rsarray/lib/_index_tricks_impl.py +98 -0
- rsarray/lib/_nanfunctions_impl.py +1637 -0
- rsarray/lib/_stride_tricks_impl.py +110 -0
- rsarray/lib/recfunctions.py +1222 -0
- rsarray/lib/stride_tricks.py +106 -0
- rsarray/linalg/__init__.py +2603 -0
- rsarray/linalg/_linalg.py +91 -0
- rsarray/linalg/_pylinalg.py +1008 -0
- rsarray/linalg/lapack_lite.py +13 -0
- rsarray/ma/__init__.py +92 -0
- rsarray/ma/core.py +1385 -0
- rsarray/ma/extras.py +711 -0
- rsarray/ma/mrecords.py +144 -0
- rsarray/math_functions.py +965 -0
- rsarray/matlib.py +67 -0
- rsarray/num_core.cp315-win_amd64.pyd +0 -0
- rsarray/polynomial/__init__.py +148 -0
- rsarray/polynomial/_npcompat.py +721 -0
- rsarray/polynomial/polynomial.py +1082 -0
- rsarray/random/__init__.py +2266 -0
- rsarray/random/_distributions.py +773 -0
- rsarray/rec.py +207 -0
- rsarray/statistics.py +1360 -0
- rsarray/strings.py +349 -0
- rsarray/typing/__init__.py +26 -0
- rsarray-1.2.10.dist-info/METADATA +280 -0
- rsarray-1.2.10.dist-info/RECORD +59 -0
- rsarray-1.2.10.dist-info/WHEEL +4 -0
- rsarray-1.2.10.dist-info/licenses/LICENSE +21 -0
- rsarray-1.2.10.dist-info/licenses/NOTICE +7 -0
- rsarray-1.2.10.dist-info/sboms/rsarray.cyclonedx.json +2789 -0
|
@@ -0,0 +1,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)
|