最近在复习信号处理和机器学习时,常常遇到“傅里叶变换是函数空间上的线性变换”这种说法。对于习惯了有限维向量和矩阵的我们来说,把函数当作向量,把积分当作内积,把变换看作矩阵乘法,这种视角既抽象又迷人。但网上资料要么过于数学化,要么过于零散,缺少一个从程序员和工程师视角切入的、能建立直观理解的桥梁。

本文尝试用“线性代数”的思维,重新审视我们熟悉的傅里叶级数和傅里叶变换。我们将看到,函数确实可以构成一个“向量空间”,而傅里叶变换正是在这个无限维空间中进行“基变换”和“坐标投影”的过程。无论你是想深入理解信号处理的数学基础,还是对机器学习中的核方法、函数逼近感到好奇,这种“泛函分析”的视角都能提供强大的直觉。本文将从最基础的向量空间概念讲起,逐步构建起函数空间、内积、正交基等概念,并用 Python 代码进行可视化验证,力求让抽象的概念变得可触摸、可运行。

1. 背景与核心概念:从有限维向量到无限维函数

我们熟悉的线性代数,处理的是有限维向量空间,比如三维空间中的向量 v = (x, y, z) 。在这个空间里,我们可以定义向量的加法、数乘、内积(点积)、长度(模)和夹角。一组向量如果线性无关且能张成整个空间,它们就可以作为这个空间的一组“基”。任何一个向量都可以唯一地表示为这组基向量的线性组合,组合系数就是该向量在这组基下的“坐标”。

那么,函数能不能也享受这种待遇呢?

考虑所有定义在区间 [0, 2π] 上、平方可积的复值函数构成的集合。所谓“平方可积”,粗略理解就是函数的“能量”有限,即积分 ∫ |f(x)|² dx 存在且有限。这个集合记作 L²([0, 2π]) 。

令人惊奇的是,这个函数集合 L²([0, 2π]) 满足向量空间的所有公理:

  • 加法封闭性 :两个平方可积函数相加,结果仍是平方可积函数。
  • 数乘封闭性 :一个平方可积函数乘以一个标量(实数或复数),结果仍是平方可积函数。
  • 存在零元 :零函数 f(x) = 0 是平方可积的。
  • 其他如结合律、交换律、分配律等也都成立。

因此, L²([0, 2π]) 本身就是一个向量空间 。只不过,这个空间的“向量”不是有限个数字的排列,而是整个函数 f(x) 。这是一个 无限维 的向量空间,因为你需要无穷多个线性无关的函数才能“张成”它(例如,所有单项式 1, x, x², x³, ... 都线性无关)。

既然是一个向量空间,我们自然想为它定义“内积”,从而可以谈论长度、角度和正交。对于函数,最自然的内积定义是: ⟨f, g⟩ = ∫_a^b f(x) g*(x) dx 其中 g*(x) 表示 g(x) 的复共轭(如果是实函数,就是 g(x) 本身),积分区间 [a, b] 根据问题而定(对于周期函数,常取一个周期长度,如 [0, 2π] 或 [-π, π] )。

这个内积衡量了两个函数在整个区间上的“相似程度”。如果内积为0,我们就说这两个函数 正交 ,类似于三维空间中垂直的向量。

有了内积,我们就可以定义函数的“长度”(或称范数): ||f|| = sqrt(⟨f, f⟩) = sqrt(∫ |f(x)|² dx) 。这其实就是函数能量的平方根。

傅里叶级数的核心思想 就此浮现:在函数空间 L²([0, 2π]) 中,我们能否找到一组 标准正交基 ,使得任何函数都能方便地表示为这组基的线性组合?

答案是肯定的。这组著名的基就是: { e^{ikx} / sqrt(2π) } ,其中 k 为所有整数, i 是虚数单位。可以验证,这组函数是两两正交的: ⟨e^{ikx}, e^{ilx}⟩ = ∫_0^{2π} e^{ikx} (e^{ilx})* dx = ∫_0^{2π} e^{i(k-l)x} dx = { 2π, if k=l; 0, if k≠l } 归一化后(除以 sqrt(2π) ),它们就成了一组标准正交基。

