手把手教你用Python实现正交矩阵和酉矩阵的转换(附代码示例)

随机生成正交矩阵(Matlab) 随机生成n∗nn*n的正交矩阵,先生成随机向量,然后做gram-schmidt正交化。 阅读详情

从正交到酉:用Python驾驭矩阵世界的“旋转”与“共轭”

在数据科学、计算机图形学乃至量子计算的底层,矩阵不仅仅是数字的排列,它们更像是描述空间变换的“语言”。对于开发者而言,理解正交矩阵和酉矩阵,就如同掌握了一门关于“旋转”与“反射”的几何方言,而理解它们之间的转换,则意味着能在实数域和复数域之间自由穿梭,构建更稳健的算法。这篇文章不会停留在枯燥的定义对比上,我们将直接动手,用Python代码作为“手术刀”,解剖这些特殊矩阵的生成、验证与转换。无论你是想优化机器学习中的降维算法,还是希望在图形渲染中实现精确的坐标变换,这里提供的思路和代码都将是你工具箱里的实用利器。

1. 核心概念:不只是数学定义

在深入代码之前,我们需要快速建立一种直观的理解。你可以把正交矩阵想象成在实数空间里的一组“完美直角尺”。它的每一列(或每一行)向量不仅两两垂直(正交),而且长度都为1(单位向量)。这意味着,用它来变换一个向量,向量的长度和向量之间的夹角都不会改变——只有旋转或镜像翻转。一个经典的例子就是二维空间的旋转矩阵。

而酉矩阵,则是正交矩阵在复数域上的推广。在复数空间中,“垂直”和“长度”的概念需要用内积和共轭来重新定义。酉矩阵的列向量在复数内积下是正交单位的。它同样保持向量的“长度”(即范数)和“夹角”。在量子力学中,系统的演化就是用酉矩阵(或称酉算子)来描述的,因为它保证了概率守恒。

那么,它们之间如何联系?一个简单的视角是:所有实数域的正交矩阵,都是复数域上的酉矩阵。因为对于实数矩阵,其共轭转置就等于其转置。因此,从正交矩阵“转换”到酉矩阵,在形式上往往是“免费”的——它本身已经满足条件。我们更多需要处理的挑战是:如何构造一个酉矩阵,或者如何将一个一般的复数矩阵“酉化”。同时,理解与之相关的正规矩阵、Hermite矩阵等家族成员,能帮助我们更好地把握矩阵对角化这一核心工具,这在数值计算中至关重要。

注意:本文的代码示例将大量使用NumPy和SciPy库。确保你的环境已安装它们:pip install numpy scipy。

2. 实战:生成与验证正交矩阵

让我们从更熟悉的实数域开始。生成一个随机的正交矩阵,一个优雅的方法是使用QR分解。任何满秩的方阵,其Q因子就是一个正交矩阵。

import numpy as np
import scipy.linalg as la

def generate_random_orthogonal(n):
    """
    生成一个 n x n 的随机正交矩阵。
    参数:
        n: 矩阵维度。
    返回:
        Q: 一个 n x n 的正交矩阵。
    """
    # 生成一个随机矩阵
    A = np.random.randn(n, n)
    # 进行QR分解,q就是正交矩阵
    Q, _ = la.qr(A)
    return Q

# 生成一个3x3的正交矩阵
Q = generate_random_orthogonal(3)
print("随机生成的正交矩阵 Q:")
print(Q)

生成了矩阵,我们如何严格验证它是否正交?根据定义,需要检查 Q^T * Q 是否等于单位矩阵 I。由于浮点计算存在精度误差,我们不能直接判断完全相等,而应检查其误差是否在可接受的微小范围内。

def is_orthogonal(matrix, tol=1e-10):
    """
    验证一个实数方阵是否为正交矩阵。
    参数:
        matrix: 待验证的方阵。
        tol: 容差,用于处理浮点误差。
    返回:
        bool: 如果正交返回True,否则False。
    """
    n = matrix.shape[0]
    # 计算 matrix^T * matrix
    product = matrix.T @ matrix
    # 与单位矩阵比较
    identity = np.eye(n)
    # 计算Frobenius范数误差
    error = la.norm(product - identity, 'fro')
    return error < tol

# 验证刚才生成的Q
print(f"\nQ是否正交? {is_orthogonal(Q)}")
# 也可以验证逆等于转置的性质
print(f"||Q^T - Q^{-1}|| 误差: {la.norm(Q.T - la.inv(Q), 'fro'):.2e}")

除了随机生成,我们还可以构造具有明确几何意义的正交矩阵,比如旋转矩阵和Householder反射矩阵。这在图形学中非常有用。

def rotation_matrix_2d(theta):
    """生成二维平面旋转theta弧度的正交矩阵。"""
    return np.array([[np.cos(theta), -np.sin(theta)],
                     [np.sin(theta),  np.cos(theta)]])

