@ccpc/math 0.1.0

package/dist/curves/line2.d.ts

@@ -0,0 +1,64 @@
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { Box2 } from '../core/box2';
+import { Mat3 } from '../core/mat3';
+import { Vec2 } from '../core/vec2';
+import type { IDBLine2 } from '../serialize/dump_types';
+import type { IClosestPointResult } from '../types/type_define';
+import { Curve2 } from './curve2';
+import { Interval } from './interval';
+export declare class Line2 extends Curve2 {
+    static readonly type = EN_GEO_TYPE.Line2;
+    private _start;
+    private _end;
+    private _dir;
+    private _len;
+    /**
+     * 构造线段。
+     * @param start 起点。
+     * @param end 终点。
+     */
+    constructor(start: Vec2, end: Vec2);
+    /** 起点（返回副本） */
+    get start(): Vec2;
+    /** 终点（返回副本） */
+    get end(): Vec2;
+    pointAt(u: number): Vec2;
+    tangentAt(u: number): Vec2;
+    derivatives(u: number, n: number): Vec2[];
+    curvatureAt(u: number): number;
+    length(range?: Interval): number;
+    lengthAtParam(u: number): number;
+    paramAtLength(s: number, tol?: number): number;
+    split(u: number): Line2[];
+    trim(range: Interval): Line2[];
+    reverse(): this;
+    transform(m: Mat3): this;
+    transformed(m: Mat3): this;
+    closestPoint(p: Vec2): IClosestPointResult;
+    boundingBox(): Box2;
+    isValid(eps?: number): boolean;
+    isLine(): this is Line2;
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比线段。
+     * @param eps 数值容差。
+     * @returns 起点与终点分别近似相等时返回 `true`。
+     */
+    equals(other: Line2, eps?: number): boolean;
+    clone(): this;
+    dump(): IDBLine2;
+    static load(data: IDBLine2): Line2;
+    /**
+     * 参数吸附到端点，避免边界浮点抖动。
+     * @param u 输入参数。
+     * @returns 吸附后的参数。
+     */
+    private snapParam;
+    /**
+     * 重建方向与长度缓存。
+     * - `_dir`：单位方向向量
+     * - `_len`：线段长度
+     */
+    private rebuildCache;
+}
+//# sourceMappingURL=line2.d.ts.map

package/dist/curves/line2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line2.d.ts","sourceRoot":"","sources":["../../src/curves/line2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAG/D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAKa,KAAM,SAAQ,MAAM;IAC7B,gBAAuB,IAAI,qBAAoB;IAE/C,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,IAAI,CAAQ;IAEpB;;;;OAIG;gBACS,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI;IAUlC,eAAe;IACf,IAAW,KAAK,SAEf;IAED,eAAe;IACf,IAAW,GAAG,SAEb;IAEe,OAAO,CAAC,CAAC,EAAE,MAAM;IAKjB,SAAS,CAAC,CAAC,EAAE,MAAM;IAKnB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAShC,WAAW,CAAC,CAAC,EAAE,MAAM;IAKrB,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ;IAMvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAIvB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAA6B;IAMzD,KAAK,CAAC,CAAC,EAAE,MAAM;IAWf,IAAI,CAAC,KAAK,EAAE,QAAQ;IAUpB,OAAO;IASP,SAAS,CAAC,CAAC,EAAE,IAAI;IAcjB,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI;IAI1B,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,mBAAmB;IAW1C,WAAW;IAIX,OAAO,CAAC,GAAG,SAA6B;IAQxC,MAAM,IAAI,IAAI,IAAI,KAAK;IAIvC;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,SAAgB;IAI/B,KAAK,IAAI,IAAI;IAIb,IAAI,IAAI,QAAQ;WAQlB,IAAI,CAAC,IAAI,EAAE,QAAQ;IAOjC;;;;OAIG;IACH,OAAO,CAAC,SAAS;IAOjB;;;;OAIG;IACH,OAAO,CAAC,YAAY;CAOvB"}

