flo-mat 3.0.15 → 4.0.1

package/src/bezier/fit-quads-to-cubic.ts

@@ -1,103 +0,0 @@
-import {
-    classify, fromToInclErrorBound, cubicToQuadratic, getAbsAreaBetween,
-    bezierSelfIntersection
-} from 'flo-bezier3';
-
-
-/**
- * TODO2 - change description - just basically copied from flo-bezier3
- * Approximate the given cubic bezier curve (up to the given tolerance) by 
- * fitting an array of ordered (by `t` value) piecewise bezier curves 
- * (of quadratic order or less).
- * 
- * * the start and end point of each approximating curve lies on the cubic 
- * curve and the the tangents of each approximating curve coincide with that of
- * the cubic at each such point
- * 
- * @param ps a cubic bezier curve given as an ordered array of its
- * control point coordinates, e.g. `[[0,0], [1,1], [2,1], [2,0]]`
- * @param tolerance tolerance given as the maximum total absolute area difference 
- * between the two curves
- * 
- * @doc mdx
- */
-function fitQuadsToCubicTsOnly(
-        ps: number[][], 
-        tolerance: number): number[] {
-
-    const { collinear, realOrder, nodeType } = classify(ps);
-
-    // if all points collinear or a line (or point)
-    if (collinear || realOrder <= 1) {
-        // return a quad that's a line between the first and last points
-        // return [ps[0], [(ps[0][0] + ps[3][0])/2, (ps[0][1] + ps[3][1])/2], ps[3]];
-        return [0,1];
-    }
-
-    if (realOrder === 2) {
-        // already a quadratic in disguise
-
-        // It is not possible that `toQuadraticFromCubic(ps)` be undefined here
-        // since the `real order` is exactly 2 and the control points are *not*
-        // collinear.
-        return [0,1];
-    }
-
-    const stack: number[][] = [];
-
-    // if endpoints coincide
-    if (ps[0][0] === ps[3][0] && ps[0][1] === ps[3][1]) {
-        stack.push([0, 0.5], [0.5,1]);
-    } else if (nodeType === 'cusp') {
-        const t = bezierSelfIntersection(ps)[0];
-        stack.push([0,t], [t,1]);  // split at cusp
-    } else if (nodeType === 'crunode') {
-        const ts = bezierSelfIntersection(ps);
-        if (ts.length > 1) {
-            stack.push(
-                [0, ts[0]],
-                [ts[0], ts[1]],
-                [ts[1], 1]
-            );  // split at intersections
-        } else {
-            // the intersection is outside the range [0,1]
-            stack.push([0,1]);
-        }
-    } else {
-        stack.push([0,1]);
-    }
-
-    const qs: number[][][] = [];
-    const r: number[] = [];
-    while (stack.length !== 0) {
-        const ts = stack.pop()!;
-
-        const [tS,tE] = ts;
-        /** the piece of the cubic bezier to approximate */
-        const psCubic = fromToInclErrorBound(ps, tS, tE).ps;
-        const psQuad = cubicToQuadratic(psCubic);
-        // const spanRatio = tE - tS;
-        if (psQuad === undefined || 
-            // spanRatio*getAbsAreaBetween(psQuad, psCubic) > tolerance) {
-                getAbsAreaBetween(psQuad, psCubic) > tolerance) {
-
-            const tM = (tE + tS)/2;
-            stack.push([tS,tM], [tM,tE]);  // split cubic in 2 equal pieces
-        } else {
-            qs.push(psQuad);
-            r.push(tS);
-        }
-    }
-
-    r.reverse();
-    r.push(1);
-
-    return r;
-}
-
-
-export { fitQuadsToCubicTsOnly }
-
-
-// TESTING
-// fitQuadsToCubicTsOnly([[0,0],[1,0],[0.5,1],[2,0.4]], 0.00001); //?

package/src/bezier/total-curvature.ts

@@ -1,8 +0,0 @@
-import { totalCurvature } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-
-
-const totalCurvature$ = memoize(totalCurvature);
-
-
-export { totalCurvature$ }