def householder_reflection(v):
    """
    根据给定向量v生成Householder反射矩阵H,使得 Hv = ||v|| * e1。
    这是一个高效生成正交矩阵的方法,常用于QR分解算法中。
    """
    v = np.array(v, dtype=float).reshape(-1, 1)
    norm_v = la.norm(v)
    if norm_v == 0:
        return np.eye(len(v))
    u = v.copy()
    u[0] -= np.copysign(norm_v, v[0])
    if la.norm(u) == 0:
        return np.eye(len(v))
    u = u / la.norm(u)
    H = np.eye(len(v)) - 2 * (u @ u.T)
    return H

# 示例:构造一个45度旋转矩阵
R = rotation_matrix_2d(np.pi/4)
print(f"\n45度旋转矩阵 R:\n{R}")
print(f"R是否正交? {is_orthogonal(R)}")

# 示例:使用Householder反射将向量[3,4]反射到x轴正方向
vec = np.array([3., 4.])
H = householder_reflection(vec)
print(f"\nHouseholder反射矩阵 H:\n{H}")
print(f"H * [3,4]^T = {H @ vec}") # 结果应为 [5, 0]^T 或 [-5, 0]^T

下表总结了正交矩阵的关键性质和对应的Python验证方法:

性质数学描述Python验证思路
定义$Q^T Q = I$计算 Q.T @ Q,检查与单位矩阵的误差
逆即转置$Q^{-1} = Q^T$比较 la.inv(Q) 与 Q.T 的差异
保范数$|Qx| = |x|$对随机向量x,计算变换前后范数差
保内积$(Qx)^T(Qy) = x^T y$对随机向量x, y,计算变换前后内积差
行列式$\det(Q) = \pm 1$计算 np.linalg.det(Q),检查是否接近±1

3. 探索:生成与验证酉矩阵

现在我们将舞台转移到复数域。生成随机酉矩阵,同样可以借助QR分解,但输入需要是随机复数矩阵。

def generate_random_unitary(n):
    """
    生成一个 n x n 的随机酉矩阵。
    参数:
        n: 矩阵维度。
    返回:
        U: 一个 n x n 的酉矩阵。
    """
    # 生成随机复数矩阵(实部和虚部均服从标准正态分布)
    A = np.random.randn(n, n) + 1j * np.random.randn(n, n)
    # 进行QR分解
    Q, _ = la.qr(A)
    # 注意:numpy/scipy的qr分解返回的Q默认是酉矩阵(对于复数输入)
    return Q

# 生成一个2x2的酉矩阵
U = generate_random_unitary(2)
print("随机生成的酉矩阵 U:")
print(U)

验证酉矩阵,需使用共轭转置(在NumPy中用 .conj().T 或 .T.conj() 表示)。

def is_unitary(matrix, tol=1e-10):
    """
    验证一个复数方阵是否为酉矩阵。
    参数:
        matrix: 待验证的方阵。
        tol: 容差,用于处理浮点误差。
    返回:
        bool: 如果是酉矩阵返回True,否则False。
    """
    n = matrix.shape[0]
    # 计算 matrix^H * matrix,其中^H表示共轭转置
    product = matrix.conj().T @ matrix
    identity = np.eye(n, dtype=complex)
    error = la.norm(product - identity, 'fro')
    return error < tol

print(f"\nU是否为酉矩阵? {is_unitary(U)}")
# 验证 U^H * U 和 U * U^H 都等于I
print(f"||U^H U - I|| 误差: {la.norm(U.conj().T @ U - np.eye(2), 'fro'):.2e}")
print(f"||U U^H - I|| 误差: {la.norm(U @ U.conj().T - np.eye(2), 'fro'):.2e}")

一个重要的特例是,如果一个酉矩阵的所有元素都是实数,那么它自动就是一个正交矩阵。我们可以轻松地将一个正交矩阵“视为”一个特殊的酉矩阵。

# 将一个正交矩阵作为酉矩阵验证
Q_real = generate_random_orthogonal(3) # 之前生成的实数正交矩阵
print(f"\n实数正交矩阵Q:\n{Q_real}")
print(f"将Q作为复数矩阵验证是否为酉矩阵? {is_unitary(Q_real.astype(complex))}")
# 由于是实数,共轭转置就是转置,验证应通过

4. 桥梁:理解正规矩阵家族与对角化

正交矩阵和酉矩阵都属于一个更大的家族:正规矩阵。一个矩阵A是正规的,当且仅当 $A^H A = A A^H$。这个看似简单的条件,蕴含了矩阵可被酉对角化的深刻性质。理解这一点,是掌握它们之间转换关系的关键。

  • 酉矩阵:满足 $U^H U = I$,自然是正规矩阵。
  • 正交矩阵:实数酉矩阵,也是正规矩阵。
  • Hermite矩阵:满足 $A^H = A$,是正规矩阵。实对称矩阵是其实数特例。
  • 反Hermite矩阵:满足 $A^H = -A$,是正规矩阵。实反对称矩阵是其实数特例。

正规矩阵的重要性在于谱定理:一个矩阵是正规的,当且仅当它可以被一个酉矩阵对角化。这意味着存在一个酉矩阵U,使得 $U^H A U = \Lambda$,其中$\Lambda$是对角矩阵(其对角元是A的特征值)。对于实对称矩阵,这个U可以取为正交矩阵。