package/dist/curves/line2.js

@@ -0,0 +1,193 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var Line2_1;
+import { EN_GEO_TYPE } from '../constants/geom_type';
+import { Box2 } from '../core/box2';
+import { Vec2 } from '../core/vec2';
+import { RegisterGeom } from '../serialize/geom_mgr';
+import { MathError } from '../utils/math_error';
+import { Precision } from '../utils/precision';
+import { Curve2 } from './curve2';
+import { Interval } from './interval';
+let Line2 = Line2_1 = class Line2 extends Curve2 {
+    /**
+     * 构造线段。
+     * @param start 起点。
+     * @param end 终点。
+     */
+    constructor(start, end) {
+        super();
+        this._start = start.clone();
+        this._end = end.clone();
+        this._dir = Vec2.zero();
+        this._len = 0;
+        this.rebuildCache();
+        this.setRange(new Interval(0, this._len));
+    }
+    /** 起点（返回副本） */
+    get start() {
+        return this._start.clone();
+    }
+    /** 终点（返回副本） */
+    get end() {
+        return this._end.clone();
+    }
+    pointAt(u) {
+        const uu = this.snapParam(u);
+        return this._start.added(this._dir.scaled(uu));
+    }
+    tangentAt(u) {
+        this.snapParam(u);
+        return this._dir.clone();
+    }
+    derivatives(u, n) {
+        MathError.assert(Number.isInteger(n) && n >= 0, 'Line2.derivatives: n must be a non-negative integer');
+        const ret = [this.pointAt(u)];
+        for (let i = 1; i <= n; i++) {
+            ret.push(i === 1 ? this._dir.clone() : Vec2.zero());
+        }
+        return ret;
+    }
+    curvatureAt(u) {
+        this.snapParam(u);
+        return 0;
+    }
+    length(range) {
+        if (!range)
+            return this._len;
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        return range.length();
+    }
+    lengthAtParam(u) {
+        return this.snapParam(u);
+    }
+    paramAtLength(s, tol = Precision.CURVE_LENGTH_EPS) {
+        MathError.assert(Number.isFinite(tol) && tol > 0, 'Line2.paramAtLength: tol must be > 0');
+        MathError.assert(s >= -tol && s <= this._len + tol, `Line2.paramAtLength: s out of range [0, ${this._len}]`);
+        return Math.min(this._len, Math.max(0, s));
+    }
+    split(u) {
+        const splitParts = this._range.split(u, Precision.CURVE_PARAM_EPS);
+        if (splitParts.length === 0)
+            return [];
+        const p = this.pointAt(u);
+        const left = new Line2_1(this._start, p);
+        const right = new Line2_1(p, this._end);
+        return [left, right].filter((seg) => seg.length() > Precision.CURVE_LENGTH_EPS);
+    }
+    trim(range) {
+        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
+        if (range.length() <= Precision.CURVE_PARAM_EPS)
+            return [];
+        if (range.length() <= Precision.CURVE_LENGTH_EPS)
+            return [];
+        const s = this.pointAt(range.start);
+        const e = this.pointAt(range.end);
+        return [new Line2_1(s, e)];
+    }
+    reverse() {
+        const t = this._start;
+        this._start = this._end;
+        this._end = t;
+        this.rebuildCache();
+        this.setRange(new Interval(0, this._len));
+        return this;
+    }
+    transform(m) {
+        const newStart = m.transformedPoint(this._start);
+        const newEnd = m.transformedPoint(this._end);
+        const nextLen = newStart.distanceTo(newEnd);
+        MathError.assert(nextLen > Precision.CURVE_LENGTH_EPS, 'Line2.transform: degenerate line after transform');
+        this._start = newStart;
+        this._end = newEnd;
+        this.rebuildCache();
+        this.setRange(new Interval(0, this._len));
+        return this;
+    }
+    transformed(m) {
+        return this.clone().transform(m);
+    }
+    closestPoint(p) {
+        const sp = p.subtracted(this._start);
+        const u = Math.min(this._len, Math.max(0, sp.dot(this._dir)));
+        const point = this.pointAt(u);
+        return {
+            point,
+            param: u,
+            distance: point.distanceTo(p),
+        };
+    }
+    boundingBox() {
+        return Box2.fromPoints([this._start, this._end]);
+    }
+    isValid(eps = Precision.CURVE_LENGTH_EPS) {
+        return Number.isFinite(this._start.x) &&
+            Number.isFinite(this._start.y) &&
+            Number.isFinite(this._end.x) &&
+            Number.isFinite(this._end.y) &&
+            this._start.distanceTo(this._end) > eps;
+    }
+    isLine() {
+        return true;
+    }
+    /**
+     * 结构等价判断（字段级）。
+     * @param other 对比线段。
+     * @param eps 数值容差。
+     * @returns 起点与终点分别近似相等时返回 `true`。
+     */
+    equals(other, eps = Precision.EPS) {
+        return this._start.equals(other._start, eps) && this._end.equals(other._end, eps);
+    }
+    clone() {
+        return new Line2_1(this._start, this._end);
+    }
+    dump() {
+        return {
+            type: Line2_1.type,
+            start: { x: this._start.x, y: this._start.y },
+            end: { x: this._end.x, y: this._end.y },
+        };
+    }
+    static load(data) {
+        return new Line2_1(new Vec2(data.start.x, data.start.y), new Vec2(data.end.x, data.end.y));
+    }
+    /**
+     * 参数吸附到端点，避免边界浮点抖动。
+     * @param u 输入参数。
+     * @returns 吸附后的参数。
+     */
+    snapParam(u) {
+        this._range.assertContains(u, Precision.CURVE_PARAM_EPS);
+        if (Math.abs(u - this._range.start) <= Precision.CURVE_PARAM_EPS)
+            return this._range.start;
+        if (Math.abs(u - this._range.end) <= Precision.CURVE_PARAM_EPS)
+            return this._range.end;
+        return u;
+    }
+    /**
+     * 重建方向与长度缓存。
+     * - `_dir`：单位方向向量
+     * - `_len`：线段长度
+     */
+    rebuildCache() {
+        const v = this._end.subtracted(this._start);
+        const len = v.len();
+        MathError.assert(len > Precision.CURVE_LENGTH_EPS, 'Line2: start and end must not coincide');
+        this._len = len;
+        this._dir = v.scale(1 / len);
+    }
+};
+Line2.type = EN_GEO_TYPE.Line2;
+Line2 = Line2_1 = __decorate([
+    RegisterGeom
+    /**
+     * 二维线段曲线。
+     * 参数域固定为 `[0, len]`，其中 `len = |end - start|`。
+     */
+], Line2);
+export { Line2 };