那么,函数 f(x) 在这组基下的“坐标”是什么?正是通过内积计算得到的投影系数: c_k = ⟨f, e^{ikx} / sqrt(2π) ⟩ = (1/sqrt(2π)) ∫_0^{2π} f(x) e^{-ikx} dx 这几乎就是傅里叶级数的系数公式(差一个归一化常数)。而函数 f(x) 就可以写成: f(x) = Σ_{k=-∞}^{∞} c_k * (e^{ikx} / sqrt(2π)) 这就是傅里叶级数展开。 傅里叶变换,本质上就是求一个函数在一组特定正交基(复指数函数)下的坐标。

2. 环境准备与版本说明

为了将上述数学概念可视化并验证,我们将使用 Python 进行实验。以下环境配置足以完成本文的所有示例。

  • 操作系统 : Windows 10/11, macOS, 或 Linux 发行版均可。
  • Python 版本 : 3.8 或以上。本文示例在 Python 3.9 下测试通过。
  • 核心库 :
    • numpy : 用于数值计算和数组操作。
    • scipy : 提供科学的傅里叶变换等高级函数。
    • matplotlib : 用于绘制函数图像和频谱图。
  • 安装命令 : 如果你使用 pip ,可以通过以下命令安装所需库:
    pip install numpy scipy matplotlib
    
    如果你使用 Anaconda,这些库通常已预装。
  • IDE 或编辑器 : 任意你熟悉的即可,如 VS Code, PyCharm, Jupyter Notebook 等。Jupyter Notebook 特别适合进行交互式探索和可视化。

版本兼容性说明 :本文代码侧重于展示概念,对库的特定小版本不敏感。只要使用较新的稳定版本,通常不会有问题。如果遇到警告或弃用提示,请参考对应库的最新官方文档进行调整。

3. 核心原理拆解:内积、正交与投影

理解了函数空间是一个向量空间后,我们需要掌握三个最核心的操作:计算内积、判断正交、以及进行投影。这些是连接线性代数与傅里叶分析的桥梁。

3.1 函数内积的数值计算

在连续数学中,内积是积分。在计算机中,我们只能处理离散采样后的数据。因此,我们将区间 [a, b] 离散化为 N 个点: x = np.linspace(a, b, N, endpoint=False) 。 endpoint=False 是为了避免在周期边界上重复计算最后一个点。

对于两个采样后的函数值数组 f_vals 和 g_vals ,它们的内积近似为黎曼和: ⟨f, g⟩ ≈ Σ_{n=0}^{N-1} f_vals[n] * np.conj(g_vals[n]) * dx 其中 dx = (b - a) / N 是采样间隔, np.conj 用于处理可能存在的复数。

让我们用代码实现它,并验证一些性质。

import numpy as np
import matplotlib.pyplot as plt

def inner_product(f_vals, g_vals, a, b):
    """
    计算两个离散化函数在区间[a,b]上的内积近似值。
    参数:
        f_vals, g_vals: 在等间距点上的函数值数组,长度相同。
        a, b: 积分区间的起点和终点。
    返回:
        内积值(复数)。
    """
    N = len(f_vals)
    dx = (b - a) / N
    # 使用黎曼和近似积分
    return np.sum(f_vals * np.conj(g_vals)) * dx

# 示例1:定义区间和采样
a, b = 0, 2 * np.pi
N = 1000
x = np.linspace(a, b, N, endpoint=False)
dx = x[1] - x[0]

# 定义两个实函数:sin(x) 和 cos(x)
f_vals = np.sin(x)
g_vals = np.cos(x)

# 计算内积
ip = inner_product(f_vals, g_vals, a, b)
print(f"内积 <sin(x), cos(x)> 在 [0, 2π] 上 ≈ {ip:.6f}")
print(f"理论值应为: 0 (因为sin和cos在一个完整周期上正交)")
print(f"绝对误差: {abs(ip):.2e}")

运行这段代码,你会发现计算出的内积是一个非常接近0的小数(例如 1e-16 量级),这验证了 sin(x) 和 cos(x) 在 [0, 2π] 上是(近似)正交的。误差来源于数值离散化和浮点数计算。

3.2 标准正交基:复指数函数

