flo-mat 3.0.1 → 3.0.2

package/src/add-n-prong.ts/join-spokes.ts

@@ -0,0 +1,39 @@
+import { CpNode } from "../cp-node/cp-node.js";
+import { Circle } from "../geometry/circle.js";
+
+
+function joinSpokes(
+        circle: Circle,
+        cpNodes: CpNode[]) {
+
+    cpNodes = cpNodes.slice().sort(byAngle(circle));
+
+    const len = cpNodes.length;
+    for (let i=0; i<len; i++) {
+        cpNodes[i].nextOnCircle = cpNodes[(i + 1)%len];
+        cpNodes[i].prevOnCircle = cpNodes[(i - 1 + len)%len];
+    }
+}
+
+
+/** @internal */
+function byAngle(circle: Circle) {
+	const c = circle.center;
+
+	return function(_a: CpNode, _b: CpNode) {
+		let a = _a.cp.pointOnShape.p;
+		let b = _b.cp.pointOnShape.p;
+
+		// Move onto origin
+		a = [a[0] - c[0], a[1] - c[1]];
+		b = [b[0] - c[0], b[1] - c[1]];
+
+		const a_ = Math.atan2(a[1], a[0]);
+		const b_ = Math.atan2(b[1], b[0]);
+
+		return b_ - a_;
+	}
+}
+
+
+export { joinSpokes }

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

@@ -0,0 +1,103 @@
+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

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

package/src/bezier/total-length.ts

@@ -0,0 +1,8 @@
+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 +1,75 @@
-import { ddDeflate, allRootsCertified, RootInterval } from 'flo-poly';
-import { evalDeCasteljauDd, getFootpointPolyDd } from 'flo-bezier3';
-import { Curve } from "../curve/curve.js";
+// 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;
-        }[] {
+// /**
+//  * @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 = getFootpointPolyDd(curve.ps, p);
 
-    const poly = curve === touchedCurve
-        ? ddDeflate(_poly, t)
-        : _poly;
+//     const poly = curve === touchedCurve
+//         ? ddDeflate(_poly, t)
+//         : _poly;
 
-    const roots: Omit<RootInterval,'multiplicity'>[] = 
-        allRootsCertified(poly, tS, tE);
+//     const roots: Omit<RootInterval,'multiplicity'>[] = 
+//         allRootsCertified(poly, tS, tE);
 
-    // Also test the endpoints
-    const dontPush0 = (
-        (t === 1 && curve === touchedCurve.next) ||
-        (t === 0 && curve === touchedCurve)
-    );
+//     // 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)
-    );
+//     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 (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 });
-    }
+//     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 }
-        }
-    );
+//     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;
-}
+//     return ps;
+// }
 
 
-export { closestPointsOnCurvePrecise }
+// export { closestPointsOnCurvePrecise }

package/src/closest-boundary-point/cull-bezier-pieces.ts

@@ -1,4 +1,4 @@
-import { BezierPiece } from '../mat/bezier-piece.js';
+import { CurvePiece } from '../mat/curve-piece.js';
 import { getBestDistanceSquared } from './get-best-distance-squared.js';
 import { cullByLooseBoundingBox } from './cull-by-loose-bounding-box.js';
 import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
