HarmonyOS求解函数交点：ArkTS数值算法与Canvas可视化实战

你手里正在做一个HarmonyOS应用，需要用到两个函数交点的求法——这类需求在数学工具、图表分析、物理实验数据处理、工程计算器里都会碰到。我最初是在做图表组件时被问到“能不能直接标注出两条曲线的交点”，才发现这不只是数学课上解方程那么简单：屏幕上要可交互、可缩放、可动态刷新，数据源可能是设备传感器实时采集的，也可能是用户在输入框里手输的表达式。用HarmonyOS的ArkTS声明式开发来做，和以前用传统命令式UI写逻辑的思维方式差别不小，值得单独开一篇整理清楚。

这篇内容定位是HarmonyOS应用实例：函数交点求法。适合正在用ArkTS做应用、需要处理函数曲线可视化与数值计算的同学参考，也适合想把数学计算模块集成进鸿蒙应用的人直接抄作业。文章里我会按实际项目开发的顺序走一遍完整流程，从数学原理到UI布局再到结果校验，最后把我在这个例子里踩过的几个坑也交代清楚。

1. 为什么“求函数交点”不只是一个解方程问题

先聊聊这个题目背后真正要解决的问题。如果你只是想知道两条直线y = x + 1和y = -x + 3的交点，那手算都够，二元一次方程组几秒钟解决。但凡是上升到“应用实例”这个层面，事情就没那么简单了。

1.1 从数学题到应用功能的距离

在HarmonyOS的一个典型应用场景里，“函数交点求法”经常是某个功能的子模块，比如：

• 用户输入两个函数表达式，应用画出曲线后自动标出交点坐标。
• 内嵌数据对比工具，读取两组采样数据拟合成函数后，求交点作为阈值判断依据。
• 物理实验模拟中，求位移和时间两个函数曲线的交点，用于确定相遇时刻。

真要做成一个能交付的功能，必须满足这几条硬指标：

1. 不是只针对特定函数类型。不能假设用户永远输入线性函数，得有办法处理多项式、三角函数、指数函数任意组合出来的表达式。
2. 数值稳定性可接受。用户输入的定义域可能很广，区间内可能没有交点、有一个交点、有多个交点，算法都要能给出合理反馈。
3. 屏幕上可视化和交互要顺畅。HarmonyOS应用大量采用声明式UI写法，ArcCanvas绘图时要确保计算出来的交点能准确映射到屏幕坐标，并且缩放后依然能刷新定位。
4. 计算过程不能卡UI线程。交点求解最可靠的通用方法是数值迭代，比如二分法或牛顿法，量大时需要考虑任务调度。

1.2 为什么通用方法比解析方法实用

从这个app实际使用角度考虑，我直接放弃了符号计算求解析解的方向。原因很直接：ArkTS生态里的符号计算库不如其他平台丰富，且如果用户输入的函数是高次多项式或超越方程，解析式要么不存在，要么推导复杂度不可控，对普通应用来说是负收益。

采用数值求根思路反而更通用：把求两条函数f(x)和g(x)交点的问题，转化为求方程h(x) = f(x) - g(x) = 0的根。这是工程上成熟可靠的做法，配合二分法+扫描区间预处理，就能在一定精度内稳定求得一个或多个实根。

2. 求解算法的核心逻辑与ArkTS实现

接下来进入本篇第一个硬核环节：算法思路和代码落地。

2.1 算法选型：区间扫描+二分法为主

计算函数交点的方式有很多，比如不动点迭代、Newton-Raphson法、割线法、二分法。我实现后觉得最适合当前场景的是二分法为主，扫描法找隔离区间，再用牛顿法加速收敛的组合套路，原因在于：

• 二分法稳定性高，只要初始区间两端点函数值异号，必定收敛。
• 单独用二分法收敛速度是线性的，迭代次数稍多，但在现代机型和ArkTS运行环境中微秒级计算不是问题。
• 牛顿法在根附近收敛快，但初值不好极易发散，所以纯粹用牛顿法在通用场景下并不可靠。
• 对未知函数行为，先用等间距扫描产生一列小区间，只要检测到小区间端点函数值变号，就说明这个小区间里至少存在一个根。