现在来看我们函数空间的一组候选基: ψ_k(x) = e^{ikx} / sqrt(2π) ,其中 k 是整数。标准正交性要求:

  1. 每个基函数的范数(长度)为1: ||ψ_k|| = 1 。
  2. 不同基函数之间正交: ⟨ψ_k, ψ_l⟩ = 0 ,当 k ≠ l 。

让我们用代码验证 k=0, 1, 2 的几个基函数。

def normalized_complex_exp(k, x):
    """返回归一化的复指数基函数 e^(ikx) / sqrt(2π) 在点x处的值。"""
    return np.exp(1j * k * x) / np.sqrt(2 * np.pi)

# 验证标准正交性
print("验证标准正交基 {e^(ikx)/sqrt(2π)}:")
for k in [0, 1, 2]:
    for l in [0, 1, 2]:
        psi_k_vals = normalized_complex_exp(k, x)
        psi_l_vals = normalized_complex_exp(l, x)
        ip = inner_product(psi_k_vals, psi_l_vals, a, b)
        # 由于是数值计算,设置一个容忍度来判断是否为0或1
        if k == l:
            print(f"  <ψ_{k}, ψ_{l}> = {ip.real:.6f} (应为 1)")
        else:
            # 内积应为纯虚数或0,我们看它的模
            print(f"  <ψ_{k}, ψ_{l}> = {ip:.6f} (应为 0)")

输出会显示,当 k=l 时,内积非常接近1(实部接近1,虚部接近0);当 k≠l 时,内积的模非常接近0。这强有力地证明了这组函数在离散意义下构成了标准正交基。

3.3 投影:求傅里叶系数

一旦有了标准正交基,求一个函数 f(x) 在某一个基方向 ψ_k 上的“坐标”(即投影系数)就非常简单了,就是求内积: c_k = ⟨f, ψ_k⟩

这个 c_k 就是傅里叶系数(对于周期函数)或傅里叶变换(对于非周期函数,需要连续化)的离散版本。它告诉我们,函数 f(x) 中含有多少频率为 k 的复指数成分。

def fourier_coefficient(f_vals, k, x, a, b):
    """
    计算函数f在基ψ_k上的投影系数(傅里叶系数)。
    参数:
        f_vals: 函数在采样点x上的值。
        k: 频率索引(整数)。
        x: 采样点数组。
        a, b: 积分区间。
    返回:
        复数系数 c_k。
    """
    psi_k_vals = normalized_complex_exp(k, x)
    ck = inner_product(f_vals, psi_k_vals, a, b)
    return ck

# 以一个简单的函数为例:f(x) = sin(x) + 0.5*cos(2x)
f_vals = np.sin(x) + 0.5 * np.cos(2*x)

# 计算前5个频率的系数(k从-2到2)
coefficients = {}
for k in range(-2, 3):
    ck = fourier_coefficient(f_vals, k, x, a, b)
    coefficients[k] = ck
    print(f"c_{k} = {ck:.6f}")

# 根据理论,sin(x) = (e^{ix} - e^{-ix})/(2i), cos(2x) = (e^{i2x}+e^{-i2x})/2
# 因此,在归一化基下,我们期望:
# c_1 和 c_{-1} 与 sin(x) 相关,且互为共轭。
# c_2 和 c_{-2} 与 cos(2x) 相关,且相等。
print("\n理论分析:")
print("c_1 应主要包含 sin(x) 的信息,且 c_{-1} = -conj(c_1)")
print(f"c_1: {coefficients[1]}")
print(f"c_-1: {coefficients[-1]}")
print(f"c_2 和 c_-2 应相等,且包含 0.5*cos(2x) 的信息")
print(f"c_2: {coefficients[2]}")
print(f"c_-2: {coefficients[-2]}")

观察输出,你会发现 c_1 和 c_{-1} 是纯虚数且互为相反数, c_2 和 c_{-2} 是实数且近似相等。这与理论完全吻合,验证了投影系数的正确性。

4. 完整实战:从函数到频谱与重构

现在,我们将完成一个完整的流程:给定一个函数,计算其在一组正交基上的所有重要系数(频谱),然后利用这些系数重构原函数,并观察重构的精度。

4.1 创建目标函数并采样

我们选择一个包含多个频率成分的函数,以便观察频谱。

