@ccpc/math 0.1.0 → 0.1.7

package/dist/curves/ellipse_curve2.d.ts

@@ -1,56 +0,0 @@
-import { Box2 } from '../core/box2';
-import { Vec2 } from '../core/vec2';
-import type { IClosestPointResult } from '../types/type_define';
-import { Curve2 } from './curve2';
-import { Interval } from './interval';
-/**
- * 椭圆族曲线基类（整椭圆与椭圆弧）。
- */
-export declare abstract class EllipseCurve2 extends Curve2 {
-    protected _center: Vec2;
-    protected _rx: number;
-    protected _ry: number;
-    protected _rotation: number;
-    constructor(center: Vec2, rx: number, ry: number, rotation?: number);
-    get center(): Vec2;
-    get rx(): number;
-    get ry(): number;
-    get rotation(): number;
-    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;
-    closestPoint(p: Vec2, tol?: number): IClosestPointResult;
-    boundingBox(): Box2;
-    /** 椭圆族结构有效性检查 */
-    protected isEllipseStructValid(eps?: number): boolean;
-    /** 将存储参数转换为椭圆角参数 */
-    protected abstract paramToAngle(u: number): number;
-    /** 将椭圆角参数转换回存储参数 */
-    protected abstract angleToParam(theta: number): number;
-    /** d(theta)/d(u)，仅允许 +1 或 -1 */
-    protected abstract angleDerivativeSign(): 1 | -1;
-    protected pointAtAngle(theta: number): Vec2;
-    protected derivativeFromAngle(theta: number, order: number, sign: 1 | -1): Vec2;
-    protected normalizeParamForEval(u: number): number;
-    protected integrateLength(u0: number, u1: number, depth?: number): number;
-    protected gaussLegendre5(f: (u: number) => number, a: number, b: number): number;
-    protected compareParamForTieBreak(a: number, b: number): number;
-    /**
-     * 对当前椭圆应用仿射变换，并从变换后的形状提取规范参数
-     * （center、rx、ry、rotation）。
-     */
-    protected transformedEllipseParams(m: import('../core/mat3').Mat3): {
-        center: Vec2;
-        rx: number;
-        ry: number;
-        rotation: number;
-        mirrored: boolean;
-    };
-    /** 将椭圆上的点反解为角参数。 */
-    protected angleFromPointOnEllipse(p: Vec2, center: Vec2, rx: number, ry: number, rotation: number): number;
-}
-//# sourceMappingURL=ellipse_curve2.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ellipse_curve2.d.ts","sourceRoot":"","sources":["../../src/curves/ellipse_curve2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AACnC,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAA;AAGnC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AAC/D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAGrC;;GAEG;AACH,8BAAsB,aAAc,SAAQ,MAAM;IAC9C,SAAS,CAAC,OAAO,EAAE,IAAI,CAAA;IACvB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,SAAS,EAAE,MAAM,CAAA;gBAEf,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,SAAI;IAY9D,IAAW,MAAM,SAEhB;IAED,IAAW,EAAE,WAEZ;IAED,IAAW,EAAE,WAEZ;IAED,IAAW,QAAQ,WAElB;IAEe,OAAO,CAAC,CAAC,EAAE,MAAM;IAKjB,SAAS,CAAC,CAAC,EAAE,MAAM;IAKnB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAiBhC,WAAW,CAAC,CAAC,EAAE,MAAM;IAQrB,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ;IAQvB,aAAa,CAAC,CAAC,EAAE,MAAM;IAKvB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAA6B;IA6BzD,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,SAA6B,GAAG,mBAAmB;IAe5E,WAAW;IAuB3B,iBAAiB;IACjB,SAAS,CAAC,oBAAoB,CAAC,GAAG,SAA6B;IAU/D,oBAAoB;IACpB,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAElD,oBAAoB;IACpB,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAEtD,gCAAgC;IAChC,SAAS,CAAC,QAAQ,CAAC,mBAAmB,IAAI,CAAC,GAAG,CAAC,CAAC;IAEhD,SAAS,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM;IAepC,SAAS,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IAkCxE,SAAS,CAAC,qBAAqB,CAAC,CAAC,EAAE,MAAM;IAczC,SAAS,CAAC,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,MAAM;IAoBpE,SAAS,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAyBvE,SAAS,CAAC,uBAAuB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAStD;;;OAGG;IACH,SAAS,CAAC,wBAAwB,CAAC,CAAC,EAAE,OAAO,cAAc,EAAE,IAAI;;;;;;;IAiCjE,oBAAoB;IACpB,SAAS,CAAC,uBAAuB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CASpG"}

