flo-mat 3.0.0 → 3.0.2

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;

package/src/corner/compare-curvatures-at-interface.ts

@@ -1,5 +1,7 @@
-import { eSign, twoProduct, eDiff, expansionProduct, fastExpansionSum, scaleExpansion } from "big-float-ts";
-import { tangentAt0, evaluate2ndDerivativeAt0, toPowerBasis_3rdDerivative } from "flo-bezier3";
+import { eSign, eDiff, fastExpansionSum, scaleExpansion, eMult } from "big-float-ts";
+import { tangentAt0Exact, evaluate2ndDerivativeAt0Exact, toPowerBasis_3rdDerivativeExact } from "flo-bezier3";
+
+const { sign } = Math;
 
 
 /**
@@ -24,19 +26,16 @@ function compareCurvaturesAtInterface(
         psO: number[][]) {
 
     // Get x' and y' for incoming curve evaluated at 0
-    const [dxI, dyI] = tangentAt0(psI); // max bitlength increase / max shift === 3
+    const [dxI, dyI] = tangentAt0Exact(psI);
     // Get x'' and y'' for incoming curve evaluated at 0
-    const [ddxI, ddyI] = evaluate2ndDerivativeAt0(psI); // max bitlength increase / max shift === 5
+    const [ddxI, ddyI] = evaluate2ndDerivativeAt0Exact(psI);
 
     // Get x' and y' for outgoing curve evaluated at 0
-    const [dxO, dyO] = tangentAt0(psO); // max bitlength increase / max shift === 3
+    const [dxO, dyO] = tangentAt0Exact(psO);
     // Get x'' and y'' for outgoing curve evaluated at 0
-    const [ddxO, ddyO] = evaluate2ndDerivativeAt0(psO); // max bitlength increase / max shift === 5
-
-    //console.log('κI: ', κ(psI, 0));
-    //console.log('κO: ', κ(psO, 0));
+    const [ddxO, ddyO] = evaluate2ndDerivativeAt0Exact(psO);
 
-    // Remember the formula for the signed curvature of a parametric curve:
+    // Recall the formula for the signed curvature of a parametric curve:
     // κ = x′y′′ - y′x′′ / sqrt(x′² + y′²)³
     // κ² = (x′y′′ - y′x′′)² / (x′² + y′²)³
 
@@ -48,65 +47,46 @@ function compareCurvaturesAtInterface(
     // <=>  a²b³ > c²d³
     // Note b³ > 0 and d³ > 0
 
-    // max aggregate bitlength increase (let original bitlength === p):
-    // a -> 2 x ((p+3)+(p+5) + 1) === 4p + 18 -> max p in double precision === 8 -> too low
-    //let a = (dxI*ddyI - dyI*ddxI)**2;
-    // b -> 3 x ((p+3) + 1) === 3p + 12
-    //let b = (dxO*dxO  + dyO*dyO )**3;
-    // c -> 2 x ((p+3)+(p+5) + 1) === 4p + 18
-    //let c = (dxO*ddyO - dyO*ddxO)**2;
-    // d -> 3 x ((p+3) + 1) === 3p + 12
-    //let d = (dxI*dxI  + dyI*dyI )**3;
-
     // We need to resort to exact floating point arithmetic at this point
     const a = eDiff(
-        twoProduct(dxI, ddyI), 
-        twoProduct(dyI, ddxI)
+        eMult(dxI, ddyI), 
+        eMult(dyI, ddxI)
     );
     const c = eDiff(
-        twoProduct(dxO, ddyO),
-        twoProduct(dyO, ddxO)
+        eMult(dxO, ddyO),
+        eMult(dyO, ddxO)
     );
 
     const signA = eSign(a);
     const signC = eSign(c);
-    if (signA !== signC) {
-        //console.log('branch 3');
+    if (sign(signA) !== sign(signC)) {
+        // return a negative value if κI < κO
         return signA - signC;
     }
 
     const b = fastExpansionSum(
-        twoProduct(dxO, dxO),
-        twoProduct(dyO, dyO)
+        eMult(dxO, dxO),
+        eMult(dyO, dyO)
     );
     const d = fastExpansionSum(
-        twoProduct(dxI, dxI),
-        twoProduct(dyI, dyI)
+        eMult(dxI, dxI),
+        eMult(dyI, dyI)
     );
 
-    const b2 = expansionProduct(b, b);
-    const b3 = expansionProduct(b2, b);
-    const d2 = expansionProduct(d, d);
-    const d3 = expansionProduct(d2, d);
+    const b2 = eMult(b, b);
+    const b3 = eMult(b2, b);
+    const d2 = eMult(d, d);
+    const d3 = eMult(d2, d);
 
     if (signA !== 0 || signC !== 0) {
-        //console.log('branch 4');
-        const a2 = expansionProduct(a, a);
-        const c2 = expansionProduct(c, c);
-
-        // max aggregate bitlength increase (let original bitlength === p):
-        // κ -> (2 x ((p+3)+(p+5) + 1)) + (3 x ((p+3) + 1)) === 7p + 30
-        // e.g. for bit-aligned input bitlength p of 10 we get output bitlength 
-        // of 100, or for p === 3 (the max exact bitlength allowed to have exact
-        // results without resorting to infinite precision) we get 51 bits.
-
-        
-        const κI = expansionProduct(a2,b3);
-        const κO = expansionProduct(c2,d3);
+        const a2 = eMult(a, a);
+        const c2 = eMult(c, c);
+
+        const κI = eMult(a2,b3);
+        const κO = eMult(c2,d3);
         const δκ = eSign(eDiff(κI, κO));
 
         if (δκ !== 0) {
-            //console.log('branch 5');
             // At this point signA === signC, both +tive or -tive
             return signA > 0 ? δκ : -δκ;
         }
@@ -125,50 +105,50 @@ function compareCurvaturesAtInterface(
     // <=> i²b⁵ > j²d⁵
 
     // Get x′′′ and y′′′ for incoming curve evaluated at 1
-    const [[dddxI], [dddyI]] = toPowerBasis_3rdDerivative(psI); // max bitlength increase === max shift === 6
-    const [[dddxO], [dddyO]] = toPowerBasis_3rdDerivative(psO); // max bitlength increase === max shift === 6
+    const [[dddxI], [dddyI]] = toPowerBasis_3rdDerivativeExact(psI); // max bitlength increase === max shift === 6
+    const [[dddxO], [dddyO]] = toPowerBasis_3rdDerivativeExact(psO); // max bitlength increase === max shift === 6
 
     const e = eDiff(
-        twoProduct(dxI, dddyI),
-        twoProduct(dyI, dddxI)
+        eMult(dxI, dddyI),
+        eMult(dyI, dddxI)
     );
 
     const f = fastExpansionSum(
-        twoProduct(dxI, ddxI),
-        twoProduct(dyI, ddyI)
+        eMult(dxI, ddxI),
+        eMult(dyI, ddyI)
     );
 
     const g = eDiff(
-        twoProduct(dxO, dddyO),
-        twoProduct(dyO, dddxO)
+        eMult(dxO, dddyO),
+        eMult(dyO, dddxO)
     );
 
     const h = fastExpansionSum(
-        twoProduct(dxO, ddxO),
-        twoProduct(dyO, ddyO)
+        eMult(dxO, ddxO),
+        eMult(dyO, ddyO)
     );
 
     // (de - 3af)²b⁵ > (bg - 3ch)²d⁵
     // i²b⁵ > j²d⁵
     const i = eDiff(
-        expansionProduct(d, e),
+        eMult(d, e),
         scaleExpansion(
-            expansionProduct(a, f),
+            eMult(a, f),
             3
         )
     );
 
     const j = eDiff(
-        expansionProduct(b, g),
+        eMult(b, g),
         scaleExpansion(
-            expansionProduct(c, h),
+            eMult(c, h),
             3
         )
     );
 
     const signI = eSign(i);
     const signJ = eSign(j);
-    if (signA !== signC) {
+    if (signI !== signJ) {
         return signI - signJ;
     }
 
@@ -177,13 +157,13 @@ function compareCurvaturesAtInterface(
         return 0;
     }
 
-    const i2 = expansionProduct(i,i);
-    const b5 = expansionProduct(b2,b3);
-    const j2 = expansionProduct(j,j);
-    const d5 = expansionProduct(d2,d3);
+    const i2 = eMult(i,i);
+    const b5 = eMult(b2,b3);
+    const j2 = eMult(j,j);
+    const d5 = eMult(d2,d3);
 
-    const dκI = expansionProduct(i2,b5);
-    const dκO = expansionProduct(j2,d5);
+    const dκI = eMult(i2,b5);
+    const dκO = eMult(j2,d5);
 
     const sgn = eSign(eDiff(dκI, dκO));
 

package/src/corner/corner.ts

@@ -11,7 +11,7 @@ interface Corner {
      */
     tangents: number[][];
     /** The cross of the unit tangents. */
