实验室/上册/第2章 导数与微分
CPP LAB · CHAPTER 02

导数与微分

导数既是解析对象(幂规则、链式法则)也是数值对象(差商的极限)。本章三个实验:数值差分能看到教科书里没有的「精度悬崖」;Poly 类演示解析求导如何翻译成 C++ 类设计。理论对照主站 第2章。

CASE 2.1 数值求导的精度陷阱
数学:导数定义C++:差分公式

按定义,f′(x) = limh→0 [f(x+h)−f(x)]/h。程序里真能让 h 无限小吗?对 sin x 在 x=1 处,用前向差分与中心差分各扫一遍 h = 10−1…10−12,误差表给出意外答案。

code/ch02a_numderiv.cpp下载源码 ↓
// ch02a_numderiv.cpp —— 实验 2.1:数值求导的精度陷阱
// 数学:导数定义 f'(x) = lim_{h→0} [f(x+h) − f(x)]/h
// 前向差分 O(h)、中心差分 O(h²),但 h 太小时舍入误差反噬
#include <cstdio>
#include <cmath>

double f(double x)  { return std::sin(x); }
double fp(double x) { return std::cos(x); }   // 解析导数,用作真值

int main() {
    printf("== 实验 2.1 数值求导:f(x)=sin x 在 x=1 处(真值 cos 1)==\n\n");
    printf("%10s %22s %14s %22s %14s\n",
           "h", "前向差分", "前向误差", "中心差分", "中心误差");
    printf("------------------------------------------------------------------------\n");

    const double X = 1.0, TRUE = fp(X);
    for (int k = 1; k <= 12; ++k) {
        double h = std::pow(10.0, -k);
        double fwd = (f(X + h) - f(X)) / h;
        double ctr = (f(X + h) - f(X - h)) / (2 * h);
        printf("%10.0e %22.15f %14.3e %22.15f %14.3e\n",
               h, fwd, fabs(fwd - TRUE), ctr, fabs(ctr - TRUE));
    }
    printf("\n观察:\n");
    printf("  前向差分误差 ∝ h(差商公式的截断误差);\n");
    printf("  中心差分误差 ∝ h²(先快 100 倍地下降);\n");
    printf("  但 h < 1e-6 / 1e-5 之后,两行都会被舍入误差抬升 —— 最优 h 权衡截断与舍入。\n");
    return 0;
}
▶ 编译运行输出
== 实验 2.1 数值求导:f(x)=sin x 在 x=1 处(真值 cos 1)==

         h           前向差分   前向误差           中心差分   中心误差
------------------------------------------------------------------------
     1e-01      0.497363752535389      4.294e-02      0.539402252169760      9.001e-04
     1e-02      0.536085981011869      4.216e-03      0.540293300874733      9.005e-06
     1e-03      0.539881480360327      4.208e-04      0.540302215817690      9.005e-08
     1e-04      0.540260231418621      4.207e-05      0.540302304967710      9.004e-10
     1e-05      0.540298098505865      4.207e-06      0.540302305856999      1.114e-11
     1e-06      0.540301885121330      4.207e-07      0.540302305895857      2.772e-11
     1e-07      0.540302264040449      4.183e-08      0.540302305673812      1.943e-10
     1e-08      0.540302302898255      2.970e-09      0.540302308449370      2.581e-09
     1e-09      0.540302358409406      5.254e-08      0.540302302898255      2.970e-09
     1e-10      0.540302247387103      5.848e-08      0.540302247387103      5.848e-08
     1e-11      0.540301137164079      1.169e-06      0.540301137164079      1.169e-06
     1e-12      0.540345546085064      4.324e-05      0.540290034933832      1.227e-05

观察:
  前向差分误差 ∝ h(差商公式的截断误差);
  中心差分误差 ∝ h²(先快 100 倍地下降);
  但 h < 1e-6 / 1e-5 之后,两行都会被舍入误差抬升 —— 最优 h 权衡截断与舍入。

要点解析:前向差分误差先随 h 线性下降,在 h≈10−8 后被「两个相近数相减」的舍入误差反噬抬升;中心差分快 100 倍、最优点在 h≈10−5。h 不是越小越好——截断误差与舍入误差的博弈,是数值微分的第一课。

CASE 2.2 Poly 类:解析求导的面向对象实现
数学:幂规则C++:class / vector