package/dist/curves/ellipse_curve2.js

@@ -1,262 +0,0 @@
-import { Box2 } from '../core/box2';
-import { Vec2 } from '../core/vec2';
-import { MathError } from '../utils/math_error';
-import { Precision } from '../utils/precision';
-import { Curve2 } from './curve2';
-import { PeriodInterval } from './period_interval';
-/**
- * 椭圆族曲线基类（整椭圆与椭圆弧）。
- */
-export class EllipseCurve2 extends Curve2 {
-    constructor(center, rx, ry, rotation = 0) {
-        super();
-        MathError.assert(Number.isFinite(center.x) && Number.isFinite(center.y), 'EllipseCurve2: center must be finite');
-        MathError.assert(Number.isFinite(rx) && rx > 0, 'EllipseCurve2: rx must be > 0');
-        MathError.assert(Number.isFinite(ry) && ry > 0, 'EllipseCurve2: ry must be > 0');
-        MathError.assert(Number.isFinite(rotation), 'EllipseCurve2: rotation must be finite');
-        this._center = center.clone();
-        this._rx = rx;
-        this._ry = ry;
-        this._rotation = rotation;
-    }
-    get center() {
-        return this._center.clone();
-    }
-    get rx() {
-        return this._rx;
-    }
-    get ry() {
-        return this._ry;
-    }
-    get rotation() {
-        return this._rotation;
-    }
-    pointAt(u) {
-        const uu = this.normalizeParamForEval(u);
-        return this.pointAtAngle(this.paramToAngle(uu));
-    }
-    tangentAt(u) {
-        const uu = this.normalizeParamForEval(u);
-        return this.derivativeFromAngle(this.paramToAngle(uu), 1, this.angleDerivativeSign());
-    }
-    derivatives(u, n) {
-        MathError.assert(Number.isInteger(n) && n >= 0, 'EllipseCurve2.derivatives: n must be a non-negative integer');
-        const uu = this.normalizeParamForEval(u);
-        const theta = this.paramToAngle(uu);
-        const sign = this.angleDerivativeSign();
-        const ret = [];
-        for (let k = 0; k <= n; k++) {
-            if (k === 0) {
-                ret.push(this.pointAtAngle(theta));
-                continue;
-            }
-            ret.push(this.derivativeFromAngle(theta, k, sign));
-        }
-        return ret;
-    }
-    curvatureAt(u) {
-        const d1 = this.derivativeAt(u, 1);
-        const d2 = this.derivativeAt(u, 2);
-        const denom = Math.pow(d1.lenSq(), 1.5);
-        MathError.assert(denom > Precision.CURVE_NEWTON_EPS, 'EllipseCurve2.curvatureAt: tangent is degenerate');
-        return Math.abs(d1.cross(d2)) / denom;
-    }
-    length(range) {
-        if (!range) {
-            return this.integrateLength(this._range.start, this._range.end);
-        }
-        this._range.assertContainsRange(range, Precision.CURVE_PARAM_EPS);
-        return this.integrateLength(range.start, range.end);
-    }
-    lengthAtParam(u) {
-        const uu = this.normalizeParamForEval(u);
-        return this.integrateLength(this._range.start, uu);
-    }
-    paramAtLength(s, tol = Precision.CURVE_LENGTH_EPS) {
-        MathError.assert(Number.isFinite(tol) && tol > 0, 'EllipseCurve2.paramAtLength: tol must be > 0');
-        const total = this.length();
-        const start = this._range.start;
-        const end = this._range.end;
-        MathError.assert(s >= -tol && s <= total + tol, `EllipseCurve2.paramAtLength: s out of range [0, ${total}]`);
-        if (s <= tol)
-            return start;
-        if (total - s <= tol)
-            return end;
-        const target = Math.min(total, Math.max(0, s));
-        // 与 B-spline 保持同一套求解策略：Newton 优先，失败时回退二分。
-        return this.solveParamByHybridNewton(target, start, end, tol, (u) => this.integrateLength(start, u), (u) => this.tangentAt(u).len(), 'EllipseCurve2.paramAtLength: failed to converge', start + (target / total) * (end - start));
-    }
-    closestPoint(p, tol = Precision.CURVE_LENGTH_EPS) {
-        MathError.assert(Number.isFinite(tol) && tol > 0, 'EllipseCurve2.closestPoint: tol must be > 0');
-        // 椭圆/椭圆弧都走统一最近点模板，tie-break 由子类参数语义决定。
-        return this.solveClosestPointBySampleNewton(p, tol, 96, (u) => this.pointAt(u), (u) => this.derivativeAt(u, 1), (u) => this.derivativeAt(u, 2), 'EllipseCurve2.closestPoint: failed to converge', (a, b) => this.compareParamForTieBreak(a, b));
-    }
-    boundingBox() {
-        const points = [
-            this.pointAt(this._range.start),
-            this.pointAt(this._range.end),
-        ];
-        const c = Math.cos(this._rotation);
-        const s = Math.sin(this._rotation);
-        const tx = Math.atan2(-s * this._ry, c * this._rx);
-        const ty = Math.atan2(c * this._ry, s * this._rx);
-        const candidates = [tx, tx + Math.PI, ty, ty + Math.PI];
-        for (const theta of candidates) {
-            const u = this.angleToParam(theta);
-            if (this.containsParam(u)) {
-                points.push(this.pointAt(u));
-            }
-        }
-        return Box2.fromPoints(points);
-    }
-    /** 椭圆族结构有效性检查 */
-    isEllipseStructValid(eps = Precision.CURVE_LENGTH_EPS) {
-        return Number.isFinite(this._center.x) &&
-            Number.isFinite(this._center.y) &&
-            Number.isFinite(this._rx) &&
-            Number.isFinite(this._ry) &&
-            Number.isFinite(this._rotation) &&
-            this._rx > eps &&
-            this._ry > eps;
-    }
-    pointAtAngle(theta) {
-        const c = Math.cos(this._rotation);
-        const s = Math.sin(this._rotation);
-        const ct = Math.cos(theta);
-        const st = Math.sin(theta);
-        const lx = this._rx * ct;
-        const ly = this._ry * st;
-        return new Vec2(this._center.x + c * lx - s * ly, this._center.y + s * lx + c * ly);
-    }
-    derivativeFromAngle(theta, order, sign) {
-        const c = Math.cos(this._rotation);
-        const s = Math.sin(this._rotation);
-        const ct = Math.cos(theta);
-        const st = Math.sin(theta);
-        let lx = 0;
-        let ly = 0;
-        const phase = order % 4;
-        switch (phase) {
-            case 0:
-                lx = this._rx * ct;
-                ly = this._ry * st;
-                break;
-            case 1:
-                lx = -this._rx * st;
-                ly = this._ry * ct;
-                break;
-            case 2:
-                lx = -this._rx * ct;
-                ly = -this._ry * st;
-                break;
-            default:
-                lx = this._rx * st;
-                ly = -this._ry * ct;
-                break;
-        }
-        const signPow = sign === 1 ? 1 : (order % 2 === 0 ? 1 : -1);
-        const x = (c * lx - s * ly) * signPow;
-        const y = (s * lx + c * ly) * signPow;
-        return new Vec2(x, y);
-    }
-    normalizeParamForEval(u) {
-        this._range.assertContains(u, Precision.CURVE_PARAM_EPS);
-        const start = this._range.start;
-        const end = this._range.end;
-        if (Math.abs(u - start) <= Precision.CURVE_PARAM_EPS)
-            return start;
-        if (Math.abs(u - end) <= Precision.CURVE_PARAM_EPS)
-            return end;
-        if (this._range instanceof PeriodInterval) {
-            return this._range.normalizeInPeriod(u, start);
-        }
-        return u;
-    }
-    integrateLength(u0, u1, depth = 0) {
-        if (u1 < u0)
-            return 0;
-        const f = (u) => this.tangentAt(u).len();
-        const whole = this.gaussLegendre5(f, u0, u1);
-        if (depth >= Precision.CURVE_INTEGRAL_MAX_DEPTH) {
-            return whole;
-        }
-        const mid = (u0 + u1) * 0.5;
-        const left = this.gaussLegendre5(f, u0, mid);
-        const right = this.gaussLegendre5(f, mid, u1);
-        const err = Math.abs((left + right) - whole);
-        if (err <= Precision.CURVE_LENGTH_EPS) {
-            return left + right;
-        }
-        return this.integrateLength(u0, mid, depth + 1) + this.integrateLength(mid, u1, depth + 1);
-    }
-    gaussLegendre5(f, a, b) {
-        const nodes = [
-            0,
-            -0.5384693101056831,
-            0.5384693101056831,
-            -0.906179845938664,
-            0.906179845938664,
-        ];
-        const weights = [
-            0.5688888888888889,
-            0.47862867049936647,
-            0.47862867049936647,
-            0.23692688505618908,
-            0.23692688505618908,
-        ];
-        const c1 = (b - a) * 0.5;
-        const c2 = (b + a) * 0.5;
-        let sum = 0;
-        for (let i = 0; i < nodes.length; i++) {
-            sum += weights[i] * f(c1 * nodes[i] + c2);
-        }
-        return c1 * sum;
-    }
-    compareParamForTieBreak(a, b) {
-        if (this._range instanceof PeriodInterval) {
-            const aa = this._range.normalizeInPeriod(a, this._range.start);
-            const bb = this._range.normalizeInPeriod(b, this._range.start);
-            return aa - bb;
-        }
-        return a - b;
-    }
-    /**
-     * 对当前椭圆应用仿射变换，并从变换后的形状提取规范参数
-     * （center、rx、ry、rotation）。
-     */
-    transformedEllipseParams(m) {
-        const me = m.toArray();
-        const a = me[0], b = me[1], c = me[3], d = me[4];
-        const cr = Math.cos(this._rotation);
-        const sr = Math.sin(this._rotation);
-        const ex = new Vec2(this._rx * cr, this._rx * sr);
-        const ey = new Vec2(-this._ry * sr, this._ry * cr);
-        const vx = new Vec2(a * ex.x + b * ex.y, c * ex.x + d * ex.y);
-        const vy = new Vec2(a * ey.x + b * ey.y, c * ey.x + d * ey.y);
-        const gxx = vx.x * vx.x + vy.x * vy.x;
-        const gxy = vx.x * vx.y + vy.x * vy.y;
-        const gyy = vx.y * vx.y + vy.y * vy.y;
-        const trace = gxx + gyy;
-        const delta = Math.sqrt(Math.max(0, (gxx - gyy) * (gxx - gyy) + 4 * gxy * gxy));
-        let lambdaMax = (trace + delta) * 0.5;
-        let lambdaMin = (trace - delta) * 0.5;
-        lambdaMax = Math.max(0, lambdaMax);
-        lambdaMin = Math.max(0, lambdaMin);
-        const rx = Math.sqrt(lambdaMax);
-        const ry = Math.sqrt(lambdaMin);
-        const rotation = 0.5 * Math.atan2(2 * gxy, gxx - gyy);
-        const center = m.transformedPoint(this._center);
-        const mirrored = a * d - b * c < 0;
-        return { center, rx, ry, rotation, mirrored };
-    }
-    /** 将椭圆上的点反解为角参数。 */
-    angleFromPointOnEllipse(p, center, rx, ry, rotation) {
-        const dx = p.x - center.x;
-        const dy = p.y - center.y;
-        const c = Math.cos(rotation);
-        const s = Math.sin(rotation);
-        const lx = c * dx + s * dy;
-        const ly = -s * dx + c * dy;
-        return Math.atan2(ly / ry, lx / rx);
-    }
-}

