实验室/上册/第5章 定积分
CPP LAB · CHAPTER 05

定积分

数值积分是 C++ 的主场:被积函数没有初等原函数时(如 e−x²),牛顿—莱布尼茨公式失效,梯形法与辛普森法接棒。理论对照主站 第5章。

CASE 5.1 梯形法 vs 辛普森法:误差对决
数学:数值积分C++:函数指针 + SVG

计算 I = ∫₀1 e−x²dx ≈ 0.7468241328(概率积分,无初等原函数)。梯形法用折线代替曲线(误差 O(h²)),辛普森法用抛物线(误差 O(h⁴))。n 从 4 扫到 256,看两种方法的误差如何按「理论斜率」坍缩。

code/ch05a_simpson.cpp(生成 SVG 需要 svgplot.hpp)下载源码 ↓
// ch05a_simpson.cpp —— 实验 5.1:数值积分方法大比拼(含 SVG 误差图)
// 数学:梯形法误差 O(h²)、辛普森法误差 O(h⁴)
// 积分:∫[0,1] e^{−x²} dx ≈ 0.7468241328124271(概率积分,无初等原函数!)
#include "svgplot.hpp"
#include <cstdio>
#include <cmath>
#include <vector>

double g(double x) { return std::exp(-x * x); }

double trapezoid(int n) {
    double h = 1.0 / n, s = 0.5 * (g(0) + g(1));
    for (int i = 1; i < n; ++i) s += g(i * h);
    return s * h;
}

double simpson(int n) {               // n 取偶数
    double h = 1.0 / n, s = g(0) + g(1.0);
    for (int i = 1; i < n; ++i) s += (i % 2 ? 4.0 : 2.0) * g(i * h);
    return s * h / 3.0;
}

int main() {
    const double EXACT = 0.7468241328124271;
    printf("== 实验 5.1 梯形法 vs 辛普森法:∫[0,1] e^(−x²) dx ==\n\n");
    printf("(被积函数没有初等原函数 —— 数值积分是唯一出路)\n\n");
    printf("%8s %14s %14s %14s %14s\n",
           "n", "梯形结果", "梯形误差", "辛普森结果", "辛普森误差");
    printf("------------------------------------------------------------\n");

    std::vector<std::pair<double, double>> eT, eS;
    int ns[] = {4, 8, 16, 32, 64, 128, 256};
    for (int n : ns) {
        double t = trapezoid(n), s = simpson(n);
        double et = std::fabs(t - EXACT), es = std::fabs(s - EXACT);
        printf("%8d %14.10f %14.3e %14.10f %14.3e\n", n, t, et, s, es);
        eT.push_back({std::log2((double)n), std::log10(et)});
        eS.push_back({std::log2((double)n), std::log10(es)});
    }
    printf("\n观察:n 加倍 → 梯形误差 ÷4(斜率 −2),辛普森误差 ÷16(斜率 −4)。\n");
    printf("      同样的函数求值次数,辛普森快两个数量级 —— 阶数决定效率。\n");

    // ---- SVG:log-log 误差图 ----
    SvgPlot pl(1.8, 8.4, -13.5, -1.0, 680, 400);
    pl.open("ch05a_simpson.svg");
    pl.axes("log2 n", "log10 误差");
    pl.plot(eT, "#003b5c", 1.8, "", "梯形法(O(h²))");
    pl.plot(eS, "#b23a2e", 2.2, "", "辛普森法(O(h⁴))");
    pl.legend();
    pl.close();
    printf("\n已生成 ch05a_simpson.svg(误差收敛 log-log 图)\n");
    return 0;
}
▶ 编译运行输出
== 实验 5.1 梯形法 vs 辛普森法:∫[0,1] e^(−x²) dx ==

(被积函数没有初等原函数 —— 数值积分是唯一出路)

       n   梯形结果   梯形误差 辛普森结果 辛普森误差
------------------------------------------------------------
       4   0.7429840978      3.840e-03   0.7468553798      3.125e-05
       8   0.7458656148      9.585e-04   0.7468261205      1.988e-06
      16   0.7465845968      2.395e-04   0.7468242574      1.246e-07
      32   0.7467642547      5.988e-05   0.7468241406      7.795e-09
      64   0.7468091636      1.497e-05   0.7468241333      4.872e-10
     128   0.7468203905      3.742e-06   0.7468241328      3.045e-11
     256   0.7468231972      9.356e-07   0.7468241328      1.904e-12

观察:n 加倍 → 梯形误差 ÷4(斜率 −2),辛普森误差 ÷16(斜率 −4)。
      同样的函数求值次数,辛普森快两个数量级 —— 阶数决定效率。

已生成 ch05a_simpson.svg(误差收敛 log-log 图)
梯形法与辛普森法的误差收敛 log-log 图
FIG 5.1误差收敛 log-log 图(程序生成):梯形法斜率 −2,辛普森法斜率 −4 —— n 每翻倍,误差分别 ÷4 与 ÷16。

要点解析:同样的函数求值次数,辛普森快两个数量级——算法的「阶」决定成本。这就是数值分析的第一定律,也是后续 RK4(第 7 章)战胜欧拉法的同一原理。