# 定义目标函数:一个方波与一个正弦波的叠加
def target_function(x):
    # 一个简单的方波,周期为2π
    square_wave = np.where(np.sin(x) > 0, 1, -1)
    # 一个高频正弦波
    sin_wave = 0.3 * np.sin(5 * x)
    return square_wave + sin_wave

# 采样
a, b = -np.pi, np.pi  # 使用对称区间
N = 2000  # 增加采样点以提高精度
x = np.linspace(a, b, N, endpoint=False)
f_vals = target_function(x)

# 绘制原函数
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.plot(x, f_vals, 'b-', linewidth=1.5, label='f(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('目标函数 (方波 + sin(5x))')
plt.grid(True, alpha=0.3)
plt.legend()

4.2 计算傅里叶系数(离散频谱)

我们不再手动循环计算每个系数,而是利用 NumPy 的快速傅里叶变换 (FFT) 算法。FFT 高效地计算了所有 k 从 0 到 N-1 的系数,但需要注意其输出的排序和归一化。

# 使用FFT计算离散傅里叶系数
# FFT计算的是: F_k = Σ_{n=0}^{N-1} f_n * exp(-2πi * k * n / N)
# 这和我们定义的内积 ⟨f, e^{ikx}⟩ 形式一致,但区间和归一化不同。
# 我们的区间是 [a, b] = [-π, π],长度为 L = 2π。
# 采样点 x_n = a + n*dx, dx = L/N。
# 因此 e^{-ikx_n} = e^{-ik(a + n*dx)} = e^{-ika} * e^{-ik n dx}
# 而 k dx = k * (2π/N) = 2πk/N。所以FFT的指数项匹配。
# 但FFT结果 F_k 对应的是未归一化的系数,且求和代替了积分。
# 真正的系数 c_k = (1/L) * F_k * dx * e^{ika}? 更简单的做法是调整输入。

# 更直接的方法:利用我们定义的内积函数,但只计算一部分频率。
# 为了效率,我们计算前M个和后M个系数。
M = 50  # 计算从 -M 到 M 的系数
coeffs = {}
for k in range(-M, M+1):
    ck = fourier_coefficient(f_vals, k, x, a, b)
    coeffs[k] = ck

# 准备绘制频谱的数据
freqs = list(coeffs.keys())
coeff_vals = np.array([coeffs[k] for k in freqs])
# 频谱的模(幅度)
magnitudes = np.abs(coeff_vals)
# 频谱的相位
phases = np.angle(coeff_vals)

# 绘制幅度谱
plt.subplot(1, 2, 2)
plt.stem(freqs, magnitudes, linefmt='C1-', markerfmt='C1o', basefmt='C7-')
plt.xlabel('频率 k')
plt.ylabel('|c_k|')
plt.title(f'傅里叶系数幅度谱 (k从 -{M} 到 {M})')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

运行后,你会看到左边的函数图像和右边的频谱图。频谱图在 k=±1, ±3, ±5, ... (方波的奇次谐波)以及 k=±5 (我们添加的 sin(5x) )处有显著的峰值。这正是方波傅里叶级数的特征。

4.3 利用系数重构函数

根据傅里叶级数展开式,我们可以用得到的系数 c_k 和基函数 ψ_k 来重构原函数: f_reconstructed(x) = Σ_{k=-M}^{M} c_k * ψ_k(x)

def reconstruct_from_coeffs(coeff_dict, x, a, b):
    """
    使用有限个傅里叶系数重构函数。
    参数:
        coeff_dict: 字典,键为频率k,值为系数c_k。
        x: 需要重构的点的数组。
        a, b: 原始积分区间,用于基函数。
    返回:
        重构的函数值数组。
    """
    f_recon = np.zeros_like(x, dtype=complex)  # 初始化为复数数组
    for k, ck in coeff_dict.items():
        psi_k_vals = normalized_complex_exp(k, x)
        f_recon += ck * psi_k_vals
    # 对于实值函数,重构结果应为实数(虚部接近0)
    return f_recon.real

# 使用我们计算出的系数进行重构
f_recon_vals = reconstruct_from_coeffs(coeffs, x, a, b)

# 绘制原函数与重构函数的对比
plt.figure(figsize=(10, 4))
plt.plot(x, f_vals, 'b-', linewidth=2, alpha=0.7, label='原函数')
plt.plot(x, f_recon_vals, 'r--', linewidth=1.5, label=f'重构 (M={M})')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.title('函数重构对比')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# 计算重构误差
error = f_vals - f_recon_vals
mse = np.mean(error**2)
print(f"重构的均方误差 (MSE): {mse:.6f}")
print(f"最大绝对误差: {np.max(np.abs(error)):.6f}")

你会看到,使用 M=50 (即101个系数)已经能够非常精确地重构出原函数,除了在方波的跳变点(吉布斯现象)附近有一些振荡。误差非常小,这证明了我们的“坐标投影-线性组合”过程是有效的。

4.4 探索不同数量的系数对重构的影响

让我们直观感受一下,使用不同数量的傅里叶系数(即不同维度的子空间投影)重构函数的效果。

M_list = [1, 5, 10, 20]
plt.figure(figsize=(12, 8))
for i, M in enumerate(M_list):
    # 计算有限个系数
    limited_coeffs = {k: coeffs.get(k, 0) for k in range(-M, M+1)}
    f_recon_limited = reconstruct_from_coeffs(limited_coeffs, x, a, b)
    
    plt.subplot(2, 2, i+1)
    plt.plot(x, f_vals, 'b-', alpha=0.4, label='原函数')
    plt.plot(x, f_recon_limited, 'r-', linewidth=1.5, label=f'M={M}')
    plt.xlabel('x')
    plt.ylabel('f(x)')
    plt.title(f'使用频率 |k| <= {M} 重构')
    plt.legend()
    plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

这个对比图清晰地展示了线性代数中的“投影”思想:我们是在用一个有限维的子空间(由 |k|<=M 的基函数张成)去逼近一个无限维空间中的函数。 M 越大,子空间维度越高,逼近效果越好。

5. 常见问题与排查思路

在将傅里叶分析理解为函数空间线性代数的过程中,以及在数值实现时,常会遇到一些困惑和问题。

问题现象 可能原因 解决思路与解释
计算的内积不为零,即使理论上是正交的 1. 数值误差(主要)。
2. 采样点数 N 太少,离散化误差大。
3. 积分区间未取完整周期。
1. 检查结果是否是一个极小的数(如 1e-15 )。这是浮点数计算的固有误差,可忽略。
2. 增加采样点数 N 。
3. 确保积分区间是函数的完整周期(对于周期函数)。对于 sin(x) 和 cos(x) ,区间长度必须是 2π 的整数倍。
重构的函数是复数,且有较大的虚部 1. 系数计算或重构时代码错误,未正确处理共轭。
2. 原函数是复函数,这很正常。
3. 数值误差累积。
1. 最关键检查 :确保内积定义中第二个函数取了共轭 np.conj(g_vals) 。
2. 对于实函数,重构结果 f_recon 应接近实数。取 .real 属性作为最终结果。
3. 检查基函数 ψ_k(x) 的归一化因子是否正确。
高频分量(大的|k|)的系数幅度不衰减 1. 函数本身不光滑或含有间断点(如方波),高频分量本就重要。
2. 混叠现象:采样频率不足( N 太小),高频信号被误认为低频。
1. 这是正常现象,例如方波的频谱按 1/k 衰减。
2. 确保采样频率( N/(b-a) )大于信号最高频率的两倍(奈奎斯特采样定理)。对于给定 M ,采样点数 N 应显著大于 2M 。
使用FFT结果直接绘图,频谱图看起来不对 FFT输出的频率顺序是 [0, 1, ..., N/2, -N/2+1, ..., -1] ,并且未经过正确的缩放。 使用 np.fft.fftshift 将零频分量移到中心。对于幅度谱,通常绘制 np.abs(fft_result) 。要获得物理频率,需要计算 freqs = np.fft.fftfreq(N, d=dx) 。仔细查阅 numpy.fft 文档。
吉布斯现象:在间断点附近重构函数总是过冲 这是用有限项傅里叶级数逼近间断函数的固有数学特性,不是程序错误。 增加项数 M 可以减少振荡的宽度,但过冲的幅度不会低于约9%。这是函数空间逼近中的一个经典现象。如果需要更平滑的逼近,可以考虑使用其他基函数(如小波)或滤波方法。
“函数空间是无限维的”到底是什么意思? 概念理解上的困难。 类比:三维空间需要3个基向量(如x,y,z轴)。要描述一个任意函数,你需要无穷多个“坐标”(傅里叶系数),因为每个点 x 的函数值 f(x) 都可以独立变化。这意味着需要无穷多个线性无关的基函数才能表示所有可能的函数。

6. 最佳实践与工程建议

将傅里叶分析视为线性代数,不仅有助于理解,也能指导我们更好地在实践中应用它。

  1. 理解域与基的选择是关键

    • 时域/空域 :函数 f(x) 本身。这里的“基”是狄拉克δ函数(脉冲函数),每个坐标就是函数在该点的值。但这种表示对于分析频率成分不方便。
    • 频域 :傅里叶系数 {c_k} 。基是复指数函数 e^{ikx} 。这种表示揭示了信号的频率结构。
    • 选择哪种基? 取决于你的问题。压缩信号?频域基可能更稀疏。处理突变?小波基可能更好。这就像在三维空间中,根据问题选择直角坐标系、球坐标系还是圆柱坐标系。
  2. 数值实现的注意事项

    • 采样与混叠 :始终牢记奈奎斯特采样定理。采样频率 f_s 必须大于信号最高频率 f_max 的两倍。在计算前,对信号进行适当的低通滤波(抗混叠滤波)是工程上的必要步骤。
    • 频谱泄露 :如果采样区间不是信号周期的整数倍,FFT 会产生频谱泄露(能量扩散到其他频率)。可以通过加窗函数(如汉宁窗)来缓解,但需明白这会改变原始信号。
    • 归一化 :不同的库(如 numpy.fft , scipy.fft )和教科书可能使用不同的归一化约定( 1 , 1/N , 1/sqrt(N) )。在混合使用代码或比较结果时,务必清楚你使用的约定。本文为了与内积定义一致,使用了 1/sqrt(2π) 的归一化。
  3. 从傅里叶级数到傅里叶变换

    • 本文主要讨论周期函数和傅里叶级数,其频谱是离散的( k 为整数)。
    • 对于非周期函数,需要将周期 T 推向无穷大,傅里叶级数演变为傅里叶变换,频谱从离散 ( c_k ) 变为连续 ( F(ω) )。此时,“基”是连续频率的复指数函数 e^{iωx} ,内积中的求和变为对整个实轴的积分。理解这种“连续基”和“连续坐标”的概念,是泛函分析中“希尔伯特空间”理论的起点。
  4. 超越傅里叶:其他正交函数系

    • 复指数函数不是唯一的选择。在特定区间和权函数下,还有许多其他正交函数系,各有其适用场景:
      • 勒让德多项式 :区间 [-1,1] ,权函数 1 。常用于球面问题。
      • 切比雪夫多项式 :区间 [-1,1] ,权函数 1/sqrt(1-x²) 。在多项式逼近中最小化最大误差。
      • 埃尔米特多项式 :区间 (-∞,∞) ,权函数 e^{-x²} 。与量子力学谐振子相关。
      • 小波 :兼具时域和频域局部性的正交基,非常适合分析非平稳信号。
    • 掌握“根据问题选择合适基”的思想,是应用泛函分析方法的精髓。
  5. 在机器学习中的应用直觉

    • 核方法 :许多核函数(如高斯核)可以看作是在某个高维(甚至无限维)特征空间中的内积。这个特征空间就是一个函数空间。
    • 函数逼近 :神经网络可以看作是在学习一个从输入到输出的复杂函数。每一层都在进行某种非线性变换,而整个网络结构定义了函数空间的一个特定子集。
    • 注意力机制 :可以理解为模型学习为序列中不同位置的信息分配不同的“权重”,这类似于用一组自适应的基函数去表示序列。

通过本文的探索,我们建立了一种强大的心智模型: 函数即向量,变换即基的切换 。傅里叶变换不再是一个神秘的积分公式,而是一个在无穷维函数空间中,将向量(函数)从一组基(时域脉冲)变换到另一组基(频域复指数)的优雅操作。这种视角为你打开了一扇门,让你能够以统一的线性代数语言,去理解更广泛的信号处理、微分方程求解和机器学习中的函数学习问题。

Logo

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目,面向数字基础设施四大核心场景(服务器、云计算、边缘计算、嵌入式),全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