flo-mat 4.1.4 → 5.0.1

package/src/closest-boundary-point/root-interval-to-distance-squared-interval.ts

@@ -1,75 +1,57 @@
-import { twoDiff, ddMultDd, ddAddDd } from 'double-double';
+import { eps } from '../error-analysis/gamma.js';
 
-const td = twoDiff;
-const qmq = ddMultDd;
-const qaq = ddAddDd;
+const { max } = Math;
 
-const eps = Number.EPSILON;
+/**
+ * Relative widening of the interval bounds - see the error analysis in
+ * `rootIntervalToDistanceSquaredInterval`: the exact first order requirement
+ * is `4u = 2eps` (`u = eps/2` the unit roundoff); `4eps = 2**-50` (exactly
+ * representable) leaves room for the `O(u²)` terms.
+ */
+const WIDEN = 4*eps;
 
 
 /**
- * Returns the distance interval squared given the root interval (currently
- * ignoring multiplicity). 
- * 
- * * the result is returned as `[minPossibleSquared, maxPossibleSquared]` distance.
- * 
- * @param box
- * @param p
- * 
+ * Returns an interval `[min, max]` guaranteed to contain the squared distance
+ * from the point `p` to *any* point of a curve piece, given an axis-aligned
+ * box that is guaranteed to engulf that piece (see `getIntervalBox`).
+ *
+ * * the minimum squared distance to the box is attained on its boundary (or
+ *   is `0` if `p` is inside): per axis the distance is the gap between `p` and
+ *   the box's range on that axis (`0` if `p` is within the range)
+ * * the maximum squared distance to the box is attained at a corner: per axis
+ *   it is the larger of the distances to the two range ends
+ *
+ * Error analysis (`u = eps/2` the unit roundoff, `fl(a∘b) = (a∘b)(1+δ)`,
+ * `|δ| <= u`): all inputs are doubles and each bound is computed with 3
+ * roundings per term path (subtraction, square, sum - `max` is exact) and
+ * widened with 1 more, so the computed bound is within a factor `(1±u)⁴` of
+ * the exact one before widening and `WIDEN >= 4u + O(u²)` makes the interval
+ * rigorous. (A gap of `0` is exact: `fl(a-b)` has the sign of `a-b`.)
+ *
+ * @param box the engulfing box given as `[[minX, minY], [maxX, maxY]]`
+ * @param p the point
+ *
  * @internal
  */
 function rootIntervalToDistanceSquaredInterval(
-        box: number[][], 
-        p: number[]) {
-
-    const bl = box[0];
-    const tr = box[1];
-    const minX = bl[0];
-    const minY = bl[1];
-    const maxX = tr[0];
-    const maxY = tr[1];
-
-    const x = p[0];  // <0>
-    const y = p[1];  // <0>
-
-    let minDSquared = +Infinity;
-    let maxDSquared = -Infinity;
-
-    // for each corner of the interval box
-    for (const [a,b] of [[minX,minY],[minX,maxY],[maxX,minY],[maxX,maxY]]) {
-        /*
-        // distance to 1st corner of interval box - `distance² = x² + y²`
-        const dc1 = (a - x)**2 + (b - y)**2;
-        // max absolute roundoff error of `dc1`
-        // <4>dc1 <-- <4>(<3>(<1>(a - x)**2) + <3>(<1>((b - y)**2))
-        const dc1E = 4*γ1*((a + x)**2 + (b + y)**2);
-        const dc1Min = dc1 - dc1E;  // distance minus max error
-        const dc1Max = dc1 + dc1E;  // distance plus max error
-        */
+        box: number[][],
+        p: number[]): number[] {
 
-        /** distance to 1st corner of interval box - `distance² = x² + y²` */
-        const ax = td(a,x);  // a - x
-        const by = td(b,y);  // b - y
-        // const dc1Exact = eadd(emult(ax,ax),emult(by,by));  // ax**2 + bx**2
-        // const dc1 = estimate(dc1Exact);
-        const dc1Dd = qaq(qmq(ax,ax),qmq(by,by));  // ax**2 + bx**2
-        const dc1 = dc1Dd[1];
+    const [[minX, minY], [maxX, maxY]] = box;
+    const [x, y] = p;
 
-        // const dc1Min = dc1*(1 - 2**maxCoordPowerOf2*eps);  // distance minus max error
-        // const dc1Max = dc1*(1 + 2**maxCoordPowerOf2*eps);  // distance plus max error
-        const dc1Min = dc1*(1 - eps);  // distance minus max error
-        const dc1Max = dc1*(1 + eps);  // distance plus max error
-        
-        if (dc1Min <= minDSquared) {
-            minDSquared = dc1Min;
-        }
+    // per axis gap between `p` and the box (`0` if `p` is within range)
+    const dxMin = max(minX - x, 0, x - maxX);
+    const dyMin = max(minY - y, 0, y - maxY);
+    // per axis distance from `p` to the furthest end of the box's range
+    const dxMax = max(x - minX, maxX - x);
+    const dyMax = max(y - minY, maxY - y);
 
-        if (dc1Max >= maxDSquared) {
-            maxDSquared = dc1Max;
-        }
-    }
+    const minDSquared = dxMin*dxMin + dyMin*dyMin;
+    const maxDSquared = dxMax*dxMax + dyMax*dyMax;
 
-    return [minDSquared,maxDSquared];
+    return [minDSquared*(1 - WIDEN), maxDSquared*(1 + WIDEN)];
 }
 
 