-    crossTangents: number;
+    // crossTangents: number;
     /** 
      * True if the corner is sharp, i.e. > 0 radians as one goes in a positive 
      * direction around the shape boundary.

package/src/corner/get-corner.ts

@@ -1,5 +1,5 @@
 import { cross, dot, toUnitVector } from "flo-vector2d";
-import { Corner } from "./corner";
+import { Corner } from "./corner.js";
 import { getInterfaceCcw } from './get-interface-ccw.js';
 
 
@@ -40,37 +40,23 @@ function getCorner(
 
 	// getInterfaceCcw must return a number !== 0 if psI and psO are not the
 	// same as seen as a curve extension with t ∈ [-∞,+∞]
-	const ccw = getInterfaceCcw(psI, psO);
+	const { ccw, tangentI, tangentO, dotTangents } = getInterfaceCcw(psI, psO);
 	const isSharp = ccw < 0;
 	const isDull  = ccw > 0;
 
-	// Find (non-normalized) tangent of curve.ps at t === 1
-	const p0E = psI[psI.length-2];
-	const p1E = psI[psI.length-1];
-	const xE = p1E[0] - p0E[0];
-	const yE = p1E[1] - p0E[1];
-	const tangentAtEnd = [xE,yE];
-
-	// Find (non-normalized) tangent of curve.next.ps at t === 0
-	const p0S = psO[0];
-	const p1S = psO[1];
-	const xS = p1S[0] - p0S[0];
-	const yS = p1S[1] - p0S[1];
-	const tangentAtStart = [xS,yS];
-
 	// These use square root and are thus not exact
-	const tangents_ = [
-		toUnitVector(tangentAtEnd), 
-		toUnitVector(tangentAtStart), 
+	const unitTangents = [
+		toUnitVector(tangentI.map(v => v[1])),
+		toUnitVector(tangentO.map(v => v[1])),
 	];
 
 	// The cross calculated below should be exact due to beziers having been
 	// normalized!
-	const crossTangents = cross(tangents_[0], tangents_[1]);
+	const crossTangents = cross(unitTangents[0], unitTangents[1]);
 
 	let isQuiteSharp: boolean; 
 	let isQuiteDull: boolean; 
-	const dotTangents = dot(tangentAtEnd, tangentAtStart);
+	// const dotTangents = dot(tangentAtIncoming, tangentAtOutgoing);
 	if (dotTangents > 0) {
 		// Curves go in same direction
 		isQuiteSharp = crossTangents < -DEGREE_LIMIT;
@@ -81,8 +67,8 @@ function getCorner(
 	}
 
 	return {
-		tangents: tangents_, 
-		crossTangents, 
+		tangents: unitTangents, 
+		// crossTangents, 
 		isSharp,
 		isDull, 
 		isQuiteSharp,

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

@@ -1,5 +1,5 @@
-import { eAdd, eEstimate, eMult, eNegativeOf, eProduct, orient2d, twoDiff } from 'big-float-ts';
-import { dot } from "flo-vector2d";
+import { eAdd, eCompress, eEstimate, eMult, eNegativeOf, eProduct, orient2d, twoDiff } from 'big-float-ts';
+// import { dot } from "flo-vector2d";
 import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.js";
 
 
@@ -14,84 +14,120 @@ import { compareCurvaturesAtInterface } from "./compare-curvatures-at-interface.
  * The above obviously necessitates that their endpoints coincide as described.
  * 
  * Preconditions (for robustness):
- * * The beziers has control points with max bit-length of 25 and bit-aligned.
  * * The bezier does not have infinite curvature at either endpoint
  * 
- * This is so the vectors between control points can be 
- * calculated exactly without resorting to adaptive infinite precision floating 
- * point operations. Note: aligned to 'grid' here means if you bitwise-and all
- * values together the resulting bitlength === the max bithlength of any value.
- * 
  * @param psI The incoming bezier that ends at the interface
  * @param psO The outgoing bezier that starts at the interface
  */