那为什么不直接扫描到精确根？因为扫描步长设得太小，计算量成倍增加；设得太大又会漏根。所以扫描只用来定位一个包含根的区间，精确求值交给二分法，这样既控制了漏根风险，也保证了计算速度。

2.2 函数类型的抽象设计

在ArkTS里，把数学函数抽象成一个可计算类型很关键。由于不同的用户输入会产生不同的函数表达式，可以在代码里定义一个接口：

typescript复制interface MathFunction {
  evaluate(x: number): number;
}

然后构造具体函数类，比如：

typescript复制class LinearFunction implements MathFunction {
  private k: number;
  private b: number;

  constructor(k: number, b: number) {
    this.k = k;
    this.b = b;
  }

  evaluate(x: number): number {
    return this.k * x + this.b;
  }
}

假如想支持用户输入任意表达式，则可以做一个通用的表达式解析器，把字符串转成可执行函数。不过HarmonyOS应用如果承载的运算量大，需要合理控制表达式解析时机。这里建议把解析结果编译成类似函数式求值的结构，不要每次求交点时反复解析字符串。

2.3 核心求解函数实现

以下是基于区间扫描+二分法的核心求解代码，为了贴近真实项目，我按照HarmonyOS ArkTS规范写，并考虑了范围检查、迭代上限、精度控制等细节：

typescript复制/**
 * 交点求解器
 */
export class IntersectionSolver {
  private readonly EPS: number = 1e-6;
  private readonly MAX_SCAN_SEGMENTS: number = 10000;

  /**
   * 在指定区间内求 f(x) = g(x) 的全部交点
   * @param f 第一个函数
   * @param g 第二个函数
   * @param xMin 扫描左边界
   * @param xMax 扫描右边界
   * @returns 交点x坐标数组
   */
  solve(
    f: (x: number) => number,
    g: (x: number) => number,
    xMin: number,
    xMax: number
  ): number[] {
    const results: number[] = [];
    if (xMax <= xMin) {
      return results;
    }

    // 自动估计扫描步长，控制在最多10000段，避免计算爆炸
    const segmentCount = Math.min(
      this.MAX_SCAN_SEGMENTS,
      Math.max(1000, Math.floor((xMax - xMin) / 0.001))
    );
    const step = (xMax - xMin) / segmentCount;

    let prevX = xMin;
    let prevH = f(prevX) - g(prevX);

    for (let i = 1; i <= segmentCount; i++) {
      const currX = xMin + i * step;
      const currH = f(currX) - g(currX);

      if (Math.abs(currH) < this.EPS) {
        // 当前点本身就是根，直接记录，并跳过可能重复区间
        results.push(currX);
        prevX = currX;
        prevH = f(currX) - g(currX);
        continue;
      }

      // 异号说明区间内有根
      if (prevH * currH < 0) {
        const root = this.bisection(
          f, g, prevX, currX
        );
        if (root !== null) {
          results.push(root);
        }
      }

      prevX = currX;
      prevH = currH;
    }

    // 去重并排序
    const unique: number[] = [];
    for (const r of results) {
      if (unique.length === 0 || Math.abs(r - unique[unique.length - 1]) > this.EPS) {
        unique.push(r);
      }
    }
    return unique.sort((a, b) => a - b);
  }

  /**
   * 二分法求根
   */
  private bisection(
    f: (x: number) => number,
    g: (x: number) => number,
    a: number,
    b: number
  ): number | null {
    let low = a;
    let high = b;
    let fLow = f(low) - g(low);
    const fHigh = f(high) - g(high);

    if (Math.abs(fLow) < this.EPS) {
      return low;
    }
    if (Math.abs(fHigh) < this.EPS) {
      return high;
    }
    if (fLow * fHigh > 0) {
      return null;
    }

    for (let i = 0; i < 200; i++) {
      const mid = (low + high) / 2;
      const fMid = f(mid) - g(mid);

      if (Math.abs(fMid) < this.EPS) {
        return mid;
      }

      if (fLow * fMid < 0) {
        high = mid;
      } else {
        low = mid;
        fLow = fMid;
      }

      if (Math.abs(high - low) < this.EPS) {
        return (low + high) / 2;
      }
    }
    return (low + high) / 2;
  }
}