package/src/bezier/total-length.ts

@@ -1,8 +0,0 @@
-import { totalLength } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-
-
-const totalLength$ = memoize(totalLength);
-
-
-export { totalLength$ }

package/src/closest-boundary-point/closest-points-on-curve-precise.ts

@@ -1,75 +0,0 @@
-// import { ddDeflate, allRootsCertified, RootInterval } from 'flo-poly';
-// import { evalDeCasteljauDd, getFootpointPolyDd } from 'flo-bezier3';
-// import { Curve } from "../curve/curve.js";
-
-
-// /**
-//  * @internal
-//  * @param curve The curve
-//  * @param p The point from which to check
-//  * @param tRange The allowed t range
-//  * @param touchedCurve The bezier on which p is located
-//  * @param t The t value of the bezier that locates p
-//  */
-// function closestPointsOnCurvePrecise(
-//         curve: Curve, 
-//         p: number[], 
-//         [tS,tE]: number[] = [0,1], 
-//         touchedCurve: Curve,
-//         t: number): {
-//             p: number[];
-//             t: number;
-//         }[] {
-
-//     const _poly = getFootpointPolyDd(curve.ps, p);
-
-//     const poly = curve === touchedCurve
-//         ? ddDeflate(_poly, t)
-//         : _poly;
-
-//     const roots: Omit<RootInterval,'multiplicity'>[] = 
-//         allRootsCertified(poly, tS, tE);
-
-//     // Also test the endpoints
-//     const dontPush0 = (
-//         (t === 1 && curve === touchedCurve.next) ||
-//         (t === 0 && curve === touchedCurve)
-//     );
-
-//     const dontPush1 = (
-//         (t === 0 && curve === touchedCurve.prev) ||
-//         (t === 1 && curve === touchedCurve)
-//     );
-
-//     if (tS === 0) {
-//         if (!dontPush0) { roots.push({ tS: 0, tE: 0 }); }
-//     } else if (tS === 1) {
-//         if (!dontPush1) { roots.push({ tS: 1, tE: 1 }); }
-//     } else {
-//         roots.push({ tS: tS, tE: tS });
-//     }
-
-//     if (tE === 0) {
-//         if (!dontPush0) { roots.push({ tS: 0, tE: 0 }); }
-//     } else if (tE === 1) {
-//         if (!dontPush1) { roots.push({ tS: 1, tE: 1 }); }
-//     } else {
-//         roots.push({ tS: tE, tE: tE });
-//     }
-
-//     const ps = roots.map(
-//         root => { 
-//             const tS = root.tS;
-//             const tE = root.tE;
-//             const t = tS < 0 
-//                 ? 0
-//                 : tE > 1 ? 1 : (tS + tE)/2;
-//             return { p: evalDeCasteljauDd(curve.ps,[0,t]).map(v => v[1]), t }
-//         }
-//     );
-
-//     return ps;
-// }
-
-
-// export { closestPointsOnCurvePrecise }

package/src/closest-boundary-point/closest-points-on-curve.ts