package/dist/curves/interval.d.ts

@@ -1,112 +0,0 @@
-export declare class Interval {
-    /**
-     * 返回数学无界区间。
-     * @returns 取值范围为 `[-Infinity, +Infinity]` 的区间实例。
-     */
-    static infinite(): Interval;
-    /**
-     * 归并多段区间。
-     * @param intervals 待归并区间数组，可无序。
-     * @param eps 判断端点相接时使用的容差。
-     * @returns 按 `start` 升序、且相交或相接段已合并的新区间数组。
-     */
-    static merge(intervals: readonly Interval[], eps?: number): Interval[];
-    /** 区间起点（闭区间） */
-    protected _start: number;
-    /** 区间终点（闭区间） */
-    protected _end: number;
-    /**
-     * 创建闭区间 `[start, end]`。
-     * @param start 区间起点。
-     * @param end 区间终点；若小于 `start` 会在内部自动交换顺序。
-     */
-    constructor(start?: number, end?: number);
-    /** 区间起点 */
-    get start(): number;
-    /** 区间终点 */
-    get end(): number;
-    /**
-     * 计算区间长度。
-     * @returns `end - start`，点区间返回 `0`。
-     */
-    length(): number;
-    /**
-     * 判断参数是否落在区间内。
-     * @param u 待判断参数。
-     * @param eps 闭区间边界比较容差。
-     * @returns 在 `[start - eps, end + eps]` 内返回 `true`，否则返回 `false`。
-     */
-    contains(u: number, eps?: number): boolean;
-    /**
-     * 断言参数在区间内。
-     * @param u 待校验参数。
-     * @param eps 区间边界比较容差。
-     * @returns 当前区间实例。
-     * @throws MathError 参数不在区间内时抛错。
-     */
-    assertContains(u: number, eps?: number): this;
-    /**
-     * 断言子区间完整落在当前区间内。
-     * @param range 待校验子区间。
-     * @param eps 区间边界比较容差。
-     * @returns 当前区间实例。
-     * @throws MathError 子区间超出当前区间时抛错。
-     */
-    assertContainsRange(range: Interval, eps?: number): this;
-    /**
-     * 将参数钳制到区间范围内。
-     * @param u 输入参数。
-     * @returns 小于起点返回 `start`，大于终点返回 `end`，否则返回自身。
-     */
-    clamp(u: number): number;
-    /**
-     * 判断两个区间是否近似相等。
-     * @param other 另一个区间。
-     * @param eps 端点比较容差。
-     * @returns 起点和终点都在容差内时返回 `true`。
-     */
-    equals(other: Interval, eps?: number): boolean;
-    /**
-     * 原地扩展区间。
-     * @param delta 扩展量；`delta > 0` 表示扩大，`delta < 0` 表示收缩。
-     * @returns 当前实例（便于链式调用）。
-     */
-    expand(delta: number): this;
-    /**
-     * 返回扩展后的新区间，不修改当前实例。
-     * @param delta 扩展量；语义同 `expand`。
-     * @returns 新的区间实例。
-     */
-    expanded(delta: number): Interval;
-    /**
-     * 计算与另一区间的交集。
-     * @param other 参与求交的区间。
-     * @param eps 判定“相离/相接”时的容差。
-     * @returns 无交集返回 `[]`；有交集返回单段 `[Interval]`；端点相接返回点区间。
-     */
-    intersect(other: Interval, eps?: number): Interval[];
-    /**
-     * 计算与另一区间的并集（普通区间语义）。
-     * @param other 参与求并的区间。
-     * @returns 单段最小覆盖区间数组（保持与 `PeriodInterval` 的返回形态一致）。
-     */
-    union(other: Interval): Interval[];
-    /**
-     * 以参数 `u` 切分区间。
-     * @param u 切分参数。
-     * @param eps 边界判定容差。
-     * @returns `u` 在边界或区间外返回 `[]`；在区间内部返回两段子区间。
-     */
-    split(u: number, eps?: number): Interval[];
-    /**
-     * 克隆当前区间。
-     * @returns 与当前区间数值相同的新实例。
-     */
-    clone(): Interval;
-    /**
-     * 规范化区间顺序，使 `_start <= _end`。
-     * 仅在内部使用。
-     */
-    protected sortRange(): void;
-}
-//# sourceMappingURL=interval.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../../src/curves/interval.ts"],"names":[],"mappings":"AASA,qBAAa,QAAQ;IACjB;;;OAGG;WACW,QAAQ;IAItB;;;;;OAKG;WACW,KAAK,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAAE,GAAG,SAAgB,GAAG,QAAQ,EAAE;IAoBpF,gBAAgB;IAChB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAA;IAExB,gBAAgB;IAChB,SAAS,CAAC,IAAI,EAAE,MAAM,CAAA;IAEtB;;;;OAIG;gBACS,KAAK,SAAI,EAAE,GAAG,SAAI;IAO9B,WAAW;IACX,IAAW,KAAK,WAEf;IAED,WAAW;IACX,IAAW,GAAG,WAEb;IAED;;;OAGG;IACI,MAAM;IAIb;;;;;OAKG;IACI,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB;IAI9C;;;;;;OAMG;IACI,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB;IAKpD;;;;;;OAMG;IACI,mBAAmB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,SAAgB;IAQ/D;;;;OAIG;IACI,KAAK,CAAC,CAAC,EAAE,MAAM;IAMtB;;;;;OAKG;IACI,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,SAAgB;IAKlD;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,MAAM;IAU3B;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM;IAI7B;;;;;OAKG;IACI,SAAS,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,SAAgB,GAAG,QAAQ,EAAE;IAWlE;;;;OAIG;IACI,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,EAAE;IAOzC;;;;;OAKG;IACI,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,SAAgB,GAAG,QAAQ,EAAE;IAQxD;;;OAGG;IACI,KAAK;IAIZ;;;OAGG;IACH,SAAS,CAAC,SAAS;CAMtB"}