package/dist/curves/period_interval.d.ts

@@ -0,0 +1,129 @@
+import { Interval } from './interval';
+export declare class PeriodInterval extends Interval {
+    /** 周期长度，必须 > 0 */
+    readonly period: number;
+    /**
+     * 创建周期区间。
+     * @param start 区间起点，可为任意实数。
+     * @param end 区间终点，可为任意实数。
+     * @param period 周期长度，必须大于 0。
+     */
+    constructor(start?: number, end?: number, period?: number);
+    /**
+     * 将参数归一化到 `[0, period)`。
+     * @param u 待归一化参数。
+     * @returns 归一化后的参数值。
+     */
+    normalize(u: number): number;
+    /**
+     * 将参数归一化到指定周期窗口 `[start, start + period)`。
+     * @param u 待归一化参数。
+     * @param start 周期窗口起点，默认当前区间起点。
+     * @returns 与 `u` 周期等价，且落在窗口内的参数。
+     */
+    normalizeInPeriod(u: number, start?: number): number;
+    /**
+     * 区间整体平移（按周期等价）。
+     * @param offset 平移量。
+     * @returns 平移后的新区间实例。
+     */
+    shift(offset: number): PeriodInterval;
+    /**
+     * 计算周期区间长度（沿正方向）。
+     * @returns 区间跨度，范围在 `[0, period]`。
+     */
+    length(): number;
+    /**
+     * 判断参数是否落在周期区间内。
+     * @param u 待判断参数。
+     * @param eps 边界比较容差。
+     * @returns 落在区间内（含容差）返回 `true`。
+     */
+    contains(u: number, eps?: number): boolean;
+    /**
+     * 将参数限制到区间内。
+     * @param u 输入参数。
+     * @returns 已在区间内返回归一化参数；否则返回最近边界参数。
+     */
+    clamp(u: number): number;
+    /**
+     * 判断两个周期区间是否近似相等。
+     * @param other 对比区间。
+     * @param eps 数值比较容差。
+     * @returns 周期一致且区间位置/长度一致时返回 `true`。
+     */
+    equals(other: PeriodInterval, eps?: number): boolean;
+    /**
+     * 计算周期交集。
+     * @param other 参与求交的周期区间。
+     * @param eps 交并判定容差。
+     * @returns 交集结果，按线性分段返回 `PeriodInterval[]`（最多 2 段）。
+     */
+    intersect(other: PeriodInterval, eps?: number): PeriodInterval[];
+    /**
+     * 计算周期并集。
+     * @param other 参与求并的周期区间。
+     * @param eps 交并判定容差。
+     * @returns 并集结果，按线性分段返回 `PeriodInterval[]`（1 到 2 段）。
+     */
+    union(other: PeriodInterval, eps?: number): PeriodInterval[];
+    /**
+     * 以参数 `u` 对周期区间切分。
+     * @param u 切分参数。
+     * @param eps 边界判定容差。
+     * @returns 边界或区间外返回 `[]`；内部切分返回两段区间。
+     */
+    split(u: number, eps?: number): PeriodInterval[];
+    /**
+     * 克隆当前周期区间。
+     * @returns 与当前数值等价的新实例。
+     */
+    clone(): PeriodInterval;
+    /**
+     * 当前区间沿正方向长度。
+     * @returns `_end - _start`。
+     */
+    private span;
+    /**
+     * 判断是否为整周期闭合区间。
+     * @param eps 比较容差。
+     * @returns 近似等于整周期长度时返回 `true`。
+     */
+    private isFull;
+    /**
+     * 计算两参数在圆周上的最短距离。
+     * @param a 参数 a。
+     * @param b 参数 b。
+     * @returns 最短圆周距离。
+     */
+    private circularDistance;
+    /**
+     * 计算从 `a` 到 `b` 的正方向差值。
+     * @param a 起点参数。
+     * @param b 终点参数。
+     * @returns 归一化到 `[0, period)` 的正向差值。
+     */
+    private forwardDelta;
+    /**
+     * 转为 `[0, period]` 上的普通线性区间段。
+     * @param eps 判定整周期与边界贴合的容差。
+     * @returns 线性区间段数组。
+     */
+    private toLinearSegments;
+    /**
+     * 规范化输入到内部表示。
+     * @param start 输入起点。
+     * @param end 输入终点。
+     * @param period 周期长度。
+     * @returns 规范化后的 `{ start, end }`，满足 `start in [0, period)` 且 `end = start + len`。
+     */
+    private static canonicalize;
+    /**
+     * 正模运算。
+     * @param x 被取模值。
+     * @param m 模（周期）。
+     * @returns 结果范围在 `[0, m)`。
+     */
+    private static mod;
+}
+//# sourceMappingURL=period_interval.d.ts.map