@@ -1,72 +0,0 @@
-import { allRoots, deflate } from 'flo-poly';
-import { evalDeCasteljau, getFootpointPoly } from 'flo-bezier3';
-import { Curve } from "../curve/curve.js";
-import { eAdd, growExpansion } from 'big-float-ts';
-
-
-/**
- * @internal
- * @param curve The curve
- * @param p The point from which to check
- * @param tRange The allowed t range
- * @param touchedCurve The bezier on which p is located
- * @param t The t value of the bezier that locates p
- */
-function closestPointsOnCurve(
-        curve: Curve, 
-        p: number[], 
-        [tS,tE]: number[] = [0,1], 
-        touchedCurve: Curve,
-        t: number): {
-            p: number[];
-            t: number;
-        }[] {
-
-    const _poly = getFootpointPoly(curve.ps, p);
-
-    const poly = curve === touchedCurve
-        ? deflate(_poly, t)
-        : _poly;
-
-    const roots = allRoots(poly, tS, tE);
-
-    // Also test the endpoints
-    let push0 = true;
-    let push1 = true;
-    if ((t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)) {
-        push0 = false;
-    }
-    if ((t === 0 && curve === touchedCurve.prev) ||
-        (t === 1 && curve === touchedCurve)) {
-        push1 = false;
-    }
-
-    if (tS === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tS === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tS);
-    }
-
-    if (tE === 0) {
-        if (push0) { roots.push(0); }
-    } else if (tE === 1) {
-        if (push1) { roots.push(1); }
-    } else {
-        roots.push(tE);
-    }
-
-    const ps = roots.map(
-        r => { 
-            const t = r < 0 ? 0 : r > 1 ? 1 : r;
-            return { p: evalDeCasteljau(curve.ps,t), t }
-        }
-    );
-
-    return ps;
-}
-
-
-export { closestPointsOnCurve }

package/src/closest-boundary-point/dd-deflate-with-running-error.ts

@@ -1,88 +0,0 @@
-// TODO - import from `flo-poly` in the future
-import { ddMultDouble2 } from "double-double";
-import { ddAddDd } from "double-double";
-import { γγ } from '../error-analysis/gamma.js';
-
-
-// We *have* to do the below❗ The assignee is a getter❗ The assigned is a pure function❗ Otherwise code is too slow❗
-const qmd = ddMultDouble2;
-const qaq = ddAddDd;
-
-const { abs } = Math;
-
-const γγ3 = γγ(3);
-
-
-/**
- * Deflates the given polynomial *approximately* by removing a factor (x - t).
- * 
- * @param p a polynomial with coefficients given densely as an array of 
- * double-double precision floating point numbers from highest to lowest power, 
- * e.g. `[[0,5],[0,-3],[0,0]]` represents the polynomial `5x^2 - 3x`
- * @param pE the coefficient-wise absolute error of the input polynomial that
- * still need to be multiplied by γγ3, i.e. it is `γγ3` times too big.
- * @param t an evaluation point of the polynomial.
- * 
- * @example
- * ```typescript
- * // The polynomial x^3 - 5x^2 + 8x - 4 has a root at 1 and a double root at 2 
- * ddDeflate([[0,1], [0,-5], [0,8], [0,-4]], [0,2]); //=> [[0,1], [0,-3], [0,2]] 
- * ddDeflate([[0,1], [0,-3], [0,2], [0,2]);          //=> [[0,1], [0,-1]] 
- * ddDeflate([[0,1], [0,-1]], [0,1]);                //=> [[0,1]]
- * ```
- * 
- * @doc
- */
-function ddDeflateWithRunningError(
-        p: number[][],
-        pE: number[],
-        t: number): {
-            coeffs: number[][];
-            errBound: number[];
-        } {
-
-    //--------------------------------------------------------------------------
-    // `var` -> a variable
-    // `$var` -> the double precision approximation to `var`
-    // `_var` -> the absolute value of $var (a prefix underscore on a variable means absolute value)
-    // `var_` -> the error in var (a postfix underscore means error bound but should still be multiplied by 3*γ²)
-    // `_var_` -> means both absolute value and absolute error bound
-    // recall: `a*b`, where both `a` and `b` have errors |a| and |b| we get for the
-    //   * error bound of (a*b) === a_|b| + |a|b_ + |a*b|   (when either of a and b is double)
-    //   * error bound of (a*b) === a_|b| + |a|b_ + 2|a*b|  (when both a and b is double-double)
-    //   * error bound of (a+b) === a_ + b_ + |a+b|         (when a and/or b is double or double-double)
-    // * the returned errors need to be multiplied by 3γ² to get the true error
-    // * can use either `$var` or `var[var.length-1]` (the approx value) in error calculations
-    //   due to multiplication by 3*γ² and not 3*u²
-    //--------------------------------------------------------------------------
-    const d = p.length - 1;
-    const bs = [p[0]];    // coefficients
-    let b_ = pE[0];       // running error
-    const bEs = [b_];     // coefficient-wise error bound
-
-    for (let i=1; i<d; i++) {
-        // p[i] + t*bs[i-1];
-
-        const a = bs[i-1];
-        const $m = t*a[1];
-        const _t = abs(t);
-        const m_ = _t*b_ + abs($m);
-
-        const pi = p[i];
-        const p_ = pE[i];
-        b_ = p_ + m_ + abs(pi[1] + $m);
-
-        const b = qaq(pi,qmd(t,a));
-
-        bs.push(b);
-        bEs.push(b_);
-    }
-
-    return {
-        coeffs: bs,
-        errBound: bEs.map(e => γγ3*e)
-    };
-}
-
-
-export { ddDeflateWithRunningError }