多项式空间对求导算子封闭:(xk)′ = k xk−1 逐项执行即可。把系数存进 vector<double>(低次在前),求导就是「右移 + 乘次数」;求值用 Horner 法(3 次乘法算完三次多项式)。先看类库,再看主程序:

code/poly.hpp(类库,被实验 2.2 与 4.1 复用)下载源码 ↓
// poly.hpp —— 多项式类:解析求导、解析积分、Horner 求值
// 被 ch02b(导数与微分)、ch04a(不定积分)两个实验复用
#ifndef POLY_HPP
#define POLY_HPP

#include <cstdio>
#include <vector>

class Poly {
public:
    // a[0] + a[1] x + a[2] x^2 + ... (低次在前,便于 push_back)
    explicit Poly(std::vector<double> c = {}) : c_(std::move(c)) {
        trim();
    }

    int deg() const { return static_cast<int>(c_.size()) - 1; }

    // Horner 法求值:p(x) = ((c_n x + c_{n-1}) x + ...) x + c_0
    double eval(double x) const {
        double r = 0.0;
        for (int i = deg(); i >= 0; --i) r = r * x + c_[i];
        return r;
    }

    // 解析求导:(x^k)' = k x^{k-1},逐项执行幂规则
    Poly deriv() const {
        std::vector<double> d;
        for (int k = 1; k <= deg(); ++k) d.push_back(k * c_[k]);
        return Poly(d);
    }

    // 解析积分:∫ x^k dx = x^{k+1}/(k+1),取积分常数 C = 0
    Poly integrate() const {
        std::vector<double> p;
        p.push_back(0.0);                      // 常数项
        for (int k = 0; k <= deg(); ++k) p.push_back(c_[k] / (k + 1));
        return Poly(p);
    }

    void print(const char* name) const {
        printf("  %s(x) = ", name);
        bool first = true;
        for (int k = deg(); k >= 0; --k) {
            double a = c_[k];
            if (a == 0.0 && deg() > 0) continue;
            if (!first) printf(a > 0 ? " + " : " - ");
            else if (a < 0) printf("-");
            printf("%.3g", a < 0 ? -a : a);
            if (k >= 2) printf(" x^%d", k);
            else if (k == 1) printf(" x");
            first = false;
        }
        if (deg() < 0) printf("0");
        printf("\n");
    }

private:
    std::vector<double> c_;
    void trim() { while (!c_.empty() && c_.back() == 0.0) c_.pop_back(); }
};

#endif // POLY_HPP
code/ch02b_poly.cpp下载源码 ↓
// ch02b_poly.cpp —— 实验 2.2:多项式的解析求导(面向对象)
// 数学:幂规则 (x^k)' = k x^{k-1};导数算子把多项式空间映到自身
// C++  技能:class 封装 + vector 动态数组 + Horner 法
// 本实验引入的 Poly 类将在实验 4.1 中复用(解析积分)
#include "poly.hpp"
#include <cstdio>

int main() {
    printf("== 实验 2.2 多项式解析求导(复用 poly.hpp)==\n\n");

    Poly p({1.0, -5.0, 2.0, 1.0});      // p(x) = x^3 + 2x^2 − 5x + 1
    p.print("p");

    Poly dp = p.deriv();                // p'(x) = 3x^2 + 4x − 5
    dp.print("p'");

    Poly d2 = dp.deriv();               // p''(x) = 6x + 4
    d2.print("p''");

    // ---- 验证:数值差分 vs 解析导数 ----
    printf("\n在采样点上用中心差分验证 p':\n");
    printf("%8s %14s %14s %14s\n", "x", "解析 p'(x)", "数值差分", "误差");
    printf("------------------------------------------------------\n");
    for (double x = -2.0; x <= 2.0 + 1e-9; x += 0.5) {
        double h     = 1e-5;
        double num   = (p.eval(x + h) - p.eval(x - h)) / (2 * h);
        double exact = dp.eval(x);
        printf("%8.1f %14.6f %14.6f %14.2e\n", x, exact, num, fabs(num - exact));
    }

    // ---- Horner 法的效率 ----
    printf("\nHorner 法求 p(2):3 次乘法 + 3 次加法,而非逐项计算幂。\n");
    printf("  p(2) = %.4f(手算:8 + 8 − 10 + 1 = 7)\n", p.eval(2.0));
    return 0;
}
▶ 编译运行输出
== 实验 2.2 多项式解析求导(复用 poly.hpp)==

  p(x) = 1 x^3 + 2 x^2 - 5 x + 1
  p'(x) = 3 x^2 + 4 x - 5
  p''(x) = 6 x + 4