package/src/corner/get-corner.ts

@@ -1,4 +1,5 @@
 import type { Corner } from "./corner.js";
+import { memoize } from 'flo-memoize';
 import { cross, toUnitVector } from "flo-vector2d";
 import { getInterfaceCcw } from './get-interface-ccw.js';
 
@@ -70,4 +71,12 @@ function getCorner(
 }
 
 
-export { getCorner }
+/**
+ * Memoized version of `getCorner` (keyed on the two control point arrays).
+ * 
+ * @internal
+ */
+const getCorner$ = memoize(getCorner);
+
+
+export { getCorner, getCorner$ }

package/src/corner/get-interface-ccw.ts

@@ -1,4 +1,4 @@
-import { eAdd, eCompress, eEstimate, eMult, eNegativeOf, eProduct, orient2d, twoDiff } from 'big-float-ts';
+import { eAdd, eEstimate, eMult, eNegativeOf, twoDiff } from 'big-float-ts';
 import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
 
 
@@ -137,4 +137,4 @@ function crossPrecise(
 }
 
 
-export { getInterfaceCcw }
+export { getInterfaceCcw }

package/src/cp-node/cp-node.ts

@@ -26,9 +26,10 @@ import { PointOnShape } from '../point-on-shape/point-on-shape.js';
  * following other branches on the MAT.
  * 
  * Call `getMatCurveBetween(cpNodeFrom, cpNodeTo)` or `getMatCurveToNext(cpNode)` 
- * (replacing the older CpNode.`matCurveToNextVertex`) to get a bezier curve 
- * from the maximal disk of this `CpNode` to the next `CpNode`'s 
- * maximal disk and thus directly representing a piece of the medial axis.
+ * (replacing the older CpNode.`matCurveToNextVertex`) to get the bezier curves 
+ * (1 or 2 lines or quadratics joined smoothly) from the maximal disk of this 
+ * `CpNode` to the next `CpNode`'s maximal disk and thus directly representing 
+ * a piece of the medial axis.
  * 
  * The function, `getChildren`, returns the children of this `CpNode` when
  * seen as a MAT edge. Only children in a 'forward' direction are returned. These

package/src/cp-node/fs/get-all-on-loop-by-loop.ts

