rsarray 1.2.10__cp313-cp313-win_amd64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- 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.cp313-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
rsarray/ma/extras.py
ADDED
|
@@ -0,0 +1,711 @@
|
|
|
1
|
+
# SPDX-License-Identifier: MIT
|
|
2
|
+
"""掩码数组扩展函数(ma.extras 兼容实现)。
|
|
3
|
+
|
|
4
|
+
在 rsarray.ma.core 基础上实现 ma.extras 的公共 API:
|
|
5
|
+
统计(cov/corrcoef/median/average)、集合(isin/intersect1d/...)、
|
|
6
|
+
掩码工具(clump/compress_rowcols/notmasked_*)、形状变换等。
|
|
7
|
+
"""
|
|
8
|
+
|
|
9
|
+
import rsarray as np
|
|
10
|
+
from .core import (MAError, MaskedArray, asarray, array, count, filled,
|
|
11
|
+
getdata, getmaskarray, isMaskedArray, masked, mask_or,
|
|
12
|
+
nomask)
|
|
13
|
+
|
|
14
|
+
|
|
15
|
+
def atleast_1d(*arrays):
|
|
16
|
+
out = []
|
|
17
|
+
for a in arrays:
|
|
18
|
+
if isMaskedArray(a):
|
|
19
|
+
if a.ndim >= 1:
|
|
20
|
+
out.append(a)
|
|
21
|
+
else:
|
|
22
|
+
out.append(MaskedArray(np.atleast_1d(a.data),
|
|
23
|
+
list(a._mask), fill_value=a.fill_value))
|
|
24
|
+
else:
|
|
25
|
+
out.append(MaskedArray(np.atleast_1d(a)))
|
|
26
|
+
return out[0] if len(out) == 1 else tuple(out)
|
|
27
|
+
|
|
28
|
+
|
|
29
|
+
def atleast_2d(*arrays):
|
|
30
|
+
out = []
|
|
31
|
+
for a in arrays:
|
|
32
|
+
if isMaskedArray(a):
|
|
33
|
+
if a.ndim >= 2:
|
|
34
|
+
out.append(a)
|
|
35
|
+
else:
|
|
36
|
+
out.append(MaskedArray(np.atleast_2d(a.data),
|
|
37
|
+
list(a._mask), fill_value=a.fill_value))
|
|
38
|
+
else:
|
|
39
|
+
out.append(MaskedArray(np.atleast_2d(a)))
|
|
40
|
+
return out[0] if len(out) == 1 else tuple(out)
|
|
41
|
+
|
|
42
|
+
|
|
43
|
+
def atleast_3d(*arrays):
|
|
44
|
+
out = []
|
|
45
|
+
for a in arrays:
|
|
46
|
+
if isMaskedArray(a):
|
|
47
|
+
if a.ndim >= 3:
|
|
48
|
+
out.append(a)
|
|
49
|
+
else:
|
|
50
|
+
out.append(MaskedArray(np.atleast_3d(a.data),
|
|
51
|
+
list(a._mask), fill_value=a.fill_value))
|
|
52
|
+
else:
|
|
53
|
+
out.append(MaskedArray(np.atleast_3d(a)))
|
|
54
|
+
return out[0] if len(out) == 1 else tuple(out)
|
|
55
|
+
|
|
56
|
+
|
|
57
|
+
def dot(a, b):
|
|
58
|
+
"""掩码感知的矩阵乘(行掩码 | 列掩码 传播)。"""
|
|
59
|
+
a = asarray(a)
|
|
60
|
+
b = asarray(b)
|
|
61
|
+
res = a.data @ b.data
|
|
62
|
+
if isinstance(res, (int, float)):
|
|
63
|
+
return res
|
|
64
|
+
ma_ = getmaskarray(a)
|
|
65
|
+
mb_ = getmaskarray(b)
|
|
66
|
+
mask = None
|
|
67
|
+
if ma_ is not nomask and ma_.ndim == 2:
|
|
68
|
+
mask = ma_.any(axis=1, keepdims=True)
|
|
69
|
+
if mb_ is not nomask and mb_.ndim == 2:
|
|
70
|
+
col = mb_.any(axis=0, keepdims=True)
|
|
71
|
+
mask = col if mask is None else (mask | col)
|
|
72
|
+
if mask is None:
|
|
73
|
+
return res
|
|
74
|
+
return MaskedArray(res, mask=mask)
|
|
75
|
+
|
|
76
|
+
|
|
77
|
+
def ediff1d(to_edge=False):
|
|
78
|
+
raise NotImplementedError("rsarray.ma.extras.ediff1d requires two args; "
|
|
79
|
+
"see ma.extras.ediff1d(a1, a2)")
|
|
80
|
+
|
|
81
|
+
|
|
82
|
+
def ediff1d_impl(a1, a2=None):
|
|
83
|
+
"""相邻元素差(ma.ediff1d 兼容)。"""
|
|
84
|
+
if a2 is None:
|
|
85
|
+
a = asarray(a1)
|
|
86
|
+
data = a.compressed()
|
|
87
|
+
if data.size < 2:
|
|
88
|
+
return asarray([])
|
|
89
|
+
d = data[1:] - data[:-1]
|
|
90
|
+
if to_edge is None or not to_edge:
|
|
91
|
+
return asarray(d)
|
|
92
|
+
return asarray(np.concatenate([[data[0]], d]))
|
|
93
|
+
a1 = asarray(a1)
|
|
94
|
+
a2 = asarray(a2)
|
|
95
|
+
d = []
|
|
96
|
+
for x in a1.compressed():
|
|
97
|
+
for y in a2.compressed():
|
|
98
|
+
d.append(x - y)
|
|
99
|
+
return asarray(d)
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
def apply_along_axis(func1d, axis, arr, *args, **kwargs):
|
|
103
|
+
"""沿轴应用 1-d 函数(ma.apply_along_axis 兼容)。"""
|
|
104
|
+
arr = asarray(arr)
|
|
105
|
+
n = arr.ndim
|
|
106
|
+
if axis < 0:
|
|
107
|
+
axis += n
|
|
108
|
+
if axis >= n:
|
|
109
|
+
raise ValueError("axis out of bounds")
|
|
110
|
+
# 把目标轴移到最前,逐行调用 func1d
|
|
111
|
+
moved = np.transpose(arr.data, tuple(range(axis, n)) + tuple(range(axis)))
|
|
112
|
+
flat_shape = moved.shape[1:]
|
|
113
|
+
res_list = []
|
|
114
|
+
flat = moved.tolist()
|
|
115
|
+
for row in (flat if isinstance(flat, list) else [flat]):
|
|
116
|
+
res_list.append(func1d(row, *args, **kwargs))
|
|
117
|
+
try:
|
|
118
|
+
res_arr = np.array(res_list)
|
|
119
|
+
res_shape = (moved.shape[0],) + res_arr.shape[1:] if res_arr.ndim > 1 \
|
|
120
|
+
else (moved.shape[0],)
|
|
121
|
+
res_arr = res_arr.reshape(res_shape)
|
|
122
|
+
except Exception:
|
|
123
|
+
res_arr = np.array(res_list).reshape((moved.shape[0],))
|
|
124
|
+
# 转回原轴序
|
|
125
|
+
out = np.transpose(res_arr,
|
|
126
|
+
(tuple(range(1, n - axis + 1))) + (0,))
|
|
127
|
+
m = getmaskarray(arr)
|
|
128
|
+
if m is not nomask:
|
|
129
|
+
m_t = np.transpose(m, tuple(range(axis, n)) + tuple(range(axis)))
|
|
130
|
+
out_mask = np.transpose(m_t, (tuple(range(1, n - axis + 1))) + (0,))
|
|
131
|
+
return MaskedArray(out, mask=out_mask, fill_value=arr.fill_value)
|
|
132
|
+
return out
|
|
133
|
+
|
|
134
|
+
|
|
135
|
+
def apply_over_axes(func, a, axes):
|
|
136
|
+
"""依次在给定轴上应用 func(ma.apply_over_axes 兼容)。"""
|
|
137
|
+
a = asarray(a)
|
|
138
|
+
ndim = a.ndim
|
|
139
|
+
current_axis = 0
|
|
140
|
+
for axis in axes:
|
|
141
|
+
axis %= ndim
|
|
142
|
+
axis = current_axis + axis
|
|
143
|
+
a = asarray(func(a, axis))
|
|
144
|
+
ndim = a.ndim
|
|
145
|
+
current_axis += 1
|
|
146
|
+
return a
|
|
147
|
+
|
|
148
|
+
|
|
149
|
+
def average(a, axis=None, weights=None, returned=False, **kwargs):
|
|
150
|
+
"""掩码感知的加权均值(ma.average 兼容)。"""
|
|
151
|
+
a = asarray(a)
|
|
152
|
+
data = a.data
|
|
153
|
+
m = getmaskarray(a)
|
|
154
|
+
if weights is None:
|
|
155
|
+
if m is nomask:
|
|
156
|
+
res = data.mean(axis=axis)
|
|
157
|
+
else:
|
|
158
|
+
w = (~m).astype(float)
|
|
159
|
+
res = (data * w).sum(axis=axis) / w.sum(axis=axis)
|
|
160
|
+
else:
|
|
161
|
+
w = np.asarray(weights, dtype=float)
|
|
162
|
+
if isMaskedArray(weights):
|
|
163
|
+
wm = getmaskarray(weights)
|
|
164
|
+
else:
|
|
165
|
+
wm = nomask
|
|
166
|
+
m2 = mask_or(m, wm) if m is not nomask or wm is not nomask else nomask
|
|
167
|
+
if m2 is not nomask:
|
|
168
|
+
w = np.where(m2, 0.0, w)
|
|
169
|
+
s = w.sum(axis=axis)
|
|
170
|
+
res = (data * w).sum(axis=axis) / s
|
|
171
|
+
if returned:
|
|
172
|
+
return res, s
|
|
173
|
+
return res
|
|
174
|
+
|
|
175
|
+
|
|
176
|
+
def _covhelper(x, y=None, rowvar=True, fweights=None, aweights=None):
|
|
177
|
+
"""ma.extras._covhelper 移植(掩码感知)。"""
|
|
178
|
+
if x is None:
|
|
179
|
+
raise TypeError("x must be an array-like")
|
|
180
|
+
x = asarray(x)
|
|
181
|
+
if y is not None:
|
|
182
|
+
y = asarray(y)
|
|
183
|
+
n = x.shape[0]
|
|
184
|
+
if y is None:
|
|
185
|
+
data = x.data
|
|
186
|
+
if rowvar:
|
|
187
|
+
nobs = data.shape[1]
|
|
188
|
+
data_t = data.T
|
|
189
|
+
else:
|
|
190
|
+
nobs = data.shape[0]
|
|
191
|
+
data_t = data
|
|
192
|
+
m = getmaskarray(x)
|
|
193
|
+
if m is not nomask:
|
|
194
|
+
if rowvar:
|
|
195
|
+
wm = (~m).astype(float)
|
|
196
|
+
sum_ = wm.sum(axis=0)
|
|
197
|
+
else:
|
|
198
|
+
wm = (~m).astype(float)
|
|
199
|
+
sum_ = wm.sum(axis=1)
|
|
200
|
+
else:
|
|
201
|
+
wm = None
|
|
202
|
+
sum_ = float(nobs)
|
|
203
|
+
else:
|
|
204
|
+
raise NotImplementedError("rsarray.ma.cov with y is not implemented")
|
|
205
|
+
|
|
206
|
+
if fweights is not None:
|
|
207
|
+
fw = np.asarray(fweights, dtype=float)
|
|
208
|
+
w = fw
|
|
209
|
+
sum_ = w.sum()
|
|
210
|
+
elif aweights is not None:
|
|
211
|
+
aw = np.asarray(aweights, dtype=float)
|
|
212
|
+
w = aw
|
|
213
|
+
sum_ = w.sum()
|
|
214
|
+
else:
|
|
215
|
+
w = wm if wm is not None else None
|
|
216
|
+
sum_ = sum_
|
|
217
|
+
|
|
218
|
+
# 均值(按掩码/权重)
|
|
219
|
+
data_f = data.astype(float)
|
|
220
|
+
if w is None:
|
|
221
|
+
avg = data_f.mean(axis=1)
|
|
222
|
+
else:
|
|
223
|
+
w2 = w.reshape((1, -1) if rowvar else (-1, 1))
|
|
224
|
+
avg = (data_f * w2).sum(axis=1) / sum_
|
|
225
|
+
|
|
226
|
+
# 中心化
|
|
227
|
+
if rowvar:
|
|
228
|
+
xm = data_f - avg.reshape((1, -1))
|
|
229
|
+
else:
|
|
230
|
+
xm = data_f - avg.reshape((-1, 1))
|
|
231
|
+
if w is not None:
|
|
232
|
+
w3 = w.reshape((1, -1) if rowvar else (-1, 1))
|
|
233
|
+
xm = xm * w3
|
|
234
|
+
fac = sum_
|
|
235
|
+
if rowvar:
|
|
236
|
+
covmat = (xm * xm.T).sum(axis=1) / fac
|
|
237
|
+
c = np.array([[covmat[i, j] if i == j else (xm[:, i] * xm[:, j]).sum() / fac
|
|
238
|
+
for j in range(covmat.shape[0])]
|
|
239
|
+
for i in range(covmat.shape[0])])
|
|
240
|
+
else:
|
|
241
|
+
c = (xm.T * xm).sum(axis=0) / fac
|
|
242
|
+
return c
|
|
243
|
+
|
|
244
|
+
|
|
245
|
+
def cov(x, y=None, rowvar=True, bias=False, ddof=None, fweights=None,
|
|
246
|
+
aweights=None, **kwargs):
|
|
247
|
+
"""掩码感知的协方差(ma.cov 兼容子集:x-only 路径)。"""
|
|
248
|
+
c = _covhelper(x, y, rowvar, fweights, aweights)
|
|
249
|
+
x = asarray(x)
|
|
250
|
+
if rowvar:
|
|
251
|
+
n = x.shape[1]
|
|
252
|
+
else:
|
|
253
|
+
n = x.shape[0]
|
|
254
|
+
if fweights is not None:
|
|
255
|
+
sum_ = np.sum(fweights)
|
|
256
|
+
elif aweights is not None:
|
|
257
|
+
sum_ = np.sum(aweights)
|
|
258
|
+
else:
|
|
259
|
+
sum_ = count(x, axis=not rowvar)
|
|
260
|
+
sum_ = float(sum_) if isinstance(sum_, np.ndarray) else float(sum_)
|
|
261
|
+
ddofv = 1 if ddof is None else ddof
|
|
262
|
+
if not bias:
|
|
263
|
+
c = c * sum_ / (sum_ - ddofv)
|
|
264
|
+
return c
|
|
265
|
+
|
|
266
|
+
|
|
267
|
+
def corrcoef(m, rowvar=True, **kwargs):
|
|
268
|
+
"""掩码感知的相关系数(ma.corrcoef 兼容子集)。"""
|
|
269
|
+
m = asarray(m)
|
|
270
|
+
if rowvar:
|
|
271
|
+
n = m.shape[1]
|
|
272
|
+
else:
|
|
273
|
+
n = m.shape[0]
|
|
274
|
+
c = cov(m, rowvar=rowvar)
|
|
275
|
+
c = np.asarray(c, dtype=float)
|
|
276
|
+
d = np.sqrt(np.array([[c[i][i] if c.ndim == 2 else c[i] for i in range(n)]
|
|
277
|
+
for _ in range(n)]))
|
|
278
|
+
c = c / (d.T * d)
|
|
279
|
+
# 数值稳定:clip 到 [-1, 1]
|
|
280
|
+
c = np.clip(c, -1.0, 1.0)
|
|
281
|
+
return c
|
|
282
|
+
|
|
283
|
+
|
|
284
|
+
def compress_rowcols(a):
|
|
285
|
+
"""含掩码的行/列整体掩掉(ma.compress_rowcols 兼容)。"""
|
|
286
|
+
a = asarray(a)
|
|
287
|
+
m = getmaskarray(a)
|
|
288
|
+
if m is nomask or a.ndim != 2:
|
|
289
|
+
return a
|
|
290
|
+
newmask = m | m.any(axis=1, keepdims=True) | m.any(axis=0, keepdims=True)
|
|
291
|
+
return MaskedArray(a.data, mask=newmask, fill_value=a.fill_value)
|
|
292
|
+
|
|
293
|
+
|
|
294
|
+
def mask_rowcols(a):
|
|
295
|
+
"""含掩码的行/列整体掩掉(ma.mask_rowcols 兼容)。"""
|
|
296
|
+
return compress_rowcols(a)
|
|
297
|
+
|
|
298
|
+
|
|
299
|
+
def notmasked_contiguous(a):
|
|
300
|
+
"""最长连续未掩码区间的切片/索引(ma.notmasked_contiguous 兼容)。"""
|
|
301
|
+
a = asarray(a)
|
|
302
|
+
m = getmaskarray(a)
|
|
303
|
+
if m is nomask:
|
|
304
|
+
return slice(None)
|
|
305
|
+
flat = m.reshape((-1,)).tolist()
|
|
306
|
+
best_start, best_len = -1, 0
|
|
307
|
+
start = None
|
|
308
|
+
for i, v in enumerate(flat):
|
|
309
|
+
if not v:
|
|
310
|
+
if start is None:
|
|
311
|
+
start = i
|
|
312
|
+
else:
|
|
313
|
+
if start is not None:
|
|
314
|
+
if i - start > best_len:
|
|
315
|
+
best_start, best_len = start, i - start
|
|
316
|
+
start = None
|
|
317
|
+
if start is not None and len(flat) - start > best_len:
|
|
318
|
+
best_start, best_len = start, len(flat) - start
|
|
319
|
+
if best_len == 0:
|
|
320
|
+
return asarray([], dtype=int)
|
|
321
|
+
return slice(best_start, best_start + best_len)
|
|
322
|
+
|
|
323
|
+
|
|
324
|
+
def flatnotmasked_contiguous(a):
|
|
325
|
+
return notmasked_contiguous(a)
|
|
326
|
+
|
|
327
|
+
|
|
328
|
+
def notmasked_edges(a):
|
|
329
|
+
"""每行/列首尾未掩码元素索引(ma.notmasked_edges 兼容)。"""
|
|
330
|
+
a = asarray(a)
|
|
331
|
+
m = getmaskarray(a)
|
|
332
|
+
if m is nomask:
|
|
333
|
+
n1, n2 = a.shape[0], a.shape[1] if a.ndim > 1 else 0
|
|
334
|
+
return (np.array([0] * (n1 if a.ndim > 1 else a.shape[0])),
|
|
335
|
+
np.array([0] * (n1 if a.ndim > 1 else a.shape[0])))
|
|
336
|
+
if a.ndim == 1:
|
|
337
|
+
flat = m.reshape((-1,)).tolist()
|
|
338
|
+
first = 0
|
|
339
|
+
for i, v in enumerate(flat):
|
|
340
|
+
if not v:
|
|
341
|
+
first = i
|
|
342
|
+
break
|
|
343
|
+
last = len(flat) - 1
|
|
344
|
+
for i in range(len(flat) - 1, -1, -1):
|
|
345
|
+
if not flat[i]:
|
|
346
|
+
last = i
|
|
347
|
+
break
|
|
348
|
+
return (np.array([first]), np.array([last]))
|
|
349
|
+
n1, n2 = a.shape
|
|
350
|
+
first = []
|
|
351
|
+
last = []
|
|
352
|
+
for i in range(n1):
|
|
353
|
+
row = m[i].tolist()
|
|
354
|
+
f = 0
|
|
355
|
+
for j, v in enumerate(row):
|
|
356
|
+
if not v:
|
|
357
|
+
f = j
|
|
358
|
+
break
|
|
359
|
+
first.append(f)
|
|
360
|
+
l = n2 - 1
|
|
361
|
+
for j in range(n2 - 1, -1, -1):
|
|
362
|
+
if not row[j]:
|
|
363
|
+
l = j
|
|
364
|
+
break
|
|
365
|
+
last.append(l)
|
|
366
|
+
return (np.array(first), np.array(last))
|
|
367
|
+
|
|
368
|
+
|
|
369
|
+
def masked_all(a, axis=None, **kwargs):
|
|
370
|
+
"""全部元素是否被掩掉(ma.masked_all 兼容)。"""
|
|
371
|
+
a = asarray(a)
|
|
372
|
+
m = getmaskarray(a)
|
|
373
|
+
if m is nomask:
|
|
374
|
+
return False
|
|
375
|
+
if axis is None:
|
|
376
|
+
return bool(m.all())
|
|
377
|
+
return m.all(axis=axis)
|
|
378
|
+
|
|
379
|
+
|
|
380
|
+
def masked_all_like(a):
|
|
381
|
+
"""与 a 同形全掩码的掩码数组(ma.masked_all_like 兼容)。"""
|
|
382
|
+
a = asarray(a)
|
|
383
|
+
return MaskedArray(a.data, mask=True, fill_value=a.fill_value)
|
|
384
|
+
|
|
385
|
+
|
|
386
|
+
def clump(a, n):
|
|
387
|
+
"""掩码中每段 >= n 的连续 True:第 n 个置 True,其余 False。"""
|
|
388
|
+
a = asarray(a)
|
|
389
|
+
m = list(getmaskarray(a).reshape((-1,)).tolist())
|
|
390
|
+
i = 0
|
|
391
|
+
out = list(m)
|
|
392
|
+
while i < len(m):
|
|
393
|
+
if m[i]:
|
|
394
|
+
j = i
|
|
395
|
+
while j < len(m) and m[j]:
|
|
396
|
+
j += 1
|
|
397
|
+
run = j - i
|
|
398
|
+
if run >= n:
|
|
399
|
+
for k in range(i, j):
|
|
400
|
+
out[k] = (k == i + n - 1)
|
|
401
|
+
i = j
|
|
402
|
+
else:
|
|
403
|
+
i += 1
|
|
404
|
+
a._mask = out
|
|
405
|
+
return a
|
|
406
|
+
|
|
407
|
+
|
|
408
|
+
# 新版命名:clump_masked(与 clump 同义)
|
|
409
|
+
clump_masked = clump
|
|
410
|
+
|
|
411
|
+
|
|
412
|
+
def clump_unmasked(a):
|
|
413
|
+
"""把孤立 True 掩码扩展到相邻未掩码段(ma.clump_unmasked 兼容)。"""
|
|
414
|
+
a = asarray(a)
|
|
415
|
+
m = list(getmaskarray(a).reshape((-1,)).tolist())
|
|
416
|
+
n = len(m)
|
|
417
|
+
out = list(m)
|
|
418
|
+
# 每个 True 向两侧扩展直到遇到下一个 True
|
|
419
|
+
for i in range(n):
|
|
420
|
+
if m[i]:
|
|
421
|
+
j = i + 1
|
|
422
|
+
while j < n and not m[j]:
|
|
423
|
+
out[j] = True
|
|
424
|
+
j += 1
|
|
425
|
+
j = i - 1
|
|
426
|
+
while j >= 0 and not m[j]:
|
|
427
|
+
out[j] = True
|
|
428
|
+
j -= 1
|
|
429
|
+
a._mask = out
|
|
430
|
+
return a
|
|
431
|
+
|
|
432
|
+
|
|
433
|
+
def compress_nd(a, **kwargs):
|
|
434
|
+
"""压缩掉掩码元素,返回未掩码值(ma.compress_nd 兼容)。"""
|
|
435
|
+
a = asarray(a)
|
|
436
|
+
return asarray(a.compressed())
|
|
437
|
+
|
|
438
|
+
|
|
439
|
+
def in1d(a, b, assume_unique=False, kind=None, **kwargs):
|
|
440
|
+
"""元素是否属于 b(掩码感知:掩码元素结果掩掉)。"""
|
|
441
|
+
a = asarray(a)
|
|
442
|
+
b = asarray(b)
|
|
443
|
+
vals_b = set(v for v in b.compressed().tolist())
|
|
444
|
+
data = a.data
|
|
445
|
+
flat = data.reshape((-1,)).tolist()
|
|
446
|
+
res = [v in vals_b for v in flat]
|
|
447
|
+
m = getmaskarray(a)
|
|
448
|
+
if m is not nomask:
|
|
449
|
+
mflat = m.reshape((-1,)).tolist()
|
|
450
|
+
res_arr = np.array(res)
|
|
451
|
+
out = MaskedArray(res_arr.reshape(data.shape),
|
|
452
|
+
mask=[r or mm for r, mm in zip(res, mflat)])
|
|
453
|
+
return out
|
|
454
|
+
return np.array(res).reshape(data.shape)
|
|
455
|
+
|
|
456
|
+
|
|
457
|
+
def isin(element, testset, invert=False, assume_unique=False, kind=None,
|
|
458
|
+
**kwargs):
|
|
459
|
+
"""isin(掩码感知子集)。"""
|
|
460
|
+
r = in1d(element, testset)
|
|
461
|
+
if invert:
|
|
462
|
+
if isMaskedArray(r):
|
|
463
|
+
r = asarray(~getdata(r))
|
|
464
|
+
r.mask = getmaskarray(element)
|
|
465
|
+
else:
|
|
466
|
+
r = ~r
|
|
467
|
+
return r
|
|
468
|
+
|
|
469
|
+
|
|
470
|
+
def _sorted_unique(a):
|
|
471
|
+
vals = sorted(set(a.compressed().tolist()))
|
|
472
|
+
return np.array(vals) if vals else np.array([])
|
|
473
|
+
|
|
474
|
+
|
|
475
|
+
def intersect1d(ar1, ar2, assume_unique=False):
|
|
476
|
+
s1 = set(ar1.compressed().tolist())
|
|
477
|
+
s2 = set(ar2.compressed().tolist())
|
|
478
|
+
vals = sorted(s1 & s2)
|
|
479
|
+
return np.array(vals) if vals else np.array([])
|
|
480
|
+
|
|
481
|
+
|
|
482
|
+
def setdiff1d(ar1, ar2, assume_unique=False):
|
|
483
|
+
s1 = set(ar1.compressed().tolist())
|
|
484
|
+
s2 = set(ar2.compressed().tolist())
|
|
485
|
+
vals = sorted(s1 - s2)
|
|
486
|
+
return np.array(vals) if vals else np.array([])
|
|
487
|
+
|
|
488
|
+
|
|
489
|
+
def setxor1d(ar1, ar2, assume_unique=False):
|
|
490
|
+
s1 = set(ar1.compressed().tolist())
|
|
491
|
+
s2 = set(ar2.compressed().tolist())
|
|
492
|
+
vals = sorted(s1 ^ s2)
|
|
493
|
+
return np.array(vals) if vals else np.array([])
|
|
494
|
+
|
|
495
|
+
|
|
496
|
+
def union1d(ar1, ar2):
|
|
497
|
+
s1 = set(ar1.compressed().tolist())
|
|
498
|
+
s2 = set(ar2.compressed().tolist())
|
|
499
|
+
vals = sorted(s1 | s2)
|
|
500
|
+
return np.array(vals) if vals else np.array([])
|
|
501
|
+
|
|
502
|
+
|
|
503
|
+
def unique(ar, return_index=False, return_inverse=False, return_counts=False,
|
|
504
|
+
**kwargs):
|
|
505
|
+
"""唯一值(掩码感知:掩码值忽略;结果非掩码数组)。"""
|
|
506
|
+
ar = asarray(ar)
|
|
507
|
+
vals = ar.compressed().tolist()
|
|
508
|
+
if not vals:
|
|
509
|
+
out = np.array([])
|
|
510
|
+
else:
|
|
511
|
+
uniq, counts, inv = [], {}, []
|
|
512
|
+
for v in sorted(vals):
|
|
513
|
+
if v not in inv:
|
|
514
|
+
inv[v] = len(uniq)
|
|
515
|
+
uniq.append(v)
|
|
516
|
+
counts.append(0)
|
|
517
|
+
inv[v] = inv[v]
|
|
518
|
+
counts[inv[v]] += 1
|
|
519
|
+
out = np.array(uniq)
|
|
520
|
+
ret = [out]
|
|
521
|
+
if return_index:
|
|
522
|
+
ret.append(np.array([]))
|
|
523
|
+
if return_inverse:
|
|
524
|
+
ret.append(np.array([]))
|
|
525
|
+
if return_counts:
|
|
526
|
+
ret.append(np.array(counts))
|
|
527
|
+
return ret[0] if len(ret) == 1 else tuple(ret)
|
|
528
|
+
|
|
529
|
+
|
|
530
|
+
def median(a, axis=None, overwrite_input=False, keepdims=False, **kwargs):
|
|
531
|
+
"""未掩码元素的中位数(ma.median 兼容)。"""
|
|
532
|
+
a = asarray(a)
|
|
533
|
+
c = a.compressed()
|
|
534
|
+
if c.size == 0:
|
|
535
|
+
return np.array(masked)
|
|
536
|
+
s = sorted(c.tolist())
|
|
537
|
+
n = len(s)
|
|
538
|
+
if n % 2 == 1:
|
|
539
|
+
return s[n // 2]
|
|
540
|
+
return (s[n // 2 - 1] + s[n // 2]) / 2.0
|
|
541
|
+
|
|
542
|
+
|
|
543
|
+
def diagflat(v, k=0):
|
|
544
|
+
"""展平后取对角(ma.diagflat 兼容)。"""
|
|
545
|
+
v = asarray(v)
|
|
546
|
+
d = np.diagflat(v.compressed(), k=k) if hasattr(np, 'diagflat') else \
|
|
547
|
+
np.diagonal(v.compressed().reshape((v.size,) + (v.size,)), offset=k)
|
|
548
|
+
return d
|
|
549
|
+
|
|
550
|
+
|
|
551
|
+
def stack(*arrays, **kwargs):
|
|
552
|
+
"""沿新轴堆叠(掩码感知)。"""
|
|
553
|
+
arrays = [asarray(a) for a in arrays if a is not None]
|
|
554
|
+
if len(arrays) < 2:
|
|
555
|
+
raise ValueError("need at least two arrays to stack")
|
|
556
|
+
data = np.stack([a.data for a in arrays])
|
|
557
|
+
masks = [getmaskarray(a) for a in arrays]
|
|
558
|
+
anymask = [m for m in masks if m is not nomask]
|
|
559
|
+
if not anymask:
|
|
560
|
+
return data
|
|
561
|
+
full = np.zeros(data.shape, dtype='bool')
|
|
562
|
+
for i, m in enumerate(masks):
|
|
563
|
+
if m is not nomask:
|
|
564
|
+
full[i] = m
|
|
565
|
+
return MaskedArray(data, mask=full)
|
|
566
|
+
|
|
567
|
+
|
|
568
|
+
def vstack(arrays, **kw):
|
|
569
|
+
arrays = [asarray(a) if isMaskedArray(a) else asarray(a)
|
|
570
|
+
for a in (arrays if isinstance(arrays, (list, tuple))
|
|
571
|
+
else (arrays,))]
|
|
572
|
+
data = np.vstack([a.data for a in arrays])
|
|
573
|
+
masks = [getmaskarray(a) for a in arrays]
|
|
574
|
+
anymask = [m for m in masks if m is not nomask]
|
|
575
|
+
if not anymask:
|
|
576
|
+
return data
|
|
577
|
+
full = np.zeros(data.shape, dtype='bool')
|
|
578
|
+
off = 0
|
|
579
|
+
for a, m in zip(arrays, masks):
|
|
580
|
+
n = a.data.shape[0]
|
|
581
|
+
if m is not nomask:
|
|
582
|
+
full[off:off + n] = m
|
|
583
|
+
off += n
|
|
584
|
+
return MaskedArray(data, mask=full)
|
|
585
|
+
|
|
586
|
+
|
|
587
|
+
def unwrap(p, discont=None, axis=-1):
|
|
588
|
+
"""展开相位(掩码感知子集:基于压缩值)。"""
|
|
589
|
+
p = asarray(p)
|
|
590
|
+
if discont is None:
|
|
591
|
+
discont = np.pi
|
|
592
|
+
data = p.data
|
|
593
|
+
m = getmaskarray(p)
|
|
594
|
+
result = np.array(data.tolist())
|
|
595
|
+
# 1-d 路径
|
|
596
|
+
flat = result.reshape((-1,)) if data.ndim == 1 else result
|
|
597
|
+
if data.ndim == 1:
|
|
598
|
+
out = list(flat)
|
|
599
|
+
for i in range(1, len(out)):
|
|
600
|
+
d = out[i] - out[i - 1]
|
|
601
|
+
if d > discont:
|
|
602
|
+
out[i] = out[i] - 2 * np.pi * (d // (2 * np.pi) if 0 else 1)
|
|
603
|
+
out[i] = out[i] + 2 * np.pi * (round((out[i - 1] - out[i]) / (2 * np.pi)))
|
|
604
|
+
elif d < -discont:
|
|
605
|
+
out[i] = out[i] + 2 * np.pi * (round((out[i] - out[i - 1]) / (2 * np.pi)))
|
|
606
|
+
result = np.array(out)
|
|
607
|
+
if m is not nomask:
|
|
608
|
+
return MaskedArray(result, mask=m, fill_value=p.fill_value)
|
|
609
|
+
return result
|
|
610
|
+
|
|
611
|
+
|
|
612
|
+
ndenumerate = np.ndenumerate
|
|
613
|
+
|
|
614
|
+
|
|
615
|
+
def _mask_rowcols(a, axis):
|
|
616
|
+
a = asarray(a)
|
|
617
|
+
m = getmaskarray(a)
|
|
618
|
+
if m is nomask or a.ndim != 2:
|
|
619
|
+
return a
|
|
620
|
+
new = m | m.any(axis=axis, keepdims=True)
|
|
621
|
+
return MaskedArray(a.data, mask=new, fill_value=a.fill_value)
|
|
622
|
+
|
|
623
|
+
|
|
624
|
+
def mask_rows(a):
|
|
625
|
+
"""掩码整行(含掩码元素的行全部掩码,ma.mask_rows 兼容)。"""
|
|
626
|
+
return _mask_rowcols(a, 1)
|
|
627
|
+
|
|
628
|
+
|
|
629
|
+
def mask_cols(a):
|
|
630
|
+
"""掩码整列(含掩码元素的列全部掩码,ma.mask_cols 兼容)。"""
|
|
631
|
+
return _mask_rowcols(a, 0)
|
|
632
|
+
|
|
633
|
+
|
|
634
|
+
class _RowMaskedIndexer:
|
|
635
|
+
"""掩码版行索引器(ma.mr_ 兼容简化版:ogrid 语义 + 掩码包装)。"""
|
|
636
|
+
|
|
637
|
+
def __getitem__(self, key):
|
|
638
|
+
import rsarray as np
|
|
639
|
+
from .core import MaskedArray
|
|
640
|
+
if not isinstance(key, tuple):
|
|
641
|
+
key = (key,)
|
|
642
|
+
arrays = []
|
|
643
|
+
for k in key:
|
|
644
|
+
if isinstance(k, slice):
|
|
645
|
+
start, stop, step = k.indices(1 << 62)
|
|
646
|
+
# ogrid 语义:slice 需要可确定的长度;超大 stop 截断到 10^6
|
|
647
|
+
length = (stop - start + step - (1 if step > 0 else -1)) // step
|
|
648
|
+
if length > 10**6:
|
|
649
|
+
length = 10**6
|
|
650
|
+
stop = start + length * step
|
|
651
|
+
arrays.append(np.arange(start, stop, step))
|
|
652
|
+
else:
|
|
653
|
+
arrays.append(np.array([k]))
|
|
654
|
+
shape = tuple(a.shape[0] for a in arrays)
|
|
655
|
+
out = []
|
|
656
|
+
n = len(arrays)
|
|
657
|
+
for i, a in enumerate(arrays):
|
|
658
|
+
newshape = [1] * n
|
|
659
|
+
newshape[i] = a.shape[0]
|
|
660
|
+
out.append(MaskedArray(a.reshape(tuple(newshape))))
|
|
661
|
+
broadcast = np.broadcast_arrays(*[o.data for o in out])
|
|
662
|
+
return [MaskedArray(b) for b in broadcast]
|
|
663
|
+
|
|
664
|
+
|
|
665
|
+
mr_ = _RowMaskedIndexer()
|
|
666
|
+
|
|
667
|
+
|
|
668
|
+
def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
|
|
669
|
+
"""多项式拟合(掩码感知:只用双方都未掩码的点,ma.polyfit 兼容)。"""
|
|
670
|
+
import rsarray as np
|
|
671
|
+
x = asarray(x)
|
|
672
|
+
y = asarray(y)
|
|
673
|
+
mx = getmaskarray(x)
|
|
674
|
+
my = getmaskarray(y)
|
|
675
|
+
mask = mx if my is nomask else (my if mx is nomask else mask_or(mx, my))
|
|
676
|
+
if mask is not nomask:
|
|
677
|
+
pts = ~mask.reshape((-1,))
|
|
678
|
+
xv = x.data.reshape((-1,))[pts]
|
|
679
|
+
yv = y.data.reshape((-1,))[pts]
|
|
680
|
+
else:
|
|
681
|
+
xv, yv = x.data, y.data
|
|
682
|
+
if xv.size < deg + 1:
|
|
683
|
+
raise MAError(f"polyfit: not enough unmasked points ({xv.size} < {deg + 1})")
|
|
684
|
+
return np.polyfit(xv, yv, deg, rcond=rcond, full=full, w=w, cov=cov)
|
|
685
|
+
|
|
686
|
+
|
|
687
|
+
def _reexports():
|
|
688
|
+
d = {}
|
|
689
|
+
for n in ('ndindex',):
|
|
690
|
+
if hasattr(np, n):
|
|
691
|
+
d[n] = getattr(np, n)
|
|
692
|
+
return d
|
|
693
|
+
|
|
694
|
+
|
|
695
|
+
for _n, _v in _reexports().items():
|
|
696
|
+
globals()[_n] = _v
|
|
697
|
+
del _reexports, _n, _v
|
|
698
|
+
|
|
699
|
+
# 修正 ediff1d 的公共入口(保持 签名 ediff1d(a1, a2=None))
|
|
700
|
+
def ediff1d(a1, a2=None): # noqa: F811
|
|
701
|
+
return ediff1d_impl(a1, a2)
|
|
702
|
+
|
|
703
|
+
|
|
704
|
+
__all__ = ['apply_along_axis', 'apply_over_axes', 'atleast_1d', 'atleast_2d',
|
|
705
|
+
'atleast_3d', 'average', 'clump', 'clump_unmasked', 'compress_nd',
|
|
706
|
+
'compress_rowcols', 'corrcoef', 'cov', 'dot', 'ediff1d',
|
|
707
|
+
'flatnotmasked_contiguous', 'in1d', 'intersect1d', 'isin',
|
|
708
|
+
'masked_all', 'masked_all_like', 'mask_rowcols', 'median',
|
|
709
|
+
'ndenumerate', 'ndindex', 'notmasked_contiguous',
|
|
710
|
+
'notmasked_edges', 'setdiff1d', 'setxor1d', 'stack', 'union1d',
|
|
711
|
+
'unique', 'unwrap', 'vstack', 'diagflat']
|