package/src/contact-point/contact-point.ts

@@ -1,42 +0,0 @@
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { comparePoss } from '../point-on-shape/compare-poss.js';
-import { Circle } from '../geometry/circle.js';
-
-
-/**
- * Represents a point on the shape boundary for which MAT data has been
- * calculated.  
- */
-interface ContactPoint {
-    /** Identifies the point on the shape boundary. */
-    pointOnShape: PointOnShape;
-    /** The maximal disk circle touching this point. */
-    circle: Circle;
-    /** Internally used to order two points lying at the same planar point. */
-    order: number;
-    /** Internally used to order two points lying at the same planar point. */
-    order2: number;
-}
-
-
-/**
- * Primarily for internal use.
- * 
- * Compares the two contact points according to their order along the shape
- * boundary. Returns > 0 if a > b, < 0 if a < b or 0 if a === b.
- * @param a The first contact point.
- * @param b The second contact point.
- */
-function compareCps(a: ContactPoint, b: ContactPoint) {
-    let res = comparePoss(a.pointOnShape, b.pointOnShape);
-
-    if (res !== 0) { return res; }
-
-    res = a.order - b.order;
-    if (res !== 0) { return res; }
-
-    return a.order2 - b.order2;
-} 
-
-
-export { ContactPoint, compareCps }

package/src/cp-node/fs/get-avg-speed.ts

@@ -1,31 +0,0 @@
-import { totalAbsoluteCurvature, totalLength } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-import { totalCurvature$ } from "../../bezier/total-curvature.js";
-import { CpNode } from "../cp-node.js";
-import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
-import { getRealProngCount } from "./get-real-prong-count.js";
-
-const { min, abs } = Math;
-
-
-const getAvgSpeed$ = memoize(getAvgSpeed);
-
-
-function getAvgSpeed(cpNode: CpNode): number | undefined {
-    if (getRealProngCount(cpNode) !== 2) {
-        return 0;
-    }
-
-    const { radius: r } = cpNode.cp.circle;
-    const matPs = getMatCurveToNext(cpNode);
-    const T = totalCurvature$(matPs);
-    const l = totalLength(matPs);
-    if (l === 0) {
-        return undefined;
-    }
-    
-    return -r*T/l;
-}
-
-
-export { getAvgSpeed, getAvgSpeed$ }

package/src/cp-node/fs/get-smoothed-speed.ts