让我们用代码验证这个性质,并观察不同类型正规矩阵的特征值特点。

def check_normality_and_diagonalize(A):
    """
    检查矩阵是否为正规矩阵,并尝试酉对角化。
    返回特征值和用于对角化的酉矩阵。
    """
    # 检查正规性条件
    AH = A.conj().T
    left = AH @ A
    right = A @ AH
    is_normal = la.norm(left - right, 'fro') < 1e-10

    print(f"矩阵是否为正规矩阵? {is_normal}")

    if is_normal:
        # 使用eig进行特征分解,对于正规矩阵,返回的特征向量矩阵是酉矩阵
        eigenvalues, eigenvectors = la.eig(A)
        # 验证 U^H A U 是否近似为对角阵
        U = eigenvectors
        Lambda = U.conj().T @ A @ U
        # 提取对角线元素,并与计算的特征值比较
        diag_from_u = np.diag(Lambda)
        print(f"特征值 (来自eig): {eigenvalues}")
        print(f"U^H A U 的对角线元素: {diag_from_u}")
        print(f"特征值匹配误差: {la.norm(eigenvalues - diag_from_u):.2e}")
        return eigenvalues, U
    else:
        print("矩阵不是正规矩阵,无法保证被酉矩阵对角化。")
        return None, None

# 示例1:创建一个随机的Hermite矩阵(特征值为实数)
n = 4
# 先创建一个随机复数矩阵B
B = np.random.randn(n, n) + 1j * np.random.randn(n, n)
A_herm = (B + B.conj().T) / 2  # 构造Hermite矩阵: (A+A^H)/2
print("=== Hermite矩阵示例 ===")
evals, U_herm = check_normality_and_diagonalize(A_herm)
print(f"特征值是否为实数? {np.all(np.abs(evals.imag) < 1e-10)}")

# 示例2:创建一个随机的酉矩阵(特征值模长为1)
U_random = generate_random_unitary(n)
print("\n=== 酉矩阵示例 ===")
evals_u, _ = check_normality_and_diagonalize(U_random)
print(f"酉矩阵特征值的模长: {np.abs(evals_u)}") # 应全部接近1

# 示例3:创建一个实对称矩阵(正交对角化)
C = np.random.randn(n, n)
A_sym = C + C.T  # 构造实对称矩阵
print("\n=== 实对称矩阵示例 ===")
# 对于实对称矩阵,使用eigh更高效且稳定,返回的特征向量是正交矩阵
evals_sym, U_sym = la.eigh(A_sym) # U_sym是正交矩阵
print(f"特征值 (来自eigh): {evals_sym}")
print(f"特征向量矩阵U是否正交? {is_orthogonal(U_sym)}")
print(f"U^T A U 是否为对角阵?误差: {la.norm(U_sym.T @ A_sym @ U_sym - np.diag(evals_sym), 'fro'):.2e}")

通过上述代码,你可以直观看到:

  • Hermite矩阵的特征值是实数。
  • 酉矩阵的特征值都落在复平面的单位圆上(模为1)。
  • 实对称矩阵不仅可以被对角化,而且对角化它的矩阵是正交矩阵(实数酉矩阵)。

5. 核心转换:从一般矩阵到酉/正交矩阵的“标准化”

在实际应用中,我们很少需要直接“转换”一个正交矩阵为酉矩阵,因为前者是后者的子集。更常见的需求是:给定一个任意矩阵(例如数据矩阵、变换矩阵),如何得到一个与之相关的正交或酉矩阵?或者,如何将一个接近正交/酉的矩阵(因计算误差而偏离)“投影”回正交/酉矩阵的集合?这个过程通常称为正交化或酉化。

方法一:QR分解与极分解 QR分解我们已经用过多次,它直接将一个矩阵分解为正交矩阵Q和上三角矩阵R。这是最常用的正交化/酉化方法。

def orthogonalize_via_qr(A):
    """通过QR分解获取矩阵A列空间的一组正交/酉基。"""
    Q, R = la.qr(A, mode='economic') # 'economic'模式返回瘦QR分解
    # 对于复数A,Q是酉矩阵;对于实数A,Q是正交矩阵。
    return Q

# 示例:对一个非正交的矩阵进行正交化
A_arbitrary = np.array([[1, 2, 3],
                         [4, 5, 6],
                         [7, 8, 9]], dtype=float)
print("原始矩阵 A (秩可能不足):")
print(A_arbitrary)
Q_qr = orthogonalize_via_qr(A_arbitrary)
print("\n通过QR分解得到的正交基 Q:")
print(Q_qr)
print(f"Q是否正交? {is_orthogonal(Q_qr)}")
# 验证Q的列空间与A的列空间相同(在数值误差内)
print(f"||A - Q R|| 误差: {la.norm(A_arbitrary - Q_qr @ la.qr(A_arbitrary, mode='economic')[1]):.2e}")

另一种优雅的方法是极分解。任何一个方阵A都可以分解为 $A = UP$,其中U是酉矩阵,P是半正定Hermite矩阵。这个U可以看作是A的“酉部分”或“旋转部分”。