-// TODO - improve and make at least 46-bitlength precondition
-function getInterfaceCcw(psI: number[][], psO: number[][]) {
+function getInterfaceCcw(
+        psI: number[][],
+        psO: number[][]): {
+            ccw: number,
+            tangentI: number[][],
+            tangentO: number[][],
+            // crossTangents: number,
+            dotTangents: number
+        } {
+
     const lenI = psI.length;
 
     // second last control point of incoming curve
-    const p0 = psI[lenI-2];  
+    let p0 = psI[lenI-2];  
     // last control point of incoming curve / first control point of outgoing
-    const p1 = psO[0];
+    let p1 = psO[0];
     // second control point of outgoing curve
-    const p2 = psO[1];
-
-    // Max one bit can be added in the calculations below due to bit-alignment
-    const xE = p1[0] - p0[0];  // tangent x-coordinate
-	const yE = p1[1] - p0[1];  // tangent y-coordinate
-	const xS = p2[0] - p1[0];  // tangent x-coordinate
-    const yS = p2[1] - p1[1];  // tangent y-coordinate
-    
-	// If the tangent is to be found at t === 0 or t === 1 then using a basic 
-    // property of bezier curves we can find the tangents easily as below
-    
-    // (non-normalized) tangent of incoming curve at t === 1
-    const tangentAtEnd = [xE,yE];
-    // (non-normalized) tangent of outgoing curve at t === 0
-	const tangentAtStart = [xS,yS];
-
-    // const crossTangents = orient2d(p0, p1, p2);
-    const crossTangents = orient2dPrecise(p0, p1, p2);
-
-	if (crossTangents !== 0) {
-		return crossTangents;
-    } 
+    let p2 = psO[1];
+
+    // infinite curvature - we're now handling this as well
+    if (pointsEqual(p0,p1)) {
+        p0 = psI[lenI-3];  // length cannot be 2
+    }
+    if (pointsEqual(p1,p2)) {
+        p2 = psO[2];  // length cannot be 2
+    }
+
+    const crossTangents = crossPrecise(p0,p1,p2);  // sign will be correct
+
+    const xI = twoDiff(p1[0],p0[0]);  // tangent x-coordinate
+	const yI = twoDiff(p1[1],p0[1]);  // tangent y-coordinate
+	const xO = twoDiff(p2[0],p1[0]);  // tangent x-coordinate
+    const yO = twoDiff(p2[1],p1[1]);  // tangent y-coordinate
+
+    const tangentI = [xI,yI];
+    const tangentO = [xO,yO];
+    const dotTangents = dotPrecise(tangentI,tangentO);
+
+    if (crossTangents !== 0 || dotTangents > 0) {
+		return {
+            ccw: crossTangents,
+            tangentI,
+            tangentO,
+            // crossTangents,
+            dotTangents
+        }
+    }
     
-    // The dot calculated below will have a max bitlength of 
-    // (2*(maxBitLength + 1)) + 1 === e.g. (2*(25 + 1)) + 1 === 53
-    // If the preconditions are met it is exact
-    const dotTangents = dot(tangentAtEnd, tangentAtStart);
-    if (dotTangents > 0) {
-        // Curves go in same direction at interface - neither clock or 
-        // anti-clockwise.
-        // Note: The above comment is not strictly true but as this case is not
-        // important for the algorithm we return 0
-        return 0;
-    } 
-
     // Curves go in opposite directions at interface starting off with the exact
     // same tangent - look now at curvature to see which has the largest 
     // curvature so we can base the clock or anti-clockwise result on that
-    
+
     // Look at curvature
-    return compareCurvaturesAtInterface(psI.slice().reverse(), psO);
+
+    // TODO2
+    // The line below is probably not working correctly for infinite
+    // curvature but it should be rare to get here - investiagte.
+    // Probably need to resort to length of tangents and then if this is
+    // also the same simply look at the last point's ccw wrt the 1st or
+    // the second?
+    return {
+        ccw: compareCurvaturesAtInterface(psI.slice().reverse(), psO),
+        tangentI,
+        tangentO,
+        // crossTangents,
+        dotTangents
+    }
+}
+
+
+function pointsEqual(
+        p1: number[],
+        p2: number[]) {
+
+    return p1[0] === p2[0] && p1[1] === p2[1];
 }
 
+/**
+ * The input is two exact double-double coefficient vectors
+ * 
+ * * returns the correct sign
+ */
+function dotPrecise(
+        tangentI: number[][],
+        tangentO: number[][]): number {
+
+    const abx = eMult(tangentI[0],tangentO[0]);
+    const aby = eMult(tangentI[1],tangentO[1]);
+
+    const dot = eAdd(abx,aby);
 
-/** Returns the cross from A to B to C */
-function orient2dPrecise(
-        A: number[],
-        B: number[],
-        C: number[]) {
+    return eEstimate(dot);
+}
 
-    // const detleft  = (A[0] - C[0]) * (B[1] - C[1]);
-    // const detright = (A[1] - C[1]) * (B[0] - C[0]);
-    // const det = detleft - detright;
 
-    const a = twoDiff(A[0],C[0]);
-    const b = twoDiff(B[1],C[1]);
-    const c = twoDiff(A[1],C[1]);
-    const d = twoDiff(B[0],C[0]);
+/**
+ * Returns the cross from A to B to C
+ * 
+ * * returns the correct sign
+ */
+function crossPrecise(
+        p0: number[],
+        p1: number[],
+        p2: number[]) {
+
+    const a = twoDiff(p0[0],p2[0]);
+    const b = twoDiff(p1[1],p2[1]);
+    const c = twoDiff(p0[1],p2[1]);
+    const d = twoDiff(p1[0],p2[0]);
 
     const e = eMult(a,b);
     const f = eMult(c,d);