@@ -1,97 +0,0 @@
-import { memoize } from "flo-memoize";
-import { totalCurvature$ } from "../../bezier/total-curvature.js";
-import { totalLength$ } from "../../bezier/total-length.js";
-import { memoizePrimitive } from "../../memoize-primitive.js";
-import { CpNode } from "../cp-node.js";
-import { getMatCurveToNext$ } from "./get-mat-curve-to-next.js";
-import { getRealProngCount } from "./get-real-prong-count.js";
-import { isFullyTerminating } from "./is-fully-terminating.js";
-
-
-const RLen = 40;
-
-const getSmoothedSpeed$ = memoizePrimitive(
-    function (L: number) {
-        return memoize(
-            function getSmoothedSpeed(
-                    cpNode: CpNode): number | undefined {
-
-                let cpStart = cpNode;
-
-                let cumLB = 0;
-                let cumLF = 0;
-                let curB = cpStart.prev;
-                let curF = cpStart;
-                let cumKB = 0;
-                let cumKF = 0;
-                let cumLRB = 0;
-                let cumLRF = 0;
-                while (cumLRF < L/2/RLen &&
-                       curF !== cpStart.prev &&
-                       !isFullyTerminating(curF) &&
-                       getRealProngCount(curF) <= 2) {
-                    const { radius: r } = curF.cp.circle;
-                    const ps = getMatCurveToNext$(curF);
-                    const turn = totalCurvature$(ps);
-
-                    let rot = 0;
-                    // if (getProngCount(curF) >= 3) {
-                    //     rot = -getInterfaceRotation(
-                    //         tangentAt0(ps),
-                    //         tangentAt1(curF.prev.cp.pointOnShape.curve.ps)
-                    //     );
-                    // }
-
-                    const l = totalLength$(getMatCurveToNext$(curF));
-                    cumKF += r*(turn + rot);
-                    cumLF += l;
-                    cumLRF += l/r;
-
-                    curF = curF.next;
-                }
-                while (cumLRB < L/2/RLen &&
-                       curB !== cpStart &&
-                       !isFullyTerminating(curB) &&
-                       getRealProngCount(curB) <= 2) {
-                    const { radius: r } = curB.cp.circle;
-                    const ps = getMatCurveToNext$(curB);
-                    const turn = totalCurvature$(ps);
-
-                    let rot = 0;
-                    // if (getProngCount(curB) >= 3) {
-                    //     rot = -getInterfaceRotation(
-                    //         tangentAt0(ps),
-                    //         tangentAt1(curB.prev.cp.pointOnShape.curve.ps)
-                    //     )
-                    // }
-
-                    const l = totalLength$(getMatCurveToNext$(curB));
-                    cumKB += r*(turn + rot);
-                    cumLB += l;
-                    cumLRB += l/r;
-
-                    curB = curB.prev;
-                }
-                const cumL = cumLB + cumLF;
-                const cumK = cumKB + cumKF;
-
-                if (cumL === 0) {
-                    return undefined;
-                }
-
-                const x = -cumK/cumL;
-
-                // f(x) = 1 - exp(-x)
-                // f(x) = 1 - 1/(1 + x)
-                // f(x) = x/(a + x)
-                // f(x) = tanh(x)
-
-                // return 1 - Math.E**(-x)
-                return x;
-            }
-        )
-    }
-);
-
-
-export { getSmoothedSpeed$ }

package/src/cp-node/fs/get-smoothed.ts

@@ -1,62 +0,0 @@
-import { totalAbsoluteCurvature, totalCurvature, totalLength } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-import { totalCurvature$ } from "../../bezier/total-curvature.js";
-import { totalLength$ } from "../../bezier/total-length.js";
-import { memoizePrimitive } from "../../memoize-primitive.js";
-import { CpNode } from "../cp-node.js";
-import { getAvgSpeed, getAvgSpeed$ } from "./get-avg-speed.js";
-import { getMatCurveToNext, getMatCurveToNext$ } from "./get-mat-curve-to-next.js";
-import { getSpeed } from "./get-speed.js";
-
-
-const getSmoothed$ = memoizePrimitive(
-    function (L: number) {
-        return memoize(
-            function getSmoothed(
-                    cpNode: CpNode) {
-
-                // return getAvg$(cpNode)
-                // return getAvgCurvature(cpNode)
-                let cpStart = cpNode;
-
-                let cumLB = 0;
-                let cumLF = 0;
-                let curB = cpStart.prev;
-                let curF = cpStart;
-                let cumRTurnB = 0;
-                let cumRTurnF = 0;
-                while (cumLB < L/2 && curB !== cpStart) {
-                    const { radius: r } = curB.cp.circle;
-                    const ps = getMatCurveToNext$(curB);
-                    const absK = totalCurvature$(ps);
-                    const l = totalLength$(getMatCurveToNext$(curB));
-                    cumRTurnB += r*absK;
-                    cumLB += l;
-
-                    curB = curB.prev;
-                }
-                while (cumLF < L/2 && curF !== cpStart.prev) {
-                    const { radius: r } = curF.cp.circle;
-                    const ps = getMatCurveToNext$(curF);
-                    const absK = totalCurvature$(ps);
-                    const l = totalLength$(getMatCurveToNext$(curF));
-                    cumRTurnF += r*absK;
-                    cumLF += l;
-
-                    curF = curF.next;
-                }
-                const cumL = cumLB + cumLF;
-                const cumRTurn = cumRTurnB + cumRTurnF;
-
-                if (cumL === 0) {
-                    return undefined;
-                }
-
-                return { cumRTurn, cumL };
-            }
-        )
-    }
-);
-
-
-export { getSmoothed$ }