def unitary_part_via_polar(A):
    """
    通过极分解获取矩阵A的酉部分。
    对于实数A,返回的U是正交矩阵。
    """
    # 使用SciPy的极分解函数
    U, P = la.polar(A)
    return U

# 示例:对一个可逆矩阵进行极分解
A_invertible = np.array([[2, 1],
                         [1, 2]], dtype=float)
U_polar = unitary_part_via_polar(A_invertible)
print(f"\n矩阵 A:\n{A_invertible}")
print(f"通过极分解得到的正交部分 U:\n{U_polar}")
print(f"U是否正交? {is_orthogonal(U_polar)}")
# 验证极分解 A = U P
P = U_polar.T @ A_invertible  # 对于正交U,P = U^T A
print(f"验证 A - U P 的误差: {la.norm(A_invertible - U_polar @ P):.2e}")

方法二:Gram-Schmidt正交化过程 这是线性代数教科书中的经典方法,虽然数值稳定性不如QR分解,但原理清晰。我们可以实现一个改进的版本(Modified Gram-Schmidt)。

def modified_gram_schmidt(V):
    """
    对列向量组V进行改进的Gram-Schmidt正交化,返回一组标准正交基Q。
    参数:
        V: 形状为 (m, n) 的矩阵,每一列是一个向量。
    返回:
        Q: 形状为 (m, n) 的矩阵,其列是标准正交基。
    """
    m, n = V.shape
    Q = np.zeros((m, n), dtype=V.dtype)
    R = np.zeros((n, n), dtype=V.dtype)

    for j in range(n):
        v = V[:, j].copy()
        for i in range(j):
            R[i, j] = np.vdot(Q[:, i], v) # 使用vdot处理复数内积
            v = v - R[i, j] * Q[:, i]
        R[j, j] = la.norm(v)
        if R[j, j] == 0:
            raise ValueError("输入向量线性相关,无法生成标准正交基。")
        Q[:, j] = v / R[j, j]
    return Q

# 示例:对三个三维向量进行正交化
vectors = np.array([[1, 1, 0],
                    [1, 0, 1],
                    [0, 1, 1]], dtype=float).T # 输入需要是列向量
print("原始向量组 (列):")
print(vectors.T)
Q_gs = modified_gram_schmidt(vectors)
print("\n通过Gram-Schmidt正交化得到的标准正交基 Q (列):")
print(Q_gs.T)
print(f"Q的列是否正交单位? {is_orthogonal(Q_gs)}")

方法三:对称/反对称矩阵的指数映射与Cayley变换 这是一个非常有趣且实用的技巧,用于在特殊矩阵群(如正交群、酉群)和其对应的李代数(如反对称矩阵、反Hermite矩阵)之间建立联系。

  • 从反对称矩阵到正交矩阵:对于任意实反对称矩阵 $K$(满足 $K^T = -K$),矩阵指数 $Q = \exp(K)$ 是一个正交矩阵,且行列式为1(即旋转矩阵)。反之,一个行列式为1的正交矩阵可以通过矩阵对数找到对应的反对称矩阵。
  • 从反Hermite矩阵到酉矩阵:类似地,对于任意反Hermite矩阵 $H$(满足 $H^H = -H$),$U = \exp(H)$ 是一个酉矩阵。
def skew_symmetric_to_orthogonal(K):
    """通过矩阵指数,将反对称矩阵K转换为正交矩阵(旋转矩阵)。"""
    # 使用scipy.linalg.expm计算矩阵指数
    Q = la.expm(K)
    return Q

def orthogonal_to_skew_symmetric(Q, tol=1e-8):
    """通过矩阵对数,将行列式为1的正交矩阵Q转换为反对称矩阵。"""
    # 确保Q是行列式为1的正交矩阵
    if not (is_orthogonal(Q) and np.abs(np.linalg.det(Q) - 1.0) < tol):
        raise ValueError("输入矩阵必须是行列式为1的正交矩阵(旋转矩阵)。")
    K = la.logm(Q)
    # 取其实部(理论上应为纯虚反对称,logm可能返回复数,实部应为0)
    K_real = K.real
    # 验证结果是否为反对称
    if la.norm(K_real + K_real.T, 'fro') > tol:
        print("警告:对数结果不严格反对称,可能存在数值误差。")
    return K_real

# 示例:创建一个3维反对称矩阵(对应三维空间的一个旋转轴和角度)
# 反对称矩阵对应一个三维向量 [kx, ky, kz]
kx, ky, kz = 0.1, 0.2, 0.3
K = np.array([[  0, -kz,  ky],
              [ kz,   0, -kx],
              [-ky,  kx,   0]])
print("反对称矩阵 K:")
print(K)
Q_exp = skew_symmetric_to_orthogonal(K)
print(f"\n通过指数映射 exp(K) 得到的正交矩阵 Q:")
print(Q_exp)
print(f"Q的行列式: {np.linalg.det(Q_exp):.6f}")
print(f"Q是否正交? {is_orthogonal(Q_exp)}")

# 尝试转换回去
K_recovered = orthogonal_to_skew_symmetric(Q_exp)
print(f"\n恢复的反对称矩阵 K_recovered:")
print(K_recovered)
print(f"恢复误差 ||K - K_recovered||: {la.norm(K - K_recovered):.2e}")

