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,1008 @@
|
|
|
1
|
+
# SPDX-License-Identifier: MIT
|
|
2
|
+
"""纯 Python linalg 回退算法与共享 helper(数组语义对照实现)。
|
|
3
|
+
|
|
4
|
+
Rust 核心只覆盖小方阵(2×2/3×3);本模块提供通用形状算法:
|
|
5
|
+
Cholesky、LU 行列式、快速矩阵幂、矩阵范数,以及 dtype 规则 /
|
|
6
|
+
nonfinite 检查 / stacked 切片等共享 helper。
|
|
7
|
+
所有矩阵运算用 Python 浮点(f64)完成,构造结果时再 astype 回
|
|
8
|
+
输入对应的输出 dtype(与 _commonType 规则一致,精度只升不降)。
|
|
9
|
+
"""
|
|
10
|
+
|
|
11
|
+
import cmath
|
|
12
|
+
import math
|
|
13
|
+
|
|
14
|
+
__all__ = [
|
|
15
|
+
'NoValue',
|
|
16
|
+
'_common_type',
|
|
17
|
+
'_result_dtype',
|
|
18
|
+
'_real_dtype',
|
|
19
|
+
'_is_inexact',
|
|
20
|
+
'_nonfinite_check',
|
|
21
|
+
'_stacked_2d',
|
|
22
|
+
'_is_empty_2d',
|
|
23
|
+
'_matmul',
|
|
24
|
+
'_matrix_power_mat',
|
|
25
|
+
'_py_cholesky',
|
|
26
|
+
'_py_det',
|
|
27
|
+
'_py_slogdet',
|
|
28
|
+
'_eigvals_qr',
|
|
29
|
+
'_mat_norm_2d',
|
|
30
|
+
'_finfo_eps',
|
|
31
|
+
]
|
|
32
|
+
|
|
33
|
+
|
|
34
|
+
class _NoValue:
|
|
35
|
+
"""未提供参数的哨兵(对应 的 _NoValue)。"""
|
|
36
|
+
|
|
37
|
+
def __repr__(self):
|
|
38
|
+
return '<no value>'
|
|
39
|
+
|
|
40
|
+
|
|
41
|
+
NoValue = _NoValue()
|
|
42
|
+
|
|
43
|
+
|
|
44
|
+
def _finfo_eps(dt):
|
|
45
|
+
"""float/complex dtype 对应的机器精度 eps。"""
|
|
46
|
+
if dt in ('float32', 'complex64'):
|
|
47
|
+
return 1.1920928955078125e-07
|
|
48
|
+
if dt in ('float16',):
|
|
49
|
+
return 9.765625e-04
|
|
50
|
+
return 2.220446049250313e-16
|
|
51
|
+
|
|
52
|
+
|
|
53
|
+
def _real_dtype(dt):
|
|
54
|
+
"""complex → 对应实 dtype;其余原样返回。"""
|
|
55
|
+
if dt == 'complex64':
|
|
56
|
+
return 'float32'
|
|
57
|
+
if dt == 'complex128':
|
|
58
|
+
return 'float64'
|
|
59
|
+
return dt
|
|
60
|
+
|
|
61
|
+
|
|
62
|
+
def _is_inexact(dt):
|
|
63
|
+
return dt in ('float16', 'float32', 'float64', 'complex64', 'complex128')
|
|
64
|
+
|
|
65
|
+
|
|
66
|
+
def _common_type(a_dtype):
|
|
67
|
+
"""(计算 dtype, 返回 dtype)——_commonType 语义。
|
|
68
|
+
|
|
69
|
+
inexact(除 float16)保持原 dtype;float16 → TypeError;
|
|
70
|
+
int/bool/其它 → float64。
|
|
71
|
+
"""
|
|
72
|
+
if a_dtype == 'float16':
|
|
73
|
+
raise TypeError("unsupported in linalg.")
|
|
74
|
+
if a_dtype in ('float32', 'float64', 'complex64', 'complex128'):
|
|
75
|
+
return (a_dtype, a_dtype)
|
|
76
|
+
return ('float64', 'float64')
|
|
77
|
+
|
|
78
|
+
|
|
79
|
+
def _result_dtype(a_dtype):
|
|
80
|
+
return _common_type(a_dtype)[1]
|
|
81
|
+
|
|
82
|
+
|
|
83
|
+
def _nonfinite_check(mat, msg="SVD did not converge"):
|
|
84
|
+
"""嵌套矩阵含 inf/nan 时抛 LinAlgError(模拟 LAPACK 不收敛)。"""
|
|
85
|
+
from rsarray.linalg import LinAlgError
|
|
86
|
+
|
|
87
|
+
def scan(v):
|
|
88
|
+
if isinstance(v, (list, tuple)):
|
|
89
|
+
for x in v:
|
|
90
|
+
scan(x)
|
|
91
|
+
else:
|
|
92
|
+
if isinstance(v, complex):
|
|
93
|
+
r, i = v.real, v.imag
|
|
94
|
+
else:
|
|
95
|
+
r, i = float(v), 0.0
|
|
96
|
+
if r != r or i != i or math.isinf(r) or math.isinf(i):
|
|
97
|
+
raise LinAlgError(msg)
|
|
98
|
+
|
|
99
|
+
scan(mat)
|
|
100
|
+
|
|
101
|
+
|
|
102
|
+
def _stacked_2d(arr):
|
|
103
|
+
"""ndarray (...,M,N) → (lead_shape, [2-d 子数组, ...])。2-d 时 lead=(())。
|
|
104
|
+
|
|
105
|
+
注意:不能用 reshape((-1, M, N))——size-0 时 rsarray 把 -1 解成 0,
|
|
106
|
+
会丢掉 lead 维((3,0,5) 变 (0,0,5));这里显式算 total。
|
|
107
|
+
"""
|
|
108
|
+
shape = arr.shape
|
|
109
|
+
if len(shape) == 2:
|
|
110
|
+
return ((), arr)
|
|
111
|
+
lead = shape[:-2]
|
|
112
|
+
total = 1
|
|
113
|
+
for d in lead:
|
|
114
|
+
total *= d
|
|
115
|
+
last2 = shape[-2:]
|
|
116
|
+
flat = arr.reshape((total,) + last2)
|
|
117
|
+
return (lead, [flat[i] for i in range(total)])
|
|
118
|
+
|
|
119
|
+
|
|
120
|
+
def _is_empty_2d(arr):
|
|
121
|
+
return arr.size == 0 and 0 in arr.shape[-2:]
|
|
122
|
+
|
|
123
|
+
|
|
124
|
+
def _matmul(A, B):
|
|
125
|
+
"""嵌套列表矩阵乘 (m×n)·(n×p),元素可为 int/float/complex/object。"""
|
|
126
|
+
m = len(A)
|
|
127
|
+
n = len(A[0]) if m else 0
|
|
128
|
+
p = len(B[0]) if B and B[0] else 0
|
|
129
|
+
out = [[0] * p for _ in range(m)]
|
|
130
|
+
for i in range(m):
|
|
131
|
+
row_a = A[i]
|
|
132
|
+
row_o = out[i]
|
|
133
|
+
for k in range(n):
|
|
134
|
+
aik = row_a[k]
|
|
135
|
+
if aik == 0:
|
|
136
|
+
continue
|
|
137
|
+
row_b = B[k]
|
|
138
|
+
for j in range(p):
|
|
139
|
+
row_o[j] += aik * row_b[j]
|
|
140
|
+
return out
|
|
141
|
+
|
|
142
|
+
|
|
143
|
+
def _matrix_power_mat(A, n):
|
|
144
|
+
"""嵌套列表方阵快速幂(二进制分解),n >= 0(0 → 单位矩阵)。"""
|
|
145
|
+
if n == 0:
|
|
146
|
+
m = len(A)
|
|
147
|
+
return [[1 if i == j else 0 for j in range(m)] for i in range(m)]
|
|
148
|
+
if n == 1:
|
|
149
|
+
return [list(row) for row in A]
|
|
150
|
+
if n == 2:
|
|
151
|
+
return _matmul(A, A)
|
|
152
|
+
if n == 3:
|
|
153
|
+
return _matmul(_matmul(A, A), A)
|
|
154
|
+
z = None
|
|
155
|
+
result = None
|
|
156
|
+
while n > 0:
|
|
157
|
+
z = [list(row) for row in A] if z is None else _matmul(z, z)
|
|
158
|
+
n, bit = divmod(n, 2)
|
|
159
|
+
if bit:
|
|
160
|
+
result = z if result is None else _matmul(result, z)
|
|
161
|
+
return result
|
|
162
|
+
|
|
163
|
+
|
|
164
|
+
def _qr_raw(mat):
|
|
165
|
+
"""Householder QR(LAPACK geqrf 约定)。
|
|
166
|
+
|
|
167
|
+
返回 (h, tau):h 为 (n, m)(FORTRAN 序,即行主序 (m, n) 的转置:
|
|
168
|
+
上三角 = R,第 j 列下三角 = Householder 向量 v_j/r1j_j),tau (k,)
|
|
169
|
+
(k = min(m, n))。重建:x' = x - tau_j * w_j * (w_j^H x),
|
|
170
|
+
w_j = [1, h(j+1:m, j)]^T。
|
|
171
|
+
"""
|
|
172
|
+
m = len(mat)
|
|
173
|
+
n = len(mat[0]) if m else 0
|
|
174
|
+
k = min(m, n)
|
|
175
|
+
is_c = any(isinstance(v, complex) for row in mat for v in row)
|
|
176
|
+
H = [list(row) for row in mat] # (m, n) 行主序工作矩阵
|
|
177
|
+
zero = (0.0 + 0j) if is_c else 0.0
|
|
178
|
+
tau = [zero] * k
|
|
179
|
+
for j in range(k):
|
|
180
|
+
col = [H[i][j] for i in range(j, m)]
|
|
181
|
+
norm = math.sqrt(sum(abs(x) ** 2 for x in col))
|
|
182
|
+
if norm == 0:
|
|
183
|
+
continue
|
|
184
|
+
x0 = col[0]
|
|
185
|
+
if is_c:
|
|
186
|
+
alpha = -(x0 / abs(x0)) * norm if x0 != 0 else -norm
|
|
187
|
+
else:
|
|
188
|
+
alpha = -norm if x0 >= 0 else norm
|
|
189
|
+
r1j = x0 - alpha
|
|
190
|
+
if r1j == 0:
|
|
191
|
+
continue
|
|
192
|
+
if is_c:
|
|
193
|
+
tau[j] = (r1j.conjugate() * alpha
|
|
194
|
+
/ (abs(alpha) ** 2 + abs(r1j) ** 2)) / r1j
|
|
195
|
+
else:
|
|
196
|
+
tau[j] = (r1j * alpha / (alpha * alpha + r1j * r1j)) / r1j
|
|
197
|
+
for i in range(j + 1, m):
|
|
198
|
+
H[i][j] = mat[i][j] / r1j
|
|
199
|
+
# FORTRAN 序:转置为 (n, m)
|
|
200
|
+
h = [[H[i][j] for i in range(m)] for j in range(n)]
|
|
201
|
+
return h, tau
|
|
202
|
+
|
|
203
|
+
|
|
204
|
+
def _py_cholesky(mat, upper=False):
|
|
205
|
+
"""Cholesky-Crout 分解:A = L·L^H(lower)或 U^H·U(upper)。
|
|
206
|
+
|
|
207
|
+
只用下三角(lower)或上三角(upper)+对角;非正定抛 LinAlgError。
|
|
208
|
+
返回嵌套列表(与输入同 complex/float 性)。
|
|
209
|
+
"""
|
|
210
|
+
from rsarray.linalg import LinAlgError
|
|
211
|
+
|
|
212
|
+
n = len(mat)
|
|
213
|
+
if upper:
|
|
214
|
+
if n == 0:
|
|
215
|
+
return []
|
|
216
|
+
is_c = any(isinstance(v, complex) for row in mat for v in row)
|
|
217
|
+
# 对 A^H 做下三角分解再共轭转置(等价于用 A 的上三角)。
|
|
218
|
+
# A^H[i][j] = conj(A[j][i])——必须取共轭,否则复数矩阵分解错误。
|
|
219
|
+
a_h = [[mat[j][i].conjugate() if is_c else mat[j][i]
|
|
220
|
+
for j in range(n)] for i in range(n)]
|
|
221
|
+
l = _py_cholesky(a_h, False)
|
|
222
|
+
return [[l[j][i].conjugate() if is_c else l[j][i]
|
|
223
|
+
for j in range(n)] for i in range(n)]
|
|
224
|
+
|
|
225
|
+
if n == 0:
|
|
226
|
+
return []
|
|
227
|
+
is_c = any(isinstance(v, complex) for row in mat for v in row)
|
|
228
|
+
zero = 0j if is_c else 0.0
|
|
229
|
+
|
|
230
|
+
def _cj(z):
|
|
231
|
+
return z.conjugate() if is_c else z
|
|
232
|
+
|
|
233
|
+
L = [[zero] * n for _ in range(n)]
|
|
234
|
+
for i in range(n):
|
|
235
|
+
for j in range(i + 1):
|
|
236
|
+
# A = L·L^H 约定:A[i][j] = Σ_k L[i][k]·conj(L[j][k])
|
|
237
|
+
s = zero
|
|
238
|
+
for k in range(j):
|
|
239
|
+
s += L[i][k] * _cj(L[j][k])
|
|
240
|
+
if i == j:
|
|
241
|
+
# s = Σ|L[i][k]|²(j=i 时两种约定一致)
|
|
242
|
+
d = mat[i][i] - s
|
|
243
|
+
if is_c:
|
|
244
|
+
if d.real <= 0:
|
|
245
|
+
raise LinAlgError(
|
|
246
|
+
"matrix is not positive-definite (cholesky)")
|
|
247
|
+
L[i][i] = cmath.sqrt(complex(d))
|
|
248
|
+
else:
|
|
249
|
+
if d <= 0:
|
|
250
|
+
raise LinAlgError(
|
|
251
|
+
"matrix is not positive-definite (cholesky)")
|
|
252
|
+
L[i][i] = math.sqrt(d)
|
|
253
|
+
else:
|
|
254
|
+
L[i][j] = (mat[i][j] - s) / _cj(L[j][j])
|
|
255
|
+
return L
|
|
256
|
+
|
|
257
|
+
|
|
258
|
+
def _py_det(mat):
|
|
259
|
+
"""LU 分解(列主元)求行列式,complex-aware。返回 float/complex 标量。
|
|
260
|
+
|
|
261
|
+
空矩阵(0×0)行列式为 1。
|
|
262
|
+
"""
|
|
263
|
+
n = len(mat)
|
|
264
|
+
if n == 0:
|
|
265
|
+
return 1.0
|
|
266
|
+
is_c = any(isinstance(v, complex) for row in mat for v in row)
|
|
267
|
+
w = [list(row) for row in mat]
|
|
268
|
+
sign = 1.0
|
|
269
|
+
det = (1.0 + 0j) if is_c else 1.0
|
|
270
|
+
for col in range(n):
|
|
271
|
+
pivot = max(range(col, n), key=lambda r: abs(w[r][col]))
|
|
272
|
+
if abs(w[pivot][col]) == 0:
|
|
273
|
+
return (0.0 + 0j) if is_c else 0.0
|
|
274
|
+
if pivot != col:
|
|
275
|
+
w[col], w[pivot] = w[pivot], w[col]
|
|
276
|
+
sign = -sign
|
|
277
|
+
det *= w[col][col]
|
|
278
|
+
for r in range(col + 1, n):
|
|
279
|
+
if w[r][col] == 0:
|
|
280
|
+
continue
|
|
281
|
+
f = w[r][col] / w[col][col]
|
|
282
|
+
wr = w[r]
|
|
283
|
+
wc = w[col]
|
|
284
|
+
for c2 in range(col, n):
|
|
285
|
+
wr[c2] -= f * wc[c2]
|
|
286
|
+
return sign * det
|
|
287
|
+
|
|
288
|
+
|
|
289
|
+
def _py_slogdet(mat):
|
|
290
|
+
"""LU 分解(列主元)→ (sign, log|det|)。
|
|
291
|
+
|
|
292
|
+
实矩阵 sign 为 ±1(奇异为 0.0),复矩阵 sign 为相位(模 1 复数,
|
|
293
|
+
奇异为 0j);奇异 → logabs 为 -inf;空矩阵 (0×0) → (1, 0)。
|
|
294
|
+
"""
|
|
295
|
+
n = len(mat)
|
|
296
|
+
if n == 0:
|
|
297
|
+
return 1.0, 0.0
|
|
298
|
+
is_c = any(isinstance(v, complex) for row in mat for v in row)
|
|
299
|
+
w = [list(row) for row in mat]
|
|
300
|
+
sign = (1.0 + 0j) if is_c else 1.0
|
|
301
|
+
logabs = 0.0
|
|
302
|
+
for col in range(n):
|
|
303
|
+
pivot = max(range(col, n), key=lambda r: abs(w[r][col]))
|
|
304
|
+
if abs(w[pivot][col]) == 0:
|
|
305
|
+
return (0.0 + 0j) if is_c else 0.0, float('-inf')
|
|
306
|
+
if pivot != col:
|
|
307
|
+
w[col], w[pivot] = w[pivot], w[col]
|
|
308
|
+
sign = -sign
|
|
309
|
+
p = w[col][col]
|
|
310
|
+
mag = abs(p)
|
|
311
|
+
logabs += math.log(mag)
|
|
312
|
+
if is_c:
|
|
313
|
+
sign *= p / mag
|
|
314
|
+
elif p < 0:
|
|
315
|
+
sign = -sign # 实枢轴符号必须计入——只数行交换会漏掉
|
|
316
|
+
for r in range(col + 1, n):
|
|
317
|
+
if w[r][col] == 0:
|
|
318
|
+
continue
|
|
319
|
+
f = w[r][col] / p
|
|
320
|
+
wr = w[r]
|
|
321
|
+
wc = w[col]
|
|
322
|
+
for c2 in range(col, n):
|
|
323
|
+
wr[c2] -= f * wc[c2]
|
|
324
|
+
return sign, logabs
|
|
325
|
+
|
|
326
|
+
|
|
327
|
+
def _hessenberg_reduce(mat):
|
|
328
|
+
"""复数 Householder 相似约化到上 Hessenberg 形式(特征值不变)。"""
|
|
329
|
+
n = len(mat)
|
|
330
|
+
A = [[complex(v) for v in row] for row in mat]
|
|
331
|
+
for j in range(n - 2):
|
|
332
|
+
x = [A[r][j] for r in range(j + 1, n)]
|
|
333
|
+
norm_x = math.sqrt(sum(abs(z) ** 2 for z in x))
|
|
334
|
+
if norm_x == 0:
|
|
335
|
+
continue
|
|
336
|
+
sgn = x[0] / abs(x[0]) if abs(x[0]) > 0 else 1.0
|
|
337
|
+
v = [x[0] + sgn * norm_x] + x[1:]
|
|
338
|
+
nv = math.sqrt(sum(abs(z) ** 2 for z in v))
|
|
339
|
+
if nv == 0:
|
|
340
|
+
continue
|
|
341
|
+
v = [z / nv for z in v]
|
|
342
|
+
lo = j + 1
|
|
343
|
+
# 左乘 P = I - 2vv^H:行 lo..n-1 × 列 j..n-1(前列下段已为零,
|
|
344
|
+
# 限制列范围避免浮点垃圾重新渗入)。w = v^H A[:, j..] 先从
|
|
345
|
+
# 未修改的 A 完整算出——A[r][c] -= 2v[r]w[c] 各行无原地依赖。
|
|
346
|
+
w = [sum(v[t - lo].conjugate() * A[t][c]
|
|
347
|
+
for t in range(lo, n)) for c in range(j, n)]
|
|
348
|
+
for r in range(lo, n):
|
|
349
|
+
vr = v[r - lo]
|
|
350
|
+
for c in range(j, n):
|
|
351
|
+
A[r][c] -= 2 * vr * w[c - j]
|
|
352
|
+
# 右乘 P:(AP)[r][c] = A[r][c] - 2(Av)[r] conj(v[c])
|
|
353
|
+
avs = [sum(A[r][t] * v[t - lo]
|
|
354
|
+
for t in range(lo, n)) for r in range(n)]
|
|
355
|
+
for c in range(lo, n):
|
|
356
|
+
vc = v[c - lo].conjugate()
|
|
357
|
+
for r in range(n):
|
|
358
|
+
A[r][c] -= 2 * avs[r] * vc
|
|
359
|
+
return A
|
|
360
|
+
|
|
361
|
+
|
|
362
|
+
def _qr_factor(H, i, m, q):
|
|
363
|
+
"""H[i:m, i:m] - qI 的 Householder QR 分解,返回 (Q, R)(B = QR)。"""
|
|
364
|
+
k = m - i
|
|
365
|
+
B = [[H[r][c] - (q if r == c else 0j) for c in range(i, m)]
|
|
366
|
+
for r in range(i, m)]
|
|
367
|
+
R = [row[:] for row in B]
|
|
368
|
+
Q = [[(1.0 + 0j) if r == c else 0j for c in range(k)] for r in range(k)]
|
|
369
|
+
for j in range(k - 1):
|
|
370
|
+
x = [R[r][j] for r in range(j, k)]
|
|
371
|
+
norm_x = math.sqrt(sum(abs(z) ** 2 for z in x))
|
|
372
|
+
if norm_x == 0:
|
|
373
|
+
continue
|
|
374
|
+
sgn = x[0] / abs(x[0]) if abs(x[0]) > 0 else 1.0
|
|
375
|
+
v = [x[0] + sgn * norm_x] + x[1:]
|
|
376
|
+
nv = math.sqrt(sum(abs(z) ** 2 for z in v))
|
|
377
|
+
if nv == 0:
|
|
378
|
+
continue
|
|
379
|
+
v = [z / nv for z in v]
|
|
380
|
+
# R <- P R(P = I - 2vv^H,作用于第 j..k-1 行/列)。w = v^H R[:, j..]
|
|
381
|
+
# 先从未修改的 R 完整算出,避免行方向原地覆盖。
|
|
382
|
+
w = [sum(v[t - j].conjugate() * R[t][c]
|
|
383
|
+
for t in range(j, k)) for c in range(j, k)]
|
|
384
|
+
for r in range(j, k):
|
|
385
|
+
vr = v[r - j]
|
|
386
|
+
for c in range(j, k):
|
|
387
|
+
R[r][c] -= 2 * vr * w[c - j]
|
|
388
|
+
# Q <- Q P:(QP)[r][c] = Q[r][c] - 2(Qv)[r] conj(v[c])
|
|
389
|
+
for r in range(k):
|
|
390
|
+
qv = sum(Q[r][t] * v[t - j] for t in range(j, k))
|
|
391
|
+
if qv == 0:
|
|
392
|
+
continue
|
|
393
|
+
for c in range(j, k):
|
|
394
|
+
Q[r][c] -= 2 * qv * v[c - j].conjugate()
|
|
395
|
+
return Q, R
|
|
396
|
+
|
|
397
|
+
|
|
398
|
+
def _qr_shift_step(H, i, m, q):
|
|
399
|
+
"""对 H[i:m, i:m] 块做一次单位移(q)QR 步骤,原地回写。
|
|
400
|
+
|
|
401
|
+
B = block - qI = QR → block' = RQ + qI(相似变换)。
|
|
402
|
+
"""
|
|
403
|
+
k = m - i
|
|
404
|
+
Q, R = _qr_factor(H, i, m, q)
|
|
405
|
+
for r in range(k):
|
|
406
|
+
for c in range(k):
|
|
407
|
+
H[i + r][i + c] = sum(R[r][t] * Q[t][c] for t in range(k)) \
|
|
408
|
+
+ (q if r == c else 0j)
|
|
409
|
+
|
|
410
|
+
|
|
411
|
+
def _qr_double_step(H, i, m):
|
|
412
|
+
"""Francis 双移位步:以尾部 2x2 块的两个特征值 p、q 为连续两次
|
|
413
|
+
单位移 QR 的移位(显式双移位),三次收敛。要求 m - i >= 3。"""
|
|
414
|
+
import cmath
|
|
415
|
+
a, b = H[m - 2][m - 2], H[m - 2][m - 1]
|
|
416
|
+
c, d = H[m - 1][m - 2], H[m - 1][m - 1]
|
|
417
|
+
tr = a + d
|
|
418
|
+
detv = a * d - b * c
|
|
419
|
+
disc = cmath.sqrt(tr * tr - 4.0 * detv)
|
|
420
|
+
_qr_shift_step(H, i, m, (tr + disc) / 2.0)
|
|
421
|
+
_qr_shift_step(H, i, m, (tr - disc) / 2.0)
|
|
422
|
+
|
|
423
|
+
|
|
424
|
+
def _eigvals_fl_dk(mat):
|
|
425
|
+
"""特征多项式法(f64 FL + DK 多起点 + c0 校正 + Newton 抛光)。
|
|
426
|
+
|
|
427
|
+
f64 FL 系数累积 ~1e-11 相对误差,常数项 c[0] 直接决定根乘积
|
|
428
|
+
(=det),故把 c[0] 校正为 f64 LU 行列式(相对 ~1e-15)得校正
|
|
429
|
+
多项式 p̃',再对每个 DK 候选根做 3 步 Newton 抛光。n≤8 可靠;
|
|
430
|
+
n≥9 系数量级(~‖A‖^n)超出 f64 有效位,根不可靠。
|
|
431
|
+
"""
|
|
432
|
+
import cmath
|
|
433
|
+
n = len(mat)
|
|
434
|
+
c = _fl_coefficients(mat)
|
|
435
|
+
roots = _dk_roots(c)
|
|
436
|
+
target = ((-1.0) ** n) * _py_det(mat)
|
|
437
|
+
dc = target - c[0]
|
|
438
|
+
for i, z in enumerate(roots):
|
|
439
|
+
for _ in range(3):
|
|
440
|
+
f = _poly_eval(c, z) + dc
|
|
441
|
+
dp = _poly_deriv(c, z)
|
|
442
|
+
if dp == 0:
|
|
443
|
+
break
|
|
444
|
+
st = f / dp
|
|
445
|
+
z -= st
|
|
446
|
+
if st == 0:
|
|
447
|
+
break
|
|
448
|
+
roots[i] = z
|
|
449
|
+
return roots
|
|
450
|
+
|
|
451
|
+
|
|
452
|
+
def _cgivens(a, b):
|
|
453
|
+
"""复 Givens:返回 (c, s, r),G = [[c, s], [-conj(s), conj(c)]],
|
|
454
|
+
G^H [a, b]^T = [r, 0]^T(r ≥ 0 实)。c = a/t, s = -conj(b)/t。"""
|
|
455
|
+
import math
|
|
456
|
+
t = math.sqrt(abs(a) ** 2 + abs(b) ** 2)
|
|
457
|
+
if t == 0:
|
|
458
|
+
return 1.0 + 0j, 0j, 0.0
|
|
459
|
+
return a / t, -complex(b).conjugate() / t, t
|
|
460
|
+
|
|
461
|
+
|
|
462
|
+
def _rot_rows(H, r1, r2, jlo, jhi, c, s):
|
|
463
|
+
"""左乘 G^H 于行 r1, r2(列 jlo..jhi):new1 = conj(c)·x - s·y,
|
|
464
|
+
new2 = conj(s)·x + c·y。"""
|
|
465
|
+
ca = c.conjugate()
|
|
466
|
+
cs = s.conjugate()
|
|
467
|
+
for j in range(jlo, jhi + 1):
|
|
468
|
+
x = H[r1][j]
|
|
469
|
+
y = H[r2][j]
|
|
470
|
+
H[r1][j] = ca * x - s * y
|
|
471
|
+
H[r2][j] = cs * x + c * y
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
def _rot_cols(H, c1, c2, rlo, rhi, c, s):
|
|
475
|
+
"""右乘 G 于列 c1, c2(行 rlo..rhi):new1 = c·x - conj(s)·y,
|
|
476
|
+
new2 = s·x + conj(c)·y。"""
|
|
477
|
+
cs = s.conjugate()
|
|
478
|
+
cc = c.conjugate()
|
|
479
|
+
for r in range(rlo, rhi + 1):
|
|
480
|
+
x = H[r][c1]
|
|
481
|
+
y = H[r][c2]
|
|
482
|
+
H[r][c1] = c * x - cs * y
|
|
483
|
+
H[r][c2] = s * x + cc * y
|
|
484
|
+
|
|
485
|
+
|
|
486
|
+
def _francis_step(H, lo, hi, exc=False):
|
|
487
|
+
"""窗口 [lo, hi](含端点)上的隐式 Francis 双移位 QR 步
|
|
488
|
+
(bulge chasing,复 Givens;数值稳定,不显式构造奇异因子分解)。
|
|
489
|
+
exc=True 用异常移位(dlahqr 对策:每 10 步无收缩扰动一次,
|
|
490
|
+
打破移位与特征值重合导致的停滞)。"""
|
|
491
|
+
import cmath
|
|
492
|
+
if exc:
|
|
493
|
+
# LAPACK 式异常移位:0.75×次对角范数 + 尾对角
|
|
494
|
+
w1 = w2 = H[hi][hi] + 0.75 * (abs(H[hi][hi - 1])
|
|
495
|
+
+ abs(H[hi - 1][hi - 2]))
|
|
496
|
+
else:
|
|
497
|
+
a, b = H[hi - 1][hi - 1], H[hi - 1][hi]
|
|
498
|
+
c, d = H[hi][hi - 1], H[hi][hi]
|
|
499
|
+
tr = a + d
|
|
500
|
+
disc = cmath.sqrt(tr * tr - 4.0 * (a * d - b * c))
|
|
501
|
+
w1 = (tr + disc) / 2.0
|
|
502
|
+
w2 = (tr - disc) / 2.0
|
|
503
|
+
# 初始 chase 向量 u = (H-w1·I)(H-w2·I) e_lo 的前两个非零分量
|
|
504
|
+
u0 = (H[lo][lo] - w1) * (H[lo][lo] - w2) \
|
|
505
|
+
+ H[lo][lo + 1] * H[lo + 1][lo]
|
|
506
|
+
u1 = H[lo + 1][lo] * ((H[lo][lo] - w2) + (H[lo + 1][lo + 1] - w1))
|
|
507
|
+
c0, s0, _ = _cgivens(u0, u1)
|
|
508
|
+
_rot_rows(H, lo, lo + 1, lo, hi, c0, s0)
|
|
509
|
+
_rot_cols(H, lo, lo + 1, lo, min(lo + 2, hi), c0, s0)
|
|
510
|
+
# 追逐 bulge:第 t 步 bulge 在 (lo+2+t, lo+t)
|
|
511
|
+
for t in range(hi - lo - 1):
|
|
512
|
+
r1 = lo + 1 + t
|
|
513
|
+
r2 = lo + 2 + t
|
|
514
|
+
x = H[r1][lo + t]
|
|
515
|
+
y = H[r2][lo + t]
|
|
516
|
+
ck, sk, _ = _cgivens(x, y)
|
|
517
|
+
# 左旋须含 bulge 列 lo+t:x→r、y→0(漏掉该列会破坏相似性)
|
|
518
|
+
_rot_rows(H, r1, r2, lo + t, hi, ck, sk)
|
|
519
|
+
H[r2][lo + t] = 0j # 数值保险
|
|
520
|
+
_rot_cols(H, r1, r2, lo, min(r2 + 1, hi), ck, sk)
|
|
521
|
+
|
|
522
|
+
|
|
523
|
+
def _qr_iter_eigvals(H):
|
|
524
|
+
"""Hessenberg 矩阵特征值(dlahqr 式驱动):窗口递归 + 尾块 1x1/2x2
|
|
525
|
+
正确提取 + 隐式 Francis 双移位。H[i+1][i]≈0 时矩阵分裂为两个独立
|
|
526
|
+
块(尾块递归,前导块继续),绝不可把未三角化的尾块当对角读取。"""
|
|
527
|
+
import cmath
|
|
528
|
+
n = len(H)
|
|
529
|
+
eps = 2.220446049250313e-16
|
|
530
|
+
evals = []
|
|
531
|
+
state = {'it': 0}
|
|
532
|
+
|
|
533
|
+
def _2x2(lo):
|
|
534
|
+
a, b = H[lo][lo], H[lo][lo + 1]
|
|
535
|
+
c, d = H[lo + 1][lo], H[lo + 1][lo + 1]
|
|
536
|
+
tr = a + d
|
|
537
|
+
disc = cmath.sqrt(tr * tr - 4.0 * (a * d - b * c))
|
|
538
|
+
return (tr + disc) / 2.0, (tr - disc) / 2.0
|
|
539
|
+
|
|
540
|
+
def _window(lo, hi):
|
|
541
|
+
# stall:本窗口连续无收缩的步数(每 10 步触发一次异常移位)
|
|
542
|
+
stall = 0
|
|
543
|
+
while hi - lo + 1 > 0:
|
|
544
|
+
size = hi - lo + 1
|
|
545
|
+
if size == 1:
|
|
546
|
+
evals.append(complex(H[lo][lo]))
|
|
547
|
+
return
|
|
548
|
+
if size == 2:
|
|
549
|
+
e1, e2 = _2x2(lo)
|
|
550
|
+
evals.append(e1)
|
|
551
|
+
evals.append(e2)
|
|
552
|
+
return
|
|
553
|
+
# 从底部向上找第一个可收缩次对角元 H[j+1][j]
|
|
554
|
+
split = None
|
|
555
|
+
for j in range(hi - 1, lo - 1, -1):
|
|
556
|
+
if H[j + 1][j] == 0:
|
|
557
|
+
split = j
|
|
558
|
+
break
|
|
559
|
+
if abs(H[j + 1][j]) <= eps * (abs(H[j][j])
|
|
560
|
+
+ abs(H[j + 1][j + 1])):
|
|
561
|
+
H[j + 1][j] = 0j
|
|
562
|
+
split = j
|
|
563
|
+
break
|
|
564
|
+
if split is not None:
|
|
565
|
+
stall = 0
|
|
566
|
+
tsize = hi - split # 尾块 [split+1, hi] 大小
|
|
567
|
+
if tsize == 1:
|
|
568
|
+
evals.append(complex(H[hi][hi]))
|
|
569
|
+
hi = split
|
|
570
|
+
continue
|
|
571
|
+
if tsize == 2:
|
|
572
|
+
e1, e2 = _2x2(split + 1)
|
|
573
|
+
evals.append(e1)
|
|
574
|
+
evals.append(e2)
|
|
575
|
+
hi = split
|
|
576
|
+
continue
|
|
577
|
+
# 尾块 ≥3:仍是独立 Hessenberg 块,递归处理后再回头
|
|
578
|
+
_window(split + 1, hi)
|
|
579
|
+
hi = split
|
|
580
|
+
continue
|
|
581
|
+
# 显式双移位 QR 步(两次单位移 QR,移位取尾部 2x2 特征值);
|
|
582
|
+
# 每 10 步无收缩改用异常移位(dlahqr 对策)
|
|
583
|
+
if stall % 10 == 9:
|
|
584
|
+
_qr_shift_step(H, lo, hi + 1,
|
|
585
|
+
H[hi][hi] + 0.75 * (abs(H[hi][hi - 1])
|
|
586
|
+
+ abs(H[hi - 1][hi - 2])))
|
|
587
|
+
else:
|
|
588
|
+
_qr_double_step(H, lo, hi + 1)
|
|
589
|
+
stall += 1
|
|
590
|
+
state['it'] += 1
|
|
591
|
+
if state['it'] > 60 * n:
|
|
592
|
+
raise RuntimeError(
|
|
593
|
+
'QR eigenvalue iteration did not converge')
|
|
594
|
+
|
|
595
|
+
_window(0, n - 1)
|
|
596
|
+
# 实输入的实特征值:复算术残留的微小虚部归零
|
|
597
|
+
out = []
|
|
598
|
+
for z in evals:
|
|
599
|
+
if abs(z.imag) < 1e-11 * max(1.0, abs(z.real)):
|
|
600
|
+
z = complex(z.real, 0.0)
|
|
601
|
+
out.append(z)
|
|
602
|
+
return out
|
|
603
|
+
|
|
604
|
+
|
|
605
|
+
def _eigvals_qr(mat):
|
|
606
|
+
"""通用特征值(纯 Python),返回 complex 列表(顺序任意,同 LAPACK 语义)。
|
|
607
|
+
|
|
608
|
+
n≤2 解析式;n≤8 特征多项式法(FL+DK+c0 校正,精度 ~1e-15 相对);
|
|
609
|
+
n≥9 FL 系数量级超出 f64 有效位 → Hessenberg + Francis 双移位 QR
|
|
610
|
+
迭代(不收敛回退 FL+DK,保持旧行为下界)。
|
|
611
|
+
"""
|
|
612
|
+
import cmath
|
|
613
|
+
n = len(mat)
|
|
614
|
+
if n == 0:
|
|
615
|
+
return []
|
|
616
|
+
if n == 1:
|
|
617
|
+
return [complex(mat[0][0])]
|
|
618
|
+
if n == 2:
|
|
619
|
+
a, b = mat[0][0], mat[0][1]
|
|
620
|
+
c, d = mat[1][0], mat[1][1]
|
|
621
|
+
tr = a + d
|
|
622
|
+
det = a * d - b * c
|
|
623
|
+
disc = cmath.sqrt(tr * tr - 4.0 * det)
|
|
624
|
+
return [(tr + disc) / 2.0, (tr - disc) / 2.0]
|
|
625
|
+
if n >= 9:
|
|
626
|
+
H = _hessenberg_reduce(mat)
|
|
627
|
+
try:
|
|
628
|
+
return _qr_iter_eigvals(H)
|
|
629
|
+
except Exception:
|
|
630
|
+
pass # 不收敛:回退 FL+DK(旧路径)
|
|
631
|
+
return _eigvals_fl_dk(mat)
|
|
632
|
+
|
|
633
|
+
|
|
634
|
+
def _eigvals_highprec(mat):
|
|
635
|
+
"""通用 n×n 特征值:高精度 FL 系数 + f64 DK 候选 + 高精度 Newton。
|
|
636
|
+
|
|
637
|
+
复数 Decimal 用 (re, im) 对表示;FL 递推 B_{k+1} = B_k·A + c_{n-k}·I,
|
|
638
|
+
c_{n-k} = −tr(B_k·A)/k(复矩阵迹可为复数)。
|
|
639
|
+
"""
|
|
640
|
+
from decimal import Decimal, localcontext
|
|
641
|
+
n = len(mat)
|
|
642
|
+
D = Decimal
|
|
643
|
+
TINY = D(10) ** -30
|
|
644
|
+
|
|
645
|
+
def _cadd(x, y):
|
|
646
|
+
return (x[0] + y[0], x[1] + y[1])
|
|
647
|
+
|
|
648
|
+
def _cmul(x, y):
|
|
649
|
+
return (x[0] * y[0] - x[1] * y[1], x[0] * y[1] + x[1] * y[0])
|
|
650
|
+
|
|
651
|
+
def _to_cd(v):
|
|
652
|
+
if isinstance(v, complex):
|
|
653
|
+
return (D(repr(v.real)), D(repr(v.imag)))
|
|
654
|
+
return (D(repr(v)), D(0))
|
|
655
|
+
|
|
656
|
+
def _peval(c, zr, zi):
|
|
657
|
+
re, im = c[-1]
|
|
658
|
+
for k in range(len(c) - 2, -1, -1):
|
|
659
|
+
cr, ci = c[k]
|
|
660
|
+
re, im = re * zr - im * zi + cr, re * zi + im * zr + ci
|
|
661
|
+
return re, im
|
|
662
|
+
|
|
663
|
+
def _pderiv(c, zr, zi):
|
|
664
|
+
re, im = D(0), D(0)
|
|
665
|
+
for k in range(len(c) - 1, 0, -1):
|
|
666
|
+
cr, ci = c[k]
|
|
667
|
+
re, im = (re * zr - im * zi + k * cr,
|
|
668
|
+
re * zi + im * zr + k * ci)
|
|
669
|
+
return re, im
|
|
670
|
+
|
|
671
|
+
with localcontext() as ctx:
|
|
672
|
+
ctx.prec = 45
|
|
673
|
+
A = [[_to_cd(v) for v in row] for row in mat]
|
|
674
|
+
c = [(D(0), D(0))] * (n + 1)
|
|
675
|
+
c[n] = (D(1), D(0))
|
|
676
|
+
B = [[(D(1) if i == j else D(0), D(0)) for j in range(n)]
|
|
677
|
+
for i in range(n)]
|
|
678
|
+
for k in range(1, n + 1):
|
|
679
|
+
BA = [[(D(0), D(0)) for _ in range(n)] for _ in range(n)]
|
|
680
|
+
for i in range(n):
|
|
681
|
+
for j in range(n):
|
|
682
|
+
s = (D(0), D(0))
|
|
683
|
+
for t in range(n):
|
|
684
|
+
s = _cadd(s, _cmul(B[i][t], A[t][j]))
|
|
685
|
+
BA[i][j] = s
|
|
686
|
+
tre = D(0)
|
|
687
|
+
tim = D(0)
|
|
688
|
+
for i in range(n):
|
|
689
|
+
tre += BA[i][i][0]
|
|
690
|
+
tim += BA[i][i][1]
|
|
691
|
+
c[n - k] = (-tre / k, -tim / k)
|
|
692
|
+
for i in range(n):
|
|
693
|
+
BA[i][i] = _cadd(BA[i][i], c[n - k])
|
|
694
|
+
B = BA
|
|
695
|
+
# f64 舍入系数 → DK 候选(~1e-11 精度,落 Newton 收敛域内)
|
|
696
|
+
cf = [complex(float(c[k][0]), float(c[k][1])) for k in range(n + 1)]
|
|
697
|
+
approx = _dk_roots(cf)
|
|
698
|
+
roots = []
|
|
699
|
+
for z in approx:
|
|
700
|
+
zr = D(repr(z.real))
|
|
701
|
+
zi = D(repr(z.imag))
|
|
702
|
+
for _ in range(100):
|
|
703
|
+
fr, fi = _peval(c, zr, zi)
|
|
704
|
+
dr, di = _pderiv(c, zr, zi)
|
|
705
|
+
den = dr * dr + di * di
|
|
706
|
+
if den == 0:
|
|
707
|
+
break
|
|
708
|
+
sr = (fr * dr + fi * di) / den
|
|
709
|
+
si = (fi * dr - fr * di) / den
|
|
710
|
+
zr -= sr
|
|
711
|
+
zi -= si
|
|
712
|
+
if max(abs(sr), abs(si)) < TINY:
|
|
713
|
+
break
|
|
714
|
+
roots.append(complex(float(zr), float(zi)))
|
|
715
|
+
return roots
|
|
716
|
+
|
|
717
|
+
|
|
718
|
+
def _fl_coefficients(mat):
|
|
719
|
+
"""Faddeev–LeVerrier:p(λ)=det(λI−A)=Σ c[k]λ^k 的系数(c 长 n+1,c[n]=1)。
|
|
720
|
+
|
|
721
|
+
递推:B_1 = I,c_{n-k} = −tr(B_k·A)/k,B_{k+1} = B_k·A + c_{n-k}·I。
|
|
722
|
+
(迹必须取 B_k·A——直接取 tr(B_k) 会双重计数,系数全错。)
|
|
723
|
+
"""
|
|
724
|
+
n = len(mat)
|
|
725
|
+
c = [0.0j] * (n + 1)
|
|
726
|
+
c[n] = 1.0
|
|
727
|
+
B = [[1.0 + 0j if i == j else 0.0j for j in range(n)] for i in range(n)]
|
|
728
|
+
for k in range(1, n + 1):
|
|
729
|
+
BA = [[sum(B[i][t] * mat[t][j] for t in range(n))
|
|
730
|
+
for j in range(n)] for i in range(n)]
|
|
731
|
+
c[n - k] = -sum(BA[i][i] for i in range(n)) / k
|
|
732
|
+
for i in range(n):
|
|
733
|
+
BA[i][i] += c[n - k]
|
|
734
|
+
B = BA
|
|
735
|
+
return c
|
|
736
|
+
|
|
737
|
+
|
|
738
|
+
def _poly_eval(coeffs, z):
|
|
739
|
+
"""Horner 求 Σ coeffs[k]·z^k(必须从最高次项起迭代——
|
|
740
|
+
从 c[0] 正向迭代会得到倒数多项式 z^d·p(1/z))。"""
|
|
741
|
+
r = coeffs[-1]
|
|
742
|
+
for k in range(len(coeffs) - 2, -1, -1):
|
|
743
|
+
r = r * z + coeffs[k]
|
|
744
|
+
return r
|
|
745
|
+
|
|
746
|
+
|
|
747
|
+
def _poly_deriv(coeffs, z):
|
|
748
|
+
"""Horner 求导数 Σ k·coeffs[k]·z^(k−1)。"""
|
|
749
|
+
r = 0.0j
|
|
750
|
+
for k in range(len(coeffs) - 1, 0, -1):
|
|
751
|
+
r = r * z + k * coeffs[k]
|
|
752
|
+
return r
|
|
753
|
+
|
|
754
|
+
|
|
755
|
+
def _dk_roots(c, dk_iters=60):
|
|
756
|
+
"""求 p(λ)=Σ c[k]λ^k 的全体根:逐轮“多起点 DK + Newton 验证 + 降阶”。
|
|
757
|
+
|
|
758
|
+
每轮用多组初值相位做 DK 同步迭代收集候选点,按牛顿步长
|
|
759
|
+
|p(z)|/|p'(z)| 评分,对前列候选逐个 Newton 抛光并验证(收敛且
|
|
760
|
+
未逃逸),接受第一个验证通过的根;仅用已验证根做合成除法降阶
|
|
761
|
+
——绝不接受伪根,避免伪根降阶后的 NaN 级联。
|
|
762
|
+
"""
|
|
763
|
+
n = len(c) - 1
|
|
764
|
+
if n == 0:
|
|
765
|
+
return []
|
|
766
|
+
mono = [z / c[n] for z in c]
|
|
767
|
+
roots = []
|
|
768
|
+
cur = mono
|
|
769
|
+
deg = n
|
|
770
|
+
while deg > 0:
|
|
771
|
+
if deg == 1:
|
|
772
|
+
roots.append(complex(-cur[0]))
|
|
773
|
+
break
|
|
774
|
+
R = 1.0 + max(abs(z) for z in cur[:-1])
|
|
775
|
+
cands = []
|
|
776
|
+
for phase in (0.35, 1.7, 3.05, 4.3, 5.5, 0.9):
|
|
777
|
+
w = [cmath.rect(0.7 * R, 2.0 * math.pi * i / deg + phase)
|
|
778
|
+
for i in range(deg)]
|
|
779
|
+
for _ in range(dk_iters):
|
|
780
|
+
new = [0.0j] * deg
|
|
781
|
+
for i in range(deg):
|
|
782
|
+
den = 1.0 + 0.0j
|
|
783
|
+
for j in range(deg):
|
|
784
|
+
if j != i:
|
|
785
|
+
den *= w[i] - w[j]
|
|
786
|
+
step = (_poly_eval(cur, w[i]) / den
|
|
787
|
+
if abs(den) > 1e-300 else 0.0j)
|
|
788
|
+
new[i] = w[i] - step
|
|
789
|
+
w = new
|
|
790
|
+
if max(abs(z) for z in w) > 100.0 * R:
|
|
791
|
+
break # 逃逸 → 该组初值作废
|
|
792
|
+
cands.extend(w)
|
|
793
|
+
scored = []
|
|
794
|
+
for z in cands:
|
|
795
|
+
if z != z:
|
|
796
|
+
continue
|
|
797
|
+
dp = _poly_deriv(cur, z)
|
|
798
|
+
s = (abs(_poly_eval(cur, z)) / abs(dp)) if dp != 0 \
|
|
799
|
+
else float('inf')
|
|
800
|
+
scored.append((s, z))
|
|
801
|
+
scored.sort(key=lambda t: t[0])
|
|
802
|
+
accepted = None
|
|
803
|
+
for _s, z in scored[:8]:
|
|
804
|
+
r = z
|
|
805
|
+
ok = False
|
|
806
|
+
for _ in range(200):
|
|
807
|
+
f = _poly_eval(cur, r)
|
|
808
|
+
dp = _poly_deriv(cur, r)
|
|
809
|
+
if dp == 0 or r != r or abs(r) > 100.0 * R:
|
|
810
|
+
break
|
|
811
|
+
st = f / dp
|
|
812
|
+
r -= st
|
|
813
|
+
if abs(st) < 1e-13:
|
|
814
|
+
ok = True
|
|
815
|
+
break
|
|
816
|
+
if ok:
|
|
817
|
+
accepted = r
|
|
818
|
+
break
|
|
819
|
+
if accepted is None:
|
|
820
|
+
# 兜底:取评分最低候选(退化模式,随机测试矩阵不会走到)
|
|
821
|
+
accepted = scored[0][1] if scored else 0.0j
|
|
822
|
+
roots.append(complex(accepted))
|
|
823
|
+
# 合成除法降阶:cur = (z − r)·q
|
|
824
|
+
q = [0.0j] * deg
|
|
825
|
+
q[deg - 1] = 1.0
|
|
826
|
+
for k in range(deg - 2, -1, -1):
|
|
827
|
+
q[k] = cur[k + 1] + r * q[k + 1]
|
|
828
|
+
cur = q
|
|
829
|
+
deg -= 1
|
|
830
|
+
return roots
|
|
831
|
+
|
|
832
|
+
|
|
833
|
+
def _solve_pivot(A, b):
|
|
834
|
+
"""列主元高斯消元解 Ax = b(奇异矩阵用最大可用枢轴继续,不抛异常)。"""
|
|
835
|
+
n = len(A)
|
|
836
|
+
work = [list(row) for row in A]
|
|
837
|
+
rhs = list(b)
|
|
838
|
+
for col in range(n):
|
|
839
|
+
p = max(range(col, n), key=lambda r: abs(work[r][col]))
|
|
840
|
+
if p != col:
|
|
841
|
+
work[col], work[p] = work[p], work[col]
|
|
842
|
+
rhs[col], rhs[p] = rhs[p], rhs[col]
|
|
843
|
+
pv = work[col][col]
|
|
844
|
+
if pv == 0:
|
|
845
|
+
continue
|
|
846
|
+
for r in range(col + 1, n):
|
|
847
|
+
f = work[r][col] / pv
|
|
848
|
+
if f != 0:
|
|
849
|
+
for c2 in range(col, n):
|
|
850
|
+
work[r][c2] -= f * work[col][c2]
|
|
851
|
+
rhs[r] -= f * rhs[col]
|
|
852
|
+
x = [0.0j] * n
|
|
853
|
+
for r in range(n - 1, -1, -1):
|
|
854
|
+
pv = work[r][r]
|
|
855
|
+
if pv == 0:
|
|
856
|
+
continue
|
|
857
|
+
s = rhs[r]
|
|
858
|
+
for c2 in range(r + 1, n):
|
|
859
|
+
s -= work[r][c2] * x[c2]
|
|
860
|
+
x[r] = s / pv
|
|
861
|
+
return x
|
|
862
|
+
|
|
863
|
+
|
|
864
|
+
def _eigenvectors_general(mat, evals):
|
|
865
|
+
"""通用 n×n 特征向量(正规方程 + 列主元高斯消元)。
|
|
866
|
+
|
|
867
|
+
解 (A−λI)^H(A−λI) v = e:λ 处该矩阵近奇异,解的方向即零空间
|
|
868
|
+
= 特征向量;若 e 与零空间近正交(解范数过小)换下一坐标方向。
|
|
869
|
+
返回行主序嵌套 list [row][eig_index](与小矩阵路径格式一致),
|
|
870
|
+
第 i 个特征向量对应 evals[i](与 eigvals 顺序一致)。
|
|
871
|
+
"""
|
|
872
|
+
n = len(mat)
|
|
873
|
+
evecs_cols = []
|
|
874
|
+
for lam in evals:
|
|
875
|
+
B = [[0.0j] * n for _ in range(n)]
|
|
876
|
+
for i in range(n):
|
|
877
|
+
for j in range(n):
|
|
878
|
+
s = 0.0j
|
|
879
|
+
for k in range(n):
|
|
880
|
+
aik = mat[k][i] - (lam if k == i else 0.0)
|
|
881
|
+
akj = mat[k][j] - (lam if k == j else 0.0)
|
|
882
|
+
s += aik.conjugate() * akj
|
|
883
|
+
B[i][j] = s
|
|
884
|
+
v = None
|
|
885
|
+
for t in range(n):
|
|
886
|
+
b = [0.0j] * n
|
|
887
|
+
b[t] = 1.0
|
|
888
|
+
cand = _solve_pivot(B, b)
|
|
889
|
+
nrm = math.sqrt(sum(abs(z) ** 2 for z in cand))
|
|
890
|
+
if nrm > 1e-8:
|
|
891
|
+
v = [z / nrm for z in cand]
|
|
892
|
+
break
|
|
893
|
+
if v is None:
|
|
894
|
+
v = [1.0 + 0.0j if i == 0 else 0.0j for i in range(n)]
|
|
895
|
+
evecs_cols.append(v)
|
|
896
|
+
return [[col[i] for col in evecs_cols] for i in range(n)]
|
|
897
|
+
|
|
898
|
+
|
|
899
|
+
def _mat_norm_2d(mat, p):
|
|
900
|
+
"""2-d 嵌套矩阵范数(p: None/'fro'/1/-1/inf/-inf)。complex-aware。"""
|
|
901
|
+
m = len(mat)
|
|
902
|
+
n = len(mat[0]) if m else 0
|
|
903
|
+
if m == 0 or n == 0:
|
|
904
|
+
return 0.0
|
|
905
|
+
if p in (None, 'fro'):
|
|
906
|
+
return math.sqrt(sum(abs(v) ** 2 for row in mat for v in row))
|
|
907
|
+
if p == 1:
|
|
908
|
+
return max(sum(abs(row[j]) for row in mat) for j in range(n))
|
|
909
|
+
if p == -1:
|
|
910
|
+
return min(sum(abs(row[j]) for row in mat) for j in range(n))
|
|
911
|
+
if p in (float('inf'), 'inf'):
|
|
912
|
+
return max(sum(abs(v) for v in row) for row in mat)
|
|
913
|
+
if p in (float('-inf'), '-inf'):
|
|
914
|
+
return min(sum(abs(v) for v in row) for row in mat)
|
|
915
|
+
raise ValueError(f"invalid norm order {p!r} for matrix norm")
|
|
916
|
+
|
|
917
|
+
|
|
918
|
+
def _jacobi_eigh_real(a):
|
|
919
|
+
"""实对称 n×n 矩阵的循环 Jacobi 特征分解(确定性、重特征值稳健)。
|
|
920
|
+
|
|
921
|
+
返回 (特征值升序列表, 特征向量 n×n 嵌套列表)——V[i][j] 为第 j 个
|
|
922
|
+
特征向量的第 i 个分量(列正交)。
|
|
923
|
+
"""
|
|
924
|
+
n = len(a)
|
|
925
|
+
A = [[float(v) for v in row] for row in a]
|
|
926
|
+
V = [[1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
|
|
927
|
+
for _sweep in range(100):
|
|
928
|
+
off = 0.0
|
|
929
|
+
for p in range(n):
|
|
930
|
+
for q in range(p + 1, n):
|
|
931
|
+
off += A[p][q] * A[p][q]
|
|
932
|
+
if off < 1e-300:
|
|
933
|
+
break
|
|
934
|
+
for p in range(n):
|
|
935
|
+
for q in range(p + 1, n):
|
|
936
|
+
apq = A[p][q]
|
|
937
|
+
if abs(apq) < 1e-300:
|
|
938
|
+
continue
|
|
939
|
+
app, aqq = A[p][p], A[q][q]
|
|
940
|
+
if abs(app - aqq) < 1e-16 * max(abs(app), abs(aqq), 1.0):
|
|
941
|
+
t = -1.0
|
|
942
|
+
else:
|
|
943
|
+
tau = (aqq - app) / (2.0 * apq)
|
|
944
|
+
t = -(1.0 if tau >= 0 else -1.0) / (
|
|
945
|
+
abs(tau) + math.sqrt(1.0 + tau * tau))
|
|
946
|
+
c = 1.0 / math.sqrt(1.0 + t * t)
|
|
947
|
+
s = t * c
|
|
948
|
+
for k in range(n):
|
|
949
|
+
if k == p or k == q:
|
|
950
|
+
continue
|
|
951
|
+
akp, akq = A[k][p], A[k][q]
|
|
952
|
+
A[k][p] = A[p][k] = c * akp + s * akq
|
|
953
|
+
A[k][q] = A[q][k] = -s * akp + c * akq
|
|
954
|
+
A[p][p] = c * c * app + s * s * aqq + 2.0 * s * c * apq
|
|
955
|
+
A[q][q] = s * s * app + c * c * aqq - 2.0 * s * c * apq
|
|
956
|
+
A[p][q] = A[q][p] = 0.0
|
|
957
|
+
for k in range(n):
|
|
958
|
+
vkp, vkq = V[k][p], V[k][q]
|
|
959
|
+
V[k][p] = c * vkp + s * vkq
|
|
960
|
+
V[k][q] = -s * vkp + c * vkq
|
|
961
|
+
evals = [A[i][i] for i in range(n)]
|
|
962
|
+
order = sorted(range(n), key=lambda i: evals[i])
|
|
963
|
+
evals = [evals[i] for i in order]
|
|
964
|
+
V = [[V[i][j] for j in order] for i in range(n)]
|
|
965
|
+
return evals, V
|
|
966
|
+
|
|
967
|
+
|
|
968
|
+
def _herm_eigh(a, uplo):
|
|
969
|
+
"""Hermitian(实对称/复 Hermitian)n×n 矩阵特征分解。
|
|
970
|
+
|
|
971
|
+
a: n×n 嵌套列表(实数或复数;按 uplo 指定的三角为有效数据,
|
|
972
|
+
另一侧被忽略);uplo: 'L' 或 'U'。
|
|
973
|
+
返回 (特征值升序实数列表, 特征向量 n×n 嵌套列表——实输入为实、
|
|
974
|
+
复输入为复)。复 Hermitian 走 2n×2n 实对称嵌入
|
|
975
|
+
B = [[Re, -Im], [Im, Re]]:B 的特征值两两成对,特征向量 [x; y]
|
|
976
|
+
对应复特征向量 x + iy。
|
|
977
|
+
"""
|
|
978
|
+
n = len(a)
|
|
979
|
+
|
|
980
|
+
def _cj(v):
|
|
981
|
+
return v.conjugate() if isinstance(v, complex) else v
|
|
982
|
+
|
|
983
|
+
H = []
|
|
984
|
+
for i in range(n):
|
|
985
|
+
row = []
|
|
986
|
+
for j in range(n):
|
|
987
|
+
if (uplo == 'L' and i >= j) or (uplo == 'U' and i <= j):
|
|
988
|
+
row.append(a[i][j])
|
|
989
|
+
else:
|
|
990
|
+
row.append(_cj(a[j][i]))
|
|
991
|
+
H.append(row)
|
|
992
|
+
is_c = any(isinstance(v, complex) for row in H for v in row)
|
|
993
|
+
if not is_c:
|
|
994
|
+
return _jacobi_eigh_real(H)
|
|
995
|
+
R = [[v.real for v in row] for row in H]
|
|
996
|
+
I = [[v.imag for v in row] for row in H]
|
|
997
|
+
B = []
|
|
998
|
+
for i in range(n):
|
|
999
|
+
B.append([R[i][j] for j in range(n)] +
|
|
1000
|
+
[-I[i][j] for j in range(n)])
|
|
1001
|
+
for i in range(n):
|
|
1002
|
+
B.append([I[i][j] for j in range(n)] +
|
|
1003
|
+
[R[i][j] for j in range(n)])
|
|
1004
|
+
evb, Vb = _jacobi_eigh_real(B)
|
|
1005
|
+
evals = [0.5 * (evb[2 * j] + evb[2 * j + 1]) for j in range(n)]
|
|
1006
|
+
evecs = [[complex(Vb[i][2 * j], Vb[n + i][2 * j]) for j in range(n)]
|
|
1007
|
+
for i in range(n)]
|
|
1008
|
+
return evals, evecs
|