package/src/cp-node/fs/get-speed.ts

@@ -1,56 +0,0 @@
-import { totalAbsoluteCurvature, totalLength } from "flo-bezier3";
-import { memoize } from "flo-memoize";
-import { CpNode } from "../cp-node.js";
-import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
-import { getRealProngCount } from "./get-real-prong-count.js";
-
-const getSpeed$ = memoize(getSpeed);
-
-
-function getSpeed(cpNode: CpNode): number | undefined {
-    if (getRealProngCount(cpNode) !== 2) {
-        return 0;
-    }
-
-    const { radius: r } = cpNode.cp.circle;
-    const matPs = getMatCurveToNext(cpNode);
-    const absK = totalAbsoluteCurvature(matPs, [0,1]);
-    const l = totalLength(matPs);
-    if (l === 0) {
-        return undefined;  // TODO2
-    }
-    // const avgK = absK/l;
-    const avgK = absK;
-
-    return avgK*r;
-}
-
-
-
-
-// function getSpeed() {
-    // const cpNodeF = cpNode;
-    // const cpNodeB = cpNode.next.prevOnCircle;
-    // const matPs = getMatCurveToNext(cpNodeF);
-    // const boundaryPsF = getBoundaryBeziersToNext(cpNodeF);
-    // const boundaryPsB = getBoundaryBeziersToNext(cpNodeB);
-
-    // const lF = sum(boundaryPsF.map(ps => totalLength(ps)));
-    // const lB = sum(boundaryPsB.map(ps => totalLength(ps)));
-
-    // const l = totalLength(matPs);
-    // const ll = l === 0 ? 0.001 : l;
-
-    // const _speedF = lF/ll;
-    // const _speedB = lB/ll;
-
-    // const speedF = _speedF < 1 ? _speedF : 1;
-    // const speedB = _speedB < 1 ? _speedB : 1;
-
-
-    // const speed = min(speedF, speedB);
-
-    // return speed;
-// }
-
-export { getSpeed, getSpeed$ }

package/src/curve/curve.ts

@@ -1,35 +0,0 @@
-// import type { Loop } from 'flo-boolean';
-
-
-// /**
-//  * Represents a bezier curve on the shape boundary / loop.
-//  */
-// interface Curve {
-//     /**
-//      * The curve's ordered index in the loop. This imposes a cycling
-//      * ordering of the curves in the loop
-//      */
-//     readonly idx: number;
-//     /** The bezier control points. */
-//     readonly ps: number[][];
-//     /**
-//      * The closed loop of bezier curves representing the shape 
-//      * boundary this curve belongs to.
-//      */
-//     readonly loop: Loop;
-//     /**
-//      * The previous curve (when going in a negative direction around
-//      * the shape boundary, i.e. clockwise for the outer shape and anti-clockwise
-//      * for the holes (if any))
-//      */
-//     readonly prev: Curve; 
-//     /**
-//      * The next curve (when going in a positive direction around
-//      * the shape boundary, i.e. anti-clockwise for the outer shape and clockwise
-//      * for the holes (if any))
-//      */
-//     readonly next: Curve;
-// }
-
-
-// export { Curve }