package/dist/curves/period_interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"period_interval.d.ts","sourceRoot":"","sources":["../../src/curves/period_interval.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,qBAAa,cAAe,SAAQ,QAAQ;IACxC,kBAAkB;IAClB,SAAgB,MAAM,EAAE,MAAM,CAAA;IAE9B;;;;;OAKG;gBACS,KAAK,SAAI,EAAE,GAAG,SAAI,EAAE,MAAM,SAAc;IAQpD;;;;OAIG;IACI,SAAS,CAAC,CAAC,EAAE,MAAM;IAI1B;;;;;OAKG;IACI,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,SAAa;IAItD;;;;OAIG;IACI,KAAK,CAAC,MAAM,EAAE,MAAM;IAI3B;;;OAGG;IACa,MAAM;IAItB;;;;;OAKG;IACa,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB;IAMvD;;;;OAIG;IACa,KAAK,CAAC,CAAC,EAAE,MAAM;IAU/B;;;;;OAKG;IACa,MAAM,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAgB;IAOjE;;;;;OAKG;IACa,SAAS,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAgB,GAAG,cAAc,EAAE;IAcvF;;;;;OAKG;IACa,KAAK,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,SAAgB,GAAG,cAAc,EAAE;IAqBnF;;;;;OAKG;IACa,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB,GAAG,cAAc,EAAE;IAavE;;;OAGG;IACa,KAAK;IAIrB;;;OAGG;IACH,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;IACH,OAAO,CAAC,MAAM;IAId;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAKxB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;;;OAMG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY;IAS3B;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,GAAG;CAIrB"}