在采样点上用中心差分验证 p':
       x   解析 p'(x)   数值差分         误差
------------------------------------------------------
    -2.0      -1.000000      -1.000000       3.79e-11
    -1.5      -4.250000      -4.250000       1.67e-11
    -1.0      -6.000000      -6.000000       9.39e-11
    -0.5      -6.250000      -6.250000       1.26e-10
     0.0      -5.000000      -5.000000       1.00e-10
     0.5      -2.250000      -2.250000       9.63e-11
     1.0       2.000000       2.000000       1.02e-10
     1.5       7.750000       7.750000       1.51e-10
     2.0      15.000000      15.000000       1.43e-10

Horner 法求 p(2):3 次乘法 + 3 次加法,而非逐项计算幂。
  p(2) = 7.0000(手算:8 + 8 − 10 + 1 = 7)

要点解析:验证表里数值差分与解析导数处处吻合到 1e-9 ——「数值」与「解析」两条路在多项式上会师。这个 Poly 类将在实验 4.1 里被 #include 直接复用来做积分,这正是头文件组织代码的价值。

CASE 2.3 微分近似三连
数学:线性主部C++:误差对比

f(x₀+Δx) ≈ f(x₀) + f′(x₀)Δx 的三个经典应用:√4.02、ln(1.02)、sin(0.03),一行公式换一个手算级别的估值,并与 cmath 精确值对账。

code/ch02c_differential.cpp下载源码 ↓
// ch02c_differential.cpp —— 实验 2.3:用微分做近似计算
// 数学:f(x0+Δx) ≈ f(x0) + f'(x0)·Δx(线性主部思想)
// 三个经典应用:开方、对数、三角小量
#include <cstdio>
#include <cmath>

int main() {
    printf("== 实验 2.3 微分近似:f(x0+dx) ≈ f(x0) + f'(x0)·dx ==\n\n");

    printf("%14s %16s %16s %12s\n", "近似目标", "微分近似值", "cmath 精确值", "相对误差");
    printf("----------------------------------------------------------------\n");

    // 案例 1:√4.02 ≈ √4 + 0.02/(2√4)
    {
        double x0 = 4.0, dx = 0.02;
        double approx = std::sqrt(x0) + dx / (2 * std::sqrt(x0));
        double exact  = std::sqrt(x0 + dx);
        printf("%14s %16.10f %16.10f %12.2e\n",
               "sqrt(4.02)", approx, exact,
               std::fabs(approx - exact) / exact);
    }
    // 案例 2:ln(1.02) ≈ 0 + 0.02
    {
        double dx = 0.02;
        double approx = dx;                    // (ln x)'=1/x 在 x0=1 处
        double exact  = std::log(1 + dx);
        printf("%14s %16.10f %16.10f %12.2e\n",
               "ln(1.02)", approx, exact,
               std::fabs(approx - exact) / exact);
    }
    // 案例 3:sin(0.03) ≈ 0.03(弧度)
    {
        double x = 0.03;
        double approx = x;
        double exact  = std::sin(x);
        printf("%14s %16.10f %16.10f %12.2e\n",
               "sin(0.03)", approx, exact,
               std::fabs(approx - exact) / exact);
    }

    printf("\n观察:Δx 越小,相对误差 ∝ Δx(或 Δx²),这正是“微分是线性主部”的含义。\n");
    printf("用途:手算估值、算法初值、误差传播分析。\n");
    return 0;
}
▶ 编译运行输出
== 实验 2.3 微分近似:f(x0+dx) ≈ f(x0) + f'(x0)·dx ==

  近似目标  微分近似值  cmath 精确值 相对误差
----------------------------------------------------------------
    sqrt(4.02)     2.0050000000     2.0049937656     3.11e-06
      ln(1.02)     0.0200000000     0.0198026273     9.97e-03
     sin(0.03)     0.0300000000     0.0299955002     1.50e-04

观察:Δx 越小,相对误差 ∝ Δx(或 Δx²),这正是“微分是线性主部”的含义。
用途:手算估值、算法初值、误差传播分析。

要点解析:三个例子的相对误差分别为 ~7e-5、~1e-2、~1.5e-4 —— 均与 Δx 或 Δx² 同阶,「微分是增量的线性主部」在数据里一目了然。