@@ -11,7 +11,7 @@ import { cullByTightBoundingBox } from './cull-by-tight-boundary-box.js';
  * @param extreme
  */
 function cullBezierPieces1(
-        bezierPieces: BezierPiece[],
+        bezierPieces: CurvePiece[],
         p: number[]) {
 
     const bestSquaredDistance = getBestDistanceSquared(

package/src/closest-boundary-point/cull-by-loose-bounding-box.ts

@@ -1,7 +1,7 @@
 import { allRoots, deflate } from 'flo-poly';
-import { BezierPiece } from '../mat/bezier-piece.js';
+import { CurvePiece } from '../mat/curve-piece.js';
 import { getClosestSquareDistanceToRect } from '../geometry/get-closest-square-distance-to-rect.js';
-import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
+import { getBoundingBox$ } from '../geometry/get-bounding-box-.js';
 
 
 /**
@@ -13,7 +13,7 @@ import { getBoundingBox_ } from '../geometry/get-bounding-box-.js';
  * @param dSquared 
  */
 function cullByLooseBoundingBox(
-        bezierPieces: BezierPiece[],
+        bezierPieces: CurvePiece[],
         p: number[],
         dSquared: number) {
 
@@ -23,7 +23,7 @@ function cullByLooseBoundingBox(
         const bezierPiece = bezierPieces[i];
         const ps = bezierPiece.curve.ps;
         
-        const boundingBox = getBoundingBox_(ps);
+        const boundingBox = getBoundingBox$(ps);
         
         const d = getClosestSquareDistanceToRect(
             boundingBox,

package/src/closest-boundary-point/cull-by-tight-boundary-box.ts

@@ -1,6 +1,6 @@
 import { getBoundingBoxTight } from "flo-bezier3";
 import { memoize } from "flo-memoize";
-import { BezierPiece } from "../mat/bezier-piece.js";
+import { CurvePiece } from "../mat/curve-piece.js";
 import { getClosestSquaredDistanceToRotatedRect } from '../geometry/get-closest-squared-distance-to-rotated-rect.js';
 
 
@@ -16,7 +16,7 @@ const getBoundingBoxTight_ = memoize(getBoundingBoxTight);
  * @param bestSquaredDistance 
  */
 function cullByTightBoundingBox(
-        bezierPieces: BezierPiece[], 
+        bezierPieces: CurvePiece[], 
         p: number[],
         bestSquaredDistance: number) {
 

package/src/closest-boundary-point/foot-and-endpoint-info.ts

@@ -1,5 +1,5 @@
-import { RootInterval } from "flo-poly";
-import { Curve } from "../curve/curve";
+// import { RootInterval } from "flo-poly";
+import { Curve } from "../curve/curve.js";
 
 
 type FootAndEndpointInfo = {

package/src/closest-boundary-point/get-best-distance-squared.ts

@@ -1,6 +1,6 @@
 import { evalDeCasteljau } from 'flo-bezier3';
 import { squaredDistanceBetween } from 'flo-vector2d';
-import { BezierPiece } from "../mat/bezier-piece.js";
+import { CurvePiece } from "../mat/curve-piece.js";
 
 
 /**
@@ -9,7 +9,7 @@ import { BezierPiece } from "../mat/bezier-piece.js";
  * this distance away.
  */ 
 function getBestDistanceSquared(
-        bezierPieces: BezierPiece[], 
+        bezierPieces: CurvePiece[], 
         p: number[]) {
 
     let bestSquaredDistance = Number.POSITIVE_INFINITY;

package/src/closest-boundary-point/get-close-boundary-points-certified.ts

@@ -1,4 +1,4 @@
-import { BezierPiece  } from '../mat/bezier-piece.js';
+import { CurvePiece  } from '../mat/curve-piece.js';
 import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
 import { cullBezierPieces1 } from './cull-bezier-pieces.js';
 import { Curve } from '../curve/curve.js';
@@ -11,14 +11,18 @@ import { createPos } from '../point-on-shape/create-pos.js';
  * @internal
  * Returns the closest boundary point to the given point, limited to the given 
  * bezier pieces, including the beziers actually checked after culling.
+ * 
+ * @param pow
  * @param bezierPieces
  * @param x
  * @param touchedCurve
  * @param t
- * @param extreme
+ * @param for1Prong defaults to `false`;
+ * @param angle defaults to `0`
  */
 function getCloseBoundaryPointsCertified(
-        bezierPieces: BezierPiece[], 
+		pow: number,
+        bezierPieces: CurvePiece[], 
         x: number[], 
 		touchedCurve: Curve | undefined = undefined,
 		t: number | undefined = undefined,
@@ -32,6 +36,7 @@ function getCloseBoundaryPointsCertified(
 		const bezierPiece = bezierPieces[i];
 
 		const pInfos = getPotentialClosestPointsOnCurveCertified(
+			pow,
 			bezierPiece.curve, 
 			x, 
 			bezierPiece.ts, 

package/src/closest-boundary-point/get-closest-boundary-point-certified.ts

@@ -1,70 +1,70 @@
-import { getObjClosestTo } from 'flo-vector2d';
-import { Curve } from '../curve/curve.js';
-import { PointOnShape } from '../point-on-shape/point-on-shape.js';
-import { createPos } from '../point-on-shape/create-pos.js';
-import { BezierPiece  } from '../mat/bezier-piece.js';
-import { cullBezierPieces1 } from './cull-bezier-pieces.js';
-import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
-import { squaredDistanceBetweenDd } from '../find-2-prong/squared-distance-between-dd.js';
+// import { getObjClosestTo } from 'flo-vector2d';
+// import { Curve } from '../curve/curve.js';
+// import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+// import { createPos } from '../point-on-shape/create-pos.js';
+// import { BezierPiece  } from '../mat/bezier-piece.js';
+// import { cullBezierPieces1 } from './cull-bezier-pieces.js';
+// import { getPotentialClosestPointsOnCurveCertified } from './get-potential-closest-points-on-curve-certified.js';
+// import { squaredDistanceBetweenDd } from '../find-2-prong/squared-distance-between-dd.js';
 
 
-/**
- * @internal
- * Returns the closest boundary point to the given point, limited to the given 
- * bezier pieces, including the beziers actually checked after culling.
- * @param bezierPieces
- * @param x
- * @param touchedCurve
- * @param t
- * @param extreme
- */
-function getClosestBoundaryPointCertified(
-		angle: number,
-        bezierPieces: BezierPiece[], 
-        x: number[], 
-		touchedCurve: Curve, 
-		t: number,
-		for1Prong: boolean) {
+// /**
+//  * @internal
+//  * Returns the closest boundary point to the given point, limited to the given 
+//  * bezier pieces, including the beziers actually checked after culling.
+//  * @param bezierPieces
+//  * @param x
+//  * @param touchedCurve
+//  * @param t
+//  * @param extreme
+//  */
+// function getClosestBoundaryPointCertified(
+// 		angle: number,
+//         bezierPieces: BezierPiece[], 
+//         x: number[], 
+// 		touchedCurve: Curve, 
+// 		t: number,
+// 		for1Prong: boolean) {
 	
-	bezierPieces = cullBezierPieces1(bezierPieces, x);
+// 	bezierPieces = cullBezierPieces1(bezierPieces, x);
  
-	let bestDistance = Number.POSITIVE_INFINITY;
-	let pos: PointOnShape;
-	for (let i=0; i<bezierPieces.length; i++) {
-		const bezierPiece = bezierPieces[i];
+// 	let bestDistance = Number.POSITIVE_INFINITY;
+// 	let pos: PointOnShape;
+// 	for (let i=0; i<bezierPieces.length; i++) {
+// 		const bezierPiece = bezierPieces[i];
 
-        const ps = getPotentialClosestPointsOnCurveCertified(
-            bezierPiece.curve, 
-            x, 
-            bezierPiece.ts, 
-            touchedCurve, 
-            t,
-			for1Prong,
-			angle
-        );
+//         const ps = getPotentialClosestPointsOnCurveCertified(
+//             bezierPiece.curve, 
+//             x, 
+//             bezierPiece.ts, 
+//             touchedCurve, 
+//             t,
+// 			for1Prong,
+// 			angle
+//         );
 
-		const p = getObjClosestTo(x, ps, p => p.p)
+// 		const p = getObjClosestTo(x, ps, p => p.p)
 
-		if (p === undefined) { continue; }
+// 		if (p === undefined) { continue; }
 
-		const d = squaredDistanceBetweenDd(p.p, x);
+// 		const d = squaredDistanceBetweenDd(p.p, x);
 
-		let curve = bezierPiece.curve;
-		let t_= p.t;
+// 		let curve = bezierPiece.curve;
+// 		let t_= p.t;
 
-		if (d < bestDistance) {
-			if (t_ === 0) {
-				t_ = 1;
-				curve = bezierPiece.curve.prev;
-			}
+// 		if (d < bestDistance) {
+// 			if (t_ === 0) {
+// 				t_ = 1;
+// 				curve = bezierPiece.curve.prev;
+// 			}
 			
-			pos = createPos(curve, t_, false);
-			bestDistance = d;
-		}
-	}
+// 			pos = createPos(curve, t_, false);
+// 			bestDistance = d;
+// 		}
+// 	}
 
-	return pos!;
-}
+// 	return pos!;
+// }
 
 
-export { getClosestBoundaryPointCertified };
+// export { getClosestBoundaryPointCertified };

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

@@ -16,28 +16,34 @@ const { sqrt } = Math;
 
 /**
  * @internal
+ * 
+ * @param pow
  * @param curve The curve
  * @param x 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
+ * @param for1Prong defaults to `false;
+ * @param angle defaults to `0`;
  */
 function getPotentialClosestPointsOnCurveCertified(
+        pow: number,
         curve: Curve, 
         x: number[], 
-        [tS,tE]: number[] = [0,1], 
+        tRange: number[] = [0,1], 
         touchedCurve: Curve | undefined = undefined,
         t: number | undefined = undefined,
         for1Prong = false,
         angle = 0): FootAndEndpointInfo[] {
 
+    const [tS,tE] = tRange;
     const ps = curve.ps;
 
     const shouldDeflate = angle === 0 && curve === touchedCurve;
 
     let { polyDd: polyDdO, polyE: polyEO, getPolyExact: getPolyExactO } =
         getFootPointsOnBezierPolysCertified(ps, x);
-    
+
     const def = shouldDeflate
             ? ddDeflateWithRunningError(polyDdO, polyEO.map(e => e/γγ3), t!)
             : undefined;
@@ -52,10 +58,22 @@ function getPotentialClosestPointsOnCurveCertified(
     
     const { polyDd, polyE, getPolyExact } = 
               def3 !== undefined
-            ? { polyDd: def3.coeffs, polyE: def3.errBound.map(e => e/γγ3), getPolyExact:  () => eDeflate(eDeflate(eDeflate(getPolyExactO(), t!), t!), t!) }
+            ? {
+                polyDd: def3.coeffs,
+                polyE: def3.errBound,
+                getPolyExact:  () => eDeflate(eDeflate(eDeflate(getPolyExactO(), t!), t!), t!)
+            }
             : def !== undefined
-            ? { polyDd: def.coeffs, polyE: def.errBound.map(e => e/γγ3), getPolyExact: () => eDeflate(getPolyExactO(), t!) }
-            : { polyDd: polyDdO, polyE: polyEO, getPolyExact: getPolyExactO };
+            ? {
+                polyDd: def.coeffs,
+                polyE: def.errBound,
+                getPolyExact: () => eDeflate(getPolyExactO(), t!)
+            }
+            : {
+                polyDd: polyDdO,
+                polyE: polyEO,
+                getPolyExact: getPolyExactO
+            };
     
     const ris = allRootsCertified(polyDd, tS, tE, polyE, getPolyExact);
 
@@ -98,7 +116,7 @@ function getPotentialClosestPointsOnCurveCertified(
         const box = getIntervalBox(ps, [ts, te]);
         const p_ = getPFromBox(box);
         
-        const dSquaredI = rootIntervalToDistanceSquaredInterval(box, x);
+        const dSquaredI = rootIntervalToDistanceSquaredInterval(pow, box, x);
 
         const t_ = t === 0 ? 1 : t;
         const curve_ = t === 0 ? curve.prev : curve;

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

@@ -1,11 +1,14 @@
 import { twoDiff, eEstimate, eMult, eAdd } from 'big-float-ts';
+import { ddMultDd, ddAddDd } from 'double-double';
 
 
 // We *have* to do the below to improve performance with bundlers❗ The assignee is a getter❗ The assigned is a pure function❗
 const estimate = eEstimate;
 const td = twoDiff;
-const emult = eMult;
-const eadd = eAdd;
+// const emult = eMult;
+// const eadd = eAdd;
+const qmq = ddMultDd;
+const qaq = ddAddDd;
 
 const eps = Number.EPSILON;
 
@@ -22,6 +25,7 @@ const eps = Number.EPSILON;
  * @internal
  */
 function rootIntervalToDistanceSquaredInterval(
+        pow: number,
         box: number[][], 
         p: number[]) {
 
@@ -53,11 +57,13 @@ function rootIntervalToDistanceSquaredInterval(
         /** 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 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 dc1Min = dc1*(1 - eps);  // distance minus max error
-        const dc1Max = dc1*(1 + eps);  // distance plus max error
+        const dc1Min = dc1*(1 - 2**pow*eps);  // distance minus max error
+        const dc1Max = dc1*(1 + 2**pow*eps);  // distance plus max error
         
         if (dc1Min <= minDSquared) {
             minDSquared = dc1Min;