package/dist/curves/period_interval.js

@@ -0,0 +1,240 @@
+/*
+ * Linea Math - Curves
+ * PeriodInterval: 周期参数区间
+ */
+import { MathError } from '../utils/math_error';
+import { Precision } from '../utils/precision';
+import { Interval } from './interval';
+export class PeriodInterval extends Interval {
+    /**
+     * 创建周期区间。
+     * @param start 区间起点，可为任意实数。
+     * @param end 区间终点，可为任意实数。
+     * @param period 周期长度，必须大于 0。
+     */
+    constructor(start = 0, end = 0, period = Math.PI * 2) {
+        MathError.assert(Number.isFinite(start) && Number.isFinite(end), 'PeriodInterval: start/end must be finite');
+        MathError.assert(period > 0, 'PeriodInterval: period must be > 0');
+        const canonical = PeriodInterval.canonicalize(start, end, period);
+        super(canonical.start, canonical.end);
+        this.period = period;
+    }
+    /**
+     * 将参数归一化到 `[0, period)`。
+     * @param u 待归一化参数。
+     * @returns 归一化后的参数值。
+     */
+    normalize(u) {
+        return PeriodInterval.mod(u, this.period);
+    }
+    /**
+     * 将参数归一化到指定周期窗口 `[start, start + period)`。
+     * @param u 待归一化参数。
+     * @param start 周期窗口起点，默认当前区间起点。
+     * @returns 与 `u` 周期等价，且落在窗口内的参数。
+     */
+    normalizeInPeriod(u, start = this.start) {
+        return start + PeriodInterval.mod(u - start, this.period);
+    }
+    /**
+     * 区间整体平移（按周期等价）。
+     * @param offset 平移量。
+     * @returns 平移后的新区间实例。
+     */
+    shift(offset) {
+        return new PeriodInterval(this._start + offset, this._start + this.span() + offset, this.period);
+    }
+    /**
+     * 计算周期区间长度（沿正方向）。
+     * @returns 区间跨度，范围在 `[0, period]`。
+     */
+    length() {
+        return this.span();
+    }
+    /**
+     * 判断参数是否落在周期区间内。
+     * @param u 待判断参数。
+     * @param eps 边界比较容差。
+     * @returns 落在区间内（含容差）返回 `true`。
+     */
+    contains(u, eps = Precision.EPS) {
+        if (this.isFull(eps))
+            return true;
+        const d = this.forwardDelta(this._start, this.normalize(u));
+        return d <= this.span() + eps || this.period - d <= eps;
+    }
+    /**
+     * 将参数限制到区间内。
+     * @param u 输入参数。
+     * @returns 已在区间内返回归一化参数；否则返回最近边界参数。
+     */
+    clamp(u) {
+        const t = this.normalize(u);
+        if (this.contains(t))
+            return t;
+        const end = this.normalize(this._start + this.span());
+        const dStart = this.circularDistance(t, this._start);
+        const dEnd = this.circularDistance(t, end);
+        return dStart <= dEnd ? this._start : end;
+    }
+    /**
+     * 判断两个周期区间是否近似相等。
+     * @param other 对比区间。
+     * @param eps 数值比较容差。
+     * @returns 周期一致且区间位置/长度一致时返回 `true`。
+     */
+    equals(other, eps = Precision.EPS) {
+        if (!Precision.equal(this.period, other.period, eps))
+            return false;
+        if (this.isFull(eps) && other.isFull(eps))
+            return true;
+        return Precision.equal(this._start, other._start, eps) &&
+            Precision.equal(this.span(), other.span(), eps);
+    }
+    /**
+     * 计算周期交集。
+     * @param other 参与求交的周期区间。
+     * @param eps 交并判定容差。
+     * @returns 交集结果，按线性分段返回 `PeriodInterval[]`（最多 2 段）。
+     */
+    intersect(other, eps = Precision.EPS) {
+        if (!Precision.equal(this.period, other.period, eps)) {
+            MathError.throw('PeriodInterval.intersect: period mismatch');
+        }
+        const ret = [];
+        for (const a of this.toLinearSegments(eps)) {
+            for (const b of other.toLinearSegments(eps)) {
+                ret.push(...a.intersect(b, eps));
+            }
+        }
+        return Interval.merge(ret, eps).map((seg) => new PeriodInterval(seg.start, seg.end, this.period));
+    }
+    /**
+     * 计算周期并集。
+     * @param other 参与求并的周期区间。
+     * @param eps 交并判定容差。
+     * @returns 并集结果，按线性分段返回 `PeriodInterval[]`（1 到 2 段）。
+     */
+    union(other, eps = Precision.EPS) {
+        if (!Precision.equal(this.period, other.period, eps)) {
+            MathError.throw('PeriodInterval.union: period mismatch');
+        }
+        const merged = Interval.merge([
+            ...this.toLinearSegments(eps),
+            ...other.toLinearSegments(eps),
+        ], eps);
+        if (merged.length >= 2) {
+            const first = merged[0];
+            const last = merged[merged.length - 1];
+            if (Precision.equal(first.start, 0, eps) && Precision.equal(last.end, this.period, eps)) {
+                const stitched = new Interval(last.start, this.period + first.end);
+                return [stitched, ...merged.slice(1, -1)].map((seg) => new PeriodInterval(seg.start, seg.end, this.period));
+            }
+        }
+        return merged.map((seg) => new PeriodInterval(seg.start, seg.end, this.period));
+    }
+    /**
+     * 以参数 `u` 对周期区间切分。
+     * @param u 切分参数。
+     * @param eps 边界判定容差。
+     * @returns 边界或区间外返回 `[]`；内部切分返回两段区间。
+     */
+    split(u, eps = Precision.EPS) {
+        if (!this.contains(u, eps))
+            return [];
+        const d = this.forwardDelta(this._start, this.normalize(u));
+        const len = this.span();
+        if (d <= eps || d >= len - eps)
+            return [];
+        const mid = this._start + d;
+        return [
+            new PeriodInterval(this._start, mid, this.period),
+            new PeriodInterval(mid, this._start + len, this.period),
+        ];
+    }
+    /**
+     * 克隆当前周期区间。
+     * @returns 与当前数值等价的新实例。
+     */
+    clone() {
+        return new PeriodInterval(this._start, this._start + this.span(), this.period);
+    }
+    /**
+     * 当前区间沿正方向长度。
+     * @returns `_end - _start`。
+     */
+    span() {
+        return this._end - this._start;
+    }
+    /**
+     * 判断是否为整周期闭合区间。
+     * @param eps 比较容差。
+     * @returns 近似等于整周期长度时返回 `true`。
+     */
+    isFull(eps = Precision.EPS) {
+        return Precision.equal(this.span(), this.period, eps);
+    }
+    /**
+     * 计算两参数在圆周上的最短距离。
+     * @param a 参数 a。
+     * @param b 参数 b。
+     * @returns 最短圆周距离。
+     */
+    circularDistance(a, b) {
+        const d = Math.abs(a - b);
+        return Math.min(d, this.period - d);
+    }
+    /**
+     * 计算从 `a` 到 `b` 的正方向差值。
+     * @param a 起点参数。
+     * @param b 终点参数。
+     * @returns 归一化到 `[0, period)` 的正向差值。
+     */
+    forwardDelta(a, b) {
+        return PeriodInterval.mod(b - a, this.period);
+    }
+    /**
+     * 转为 `[0, period]` 上的普通线性区间段。
+     * @param eps 判定整周期与边界贴合的容差。
+     * @returns 线性区间段数组。
+     */
+    toLinearSegments(eps = Precision.EPS) {
+        if (this.isFull(eps)) {
+            return [new Interval(0, this.period)];
+        }
+        const s = this._start;
+        const e = this._start + this.span();
+        if (e <= this.period + eps) {
+            return [new Interval(s, Math.min(e, this.period))];
+        }
+        return [
+            new Interval(s, this.period),
+            new Interval(0, e - this.period),
+        ];
+    }
+    /**
+     * 规范化输入到内部表示。
+     * @param start 输入起点。
+     * @param end 输入终点。
+     * @param period 周期长度。
+     * @returns 规范化后的 `{ start, end }`，满足 `start in [0, period)` 且 `end = start + len`。
+     */
+    static canonicalize(start, end, period) {
+        const s = PeriodInterval.mod(start, period);
+        let len = PeriodInterval.mod(end - start, period);
+        if (Precision.equal(len, 0, Precision.EPS) && !Precision.equal(start, end, Precision.EPS)) {
+            len = period;
+        }
+        return { start: s, end: s + len };
+    }
+    /**
+     * 正模运算。
+     * @param x 被取模值。
+     * @param m 模（周期）。
+     * @returns 结果范围在 `[0, m)`。
+     */
+    static mod(x, m) {
+        const r = x % m;
+        return r < 0 ? r + m : r;
+    }
+}