2.4 为什么ArkTS里不建议直接使用匿名函数递归

代码里我把核心数学运算全部封装成普通类方法，这是有原因的。ArkTS对类型标注要求严格，之前有几个版本对匿名函数递归、闭包捕获这块有较多限制，运行时容易出现类型解释异常。在写通用数值算法时，把方法拆成职责单一的普通函数/类方法，再通过方法引用传递，能够避开很多莫名其妙的编译问题。

实测下来，在API 9及以上的HarmonyOS工程中，按照上面这个写法，性能和可读性都很稳。即使是每秒触发几十次重算，也不会卡UI。实际业务如果只求一两个交点，直接调用solve就能拿到结果，接口设计得也方便。

3. 从算法到可视化：UI布局与绘图实现

算出了交点，只是完成了一半工作。在这个HarmonyOS例子里，我选择了可视化展示：绘制两条曲线、标注交点坐标、动态显示求解结果。这需要把数学坐标系和屏幕像素坐标系做一个清晰的映射。

3.1 双坐标系映射关系设计

HarmonyOS的绘图组件一般使用Canvas，其坐标原点默认在左上角，x轴向右，y轴向下。而数学坐标通常原点在左下或中间，y轴向上。如果直接把计算出来的函数值当像素坐标画，曲线会是上下颠倒的，这算新手最常见的坑。

解决方案是维护一个画布范围内的数学视口。比如定义一个数学窗口：

typescript复制interface MathViewport {
  xMin: number;
  xMax: number;
  yMin: number;
  yMax: number;
}

然后写两个转换函数：

typescript复制function mathToCanvasX(viewport: MathViewport, canvasWidth: number, x: number): number {
  return ((x - viewport.xMin) / (viewport.xMax - viewport.xMin)) * canvasWidth;
}

function mathToCanvasY(viewport: MathViewport, canvasHeight: number, y: number): number {
  return canvasHeight - ((y - viewport.yMin) / (viewport.yMax - viewport.yMin)) * canvasHeight;
}

数学坐标y值大时，对应的屏幕y值小，所以要拿canvasHeight去减。

3.2 如何把两条曲线连续绘制出来

画曲线不推荐逐点计算后只用lineTo连接所有点，而是按固定步长采样数学坐标范围内的x值，求出每组(x, y)后转成屏幕坐标再连线。步长理论上越小曲线越平滑，但也越耗时。我在这里将采样点控制在200个左右，完全够肉眼平滑度，性能开销也低。

在HarmonyOS的Canvas组件中，常用方式是：

typescript复制private drawCurve(
  context: CanvasRenderingContext2D,
  viewport: MathViewport,
  width: number,
  height: number,
  func: (x: number) => number,
  color: string
) {
  context.beginPath();
  const segments = 200;
  let started = false;

  for (let i = 0; i <= segments; i++) {
    const x = viewport.xMin + (viewport.xMax - viewport.xMin) * i / segments;
    const y = func(x);

    // 如果函数值远超出可视范围，跳过连线，避免出现竖直长线
    if (y < viewport.yMin - 10 || y > viewport.yMax + 10) {
      started = false;
      continue;
    }

    const canvasX = mathToCanvasX(viewport, width, x);
    const canvasY = mathToCanvasY(viewport, height, y);

    if (!started) {
      context.moveTo(canvasX, canvasY);
      started = true;
    } else {
      context.lineTo(canvasX, canvasY);
    }
  }
  context.strokeStyle = color;
  context.lineWidth = 2;
  context.stroke();
}