package/dist/curves/interval.js

@@ -1,200 +0,0 @@
-/*
- * Linea Math - Curves
- * Interval: 一维闭区间 [start, end]
- */
-import { MathError } from '../utils/math_error';
-import { Precision } from '../utils/precision';
-import { MathConst } from '../constants/math_const';
-export class Interval {
-    /**
-     * 返回数学无界区间。
-     * @returns 取值范围为 `[-Infinity, +Infinity]` 的区间实例。
-     */
-    static infinite() {
-        return new Interval(MathConst.MIN, MathConst.MAX);
-    }
-    /**
-     * 归并多段区间。
-     * @param intervals 待归并区间数组，可无序。
-     * @param eps 判断端点相接时使用的容差。
-     * @returns 按 `start` 升序、且相交或相接段已合并的新区间数组。
-     */
-    static merge(intervals, eps = Precision.EPS) {
-        for (const it of intervals) {
-            MathError.assert(!Number.isNaN(it.start) && !Number.isNaN(it.end), 'Interval.merge: interval endpoint must not be NaN');
-        }
-        if (intervals.length === 0)
-            return [];
-        const sorted = [...intervals].sort((a, b) => a.start - b.start);
-        const ret = [sorted[0].clone()];
-        for (let i = 1; i < sorted.length; i++) {
-            const cur = sorted[i];
-            const last = ret[ret.length - 1];
-            if (cur.start <= last.end + eps) {
-                ret[ret.length - 1] = new Interval(last.start, Math.max(last.end, cur.end));
-            }
-            else {
-                ret.push(cur.clone());
-            }
-        }
-        return ret;
-    }
-    /**
-     * 创建闭区间 `[start, end]`。
-     * @param start 区间起点。
-     * @param end 区间终点；若小于 `start` 会在内部自动交换顺序。
-     */
-    constructor(start = 0, end = 0) {
-        MathError.assert(!Number.isNaN(start) && !Number.isNaN(end), 'Interval: start/end must not be NaN');
-        this._start = start;
-        this._end = end;
-        this.sortRange();
-    }
-    /** 区间起点 */
-    get start() {
-        return this._start;
-    }
-    /** 区间终点 */
-    get end() {
-        return this._end;
-    }
-    /**
-     * 计算区间长度。
-     * @returns `end - start`，点区间返回 `0`。
-     */
-    length() {
-        return this._end - this._start;
-    }
-    /**
-     * 判断参数是否落在区间内。
-     * @param u 待判断参数。
-     * @param eps 闭区间边界比较容差。
-     * @returns 在 `[start - eps, end + eps]` 内返回 `true`，否则返回 `false`。
-     */
-    contains(u, eps = Precision.EPS) {
-        return u >= this._start - eps && u <= this._end + eps;
-    }
-    /**
-     * 断言参数在区间内。
-     * @param u 待校验参数。
-     * @param eps 区间边界比较容差。
-     * @returns 当前区间实例。
-     * @throws MathError 参数不在区间内时抛错。
-     */
-    assertContains(u, eps = Precision.EPS) {
-        MathError.assert(this.contains(u, eps), 'Interval.assertContains: parameter out of range');
-        return this;
-    }
-    /**
-     * 断言子区间完整落在当前区间内。
-     * @param range 待校验子区间。
-     * @param eps 区间边界比较容差。
-     * @returns 当前区间实例。
-     * @throws MathError 子区间超出当前区间时抛错。
-     */
-    assertContainsRange(range, eps = Precision.EPS) {
-        MathError.assert(this.contains(range.start, eps) && this.contains(range.end, eps), 'Interval.assertContainsRange: range out of bounds');
-        return this;
-    }
-    /**
-     * 将参数钳制到区间范围内。
-     * @param u 输入参数。
-     * @returns 小于起点返回 `start`，大于终点返回 `end`，否则返回自身。
-     */
-    clamp(u) {
-        if (u < this._start)
-            return this._start;
-        if (u > this._end)
-            return this._end;
-        return u;
-    }
-    /**
-     * 判断两个区间是否近似相等。
-     * @param other 另一个区间。
-     * @param eps 端点比较容差。
-     * @returns 起点和终点都在容差内时返回 `true`。
-     */
-    equals(other, eps = Precision.EPS) {
-        return Precision.equal(this._start, other._start, eps) &&
-            Precision.equal(this._end, other._end, eps);
-    }
-    /**
-     * 原地扩展区间。
-     * @param delta 扩展量；`delta > 0` 表示扩大，`delta < 0` 表示收缩。
-     * @returns 当前实例（便于链式调用）。
-     */
-    expand(delta) {
-        MathError.assert(Number.isFinite(delta), 'Interval.expand: delta must be finite');
-        const nextStart = this._start - delta;
-        const nextEnd = this._end + delta;
-        MathError.assert(nextStart <= nextEnd, 'Interval.expand: shrink exceeds interval length');
-        this._start = nextStart;
-        this._end = nextEnd;
-        return this;
-    }
-    /**
-     * 返回扩展后的新区间，不修改当前实例。
-     * @param delta 扩展量；语义同 `expand`。
-     * @returns 新的区间实例。
-     */
-    expanded(delta) {
-        return this.clone().expand(delta);
-    }
-    /**
-     * 计算与另一区间的交集。
-     * @param other 参与求交的区间。
-     * @param eps 判定“相离/相接”时的容差。
-     * @returns 无交集返回 `[]`；有交集返回单段 `[Interval]`；端点相接返回点区间。
-     */
-    intersect(other, eps = Precision.EPS) {
-        const s = Math.max(this._start, other._start);
-        const e = Math.min(this._end, other._end);
-        if (s > e + eps)
-            return [];
-        if (Precision.equal(s, e, eps)) {
-            const m = (s + e) / 2;
-            return [new Interval(m, m)];
-        }
-        return [new Interval(s, e)];
-    }
-    /**
-     * 计算与另一区间的并集（普通区间语义）。
-     * @param other 参与求并的区间。
-     * @returns 单段最小覆盖区间数组（保持与 `PeriodInterval` 的返回形态一致）。
-     */
-    union(other) {
-        return [new Interval(Math.min(this._start, other._start), Math.max(this._end, other._end))];
-    }
-    /**
-     * 以参数 `u` 切分区间。
-     * @param u 切分参数。
-     * @param eps 边界判定容差。
-     * @returns `u` 在边界或区间外返回 `[]`；在区间内部返回两段子区间。
-     */
-    split(u, eps = Precision.EPS) {
-        if (!this.contains(u, eps))
-            return [];
-        if (Precision.equal(u, this._start, eps) || Precision.equal(u, this._end, eps)) {
-            return [];
-        }
-        return [new Interval(this._start, u), new Interval(u, this._end)];
-    }
-    /**
-     * 克隆当前区间。
-     * @returns 与当前区间数值相同的新实例。
-     */
-    clone() {
-        return new Interval(this._start, this._end);
-    }
-    /**
-     * 规范化区间顺序，使 `_start <= _end`。
-     * 仅在内部使用。
-     */
-    sortRange() {
-        if (this._start <= this._end)
-            return;
-        const t = this._start;
-        this._start = this._end;
-        this._end = t;
-    }
-}