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
|
@@ -0,0 +1,721 @@
|
|
|
1
|
+
# SPDX-License-Identifier: MIT
|
|
2
|
+
"""多项式旧 API 移植(与 2.x lib/_polynomial_impl.py 行为对齐)。
|
|
3
|
+
|
|
4
|
+
包含 poly / roots / polyint / polyder / polyfit / polyval / polyadd /
|
|
5
|
+
polysub / polymul / polydiv / poly1d,覆盖官方 TestPolynomial 语义:
|
|
6
|
+
poly1d 的 str/repr 对齐排版(_raise_power)、power 索引的 __getitem__/
|
|
7
|
+
__setitem__、p/q 返回 (商, 余数) 元组、polyfit 的 cov 参数、roots 的
|
|
8
|
+
dtype 保持(float32 输入 → float32 根)。
|
|
9
|
+
"""
|
|
10
|
+
import re as _re
|
|
11
|
+
import warnings as _py_warnings
|
|
12
|
+
|
|
13
|
+
|
|
14
|
+
def _NX():
|
|
15
|
+
import rsarray
|
|
16
|
+
return rsarray
|
|
17
|
+
|
|
18
|
+
|
|
19
|
+
class RankWarning(UserWarning):
|
|
20
|
+
"""polyfit 秩不足(病态拟合)告警,对应 exceptions.RankWarning。"""
|
|
21
|
+
|
|
22
|
+
|
|
23
|
+
def _isscalar(x):
|
|
24
|
+
"""isscalar 语义:0-d 数组/Python 标量/标量对象视为标量。"""
|
|
25
|
+
if hasattr(x, 'ndim'):
|
|
26
|
+
return getattr(x, 'ndim', 1) == 0
|
|
27
|
+
return isinstance(x, (int, float, complex, bool))
|
|
28
|
+
|
|
29
|
+
|
|
30
|
+
def _mintypecode(typechars, typeset='GDFgdf', default='d'):
|
|
31
|
+
"""最小可容纳类型字符(mintypecode 的 typeset='GDFgdf' 子集语义)。
|
|
32
|
+
|
|
33
|
+
输入字符全部在 typeset 内 → 返回其中尺寸最大者(容器须容纳全部);
|
|
34
|
+
有字符不在 typeset 内(int/bool 等)→ 安全回落到 default。
|
|
35
|
+
"""
|
|
36
|
+
if isinstance(typechars, str):
|
|
37
|
+
chars = list(typechars)
|
|
38
|
+
else:
|
|
39
|
+
chars = [c for c in typechars]
|
|
40
|
+
in_set = [c for c in chars if c in typeset]
|
|
41
|
+
if len(in_set) != len(chars):
|
|
42
|
+
return default
|
|
43
|
+
size = {'f': 4, 'd': 8, 'g': 16, 'F': 8, 'D': 16, 'G': 32}
|
|
44
|
+
return max(in_set, key=lambda c: size[c])
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def _to_real_if_imag_zero(w, t_dtype):
|
|
48
|
+
"""实输入矩阵的特征值若虚部全零 → 转实(向后兼容语义)。"""
|
|
49
|
+
k = getattr(t_dtype, 'kind', 'f')
|
|
50
|
+
if k != 'c' and hasattr(w, 'imag'):
|
|
51
|
+
im = w.imag
|
|
52
|
+
vals = im.tolist() if hasattr(im, 'tolist') else [im]
|
|
53
|
+
if all(v == 0 for v in vals):
|
|
54
|
+
return w.real
|
|
55
|
+
return w
|
|
56
|
+
|
|
57
|
+
|
|
58
|
+
def _convolve_full(a_list, b_list, dtype=None):
|
|
59
|
+
"""1-d 满卷积(纯 Python,N 小;等价 np.convolve(mode='full'))。"""
|
|
60
|
+
NX = _NX()
|
|
61
|
+
out = [0] * (len(a_list) + len(b_list) - 1)
|
|
62
|
+
for i, ai in enumerate(a_list):
|
|
63
|
+
for j, bj in enumerate(b_list):
|
|
64
|
+
out[i + j] += ai * bj
|
|
65
|
+
if dtype is not None:
|
|
66
|
+
return NX.array(out, dtype=dtype)
|
|
67
|
+
return NX.array(out)
|
|
68
|
+
|
|
69
|
+
|
|
70
|
+
def _conjugates_match(roots_list):
|
|
71
|
+
"""复根序列是否全部成共轭对(此时系数为实,poly 语义)。"""
|
|
72
|
+
cs = sorted((complex(z) for z in roots_list),
|
|
73
|
+
key=lambda z: (z.real, z.imag))
|
|
74
|
+
cj = sorted((z.conjugate() for z in cs),
|
|
75
|
+
key=lambda z: (z.real, z.imag))
|
|
76
|
+
return all(a == b for a, b in zip(cs, cj))
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
def poly(seq_of_zeros):
|
|
80
|
+
"""由根序列(或方阵)返回多项式系数(按幂次降序,首项恒为 1)。"""
|
|
81
|
+
NX = _NX()
|
|
82
|
+
seq = NX.atleast_1d(seq_of_zeros)
|
|
83
|
+
sh = seq.shape
|
|
84
|
+
if len(sh) == 2 and sh[0] == sh[1] and sh[0] != 0:
|
|
85
|
+
seq = NX.linalg.eigvals(seq)
|
|
86
|
+
elif len(sh) == 1:
|
|
87
|
+
dt = seq.dtype
|
|
88
|
+
if dt.type is not NX.object_:
|
|
89
|
+
seq = seq.astype(_mintypecode(dt.char))
|
|
90
|
+
else:
|
|
91
|
+
raise ValueError("input must be 1d or non-empty square 2d array.")
|
|
92
|
+
if len(seq) == 0:
|
|
93
|
+
return 1.0
|
|
94
|
+
dt = seq.dtype
|
|
95
|
+
a = NX.ones((1,), dtype=dt)
|
|
96
|
+
for zero in seq:
|
|
97
|
+
a = _convolve_full(a.tolist(), [1, -zero], dtype=dt)
|
|
98
|
+
if issubclass(dt.type, NX.complexfloating):
|
|
99
|
+
# 复根全为共轭对 → 系数为实
|
|
100
|
+
if _conjugates_match(seq.tolist()):
|
|
101
|
+
a = a.real.copy()
|
|
102
|
+
return a
|
|
103
|
+
|
|
104
|
+
|
|
105
|
+
def roots(p):
|
|
106
|
+
"""返回多项式的根(系数按幂次降序;伴随矩阵特征值法)。"""
|
|
107
|
+
NX = _NX()
|
|
108
|
+
p = NX.atleast_1d(p)
|
|
109
|
+
if p.ndim != 1:
|
|
110
|
+
raise ValueError("Input must be a rank-1 array.")
|
|
111
|
+
non_zero = NX.nonzero(NX.ravel(p))[0]
|
|
112
|
+
if len(non_zero) == 0:
|
|
113
|
+
return NX.array([])
|
|
114
|
+
trailing_zeros = len(p) - int(non_zero[-1]) - 1
|
|
115
|
+
p = p[int(non_zero[0]):int(non_zero[-1]) + 1]
|
|
116
|
+
# 非浮点输入 → 转浮点(int → float64)
|
|
117
|
+
if not issubclass(p.dtype.type, (NX.floating, NX.complexfloating)):
|
|
118
|
+
p = p.astype(float)
|
|
119
|
+
# 伴随矩阵 + 纯 Python 复 QR(rsarray linalg.eigvals 复特征值精度不足)
|
|
120
|
+
p_list = p.tolist()
|
|
121
|
+
while len(p_list) > 1 and p_list[0] == 0:
|
|
122
|
+
p_list = p_list[1:]
|
|
123
|
+
# 系数含 NaN:伴矩阵特征值未定义,与标准语义一致抛 LinAlgError
|
|
124
|
+
import math
|
|
125
|
+
def _has_nan(v):
|
|
126
|
+
try:
|
|
127
|
+
return math.isnan(float(v))
|
|
128
|
+
except (TypeError, ValueError, OverflowError):
|
|
129
|
+
return False
|
|
130
|
+
if any(_has_nan(v) for v in p_list):
|
|
131
|
+
import rsarray as _np
|
|
132
|
+
raise _np.linalg.LinAlgError(
|
|
133
|
+
"Eigenvalues did not converge: coefficients contain NaN")
|
|
134
|
+
deg = len(p_list) - 1
|
|
135
|
+
if deg == 0:
|
|
136
|
+
r_list = []
|
|
137
|
+
elif deg == 1:
|
|
138
|
+
r_list = [-complex(p_list[1]) / complex(p_list[0])]
|
|
139
|
+
else:
|
|
140
|
+
c0 = complex(p_list[0])
|
|
141
|
+
M = [[0j] * deg for _ in range(deg)]
|
|
142
|
+
for j in range(deg):
|
|
143
|
+
M[0][j] = -complex(p_list[j + 1]) / c0
|
|
144
|
+
for i in range(1, deg):
|
|
145
|
+
M[i][i - 1] = 1 + 0j
|
|
146
|
+
r_list = _eigvals_qr(M)
|
|
147
|
+
# 实输入且根虚部全 ~0 → 实数组(保持输入 dtype);否则复数
|
|
148
|
+
if p.dtype.kind != 'c':
|
|
149
|
+
if r_list and all(abs(z.imag) <= 1e-9 * max(1.0, abs(z.real))
|
|
150
|
+
for z in r_list):
|
|
151
|
+
r = NX.array([z.real for z in r_list], dtype=p.dtype)
|
|
152
|
+
else:
|
|
153
|
+
r = NX.array([complex(z) for z in r_list])
|
|
154
|
+
else:
|
|
155
|
+
r = NX.array([complex(z) for z in r_list], dtype=p.dtype)
|
|
156
|
+
if trailing_zeros:
|
|
157
|
+
z = NX.zeros(trailing_zeros, r.dtype if len(r) else p.dtype)
|
|
158
|
+
r = NX.hstack((r, z))
|
|
159
|
+
return r
|
|
160
|
+
|
|
161
|
+
|
|
162
|
+
def polyint(p, m=1, k=None):
|
|
163
|
+
"""返回多项式的 m 阶不定积分(常数 k,默认 0)。"""
|
|
164
|
+
NX = _NX()
|
|
165
|
+
m = int(m)
|
|
166
|
+
if m < 0:
|
|
167
|
+
raise ValueError("Order of integral must be positive (see polyder)")
|
|
168
|
+
if k is None:
|
|
169
|
+
k = NX.zeros(m, float)
|
|
170
|
+
k = NX.atleast_1d(k)
|
|
171
|
+
if len(k) == 1 and m > 1:
|
|
172
|
+
k = k[0] * NX.ones(m, float)
|
|
173
|
+
if len(k) < m:
|
|
174
|
+
raise ValueError(
|
|
175
|
+
"k must be a scalar or a rank-1 array of length 1 or >m.")
|
|
176
|
+
truepoly = isinstance(p, poly1d)
|
|
177
|
+
p = NX.asarray(p)
|
|
178
|
+
if m == 0:
|
|
179
|
+
return poly1d(p) if truepoly else p
|
|
180
|
+
# 整数/对象数组也须工作:真除法产生浮点
|
|
181
|
+
y = NX.concatenate((p / NX.arange(len(p), 0, -1),
|
|
182
|
+
NX.array([k[0]])))
|
|
183
|
+
val = polyint(y, m - 1, k=k[1:])
|
|
184
|
+
return poly1d(val) if truepoly else val
|
|
185
|
+
|
|
186
|
+
|
|
187
|
+
def polyder(p, m=1):
|
|
188
|
+
"""返回多项式的 m 阶导数。"""
|
|
189
|
+
NX = _NX()
|
|
190
|
+
m = int(m)
|
|
191
|
+
if m < 0:
|
|
192
|
+
raise ValueError("Order of derivative must be positive (see polyint)")
|
|
193
|
+
truepoly = isinstance(p, poly1d)
|
|
194
|
+
p = NX.asarray(p)
|
|
195
|
+
n = len(p) - 1
|
|
196
|
+
y = p[:-1] * NX.arange(n, 0, -1)
|
|
197
|
+
if m == 0:
|
|
198
|
+
val = p
|
|
199
|
+
else:
|
|
200
|
+
val = polyder(y, m - 1)
|
|
201
|
+
return poly1d(val) if truepoly else val
|
|
202
|
+
|
|
203
|
+
|
|
204
|
+
def polyfit(x, y, deg, rcond=None, full=False, w=None, cov=False):
|
|
205
|
+
"""最小二乘多项式拟合(支持 full 诊断与 cov 协方差矩阵)。"""
|
|
206
|
+
NX = _NX()
|
|
207
|
+
order = int(deg) + 1
|
|
208
|
+
x = NX.asarray(x) + 0.0
|
|
209
|
+
y = NX.asarray(y) + 0.0
|
|
210
|
+
if deg < 0:
|
|
211
|
+
raise ValueError("expected deg >= 0")
|
|
212
|
+
if x.ndim != 1:
|
|
213
|
+
raise TypeError("expected 1D vector for x")
|
|
214
|
+
if x.size == 0:
|
|
215
|
+
raise TypeError("expected non-empty vector for x")
|
|
216
|
+
if y.ndim < 1 or y.ndim > 2:
|
|
217
|
+
raise TypeError("expected 1D or 2D array for y")
|
|
218
|
+
if x.shape[0] != y.shape[0]:
|
|
219
|
+
raise TypeError("expected x and y to have same length")
|
|
220
|
+
if rcond is None:
|
|
221
|
+
rcond = len(x) * NX.finfo(x.dtype).eps
|
|
222
|
+
lhs = NX.vander(x, order)
|
|
223
|
+
rhs = y
|
|
224
|
+
if w is not None:
|
|
225
|
+
w = NX.asarray(w) + 0.0
|
|
226
|
+
if w.ndim != 1:
|
|
227
|
+
raise TypeError("expected a 1-d array for weights")
|
|
228
|
+
if w.shape[0] != y.shape[0]:
|
|
229
|
+
raise TypeError("expected w and y to have the same length")
|
|
230
|
+
lhs = lhs * w[:, NX.newaxis]
|
|
231
|
+
if rhs.ndim == 2:
|
|
232
|
+
rhs = rhs * w[:, NX.newaxis]
|
|
233
|
+
else:
|
|
234
|
+
rhs = rhs * w
|
|
235
|
+
# 按列缩放改善条件数
|
|
236
|
+
scale = NX.sqrt((lhs * lhs).sum(axis=0))
|
|
237
|
+
lhs = lhs / scale
|
|
238
|
+
c, resids, rank, s = NX.linalg.lstsq(lhs, rhs, rcond)
|
|
239
|
+
c = (c.T / scale).T
|
|
240
|
+
if rank != order and not full:
|
|
241
|
+
_py_warnings.warn("Polyfit may be poorly conditioned",
|
|
242
|
+
RankWarning, stacklevel=2)
|
|
243
|
+
if full:
|
|
244
|
+
return c, resids, rank, s, rcond
|
|
245
|
+
elif cov:
|
|
246
|
+
Vbase = _inv_square(NX.dot(lhs.T, lhs))
|
|
247
|
+
Vbase = Vbase / NX.outer(scale, scale)
|
|
248
|
+
if cov == "unscaled":
|
|
249
|
+
fac = 1
|
|
250
|
+
else:
|
|
251
|
+
if len(x) <= order:
|
|
252
|
+
raise ValueError("the number of data points must exceed "
|
|
253
|
+
"order to scale the covariance matrix")
|
|
254
|
+
fac = resids / (len(x) - order)
|
|
255
|
+
if y.ndim == 1:
|
|
256
|
+
return c, Vbase * fac
|
|
257
|
+
return c, Vbase[:, :, NX.newaxis] * fac
|
|
258
|
+
return c
|
|
259
|
+
|
|
260
|
+
|
|
261
|
+
def polyval(p, x):
|
|
262
|
+
"""Horner 法求值;x 为 poly1d 时返回复合多项式。
|
|
263
|
+
MaskedArray 输入时结果恢复掩码(数组语义)。"""
|
|
264
|
+
NX = _NX()
|
|
265
|
+
p = NX.asarray(p)
|
|
266
|
+
_mask = None
|
|
267
|
+
if isinstance(x, poly1d):
|
|
268
|
+
y = 0
|
|
269
|
+
else:
|
|
270
|
+
_m = getattr(x, '_mask', None)
|
|
271
|
+
if _m is not None and _m is not False:
|
|
272
|
+
_mask = NX.asarray(_m)
|
|
273
|
+
x = NX.asanyarray(x)
|
|
274
|
+
y = NX.zeros_like(x)
|
|
275
|
+
for pv in p:
|
|
276
|
+
y = y * x + pv
|
|
277
|
+
if _mask is not None:
|
|
278
|
+
return NX.ma.array(y, mask=_mask)
|
|
279
|
+
# ndarray 子类输入:结果保留子类(数组语义)
|
|
280
|
+
try:
|
|
281
|
+
if type(x) is not NX.ndarray and isinstance(x, NX.ndarray):
|
|
282
|
+
y = y.view(type(x))
|
|
283
|
+
except Exception:
|
|
284
|
+
pass
|
|
285
|
+
return y
|
|
286
|
+
|
|
287
|
+
|
|
288
|
+
def _inv_square(a):
|
|
289
|
+
"""N×N 逆矩阵(高斯消元 + 部分选主元;rsarray linalg.inv 仅 2x2/3x3)。"""
|
|
290
|
+
NX = _NX()
|
|
291
|
+
n = len(a)
|
|
292
|
+
M = [list(row) for row in a.tolist()]
|
|
293
|
+
I = [[1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
|
|
294
|
+
for col in range(n):
|
|
295
|
+
piv = max(range(col, n), key=lambda r: abs(M[r][col]))
|
|
296
|
+
if abs(M[piv][col]) < 1e-300:
|
|
297
|
+
raise ValueError("Singular matrix in polyfit covariance.")
|
|
298
|
+
if piv != col:
|
|
299
|
+
M[col], M[piv] = M[piv], M[col]
|
|
300
|
+
I[col], I[piv] = I[piv], I[col]
|
|
301
|
+
d = M[col][col]
|
|
302
|
+
M[col] = [v / d for v in M[col]]
|
|
303
|
+
I[col] = [v / d for v in I[col]]
|
|
304
|
+
for r2 in range(n):
|
|
305
|
+
if r2 != col:
|
|
306
|
+
f = M[r2][col]
|
|
307
|
+
if f != 0:
|
|
308
|
+
M[r2] = [v - f * u for v, u in zip(M[r2], M[col])]
|
|
309
|
+
I[r2] = [v - f * u for v, u in zip(I[r2], I[col])]
|
|
310
|
+
return NX.array(I)
|
|
311
|
+
|
|
312
|
+
|
|
313
|
+
def _cvec_norm(v):
|
|
314
|
+
"""复向量 2-范数。"""
|
|
315
|
+
s = 0.0
|
|
316
|
+
for z in v:
|
|
317
|
+
s += z.real * z.real + z.imag * z.imag
|
|
318
|
+
return s ** 0.5
|
|
319
|
+
|
|
320
|
+
|
|
321
|
+
def _qr_decomp(A):
|
|
322
|
+
"""n×n 复矩阵 QR 分解(修正 Gram-Schmidt;n 小)。"""
|
|
323
|
+
n = len(A)
|
|
324
|
+
Q = [[0j] * n for _ in range(n)]
|
|
325
|
+
R = [[0j] * n for _ in range(n)]
|
|
326
|
+
for j in range(n):
|
|
327
|
+
v = [complex(A[i][j]) for i in range(n)]
|
|
328
|
+
for k in range(j):
|
|
329
|
+
rq = 0j
|
|
330
|
+
for i in range(n):
|
|
331
|
+
rq += Q[i][k].conjugate() * v[i]
|
|
332
|
+
R[k][j] = rq
|
|
333
|
+
for i in range(n):
|
|
334
|
+
v[i] -= Q[i][k] * rq
|
|
335
|
+
norm = _cvec_norm(v)
|
|
336
|
+
R[j][j] = norm
|
|
337
|
+
if norm > 0:
|
|
338
|
+
for i in range(n):
|
|
339
|
+
Q[i][j] = v[i] / norm
|
|
340
|
+
return Q, R
|
|
341
|
+
|
|
342
|
+
|
|
343
|
+
def _matmul(A, B):
|
|
344
|
+
n = len(A)
|
|
345
|
+
p = len(B)
|
|
346
|
+
m = len(B[0])
|
|
347
|
+
return [[sum(A[i][k] * B[k][j] for k in range(p)) for j in range(m)]
|
|
348
|
+
for i in range(n)]
|
|
349
|
+
|
|
350
|
+
|
|
351
|
+
def _eigvals_qr(M0, maxiter=3000):
|
|
352
|
+
"""n×n 矩阵特征值(复 QR + Rayleigh 移位 + 逐层消减;2×2 闭式解)。"""
|
|
353
|
+
import cmath as _cmath
|
|
354
|
+
n = len(M0)
|
|
355
|
+
M = [[complex(v) for v in row] for row in M0]
|
|
356
|
+
eig = []
|
|
357
|
+
size = n
|
|
358
|
+
while size > 2:
|
|
359
|
+
converged = None
|
|
360
|
+
for _it in range(maxiter):
|
|
361
|
+
mu = M[size - 1][size - 1]
|
|
362
|
+
A = [[M[i][j] - (mu if i == j else 0j) for j in range(size)]
|
|
363
|
+
for i in range(size)]
|
|
364
|
+
Q, R = _qr_decomp(A)
|
|
365
|
+
RQ = _matmul(R, Q)
|
|
366
|
+
for i in range(size):
|
|
367
|
+
for j in range(size):
|
|
368
|
+
M[i][j] = RQ[i][j] + (mu if i == j else 0j)
|
|
369
|
+
scale = max(abs(M[size - 2][size - 2]),
|
|
370
|
+
abs(M[size - 1][size - 1]), 1e-300)
|
|
371
|
+
if abs(M[size - 1][size - 2]) < 1e-13 * scale:
|
|
372
|
+
converged = M[size - 1][size - 1]
|
|
373
|
+
break
|
|
374
|
+
eig.append(converged if converged is not None
|
|
375
|
+
else M[size - 1][size - 1])
|
|
376
|
+
size -= 1
|
|
377
|
+
if size == 2:
|
|
378
|
+
a, b = M[0][0], M[0][1]
|
|
379
|
+
c, d = M[1][0], M[1][1]
|
|
380
|
+
tr = a + d
|
|
381
|
+
s = _cmath.sqrt(tr * tr - 4 * (a * d - b * c))
|
|
382
|
+
eig.append((tr + s) / 2)
|
|
383
|
+
eig.append((tr - s) / 2)
|
|
384
|
+
else:
|
|
385
|
+
eig.append(M[0][0])
|
|
386
|
+
return eig
|
|
387
|
+
|
|
388
|
+
|
|
389
|
+
def polyadd(a1, a2):
|
|
390
|
+
"""两个多项式相加(任一为 poly1d → 结果 poly1d)。"""
|
|
391
|
+
NX = _NX()
|
|
392
|
+
truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))
|
|
393
|
+
a1 = NX.atleast_1d(a1)
|
|
394
|
+
a2 = NX.atleast_1d(a2)
|
|
395
|
+
diff = len(a2) - len(a1)
|
|
396
|
+
if diff == 0:
|
|
397
|
+
val = a1 + a2
|
|
398
|
+
elif diff > 0:
|
|
399
|
+
zr = NX.zeros(diff, a1.dtype)
|
|
400
|
+
val = NX.concatenate((zr, a1)) + a2
|
|
401
|
+
else:
|
|
402
|
+
zr = NX.zeros(abs(diff), a2.dtype)
|
|
403
|
+
val = a1 + NX.concatenate((zr, a2))
|
|
404
|
+
return poly1d(val) if truepoly else val
|
|
405
|
+
|
|
406
|
+
|
|
407
|
+
def polysub(a1, a2):
|
|
408
|
+
"""两个多项式相减(任一为 poly1d → 结果 poly1d)。"""
|
|
409
|
+
NX = _NX()
|
|
410
|
+
truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))
|
|
411
|
+
a1 = NX.atleast_1d(a1)
|
|
412
|
+
a2 = NX.atleast_1d(a2)
|
|
413
|
+
diff = len(a2) - len(a1)
|
|
414
|
+
if diff == 0:
|
|
415
|
+
val = a1 - a2
|
|
416
|
+
elif diff > 0:
|
|
417
|
+
zr = NX.zeros(diff, a1.dtype)
|
|
418
|
+
val = NX.concatenate((zr, a1)) - a2
|
|
419
|
+
else:
|
|
420
|
+
zr = NX.zeros(abs(diff), a2.dtype)
|
|
421
|
+
val = a1 - NX.concatenate((zr, a2))
|
|
422
|
+
return poly1d(val) if truepoly else val
|
|
423
|
+
|
|
424
|
+
|
|
425
|
+
def polymul(a1, a2):
|
|
426
|
+
"""两个多项式相乘(满卷积;任一为 poly1d → 结果 poly1d)。"""
|
|
427
|
+
NX = _NX()
|
|
428
|
+
truepoly = (isinstance(a1, poly1d) or isinstance(a2, poly1d))
|
|
429
|
+
a1, a2 = poly1d(a1), poly1d(a2)
|
|
430
|
+
val = _convolve_full(a1.coeffs.tolist(), a2.coeffs.tolist())
|
|
431
|
+
return poly1d(val) if truepoly else val
|
|
432
|
+
|
|
433
|
+
|
|
434
|
+
def polydiv(u, v):
|
|
435
|
+
"""多项式相除,返回 (商, 余数)(任一为 poly1d → 均为 poly1d)。"""
|
|
436
|
+
NX = _NX()
|
|
437
|
+
truepoly = (isinstance(u, poly1d) or isinstance(v, poly1d))
|
|
438
|
+
u = NX.atleast_1d(u) + 0.0
|
|
439
|
+
v = NX.atleast_1d(v) + 0.0
|
|
440
|
+
# w 承载公共类型
|
|
441
|
+
w = u[0] + v[0]
|
|
442
|
+
m = len(u) - 1
|
|
443
|
+
n = len(v) - 1
|
|
444
|
+
scale = 1. / v[0]
|
|
445
|
+
q = NX.zeros((max(m - n + 1, 1),), w.dtype)
|
|
446
|
+
r = u.astype(w.dtype)
|
|
447
|
+
for k in range(m - n + 1):
|
|
448
|
+
d = scale * r[k]
|
|
449
|
+
q[k] = d
|
|
450
|
+
r[k:k + n + 1] = r[k:k + n + 1] - d * v
|
|
451
|
+
while NX.allclose(r[0], 0, rtol=1e-14) and (r.shape[-1] > 1):
|
|
452
|
+
r = r[1:]
|
|
453
|
+
if truepoly:
|
|
454
|
+
return poly1d(q), poly1d(r)
|
|
455
|
+
return q, r
|
|
456
|
+
|
|
457
|
+
|
|
458
|
+
_poly_mat = _re.compile(r"\*\*([0-9]*)")
|
|
459
|
+
|
|
460
|
+
|
|
461
|
+
def _raise_power(astr, wrap=70):
|
|
462
|
+
"""poly1d 对齐排版:把 "c x**p" 拆成两行(指数行 + 系数行)。"""
|
|
463
|
+
n = 0
|
|
464
|
+
line1 = ''
|
|
465
|
+
line2 = ''
|
|
466
|
+
output = ' '
|
|
467
|
+
while True:
|
|
468
|
+
mat = _poly_mat.search(astr, n)
|
|
469
|
+
if mat is None:
|
|
470
|
+
break
|
|
471
|
+
span = mat.span()
|
|
472
|
+
power = mat.groups()[0]
|
|
473
|
+
partstr = astr[n:span[0]]
|
|
474
|
+
n = span[1]
|
|
475
|
+
toadd2 = partstr + ' ' * (len(power) - 1)
|
|
476
|
+
toadd1 = ' ' * (len(partstr) - 1) + power
|
|
477
|
+
if ((len(line2) + len(toadd2) > wrap)
|
|
478
|
+
or (len(line1) + len(toadd1) > wrap)):
|
|
479
|
+
output += line1 + "\n" + line2 + "\n "
|
|
480
|
+
line1 = toadd1
|
|
481
|
+
line2 = toadd2
|
|
482
|
+
else:
|
|
483
|
+
line2 += partstr + ' ' * (len(power) - 1)
|
|
484
|
+
line1 += ' ' * (len(partstr) - 1) + power
|
|
485
|
+
output += line1 + "\n" + line2
|
|
486
|
+
return output + astr[n:]
|
|
487
|
+
|
|
488
|
+
|
|
489
|
+
def _coef_parts(coeff):
|
|
490
|
+
"""系数 → (是否复数非零虚部, 实部, 虚部)(str 格式化用)。"""
|
|
491
|
+
v = coeff.tolist() if hasattr(coeff, 'tolist') else coeff
|
|
492
|
+
if isinstance(v, complex):
|
|
493
|
+
if v.imag == 0:
|
|
494
|
+
return False, v.real, 0.0
|
|
495
|
+
return True, v.real, v.imag
|
|
496
|
+
return False, float(v), 0.0
|
|
497
|
+
|
|
498
|
+
|
|
499
|
+
class poly1d:
|
|
500
|
+
"""一维多项式类(兼容 poly1d 接口:power 索引、str 对齐排版、
|
|
501
|
+
p/q 返回 (商, 余数) 元组、可变系数 c)。"""
|
|
502
|
+
|
|
503
|
+
__hash__ = None
|
|
504
|
+
|
|
505
|
+
@property
|
|
506
|
+
def coeffs(self):
|
|
507
|
+
return self._coeffs
|
|
508
|
+
|
|
509
|
+
@coeffs.setter
|
|
510
|
+
def coeffs(self, value):
|
|
511
|
+
# 中 p.coeffs 是自身缓冲区视图:+= 就地(无 setter),
|
|
512
|
+
# setattr 整体替换 → AttributeError。rsarray 算术恒产生新对象,
|
|
513
|
+
# 以 shape 区分:与现系数同 shape 视为 += / *= 类运算结果,接受;
|
|
514
|
+
# 异 shape 整体替换 → AttributeError。
|
|
515
|
+
NX = _NX()
|
|
516
|
+
arr = value if hasattr(value, '_array') else NX.asarray(value)
|
|
517
|
+
if tuple(arr.shape) == tuple(self._coeffs.shape):
|
|
518
|
+
self._coeffs = arr
|
|
519
|
+
else:
|
|
520
|
+
raise AttributeError("Cannot set attribute")
|
|
521
|
+
|
|
522
|
+
@property
|
|
523
|
+
def variable(self):
|
|
524
|
+
return self._variable
|
|
525
|
+
|
|
526
|
+
@property
|
|
527
|
+
def order(self):
|
|
528
|
+
return len(self._coeffs) - 1
|
|
529
|
+
|
|
530
|
+
@property
|
|
531
|
+
def roots(self):
|
|
532
|
+
return roots(self._coeffs)
|
|
533
|
+
|
|
534
|
+
c = coef = coefficients = coeffs
|
|
535
|
+
r = roots
|
|
536
|
+
o = order
|
|
537
|
+
|
|
538
|
+
def __init__(self, c_or_r, r=False, variable=None):
|
|
539
|
+
if isinstance(c_or_r, poly1d):
|
|
540
|
+
self._variable = c_or_r._variable
|
|
541
|
+
self._coeffs = c_or_r._coeffs
|
|
542
|
+
if variable is not None:
|
|
543
|
+
self._variable = variable
|
|
544
|
+
return
|
|
545
|
+
NX = _NX()
|
|
546
|
+
if r:
|
|
547
|
+
c_or_r = poly(c_or_r)
|
|
548
|
+
c_or_r = NX.atleast_1d(c_or_r)
|
|
549
|
+
if c_or_r.ndim > 1:
|
|
550
|
+
raise ValueError("Polynomial must be 1d only.")
|
|
551
|
+
_dt = c_or_r.dtype # trim 后空数组 dtype 可能丢失
|
|
552
|
+
c_or_r = NX.trim_zeros(c_or_r, trim='f')
|
|
553
|
+
if len(c_or_r) == 0:
|
|
554
|
+
c_or_r = NX.array([0], dtype=_dt)
|
|
555
|
+
self._coeffs = c_or_r
|
|
556
|
+
self._variable = 'x' if variable is None else variable
|
|
557
|
+
|
|
558
|
+
def __array__(self, t=None, copy=None):
|
|
559
|
+
# rsarray asarray 无 copy 关键字:copy=None 语义 = 按需转换
|
|
560
|
+
NX = _NX()
|
|
561
|
+
if t:
|
|
562
|
+
return NX.asarray(self.coeffs, t)
|
|
563
|
+
return NX.asarray(self.coeffs)
|
|
564
|
+
|
|
565
|
+
def __repr__(self):
|
|
566
|
+
vals = repr(self.coeffs)
|
|
567
|
+
# rsarray 数组 repr 为 "array([...])",与 同款切片
|
|
568
|
+
if vals.startswith('array(') and vals.endswith(')'):
|
|
569
|
+
vals = vals[6:-1]
|
|
570
|
+
return f"poly1d({vals})"
|
|
571
|
+
|
|
572
|
+
def __len__(self):
|
|
573
|
+
return self.order
|
|
574
|
+
|
|
575
|
+
def __str__(self):
|
|
576
|
+
NX = _NX()
|
|
577
|
+
thestr = "0"
|
|
578
|
+
var = self.variable
|
|
579
|
+
# 移除前导零(首个非零系数起);object 数组用 Python 逐元素比较
|
|
580
|
+
full = self.coeffs
|
|
581
|
+
if getattr(full.dtype, 'kind', 'f') == 'O':
|
|
582
|
+
nz_list = [c != 0 for c in full.tolist()]
|
|
583
|
+
else:
|
|
584
|
+
nz_list = (full != 0).tolist()
|
|
585
|
+
idx = next((i for i, v in enumerate(nz_list) if v), len(nz_list))
|
|
586
|
+
coeffs = full[idx:]
|
|
587
|
+
N = len(coeffs) - 1
|
|
588
|
+
|
|
589
|
+
def fmt_float(q):
|
|
590
|
+
s = f'{q:.4g}'
|
|
591
|
+
s = s.removesuffix('.0000')
|
|
592
|
+
return s
|
|
593
|
+
|
|
594
|
+
for k, coeff in enumerate(coeffs):
|
|
595
|
+
is_c, re_, im_ = _coef_parts(coeff)
|
|
596
|
+
if not is_c:
|
|
597
|
+
coefstr = fmt_float(re_)
|
|
598
|
+
elif re_ == 0:
|
|
599
|
+
coefstr = f'{fmt_float(im_)}j'
|
|
600
|
+
else:
|
|
601
|
+
coefstr = f'({fmt_float(re_)} + {fmt_float(im_)}j)'
|
|
602
|
+
power = (N - k)
|
|
603
|
+
if power == 0:
|
|
604
|
+
if coefstr != '0':
|
|
605
|
+
newstr = f'{coefstr}'
|
|
606
|
+
elif k == 0:
|
|
607
|
+
newstr = '0'
|
|
608
|
+
else:
|
|
609
|
+
newstr = ''
|
|
610
|
+
elif power == 1:
|
|
611
|
+
if coefstr == '0':
|
|
612
|
+
newstr = ''
|
|
613
|
+
else:
|
|
614
|
+
newstr = f'{coefstr} {var}'
|
|
615
|
+
elif coefstr == '0':
|
|
616
|
+
newstr = ''
|
|
617
|
+
else:
|
|
618
|
+
newstr = f'{coefstr} {var}**{power}'
|
|
619
|
+
if k > 0:
|
|
620
|
+
if newstr != '':
|
|
621
|
+
if newstr.startswith('-'):
|
|
622
|
+
thestr = f"{thestr} - {newstr[1:]}"
|
|
623
|
+
else:
|
|
624
|
+
thestr = f"{thestr} + {newstr}"
|
|
625
|
+
else:
|
|
626
|
+
thestr = newstr
|
|
627
|
+
return _raise_power(thestr)
|
|
628
|
+
|
|
629
|
+
def __call__(self, val):
|
|
630
|
+
return polyval(self.coeffs, val)
|
|
631
|
+
|
|
632
|
+
def __neg__(self):
|
|
633
|
+
return poly1d(-self.coeffs)
|
|
634
|
+
|
|
635
|
+
def __pos__(self):
|
|
636
|
+
return self
|
|
637
|
+
|
|
638
|
+
def __mul__(self, other):
|
|
639
|
+
if _isscalar(other):
|
|
640
|
+
return poly1d(self.coeffs * other)
|
|
641
|
+
other = poly1d(other)
|
|
642
|
+
return poly1d(polymul(self.coeffs, other.coeffs))
|
|
643
|
+
|
|
644
|
+
def __rmul__(self, other):
|
|
645
|
+
if _isscalar(other):
|
|
646
|
+
return poly1d(other * self.coeffs)
|
|
647
|
+
other = poly1d(other)
|
|
648
|
+
return poly1d(polymul(self.coeffs, other.coeffs))
|
|
649
|
+
|
|
650
|
+
def __add__(self, other):
|
|
651
|
+
return poly1d(polyadd(self.coeffs, poly1d(other).coeffs))
|
|
652
|
+
|
|
653
|
+
def __radd__(self, other):
|
|
654
|
+
return poly1d(polyadd(self.coeffs, poly1d(other).coeffs))
|
|
655
|
+
|
|
656
|
+
def __pow__(self, val):
|
|
657
|
+
if not _isscalar(val) or int(val) != val or val < 0:
|
|
658
|
+
raise ValueError("Power to non-negative integers only.")
|
|
659
|
+
res = [1]
|
|
660
|
+
for _ in range(val):
|
|
661
|
+
res = polymul(self.coeffs, res)
|
|
662
|
+
return poly1d(res)
|
|
663
|
+
|
|
664
|
+
def __sub__(self, other):
|
|
665
|
+
return poly1d(polysub(self.coeffs, poly1d(other).coeffs))
|
|
666
|
+
|
|
667
|
+
def __rsub__(self, other):
|
|
668
|
+
return poly1d(polysub(poly1d(other).coeffs, self.coeffs))
|
|
669
|
+
|
|
670
|
+
def __truediv__(self, other):
|
|
671
|
+
if _isscalar(other):
|
|
672
|
+
return poly1d(self.coeffs / other)
|
|
673
|
+
return polydiv(self, poly1d(other))
|
|
674
|
+
|
|
675
|
+
def __rtruediv__(self, other):
|
|
676
|
+
if _isscalar(other):
|
|
677
|
+
return poly1d(other / self.coeffs)
|
|
678
|
+
return polydiv(poly1d(other), self)
|
|
679
|
+
|
|
680
|
+
def __eq__(self, other):
|
|
681
|
+
if not isinstance(other, poly1d):
|
|
682
|
+
return NotImplemented
|
|
683
|
+
if self.coeffs.shape != other.coeffs.shape:
|
|
684
|
+
return False
|
|
685
|
+
return bool((self.coeffs == other.coeffs).all())
|
|
686
|
+
|
|
687
|
+
def __ne__(self, other):
|
|
688
|
+
if not isinstance(other, poly1d):
|
|
689
|
+
return NotImplemented
|
|
690
|
+
return not self.__eq__(other)
|
|
691
|
+
|
|
692
|
+
def __getitem__(self, val):
|
|
693
|
+
# val 是幂次(power),非数组下标
|
|
694
|
+
ind = self.order - val
|
|
695
|
+
if val > self.order:
|
|
696
|
+
return self.coeffs.dtype.type(0)
|
|
697
|
+
if val < 0:
|
|
698
|
+
return self.coeffs.dtype.type(0)
|
|
699
|
+
return self.coeffs[ind]
|
|
700
|
+
|
|
701
|
+
def __setitem__(self, key, val):
|
|
702
|
+
ind = self.order - key
|
|
703
|
+
if key < 0:
|
|
704
|
+
raise ValueError("Does not support negative powers.")
|
|
705
|
+
if key > self.order:
|
|
706
|
+
NX = _NX()
|
|
707
|
+
zr = NX.zeros(key - self.order, self.coeffs.dtype)
|
|
708
|
+
self._coeffs = NX.concatenate((zr, self.coeffs))
|
|
709
|
+
ind = 0
|
|
710
|
+
self._coeffs[ind] = val
|
|
711
|
+
|
|
712
|
+
def __iter__(self):
|
|
713
|
+
return iter(self.coeffs)
|
|
714
|
+
|
|
715
|
+
def integ(self, m=1, k=0):
|
|
716
|
+
"""不定积分(等价 polyint(self, m, k))。"""
|
|
717
|
+
return poly1d(polyint(self.coeffs, m=m, k=k))
|
|
718
|
+
|
|
719
|
+
def deriv(self, m=1):
|
|
720
|
+
"""m 阶导数(等价 polyder(self, m))。"""
|
|
721
|
+
return poly1d(polyder(self.coeffs, m=m))
|