这个实现有一个关键细节，当函数在某区间出现突变或无穷大时（比如正切函数），如果不对y值超范围的点做断开处理，会画出一条贯穿画布的直线。实测处理前后效果差异非常大。

3.3 绘制交点标记和坐标信息

结构上可以把交点画成一个实心圆，随附文本标签显示坐标。坐标文本需要在小数位保留上做到清爽，我一般保留两位或四位有效数字。

typescript复制private drawIntersectionPoints(
  context: CanvasRenderingContext2D,
  points: number[],
  f: (x: number) => number,
  viewport: MathViewport,
  width: number,
  height: number
) {
  for (const x of points) {
    const y = f(x);
    const cx = mathToCanvasX(viewport, width, x);
    const cy = mathToCanvasY(viewport, height, y);

    context.beginPath();
    context.arc(cx, cy, 5, 0, Math.PI * 2);
    context.fillStyle = '#007DFF';
    context.fill();

    // 绘制坐标标签
    const label = `(${x.toFixed(3)}, ${y.toFixed(3)})`;
    context.font = '14px sans-serif';
    context.fillStyle = '#333333';
    context.fillText(label, cx + 10, cy - 10);
  }
}

注意：数据点坐标文字的绘制需要避开曲线密集区域，否则会和曲线交叠看不清。项目里如果画布小、交点密集，我建议把坐标信息放在底部列表而不是全部画在图上，交互更好。

4. 完整的HarmonyOS页面实现

现在把算法、绘图、用户交互组装成一个可运行的ArkTS页面。这里用声明式开发范式和@Entry/@Component组织代码。

4.1 页面结构和状态设计

我的页面有三个输入框，分别定义第一个函数、第二个函数、定义域范围，然后一个“求解”按钮，下方是Canvas画布和结果区。

ArkTS的状态驱动UI意味着输入变化、计算结束后，画布重绘逻辑都要通过状态变量触发。做法是用一个dirtyFlag或直接存储函数解析结果，当点击按钮后更新交点和绘图数据。

下面是核心页面结构：

typescript复制@Entry
@Component
struct IntersectionPage {
  @State function1Str: string = 'x + 1';
  @State function2Str: string = '-x + 3';
  @State xMinStr: string = '-10';
  @State xMaxStr: string = '10';
  @State intersections: string[] = [];
  private settings: RenderingContextSettings = new RenderingContextSettings(true);
  private context: CanvasRenderingContext2D = new CanvasRenderingContext2D(this.settings);

  build() {
    Column({ space: 12 }) {
      // 第一行输入
      Row({ space: 8 }) {
        Text('f1:')
        TextInput({ text: this.function1Str })
          .onChange((value: string) => {
            this.function1Str = value;
          })
          .layoutWeight(1)
      }.width('100%').padding({ left: 16, right: 16 })

      // 第二行输入
      Row({ space: 8 }) {
        Text('f2:')
        TextInput({ text: this.function2Str })
          .onChange((value: string) => {
            this.function2Str = value;
          })
          .layoutWeight(1)
      }.width('100%').padding({ left: 16, right: 16 })

      // 求解按钮
      Button('求解交点')
        .onClick(() => {
          this.calculateIntersections();
        })

      // 画布
      Canvas(this.context)
        .width('100%')
        .height(300)
        .onReady(() => {
          this.redraw();
        })

      // 结果列表
      ForEach(this.intersections, (item: string) => {
        Text(item)
          .fontSize(14)
          .margin({ top: 4 })
      }, (item: string) => item)

      Blank()
    }
    .width('100%')
    .height('100%')
    .padding({ top: 20 })
  }
}

4.2 表达式解析策略

ArkTS本身没有内置eval，也不建议用eval。要从“x + 1”这样的字符串得到可计算的函数，需要自己解析或借助现有的表达式解析实现。

对于本项目，我这里实现了一个轻量策略：先将支持范围限定在多项式+基础的三角函数。解析流程分成两步：