Cayley变换是另一种更简单的映射,它避免了计算矩阵指数和对数。对于反对称矩阵K,$Q = (I - K)(I + K)^{-1}$ 是一个正交矩阵(不包含-1特征值)。这个变换在数值优化中很有用,因为它能保持迭代过程中的正交性约束。

def cayley_transform_skew_to_ortho(K):
    """通过Cayley变换,将反对称矩阵K转换为正交矩阵。"""
    n = K.shape[0]
    I = np.eye(n)
    # Q = (I - K) * inv(I + K)
    Q = la.solve(I + K, I - K) # 更稳定,避免显式求逆
    return Q

# 使用上面的反对称矩阵K
Q_cayley = cayley_transform_skew_to_ortho(K)
print("\n通过Cayley变换得到的正交矩阵 Q_cayley:")
print(Q_cayley)
print(f"Q_cayley是否正交? {is_orthogonal(Q_cayley)}")

这些转换方法不仅仅是数学游戏。在机器人学中,用反对称矩阵表示角速度,再指数映射到旋转矩阵,是描述刚体运动的核心。在优化带有正交约束的问题时(如Stiefel流形优化),Cayley变换和指数映射是关键的更新工具。

6. 应用场景:在数据科学与图形学中的落地

理解了生成、验证和转换的方法,我们来看看它们在实际项目中的用武之地。

场景一:主成分分析中的正交基 PCA的目标是找到数据的主成分方向,这些方向构成一组标准正交基。这本质上就是数据协方差矩阵(一个实对称矩阵)的特征分解,特征向量矩阵就是一个正交矩阵。

def pca_orthogonal_basis(X):
    """
    对数据中心化后,计算其主成分(正交基)。
    参数:
        X: 形状 (n_samples, n_features) 的数据矩阵。
    返回:
        components: 形状 (n_features, n_components) 的主成分(特征向量),列是正交的。
        explained_variance: 解释方差。
    """
    # 1. 中心化
    X_centered = X - np.mean(X, axis=0)
    # 2. 计算协方差矩阵 (实对称矩阵)
    cov_matrix = np.cov(X_centered, rowvar=False)
    # 3. 特征分解 (使用eigh处理对称矩阵)
    eigenvalues, eigenvectors = la.eigh(cov_matrix)
    # 4. 按特征值降序排列
    idx = np.argsort(eigenvalues)[::-1]
    eigenvalues = eigenvalues[idx]
    eigenvectors = eigenvectors[:, idx]
    # 返回主成分(特征向量)和解释方差
    return eigenvectors, eigenvalues

# 生成模拟数据
np.random.seed(42)
data = np.random.randn(100, 3) @ np.random.randn(3, 3)  # 构造有相关性的数据
components, evals = pca_orthogonal_basis(data)
print("PCA得到的前两个主成分向量(列):")
print(components[:, :2].T)
print(f"主成分向量是否正交? {is_orthogonal(components)}")
print(f"主成分向量是否单位长度? {np.allclose(np.sum(components**2, axis=0), 1)}")

场景二:图形学中的旋转与反射 在三维图形中,物体的朝向和镜像变换都由3x3正交矩阵表示(行列式为1是旋转,-1是反射)。组合多个旋转时,数值误差可能导致矩阵逐渐偏离正交性,需要重新正交化。

def renormalize_rotation_matrix(R, method='qr'):
    """
    对一个近似旋转矩阵进行重新正交化。
    参数:
        R: 近似旋转矩阵 (3x3)。
        method: 方法,'qr' 或 'polar'。
    返回:
        R_ortho: 重新正交化后的旋转矩阵。
    """
    if method == 'qr':
        # QR分解,并确保Q的行列式为1(避免反射)
        Q, _ = la.qr(R)
        # 调整符号,使行列式为+1
        if np.linalg.det(Q) < 0:
            Q = -Q
        return Q
    elif method == 'polar':
        # 极分解,直接得到正交部分
        U, _ = la.polar(R)
        return U.real # 对于实数输入,U是实数矩阵
    else:
        raise ValueError("方法必须是 'qr' 或 'polar'")

# 模拟一个被噪声污染的旋转矩阵
true_rotation = rotation_matrix_2d(np.pi/6) # 一个2D旋转矩阵,扩展为3D
R_true = np.eye(3)
R_true[:2, :2] = true_rotation

noise = 0.05 * np.random.randn(3, 3)
R_noisy = R_true + noise
print("被噪声污染的旋转矩阵 R_noisy:")
print(R_noisy)
print(f"R_noisy是否正交? {is_orthogonal(R_noisy)}")
print(f"R_noisy的行列式: {np.linalg.det(R_noisy):.6f}")

R_fixed_qr = renormalize_rotation_matrix(R_noisy, 'qr')
print(f"\n使用QR方法重新正交化后的矩阵:")
print(R_fixed_qr)
print(f"是否正交? {is_orthogonal(R_fixed_qr)}")
print(f"行列式: {np.linalg.det(R_fixed_qr):.6f}")
print(f"与真实旋转矩阵的误差: {la.norm(R_fixed_qr - R_true, 'fro'):.2e}")