package/dist/discretize/discretize_defaults.d.ts

@@ -0,0 +1,12 @@
+export declare const DISCRETIZE_DEFAULTS: Readonly<{
+    chordTol: 0.001;
+    angleTolRad: number;
+    maxSegmentLength: number;
+    minSegments: 8;
+    maxSegments: 4096;
+    includeEnd: true;
+}>;
+export declare const DISCRETIZE_INTERNAL_DEFAULTS: Readonly<{
+    minSegmentLengthInternal: number;
+}>;
+//# sourceMappingURL=discretize_defaults.d.ts.map

package/dist/discretize/discretize_defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discretize_defaults.d.ts","sourceRoot":"","sources":["../../src/discretize/discretize_defaults.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,mBAAmB;;;;;;;EAO9B,CAAA;AAEF,eAAO,MAAM,4BAA4B;;EAEvC,CAAA"}

package/dist/discretize/discretize_defaults.js

@@ -0,0 +1,12 @@
+import { Precision } from '../utils/precision';
+export const DISCRETIZE_DEFAULTS = Object.freeze({
+    chordTol: 1e-3,
+    angleTolRad: Math.PI / 180,
+    maxSegmentLength: Number.POSITIVE_INFINITY,
+    minSegments: 8,
+    maxSegments: 4096,
+    includeEnd: true,
+});
+export const DISCRETIZE_INTERNAL_DEFAULTS = Object.freeze({
+    minSegmentLengthInternal: Precision.CURVE_LENGTH_EPS,
+});