@@ -16,10 +16,6 @@ function getAllOnLoop_ByLoop(
 
     const cpStarts: CpNode[] = [cpNode];
     const cpStartSet = new Set(cpStarts);
-    if (cpNode.isHoleClosing) {
-        cpStartSet.add(cpNode.prevOnCircle.holeCloserTwin!);
-    }
-    cpStartSet.add(cpNode);
 
     while (cpStarts.length > 0) {
         const cpNodes: CpNode[] = [];

package/src/cp-node/fs/get-angle-between-mat-curves.ts

@@ -1,8 +1,10 @@
+import type { CpNode } from "../cp-node.js";
 import { tangent } from "flo-bezier3";
 import { cross, toUnitVector } from "flo-vector2d";
-import { CpNode } from "../cp-node.js";
 import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
 
+const { abs, asin, min, max, PI: π } = Math;
+
 
 /**
  * 
@@ -15,16 +17,18 @@ function getInitialDegAngleBetweenMatCurves(
         cpNode2: CpNode) {
 
     const tan1 = toUnitVector(tangent(
-        getMatCurveToNext(cpNode1), 
+        getMatCurveToNext(cpNode1)[0], 
         0
     ));
     const tan2 = toUnitVector(tangent(
-        getMatCurveToNext(cpNode2), 
+        getMatCurveToNext(cpNode2)[0], 
         0
     ));
 
-    const cross_ = cross(tan1, tan2);
-    const angle = Math.abs(Math.asin( cross_ ) * (180/Math.PI));
+    // clamp: rounding can push the cross product of two unit vectors just
+    // outside [-1,1], which would make `asin` return `NaN`
+    const cross_ = max(-1, min(1, cross(tan1, tan2)));
+    const angle = abs(asin( cross_ ) * (180/π));
 
     return angle;
 }

package/src/cp-node/fs/get-boundary-beziers-between.ts

@@ -4,15 +4,17 @@ import { getBoundaryBeziersToNext } from "./get-boundary-beziers-to-next.js";
 
 
 /**
- * Returns all `CpNode`s between the two given ones (inclusive).
- * 
- * * If the second `CpNode` is never encountered all on the loop will be
+ * Returns the bezier curves of the shape boundary from the contact point of
+ * the first given `CpNode` to that of the second (following `next`), together
+ * with whether a hole closer was passed on the way.
+ *
+ * * If the second `CpNode` is never encountered the entire boundary is
  * returned.
- * 
- * @param cpNode1 
- * @param cpNode2 
- * @param inclAllIfEqual if `true` and first and last `CpNode`s are equal then
- * include all `CpNode`s around the loop, otherwise include none.
+ *
+ * @param cpNode1
+ * @param cpNode2
+ * @param inclAllIfEqual if `true` and the two `CpNode`s are equal then return
+ * the entire boundary, otherwise return nothing.
  */
 function getBoundaryBeziersBetween(
         cpNode1: CpNode,

package/src/cp-node/fs/get-branch-beziers.ts

@@ -4,14 +4,15 @@ import { getMatCurveToNext } from './get-mat-curve-to-next.js';
 
 
 /**
- * Returns the branch associated with the give cpNode
+ * Returns the (flattened) array of bezier curves (lines or quadratics) 
+ * representing the branch associated with the given cpNode
  * 
  * @param cpNode `CpNode` representing the start vertex.
  */
 function getBranchBeziers(
         cpNode: CpNode): number[][][] {
 
-    return getBranch(cpNode).map(b => getMatCurveToNext(b));
+    return getBranch(cpNode).flatMap(getMatCurveToNext);
 }
 
 

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

@@ -1,6 +1,5 @@
 import { CpNode } from '../cp-node.js';
 import { getRealProngCount } from './get-real-prong-count.js';
-import { isFullyTerminating } from './is-fully-terminating.js';
 import { isTerminating } from './is-terminating.js';
 import { isTrivial } from './is-trivial.js';
 
@@ -34,7 +33,7 @@ function getBranch(
     do {
         branch.push(cpNode);
         cpNode = cpNode.next;
-    } while (!isFullyTerminating(cpNode) && getRealProngCount(cpNode) === 2)
+    } while (getRealProngCount(cpNode) === 2)
 
     return branch;
 }

package/src/cp-node/fs/get-distance-to-next.ts

@@ -7,8 +7,10 @@ import { getMatCurveToNext } from "./get-mat-curve-to-next.js";
 function getMatDistanceToNext(
         cpNode: CpNode) {
 
-    const ps = getMatCurveToNext(cpNode);
-    const l = totalLength(ps);
+    let l = 0;
+    for (const ps of getMatCurveToNext(cpNode)) {
+        l += totalLength(ps);
+    }
 
     return l;
 }

package/src/cp-node/fs/get-edge-direction.ts

@@ -4,6 +4,8 @@ import { toUnitVector, fromTo, rotate, translate, rotate90Degrees, reverse as re
 import { tangent } from 'flo-bezier3';
 import { isPosSharpCorner } from '../../point-on-shape/is-pos-sharp-corner.js';
 
+const { sqrt } = Math;
+
 
 /**
  * Returns a line segment of unit length starting in the given Vertex center and
@@ -54,8 +56,8 @@ function getEdgeDirection(
         // Recall the identities sin(acos(x)) = sqrt(1-x^2), etc. Also 
         // recall the half angle formulas. Then the rotation matrix, R, can 
         // be calculated.
-        const cosθ = Math.sqrt((1 + x)/2);
-        const sinθ = Math.sqrt((1 - x)/2);
+        const cosθ = sqrt((1 + x)/2);
+        const sinθ = sqrt((1 - x)/2);
         
         vDir = rotate(sinθ, cosθ, tan2);
     }

package/src/cp-node/fs/get-first-exit.ts

@@ -1,25 +1,26 @@
-import { CpNode } from "../cp-node.js";
+import type { CpNode } from "../cp-node.js";
+import { isTerminating } from "./is-terminating.js";
 
 
 /**
- * Returns the first `CpNode` (from this one by successively applying 
- * .nextOnCircle) that exits the circle.
+ * Returns the first `CpNode` *after* the given one (by successively applying 
+ * `.nextOnCircle`) that exits the circle, i.e. the first one that is not
+ * terminating - the given `CpNode` itself is never returned.
+ * 
+ * * returns `undefined` if no other `CpNode` on the circle exits (e.g. the 
+ *   other `CpNode` of a 1-prong, or the MAT is a single point)
  */
-function getFirstExit(cpNode: CpNode) {
-    // const startNode = this as CpNode;
-    const startNode = cpNode;
-    let cpNode_ = startNode;
+function getFirstExit(cpNode: CpNode): CpNode | undefined {
+    let cpNode_ = cpNode.nextOnCircle;
 
-    while (cpNode_.next === cpNode_.prevOnCircle) {
-        cpNode_ = cpNode_.next;
-
-        if (cpNode_ === startNode) {
-            // The very special case the MAT is a single point.
-            return undefined; 
+    while (cpNode_ !== cpNode) {
+        if (!isTerminating(cpNode_)) {
+            return cpNode_;
         }
+        cpNode_ = cpNode_.nextOnCircle;
     }
 
-    return cpNode_;
+    return undefined;
 }
 
 

package/src/cp-node/fs/get-implied-boundary-bezier-between.ts

@@ -1,76 +1,24 @@
-import { tangent } from 'flo-bezier3';
-import { 
-    fromTo, dot, cross, translate, lineLineIntersection, toUnitVector
-} from 'flo-vector2d';
-import { CpNode } from '../cp-node.js';
-
-
-/** @internal */
-const TOLERANCE_ADD_2PRONG = 0.01;
-/** @internal */
-const TOLERANCE_USE_LINE = 0.0001; // else cubic
-
-
+import type { CpNode } from '../cp-node.js';
+import { getBoundaryTangentLine } from '../../point-on-shape/get-boundary-tangent-line.js';
+import { getBeziersFromTangents } from '../../utils/get-beziers-from-tangents.js';
+
+
+/**
+ * Returns the bezier curves (an array of 1 or 2 lines or quadratics joined
+ * smoothly) approximating the shape boundary between the contact points of 
+ * two `CpNode`s.
+ * 
+ * @param cpNodeA 
+ * @param cpNodeB 
+ */
 function getImpliedBoundaryBezierBetween(
         cpNodeA: CpNode,
-        cpNodeB: CpNode): number[][] | undefined {
-
-    const posA = cpNodeA.pointOnShape;
-    const posB = cpNodeB.pointOnShape;
-
-    let { curve: curveA, p: pA, t: tA } = posA;
-    let { curve: curveB, p: pB, t: tB } = posB;
-
-    if (pA[0] === pB[0] && pA[1] === pB[1]) {
-        return [pA];
-    }
-
-    if (tA === 1) { tA = 0; curveA = curveA.next; }
-    if (tB === 0) { tB = 1; curveB = curveB.prev; }
-    
-    const { ps: psA } = curveA;
-    const { ps: psB } = curveB;
-
-    const lA = [pA,translate(pA)(toUnitVector(tangent(psA, tA)))];
-    const lB = [pB,translate(pB)(toUnitVector(tangent(psB, tB)))];
-
-    const mid = lineLineIntersection(lA, lB);
-
-    const c = fromTo(pA,pB);
-
-    let twisted: boolean;
-    if (!mid) {
-        twisted = true;
-    } else {
-        const a = fromTo(pA, mid);
-        const b = fromTo(pB, mid);
-        
-        twisted = dot(a,c) < 0 || dot(b,c) > 0;
-    }
-    
-    if (!twisted) {
-        // drawFs.bezier(g, [pA, mid!, pB], 'thin10 pink nofill', 0)
-        return [pA, mid!, pB];
-    } 
-        
-    const w1 = fromTo(lA[0], lA[1]);  // This is a unit vector
-    const w2 = fromTo(lB[0], lB[1]);  // This is a unit vector
-
-    const d1 = Math.abs(cross(c, w1)) / (3*3); 
-    const d2 = Math.abs(cross(c, w2)) / (3*3); 
-
-    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
-        // not within tolerance
-        return undefined;
-    } 
-
-    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
-        // approximate with cubic bezier?
-        return undefined;  // add 2-prong
-    } 
+        cpNodeB: CpNode): number[][][] {
 
-    // Within tolerance - approximate with a straight line.
-    return [pA, pB];
+    return getBeziersFromTangents(
+        getBoundaryTangentLine(cpNodeA.pointOnShape, true),
+        getBoundaryTangentLine(cpNodeB.pointOnShape, false)
+    );
 }
 
 

package/src/cp-node/fs/get-mat-curve-between.ts

@@ -1,81 +1,24 @@
 import type { CpNode } from '../cp-node.js';
-import { 
-    fromTo as fromToVec, dot, cross, rotate90Degrees, interpolate, translate,
-    lineLineIntersection
-} from 'flo-vector2d';
 import { getEdgeDirection } from './get-edge-direction.js';
-
-const { abs } = Math;
-
-
-/** @internal */
-const TOLERANCE_ADD_2PRONG = 0.01;
-/** @internal */
-const TOLERANCE_USE_LINE = 0.0001; // else cubic
+import { getBeziersFromTangents } from '../../utils/get-beziers-from-tangents.js';
 
 
 /**
- * Returns the bezier curve from the maximal disk of one `CpNode` to another
- * `CpNode`'s maximal disk.
+ * Returns the bezier curves (an array of 1 or 2 lines or quadratics joined
+ * smoothly) from the maximal disk of one `CpNode` to another `CpNode`'s 
+ * maximal disk.
+ * 
  * @param cpNodeFrom 
  * @param cpNodeTo 
  */
 function getMatCurveBetween(
         cpNodeFrom: CpNode, 
-        cpNodeTo: CpNode): number[][] {
-
-    const fromCc = cpNodeFrom.pointOnShape.circle.center;
-    const fromL = getEdgeDirection(cpNodeFrom);
-
-    const toCc = cpNodeTo.pointOnShape.circle.center;
-    const toL = getEdgeDirection(cpNodeTo.prevOnCircle);
-
-    const mid = lineLineIntersection(fromL, toL);
-
-    const c = fromToVec(fromCc,toCc);
-
-    let twisted: boolean;
-    if (!mid) {
-        twisted = true;
-    } else {
-        const a = fromToVec(fromCc, mid);
-        const b = fromToVec(toCc,   mid);
-        
-        twisted = dot(a,c) < 0 || dot(b,c) > 0;
-    }
-    
-    if (!twisted) {
-        return [fromCc, mid!, toCc];
-    } 
-        
-    const r = rotate90Degrees(c);
-    const w1 = fromToVec(fromL[0], fromL[1]); // This is a unit vector
-    const w2 = fromToVec(toL[0],  toL[1]);  // This is a unit vector
-
-    const d1 = abs(cross(c, w1)) / (3*3); 
-    const d2 = abs(cross(c, w2)) / (3*3); 
-
-    if (d1 > TOLERANCE_ADD_2PRONG || d2 > TOLERANCE_ADD_2PRONG) {
-        // FUTURE - not within tolerance - must add additional 2-prong
-        return [fromCc, toCc];
-    } 
-
-    if (d1 > TOLERANCE_USE_LINE || d2 > TOLERANCE_USE_LINE) {
-        // approximate with cubic bezier
-        const m1 = interpolate(fromCc,toCc,1/3);
-        const m2 = interpolate(fromCc,toCc,2/3);
-        const v1 = translate(r, m1);
-        const v2 = translate(r, m2);
-        const l1 = [m1,v1];
-        const l2 = [m2,v2];
-        const mid1 = lineLineIntersection(fromL, l1)!;
-        const mid2 = lineLineIntersection(toL,   l2)!;
-
-        return [fromCc, mid1, mid2, toCc];
-    } 
+        cpNodeTo: CpNode): number[][][] {
 
-    // Within tolerance - approximate with a straight line.
-    return [fromCc, toCc];
+    return getBeziersFromTangents(
+        getEdgeDirection(cpNodeFrom),
+        getEdgeDirection(cpNodeTo.prevOnCircle)
+    );
 }
 
 

package/src/cp-node/fs/get-mat-curves-between.ts

@@ -2,6 +2,14 @@ import { CpNode } from '../cp-node.js';
 import { getMatCurveBetween } from './get-mat-curve-between.js';
 
 
+/**
+ * Returns the (flattened) array of bezier curves (lines or quadratics) 
+ * representing the medial axis from one `CpNode` to another by following
+ * `next` repeatedly.
+ * 
+ * @param cpNodeS 
+ * @param cpNodeE 
+ */
 function getMatCurvesBetween(
         cpNodeS: CpNode,
         cpNodeE: CpNode) {
@@ -9,8 +17,7 @@ function getMatCurvesBetween(
     let cpNode = cpNodeS;
     const pss: number[][][] = [];
     while (cpNode !== cpNodeE) {
-        const ps = getMatCurveBetween(cpNode, cpNode.next);
-        pss.push(ps);
+        pss.push(...getMatCurveBetween(cpNode, cpNode.next));
 
         cpNode = cpNode.next;
     }

package/src/cp-node/fs/get-real-prong-count.ts

@@ -1,19 +1,23 @@
 import { CpNode } from "../cp-node.js";
-import { getAllOnCircle } from "./get-all-on-circle.js";
 import { isTerminating } from "./is-terminating.js";
 
 
 /**
- * Returns the number of contact points (up to planar coordinates) on the 
- * maximal disk circle implied by this `CpNode`. 
- * 
+ * Returns the number of contact points (up to planar coordinates) on the
+ * maximal disk circle implied by this `CpNode`, i.e. the number of
+ * non-terminating `CpNode`s on its circle.
+ *
  * See also `getProngCount`.
  */
 function getRealProngCount(cpNode: CpNode) {
-    const nonTerminatingCpNodes = getAllOnCircle(cpNode)
-    .filter(cpNode => !isTerminating(cpNode));
+    let count = 0;
+    let cpNode_ = cpNode;
+    do {
+        if (!isTerminating(cpNode_)) { count++; }
+        cpNode_ = cpNode_.nextOnCircle;
+    } while (cpNode_ !== cpNode);
 
-    return nonTerminatingCpNodes.length;
+    return count;
 }
 
 

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

@@ -6,8 +6,18 @@ import { sum } from '../../utils/sum.js';
 
 
 /**
+ * Returns the salience of the given `CpNode`: the ratio of the boundary length
+ * from its contact point forward to the next contact point on its circle to
+ * the straight distance between those two points.
+ *
+ * * `Infinity` if that stretch of boundary passes a hole closer
+ * * `0` if the two contact points coincide with no boundary in between (the
+ *   terminating `CpNode` of a 1-prong) - the other `CpNode` of a 1-prong,
+ *   whose stretch is the entire boundary, gives `Infinity`
+ *
  * See https://research.gold.ac.uk/id/eprint/31944/
- * @param cpNode 
+ *
+ * @param cpNode
  */
 function getSalience(cpNode: CpNode) {
     const cpNode1 = cpNode;
@@ -21,7 +31,10 @@ function getSalience(cpNode: CpNode) {
 
     const s = sum(pss.map(ps => totalLength(ps)));
 
-    return hasHoleCloser ? Infinity : s/d;
+    if (hasHoleCloser) { return Infinity; }
+    if (s === 0) { return 0; }  // (avoids `0/0` for the 1-prong case)
+
+    return s/d;
 }