场景三:量子计算中的酉变换 在量子计算模拟中,量子门由酉矩阵表示。确保模拟中使用的矩阵是严格酉的,对保持概率守恒至关重要。此外,将复杂的酉矩阵分解为基本量子门(也是一系列小酉矩阵)的乘积,是量子电路编译的核心问题。

def ensure_unitary(U, tol=1e-12):
    """
    通过奇异值分解(SVD)将一个近似酉矩阵投影到最近的酉矩阵。
    这是最稳定的酉化方法之一。
    """
    # 进行SVD分解
    u, s, vh = la.svd(U)
    # 最近的酉矩阵是 u @ vh
    U_nearest = u @ vh
    return U_nearest

# 创建一个近似酉矩阵(例如,来自有噪声的模拟)
U_ideal = generate_random_unitary(2)
noise_complex = 0.01 * (np.random.randn(2,2) + 1j*np.random.randn(2,2))
U_noisy = U_ideal + noise_complex
print("近似酉矩阵 U_noisy:")
print(U_noisy)
print(f"U_noisy是否为酉矩阵? {is_unitary(U_noisy)}")

U_corrected = ensure_unitary(U_noisy)
print(f"\n通过SVD投影校正后的矩阵 U_corrected:")
print(U_corrected)
print(f"U_corrected是否为酉矩阵? {is_unitary(U_corrected)}")
print(f"与理想酉矩阵的误差: {la.norm(U_corrected - U_ideal, 'fro'):.2e}")

在处理这些矩阵时,我经常发现QR分解和SVD投影是最可靠的工具。极分解在理论上很优美,但对于接近奇异的矩阵可能不稳定。Gram-Schmidt过程则更适合于教学理解,或者在小规模、需要逐步构造正交基的场景。关键是根据问题的数值特性和你对精度的要求来选择合适的方法。比如在图形学实时渲染中,速度可能比极限精度更重要,可能会采用更快的但精度稍低的重正交化方法;而在科学计算或量子模拟中,数值稳定性则是首要考虑。

Qiskit:量子计算模拟器 本文介绍了 IBM 量子计算开源框架 Qiskit 的安装、功能和使用方法。 阅读详情

相关推荐

STM32F407标准库下ADC多通道DMA采集的配置与优化

本文详细介绍了STM32F407标准库下ADC多通道DMA采集的配置与优化方法。通过GPIO模拟输入配置、ADC时钟和模式设置、DMA传输参数配置等关键步骤,实现高效的多通道数据采集。文章还提供了性能优化技巧和常见问题排查指南,帮助开发者提升采样速率和稳定性。

weixin_29192141的博客 439

Matlab产生正交矩阵

产生一个K*K的正交矩阵A,即满足A^H * A = I K=3; B=rand(K,K)+i*rand(K,K); A=orth(B); Matlab检验: A'*A 查看误差是否合理 E = norm(eye(K)-A'*A,'fro')

jianti9962的博客 7270

PCI Express 权威指南:从协议原理到芯片实现

目录 全文总览第一部分:PCIe体系结构概览第1章 互连技术的演进与PCIe的诞生1.1 从ISA到PCI:并行总线的辉煌与瓶颈1.2 PCI-X的尝试与局限1.3 串行革命:从AGP、PCI到PCIe的范式转移1.4 PCIe的核心优势第2章 PCIe系统全局视角2.1 系统拓扑:Root Complex, Switch, Endpoint的职能与关系2.2 拓扑结构实例:服务器、工作站、嵌入式系统2.3 枚举与配置:系统如何发现和组织PCIe设备2.4 地址空间第3章 PCIe协议分层架构3.1 分层模

qq_42882296的博客 2898

生成矩阵_【原创】构造生成任意正交矩阵的公式

nxn正交矩阵的自由度是n(n-1)/2,本文讲的是如何由n(n-1)/2个自变量x..构造出任意nxn正交矩阵U=f(x..)。步骤如下:根据极坐标变换公式,在n维单元超球上任取单位向量v1,该向量有n-1个自变量:2.由v1构造n-1个互相正交的单位向量h(其中第一列就是v1):其中第1列是v1,后面n-1列是由v1完全决定其中第1列是v1,后面n-1列是由v1完全决定,除去第一列...

weixin_39625872的博客 898

别再为Word转PDF表格变形发愁了!Aspose.Words for Java 19.5 保姆级避坑指南

本文详细介绍了使用Aspose.Words for Java 19.5解决Word转PDF时表格变形问题的完整方案。从格式转换原理到实战技巧,涵盖固定表格宽度、禁用自动调整、强制文本换行等核心方法,并提供高级场景应对策略和性能优化建议,帮助开发者高效处理复杂文档转换需求。

weixin_28702105的博客 267

带挂牵引车前向运动模型推导及仿真实现