1. 词法分析：把字符串拆成数字、运算符、变量、括号、函数名。
2. 语法分析：构建表达式树或转成后缀表达式。

但如果全都手写表达树会增加篇幅且容易绕晕。这里我们为了聚焦“求交点”，引入一个核心思路：允许用户输入内置函数类型而非任意字符串。实际交付版本中，我也确实推荐这样设计，因为普通用户输入任意表达式的边际价值不高，还要维护大量解析逻辑。

例如，让用户选择函数类型（一次函数、二次函数、正弦函数、指数函数），再填参数：

typescript复制class PolynomialFunction implements MathFunction {
  coefficients: number[];

  constructor(coeffs: number[]) {
    this.coefficients = coeffs;
  }

  evaluate(x: number): number {
    let result = 0;
    for (let i = 0; i < this.coefficients.length; i++) {
      result += this.coefficients[i] * Math.pow(x, this.coefficients.length - 1 - i);
    }
    return result;
  }
}

系数从用户输入框解析，这样安全性、可维护性、性能都有保障。

4.3 Component的onReady和重绘管理

Canvas的画布上下文不能过早绘制，必须等组件onReady触发后再执行。这里定义一个redraw方法，功能包括：

• 解析输入框里的函数
• 计算交点
• 擦除画布内容
• 绘制坐标轴
• 绘制两条曲线
• 标注交点

typescript复制private redraw() {
  const canvasWidth = this.context.width;
  const canvasHeight = this.context.height;
  this.context.clearRect(0, 0, canvasWidth, canvasHeight);

  // 解析函数
  const f = this.parseFunction(this.function1Str);
  const g = this.parseFunction(this.function2Str);
  if (!f || !g) {
    return;
  }

  // 设置视口
  const viewport: MathViewport = {
    xMin: parseFloat(this.xMinStr),
    xMax: parseFloat(this.xMaxStr),
    yMin: -10,
    yMax: 10
  };

  // 自动调整y范围，这里简化为固定范围
  this.drawAxes(viewport, canvasWidth, canvasHeight);
  this.drawCurve(this.context, viewport, canvasWidth, canvasHeight, f, '#e84026');
  this.drawCurve(this.context, viewport, canvasWidth, canvasHeight, g, '#0a59f7');

  // 求交点
  const solver = new IntersectionSolver();
  const xs = solver.solve(f, g, viewport.xMin, viewport.xMax);
  this.intersections = xs.map(x => `交点 x=${x.toFixed(4)}, y=${f(x).toFixed(4)}`);
  this.drawIntersectionPoints(this.context, xs, f, viewport, canvasWidth, canvasHeight);
}

如果屏幕旋转或窗口尺寸变化，还需要在onAreaChange里重新绘制，不然会出现画布内容拉伸或错位。

4.4 坐标轴的绘制细节

坐标轴是数学函数可视化里疏导视觉的重要道具，至少要绘制x轴和y轴。

typescript复制private drawAxes(viewport: MathViewport, width: number, height: number) {
  this.context.beginPath();
  this.context.strokeStyle = '#cccccc';
  this.context.lineWidth = 1;

  const xAxisCanvasY = mathToCanvasY(viewport, height, 0);
  const yAxisCanvasX = mathToCanvasX(viewport, width, 0);

  // 画x轴
  this.context.moveTo(0, xAxisCanvasY);
  this.context.lineTo(width, xAxisCanvasY);
  this.context.stroke();

  // 画y轴
  this.context.moveTo(yAxisCanvasX, 0);
  this.context.lineTo(yAxisCanvasX, height);
  this.context.stroke();
}

这种处理方式当定义域包含0时，轴会自然出现在图形内部；当定义域全为正或全为负时，轴会贴边或不可见，比较符合数学绘图直觉。

5. 实测验证：不同函数组合下的表现

写完第一版后，我用几组典型函数做了验证，确保算法不是只在简单的直线上有效。这里展示部分结果，并说明一些值得注意的现象。

5.1 直线与直线