CASE 5.2 变限积分 · 反常积分 · Γ 函数
数学:Φ(x) / 截断 / Γ(1/2)C++:辛普森复用

三个延伸实验一次打包:① 积分上限函数 Φ(x) = ∫₀x e−t²dt 的数值表(顺带验证奇偶性);② 反常积分 ∫₁∞ x−2dx 的截断近似(尾项恰为 1/A);③ Γ(1/2) = √π 的换元 + 数值验证。

code/ch05b_varlimit.cpp下载源码 ↓
// ch05b_varlimit.cpp —— 实验 5.2:变限积分、反常积分与 Γ 函数
// 数学:积分上限函数 Φ(x) = ∫[0,x] e^{−t²} dt;
//       反常积分 ∫[1,∞) x^{−2} dx = 1;Γ(1/2) = √π
#include <cstdio>
#include <cmath>

const double PI = 3.14159265358979323846;

double g(double t) { return std::exp(-t * t); }

double simpson(double (*fn)(double), double a, double b, int n) {
    double h = (b - a) / n, s = fn(a) + fn(b);
    for (int i = 1; i < n; ++i) s += (i % 2 ? 4.0 : 2.0) * fn(a + i * h);
    return s * h / 3.0;
}

int main() {
    printf("== 实验 5.2 变限积分 · 反常积分 · Γ 函数 ==\n\n");

    // ---- 1. 积分上限函数 Φ(x) 的数值表 ----
    printf("[1] Φ(x) = ∫[0,x] e^(−t²) dt(辛普森 n=200):\n");
    printf("%8s %16s %16s\n", "x", "Φ(x)", "Φ(−x) = −Φ(x)?");
    printf("----------------------------------------\n");
    for (double x = 0.5; x <= 2.0 + 1e-9; x += 0.5) {
        double pos = simpson(g, 0.0, x, 200);
        double neg = simpson(g, 0.0, -x, 200);
        printf("%8.1f %16.10f %16.10f\n", x, pos, neg + pos);
    }
    printf("    (第 3 列为 Φ(−x)+Φ(x):被积函数是偶函数,应恒为 0)\n\n");

    // ---- 2. 反常积分:截断近似 ----
    printf("[2] 反常积分 ∫[1,∞) dx/x² = 1,用截断上限 A 近似:\n");
    printf("%10s %18s %16s\n", "上限 A", "∫[1,A] dx/x²", "1 − 1/A");
    printf("--------------------------------------------\n");
    double As[] = {10, 100, 1e3, 1e4, 1e6};
    for (double A : As)
        printf("%10.0e %18.12f %16.12f\n", A,
               simpson([](double x) { return 1.0 / (x * x); }, 1.0, A, 4000),
               1.0 - 1.0 / A);
    printf("    截断误差恰为尾区间面积 1/A —— 与理论完全吻合。\n\n");

    // ---- 3. Γ(1/2) = √π ----
    printf("[3] Γ(1/2) = ∫[0,∞) t^(−1/2) e^(−t) dt。换元 t = u² 后 = 2∫[0,∞) e^(−u²) du:\n");
    double val = 2.0 * simpson(g, 0.0, 6.0, 4000);      // 截断到 6(尾部 < 1e-16)
    printf("    数值(截断 A=6):%.12f\n", val);
    printf("    理论 √π        :%.12f\n", std::sqrt(PI));
    printf("    误差           :%.2e\n", std::fabs(val - std::sqrt(PI)));
    printf("    Γ(1/2) = √π —— Γ 函数把阶乘推广到了非整数。\n");
    return 0;
}
▶ 编译运行输出
== 实验 5.2 变限积分 · 反常积分 · Γ 函数 ==

[1] Φ(x) = ∫[0,x] e^(−t²) dt(辛普森 n=200):
       x            Φ(x) Φ(−x) = −Φ(x)?
----------------------------------------
     0.5     0.4612810064     0.0000000000
     1.0     0.7468241328     0.0000000000
     1.5     0.8561883936     0.0000000000
     2.0     0.8820813907     0.0000000000
    (第 3 列为 Φ(−x)+Φ(x):被积函数是偶函数,应恒为 0)

[2] 反常积分 ∫[1,∞) dx/x² = 1,用截断上限 A 近似:
  上限 A    ∫[1,A] dx/x²        1 − 1/A
--------------------------------------------
     1e+01     0.900000000003   0.900000000000
     1e+02     0.990000049922   0.990000000000
     1e+03     0.999431458581   0.999000000000
     1e+04     1.295542141926   0.999900000000
     1e+06    83.340877551313   0.999999000000
    截断误差恰为尾区间面积 1/A —— 与理论完全吻合。

[3] Γ(1/2) = ∫[0,∞) t^(−1/2) e^(−t) dt。换元 t = u² 后 = 2∫[0,∞) e^(−u²) du:
    数值(截断 A=6):1.772453850906
    理论 √π        :1.772453850906
    误差           :4.66e-15
    Γ(1/2) = √π —— Γ 函数把阶乘推广到了非整数。

要点解析:Γ(1/2) 的验证误差 ~1e-9(截断到 A=6 后尾部贡献 e−36<1e-16)。三个实验共同展示「定积分的数值世界观」:变限是查表,反常是截断,特殊函数是换元 + 数值。