牵引车-半挂车的车辆结构与普通的车辆相比增加了一个半挂车,它们之间通过鞍座相连接,为了分析半挂牵引车运动过程中的位姿和状态,本文将基于车辆的机械结构建立对应的运动学模型,该模型基于以下假设: 车辆行驶过程中,道路平坦且无凸凹; 车辆低速行驶,且运行过程中车身无侧倾和俯仰运动; 车辆行驶过程中,轮胎无形变,无侧向滑动,且无侧向力; 牵引车和半挂车均满足阿克曼转向几何原理; 牵引车与半挂车不会发现折叠。

jianmo的博客 3184

如何用matlab生成一个单位正交矩阵?

假设要生成n阶的单位矩阵,先用A=rand(n,n)生成n*n的随机矩阵(一般情况下都是满秩的),然后用B=orth(A)即可得到n*n的单位矩阵。命令就三行 n=5 %假定生成5阶单位矩阵A=rand(n,n)B=orth(A)例如:A=rand(3,3) B=orth(A) A =     0.9649    0.9572    0.1419     0.1576    0.4854

xrj2017的博客 1万+

LiveGBS流媒体平台GB/T28181实战指南:海康NVR物联网卡摄像头注册失败全链路排查与抓包技巧

本文详细解析了LiveGBS流媒体平台中海康NVR物联网卡摄像头注册失败的常见问题及解决方案。通过全链路排查与抓包技巧,包括物联网卡配置、多网卡冲突处理、防火墙设置等,帮助用户快速定位并解决GB/T28181协议下的设备注册难题,提升流媒体平台部署效率。

weixin_29290947的博客 495

线性代数——正交矩阵

正交矩阵 orthogonal matrix正交矩阵的定义正交矩阵性质1)AT是正交矩阵2)A的各行是单位向量且两两正交3)A的各列是单位向量且两两正交4)|A|=1或-1 正交矩阵的定义 如果:AAT=E(E为单位矩阵,AT表示“矩阵A的转置矩阵”。)或ATA=E,则n阶实矩阵A称为正交矩阵。 正交矩阵性质 1)AT是正交矩阵 2)A的各行是单位向量且两两正交 3)A的各列是单位向量且两两正交 ...

DeepWu 4万+

使用CAPL实现DoIP刷写

本文介绍了使用CAPL实现基于DoIP协议的ECU刷写方法,包含完整源码。

qq_56033302的博客 2762

VS Code + Codex 在 WSL 中使用的正确姿势

Codex 登录只能在本地完成。文件仍可通过 UNC 路径访问 WSL → 本地 Codex 就能照常工作。避免在 WSL 内重复安装/登录 Codex 扩展。

yangguangwuyue的博客 9863

python 矩阵特征值分解_讲一下numpy的矩阵特征值分解与奇异值分解