f(x) = x + 1，g(x) = -x + 3，求交点。心算结果是x = 1，y = 2。

使用上面的IntersectionSolver扫描区间[-10, 10]，输出结果是1.000000，说明单根场景表现正常。y值通过f(1)得到2.000000。绘图时，两个交点标注不会重叠，视觉清楚。

5.2 二次函数与直线的两个交点

f(x) = x^2 - 2，g(x) = 0（也就是x轴），在区间[-5, 5]内，应该有正负根号2两个交点。

此时扫描区间端点变号发生在[-2, -1]和[1, 2]，二分法会分别收敛到-1.41421和1.41421附近。该场景验证了在多个隔离区间存在时，算法能正确发现全部交点，而不是只返回一个。

5.3 无交点情况

f(x) = x^2 + 1，g(x) = 0。定义域[-10, 10]内函数值一直大于0，异号区间不存在。solver返回空数组，页面显示空结果列表。这里没有异常或死循环，说明异常分支处理正确。

5.4 周期函数的多交点情况

f(x) = sin(x)，g(x) = 0.5，在[-10, 10]内有多个交点。你会发现固定步长扫描有可能在sin曲线正好切到0.5时因精度问题漏掉根。比如sin(x) = 0.5在x=π/6附近，扫描点如果恰好都落在0.5同一侧且步长太大，的确会错过符号变化。

应对方式是提高扫描分辨率，或把函数相减后的极值点也纳入扫描。不过在实际HarmonyOS应用里，用户大多观察显示区间不那么大，步长足够细，所以问题影响有限。若想更强健，可以结合牛顿法等从多个初值启动找根，再合并。

6. 常见问题排查：从空白画布到交点遗漏

这个实例开发中，我遇到过几个在HarmonyOS环境里非常典型的问题，记录如下方便少走弯路。

6.1 Canvas渲染空白但代码没有报错

现象：按钮点击后没有图形，也没有报错。后来定位是绘制代码执行时机不对：在状态变量更新后立即绘制，此时画布尺寸还未就绪，CanvasRenderingContext2D的width为0。

我的解法：不要在按钮的onClick里直接调用redraw，而是把需要更新的参数存入状态变量，再用一个延迟任务或在下一次布局完成后再调用redraw。简单做法是用setTimeout(() => this.redraw(), 50)。更规范的做法是利用Canvas的onReady和重绘控制，或者在绘制前判断宽高是否为0。

6.2 y方向颠倒导致曲线错乱

第一次画sin函数时发现图形是上下颠倒的，原因是直接拿数学y作为Canvas的y。这个很快通过坐标转换函数解决。凡涉及数学坐标和Canvas坐标互转，都收敛到两个函数里，便于复用和测试。

6.3 交点遗漏在极大值/极小值点

当两条曲线相切（只有一个交点且在该点相切，不穿越）时，差函数h(x)在根的两侧符号不变，异号扫描不管用。比如f(x) = x^2，g(x) = 0，在x=0处是切触交点，h(x) = x^2，恒不小于0，二分法异号判断失效。这类问题需要额外的极值点检测或直接采样计算最小绝对值。我在当前实现里没有过度复杂化，因为相切交点在普通用户输入里频率不高，遇到时给出提示即可。如果你要完整支持，可以对abs(h(x))做最小值搜索，但要注意这属于优化问题，算力成本略高。

6.4 定义域范围过大导致扫描计算量急剧上升

• 区间[a,b]跨越大，比如用户输入[-10000, 10000]，而函数又复杂，就可能导致计算耗时不可忽略。
• 分段数上限设计限制了最坏情况，不设上限会出现计算卡顿。

实践中我对定义域范围做了限制，例如xMin不能小于-10000，xMax不能大于10000，否则提示用户缩小范围。UI提示也是有效引导，因为浏览图形本来就适合局部放大查看。

7. 进阶优化方向：从“可用”到“好用”

最后聊聊从可用到好用的过程中，可以考虑的几个增强方向。

7.1 函数表达式显式解析

