CASE 2.1
数值求导的精度陷阱
数学:导数定义C++:差分公式
按定义,f′(x) = limh→0 [f(x+h)−f(x)]/h。程序里真能让 h 无限小吗?对 sin x 在 x=1 处,用前向差分与中心差分各扫一遍 h = 10−1…10−12,误差表给出意外答案。
// 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
// 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² 同阶,「微分是增量的线性主部」在数据里一目了然。