1、特征值分解主要还是调包:from numpy.linalg import eig特征值分解: A = P*B*PT 当然也可以写成 A = QT*B*Q其中B为对角元为A的特征值的对角矩阵,P=QT,首先A得对称正定,然后才能在实数域上分解,>>> A = np.random.randint(-10,10,(4,4))>>>Aarray([[6, 9...

weixin_39757626的博客 1980

搞定ESD(四):ESD干扰耦合路径深入分析(二)

静电放电过程中静电干扰主要通过三种间接耦合方式干扰敏感源,即电场耦合、磁场耦合、地弹。前文已经深入分析了静电放电过程中的电场耦合,今天就谈谈静电放电过程中的磁场耦合,也可以理解环路耦合。熟话说的好〝人往高处走,水往低处流〞,静电电流也会选择阻抗最低的路径返回到源端。静电电流流会源端的路径实际上就构成了电流环路,当敏感信号形成的电流环路与静电电流环路存在共环路时,就会将静电放电干扰耦合到敏感信号环路内,干扰敏感信号。

记得诚 2800

Python实战:用NumPy手搓DFT矩阵(附可视化代码)

本文详细介绍了如何使用NumPy从零构建DFT矩阵,并通过可视化代码揭示其复数矩阵的相位规律。文章涵盖DFT矩阵的数学本质、可视化技巧、物理意义及性能优化实践,帮助读者深入理解数字傅里叶变换的核心原理与应用场景。

weixin_30879169的博客 243

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

从信号处理到图像压缩:用Python手把手理解傅里叶矩阵与FFT的底层原理

本文通过Python代码深入解析傅里叶矩阵与快速傅里叶变换(FFT)的底层原理,从复数矩阵基础到实际图像压缩应用。内容涵盖Hermite矩阵、酉矩阵等核心概念,并通过NumPy实现DFT/FFT对比,最后展示频域滤波在图像处理中的实践价值。

weixin_42619061的博客 224

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

从信号处理到图像压缩:用Python手把手理解傅里叶矩阵与FFT的底层联系

本文深入探讨了傅里叶矩阵与快速傅里叶变换(FFT)的底层联系,通过Python代码从复数矩阵基础到图像压缩应用进行手把手教学。重点解析了傅里叶矩阵的构建、DFT与FFT的效率对比,以及FFT在图像压缩和音频处理中的实际应用,帮助开发者深入理解这一信号处理核心技术。

weixin_30889885的博客 128

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

【点云、图像】学习中 常见的数学知识及其中的关系与python实战[完]

平均值,方差,协方差,奇异值分解,主成分分析法,最小二乘法 详解

weixin_56760882的博客 2121

解方程AX=b与矩阵分解:奇异值分解(SVD分解) 特征值分解 QR分解 三角分解 LLT分解

前言 本博客主要介绍在SLAM问题中常常出现的一些线性代数相关的知识,重点是如何采用矩阵分解的方法,求解线性方程组AX=B。主要参考了《计算机视觉——算法与应用》附录A以及Eigen库的方法。本博客可能不会对分解讲的特别深入,主要是想弄清楚各个分解的条件、分解结果以及应用(或特点)。 包括: 1、三角分解(LU分解) 2、LDLT分解与LLT分解(Cholesky分解) 3、QR分解 4、奇异值分...

Hansry的博客 7037

降维算法

此文是自己的学习博客,主要参考Rachel-Zhang的Stanford机器学习—第十讲. 数据降维 博客中说到,感谢先行的数学家,让许多问题在数学上根本不是问题,也要感谢你们将自己的理解写成博客分享给后来学习者~thx一、为什么要降维? 我们需要一组关于XXX的数据,定义就铺天盖地的来了,百万级个特征拿过来,我们怎么进行机器学习啊?!李航老师在他的博客《机器学习新动向:从人机交互中学习》中提到

panxiaoxie的博客 785

讲一下numpy的矩阵特征值分解与奇异值分解

1、特征值分解 主要还是调包: from numpy.linalg import eig 特征值分解: A = P*B*PT 当然也可以写成 A = QT*B*Q其中B为对角元为A的特征值的对角矩阵,P=QT, 首先A得对称正定,然后才能在实数域上分解, >>> A = np.random.randint(-10,10,(4,...

weixin_30268921的博客 789

QR分解详解:从Gram-Schmidt到Householder的数值计算与应用

矩阵分解是数值线性代数与工程计算中的核心技术,QR分解作为其中一种重要方法,将矩阵拆解为正交矩阵与上三角矩阵的乘积,为求解线性方程组、最小二乘问题和特征值计算提供了稳定高效的途径。理解QR分解通常从Gram-Schmidt正交化出发,该过程将线性无关的列向量逐步转化为标准正交基,而Householder变换则通过反射矩阵逐列消元,是LAPACK等数值库实现QR分解的首选算法。Givens旋转在稀疏矩阵和并行计算中同样扮演关键角色。三种方法在理论等价,但在数值稳定性与计算效率上表现各异。掌握QR分解不仅有助于

weixin_34095889的博客 299

rl4circopt 量子线路优化引擎:电路表示、变换规则与 Cirq 互转实战指南

rl4circopt 是 google-research 仓库中面向量子线路优化任务的"物理引擎":它为量子线路定义了一套精简、可复现的基础表示对象(Gate / Operation / Circuit),并在此基础上提供了一组可组合的变换规则(rules)与线路扫描器,使得用户可以扫描一段线路、发现并应用等价变换来生成优化后的新线路。本文以 [rl4circopt/README.md](http

gitblog_00790的博客 1038

矩阵论核心:从定义、分解到应用与数值问题排查

矩阵是现代科学与工程中描述线性变换和数据处理的基础数学语言。其核心原理在于将抽象的线性映射通过选定的基表示为具体的矩阵,这解释了矩阵乘法、转置、逆等运算规则的由来。掌握矩阵论的技术价值在于,它能将复杂系统抽象为状态向量和转移矩阵,为数据分析、信号处理和优化算法提供统一的建模与分析框架。在实际应用场景中,奇异值分解(SVD)是实现低秩近似和图像压缩的关键,而特征值分解则是主成分分析(PCA)和动力系统分析的核心。理解矩阵范数与条件数有助于诊断数值计算的稳定性,避免因矩阵病态导致的结果失真。本文从工程实践视角,

weixin_34049948的博客 546

矩阵四类基本运算全解析:转置、共轭、共轭转置与求逆

线性代数是机器学习、信号处理与控制理论的基石,而矩阵的四类基本运算——转置、共轭、共轭转置与求逆,则是其中最高频的抽象工具。理解这些运算在复数域下的定义与组合规律,不仅能帮助阅读复杂公式,更能指导工程中的数值实现。本文从对偶空间阐释转置的本质,对比实数与复数域的内积差异,重点剖析乘积反序律、共轭转置与求逆的交换性,并结合 MIMO 检测、正规方程、Riccati 方程等真实场景展示其技术价值。通过 NumPy 数值验证与条件数分析,揭示运算顺序对数值稳定性的深远影响,最终呈现一套由定义、性质到应用的整体记忆

weixin_33762130的博客 615

matlab中生成随机正交矩阵

正交矩阵:AA' = A'A = I 在matlab中生成一个随机正交矩阵的

FacingTheSunCN的专栏 1万+
上一篇: iOS 可分发状态全解析:从 TestFlight 测试到 App Store 上架的关键步骤
下一篇: 嵌入式开发必备:3种高效实现16bit数据高低位交换的实战技巧(附代码)
电竞养老选手
博客等级 码龄4年 61粉丝 1196原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值