如果不想限制用户只输入几种预设函数，可以增加一个真正的表达式解析器，包括词法分析、语法分析、求值过程。这部分在ArkTS里也完全可以实现，核心类是递归下降解析器。不过项目要控制规模，所以按需引入。通用思路是：

• 词法分析阶段识别出操作数、运算符、左右括号、函数名和逗号。
• 语法分析支持加减乘除、幂运算、sin/cos/tan/exp/ln/sqrt等。
• 将解析结果转为函数闭包存储，在求交点和绘图时反复使用。

这会让用户可直接输入sin(x)*cos(x)+1，体验好一个档次。

7.2 与手势缩放联动

HarmonyOS的Canvas容器可以绑定手势事件。用户在图上双指缩放或拖拽时，更新viewport的xMin/xMax/yMin/yMax并重绘，交点和曲线实时变化。这是目前应用市场上“图形计算器”类工具的核心交互。实现方式是维护当前视口状态对象，手势变化后重新计算并调用redraw。

代码如下所示的结构：

typescript复制.gesture(
  PinchGesture()
    .onActionEnd((event: GestureEvent) => {
      // 根据scale调整视口范围
    })
)

不建议直接在onActionUpdate里全量重绘，因为手势事件频率高且每次绘图成本不低。先更新视口，再通过帧回调或节流触发一次redraw，是一个更好的做法。

7.3 多交点结果分组展示

如果交点数量多，图上标注会重叠。可以在画布下方放一个List，每个listItem展示交点的序号和坐标；用户点击某个item后，画布对应位置高亮闪烁。这个方案在手机小屏上尤其重要，能给用户体验带来明显提升。

7.4 性能侧沉淀

数值计算较多时，ArkTS并发机制也同样可以利用，比如把表达式求值放到TaskPool或Worker里，让UI线程只负责渲染。不过在当前实例规模和绝大多数用户需求下，同步计算完全无压力，不需要过度设计。关键点仍是避免在主线程里做超大区间的细粒度扫描。把问题拆分为“求解前限制扫描范围+分段计算+结果汇总”是最稳妥的思路。

7.5 单元测试的必要性

无论做哪个平台，数值算法的正确性验证都不能跳过。在HarmonyOS工程里可以并行写本地测试，对IntersectionSolver做输入输出断言。我建议至少覆盖：无交点、单交点、多交点、切点边界、抛物线开口朝下与水平线的交点、无理数坐标精度。有了测试保护，后续修改表达式解析器或优化绘图流程时才敢放开手脚。

测试用例参考：

typescript复制testCase('testLinearIntersection', () => {
  let cases = new IntersectionSolver();
  let roots = cases.solve(
    (x: number) => { return x + 1; },
    (x: number) => { return -x + 3; },
    -10, 10
  );
  assertEqual(roots.length, 1);
  expect(Math.abs(roots[0] - 1) < 1e-5).toBeTrue();
});

我个人在实际开发时的体会是：把数学模块和UI模块彻底解耦，能让整个应用的核心逻辑变得非常干净。前期多花一点时间把交点求解器的接口和边界条件设计好，后面无论是接图像缩放还是接实时数据，都是一层薄薄的新代码，而不会牵一发动全身地去改老逻辑。

最后再分享一个小技巧：调试交点问题时，不少人习惯盯着控制台打印结果，但在HarmonyOS的真实场景里，眼睛看图形往往比看数值更快发现异常。我每次改完算法，都会先用一组可视化特征明显的函数（比如sin和cos）跑一遍页面，观察交点是否在预想的位置。如果图上是对的，数值结果通常也不会错。图形验证完毕再补精确测试用例，开发效率能提高不少。

如果你也正在做类似的HarmonyOS数学可视化应用，不妨直接基于IntersectionSolver和Canvas重绘这套结构搭起来。至少从我这边的实测结果来看，这套方案能稳稳支撑常见函数交点求解的全部需求，后续加表达式解析、手势缩放也都有清晰的扩展空间。