flo-mat 2.0.4 → 3.0.0

package/src/debug/functions/general.ts

@@ -1,8 +1,8 @@
-import { CpNode } from '../../cp-node.js';
-import { posToHumanString } from '../../point-on-shape.js';
+import { CpNode } from '../../cp-node/cp-node.js';
+import { posToHumanString } from '../../point-on-shape/pos-to-human-string.js';
 
 
-/** @hidden */
+/** @internal */
 export interface IGeneralDebugFunctions {
 	nameObj     : (obj: any, pre?: string) => void,
 	δToString   : (cpNodes: CpNode[]) => string[],
@@ -12,10 +12,10 @@ export interface IGeneralDebugFunctions {
 }
 
 
-/** @hidden */
+/** @internal */
 let i = 0;
 /** 
- * @hidden
+ * @internal
  * Name the given object - for debugging purposes only 
  */
 function nameObj(o: any, pre = '') {
@@ -24,7 +24,7 @@ function nameObj(o: any, pre = '') {
 
 
 /**
- * @hidden
+ * @internal
  * Transforms a boundary piece (δ) into a human readable string.
  * @param cpNodes A boundary piece given by two CpNodes.
  */
@@ -36,7 +36,7 @@ function δToString(cpNodes: CpNode[]) {
 
 
 /**
- * @hidden
+ * @internal
  * Transforms an array of boundary pieces (δs) into a human readable string. 
  * @param cpNodes An array of boundary pieces.
  */ 
@@ -46,7 +46,7 @@ function δsToString(cpNodes: CpNode[][]) {
 
 
 /**
- * @hidden
+ * @internal
  * Convert the given points into a human readable string.
  * @param ps
  */
@@ -56,7 +56,7 @@ function pointsToStr(ps: number[][], decimalPlaces = 3) {
 
 
 /**
- * @hidden
+ * @internal
  * Converts the given point into a human readable string.
  * @param p The point
  * @param decimalPlaces number of decimal places
@@ -66,7 +66,7 @@ function pointToStr(p: number[], decimalPlaces = 3) {
 }
 
 
-/** @hidden */
+/** @internal */
 const generalDebugFunctions/*: IGeneralDebugFunctions*/ = {
 	δToString,
 	δsToString,

package/src/debug/functions/three-prong.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 declare let _debug_: Debug; 
 
 import { drawFs } from 'flo-draw';
@@ -7,7 +7,7 @@ import { Debug } from '../debug.js';
 import { ThreeProngForDebugging } from '../three-prong-for-debugging.js';
 
 
-/** @hidden */
+/** @internal */
 export interface IThreeProngDebugFunctions {
 	drawSpokes       : (g: SVGGElement, n: number) => void,
 	traceConvergence : (g: SVGGElement, n: number, indx: number) => void,
@@ -22,28 +22,24 @@ export interface IThreeProngDebugFunctions {
 
 
 /**
- * @hidden
+ * @internal
  * Draws 3 lines from the given 3-prong center to its 3 contact points.
  * @param n - The 3-prong's zero-based index. 
  */
 function drawSpokes(g: SVGGElement, n: number): void {
 	const threeProng = _debug_.generated.elems.threeProng[n]; 
-	//const g = threeProng.generated.g;
 	const cc = threeProng.circle.center;
 	const poss = threeProng.poss;
 
-	//_debug_.fs.draw.line(g, [poss[0].p, cc], 'thin5 red');
-	//_debug_.fs.draw.line(g, [poss[1].p, cc], 'thin5 red');
-	//_debug_.fs.draw.line(g, [poss[2].p, cc], 'thin5 red');
-
-	drawFs.line(g, [poss[0].p, cc], 'thin5 red');
-	drawFs.line(g, [poss[1].p, cc], 'thin5 red');
-	drawFs.line(g, [poss[2].p, cc], 'thin5 red');
+	for (let i=0; i<poss.length; i++) {
+		const pos = poss[i];
+		drawFs.line(g, [pos.p, cc], 'thin5 red');
+	}
 }
 
 
 /**
- * @hidden
+ * @internal
  * Shows the circle for each boundary iteration.
  * @param n_ - The 3-prong's zero-based index. If ommitted, all will be shown.
  * @param idx - The specific boundary iteration index to view. If ommitted, all
@@ -57,7 +53,7 @@ function traceConvergence(g: SVGGElement, n_: number, idx: number): void {
 		eIndx = _debug_.generated.elems.threeProng.length;
 	} else {
 		sIndx = n_;
-		eIndx = n_+1;
+		eIndx = n_ + 1;
 	}
 	
 	for (let n=sIndx; n<eIndx; n++) {
@@ -76,14 +72,14 @@ function traceConvergence(g: SVGGElement, n_: number, idx: number): void {
 		let endIndx;
 		if (n_ === undefined || idx === -1) {
 			startIndx = forDebugging.bestIndx;
-			endIndx   = forDebugging.bestIndx+1;
+			endIndx   = forDebugging.bestIndx + 1;
 		} else {
 			if (idx === undefined) {
 				startIndx = 0;
 				endIndx   = candidateThreeProngs.length;
 			} else {
 				startIndx = idx;
-				endIndx   = idx+1;
+				endIndx   = idx + 1;
 			}	
 		}
 
@@ -105,7 +101,7 @@ function traceConvergence(g: SVGGElement, n_: number, idx: number): void {
 
 
 /**
- * @hidden
+ * @internal
  * Shows the actual boundary for each iteration.
  * @param n The 3-prong's zero-based index.
  * @param idx The specific boundary iteration index to view. If ommitted will 
@@ -166,7 +162,7 @@ function showBoundary(g: SVGGElement, n: number, idx: number): void {
 
 
 /**
- * @hidden
+ * @internal
  * @param n The 3-prong's zero-based index. 
  */
 function logδs(n: number): void {
@@ -177,7 +173,7 @@ function logδs(n: number): void {
 
 
 /**
- * @hidden
+ * @internal
  * @param p
  */
 function logNearest(
@@ -192,7 +188,7 @@ function logNearest(
 			p, 
 			generated.elems.threeProng, 
 			threeProng => threeProng.circle ? threeProng.circle.center : [0,0]
-		);
+		)!;
 
 
 		const circle = threeProng.circle;
@@ -240,7 +236,7 @@ function logNearest(
 }
 
 
-/** @hidden */
+/** @internal */
 const threeProngDebugFunctions: IThreeProngDebugFunctions = {
 	drawSpokes,
 	traceConvergence,

package/src/debug/functions/two-prong.ts

@@ -3,26 +3,29 @@ declare let _debug_: Debug;
 import { drawFs } from 'flo-draw';
 import { getObjClosestTo, distanceBetween, squaredDistanceBetween } from 'flo-vector2d';
 import { Debug, Generated } from '../debug.js';
-import { CpNode } from '../../cp-node.js';
-import { Circle } from '../../circle.js';
+import { CpNode } from '../../cp-node/cp-node.js';
+import { Circle } from '../../geometry/circle.js';
 import { TwoProngForDebugging } from '../two-prong-for-debugging.js';
 import { ElemType_TwoProng } from '../../mat/elem-type-two-prong.js';
 
 
-/** @hidden */
+/** @internal */
 interface ITwoProngDebugFunctions {
 	logδ       : (n: number, type?: ElemType_TwoProng) => void,
 	log        : (n: number, type?: ElemType_TwoProng) => void,
-	drawNormal : (g: SVGGElement, n: number, showDelay?: number) => void,
+	drawNormal : typeof drawNormal,
 	logδBasic  : (n: number) => void,
-	logNearest : (g: SVGGElement, p: number[], showDelay?: number) => void,
-	traceConvergence: (g: SVGGElement, n: number, finalOnly?: boolean, showDelay?: number,
-		range?: number[], type?: ElemType_TwoProng) => void,
+	logNearest : (
+		showSpokes?     : boolean,
+		showTrace?      : boolean,
+		showBoundaries? : boolean
+	) => (g: SVGGElement, p: number[], showDelay?: number, scale?: number) => void,
+	traceConvergence: typeof traceConvergence,
 }
 
 
 /**
- * @hidden
+ * @internal
  */
 function logδ(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
 	const δ =_debug_.generated.elems[type][n].δ;
@@ -32,7 +35,7 @@ function logδ(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
 
 
 /**
- * @hidden
+ * @internal
  */
 function log(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
 	const twoProng = _debug_.generated.elems[type][n];
@@ -41,29 +44,13 @@ function log(n: number, type: ElemType_TwoProng = 'twoProng_regular') {
 
 
 /**
- * @hidden
+ * @internal
  */
 function drawNormal(
 		g: SVGGElement,
-		n: number, 
-		showDelay = 1000, 
-		type: ElemType_TwoProng = 'twoProng_regular') {
-
-	const twoProngs = _debug_.generated.elems[type];
-	
-	// If not specified which, draw all
-	if (n === undefined) {
-		for (let i=0; i<twoProngs.length; i++) {
-			drawNormal(g, i);
-		}
-	}
-	
-	const twoProng = twoProngs[n];
+		twoProng: TwoProngForDebugging, 
+		showDelay = 1000) {
 
-	//let g = twoProng.generated.g;
-	
-	if (!twoProng) { return; }
-	
 	drawFs.line(
 		g, [twoProng.pos.p, twoProng.circle.center], 'thin10 blue', showDelay
 	);
@@ -71,7 +58,7 @@ function drawNormal(
 
 
 /**
- * @hidden
+ * @internal
  */
 function logδBasic(
 		n: number, 
@@ -79,7 +66,7 @@ function logδBasic(
 
 	const delta = _debug_.generated.elems[type][n].δ;
 
-	function f(x: CpNode) {
+	function logδBasic_(x: CpNode) {
 		const pos = x.cp.pointOnShape;
 		return {
 			bez: pos.curve.ps,
@@ -87,62 +74,93 @@ function logδBasic(
 		}
 	}
 	
-	console.log(f(delta[0]));
-	console.log(f(delta[1]));
+	console.log(logδBasic_(delta[0]));
+	console.log(logδBasic_(delta[1]));
 }
 
 
 /**
- * @hidden
+ * @internal
+ * Draws 3 lines from the given 3-prong center to its 3 contact points.
+ * @param n - The 3-prong's zero-based index. 
  */
-function logNearest(g: SVGGElement, p: number[], showDelay = 1000, type: ElemType_TwoProng = 'twoProng_regular') {
-	const closestPerLoops: TwoProngForDebugging[] = [];
-
-	const generated = _debug_.generated;
-	const twoProng = getObjClosestTo<TwoProngForDebugging>(
-		p, 
-		generated.elems[type], 
-		twoProng => twoProng.circle.center
-	);
-	closestPerLoops.push(twoProng);
+function drawSpokes(
+        g: SVGGElement,
+        twoProng: TwoProngForDebugging,
+        showDelay = 1000): void {
+
+	const cc = twoProng.circle.center;
+	const { pos, circle, cpNode, xs, z, δ } = twoProng;
+    
+	drawFs.line(g, [pos.p, cc], 'thin5 red', showDelay);
+    drawFs.line(g, [z, cc], 'thin5 red', showDelay);
+}
 
-	console.log(twoProng);
-	
-	let n;
-	for (let i=0; i<_debug_.generated.elems[type].length; i++) {
-		const twoProng_ = _debug_.generated.elems[type][i];
-		if (twoProng_ === twoProng) {
-			n = i;
-			break;
+
+/**
+ * @internal
+ */
+function logNearest(
+        showSpokes?: boolean,
+		showTrace?: boolean,
+		showBoundaries?: boolean) {
+            
+    return (g: SVGGElement,
+			p: number[],
+			showDelay = 1000,
+			scale = 1) => {
+				
+		const closestPerLoops: TwoProngForDebugging[] = [];
+
+		const generated = _debug_.generated;
+		const twoProng = getObjClosestTo<TwoProngForDebugging>(
+			p, 
+			// generated.elems[type], 
+			generated.elems['twoProng_regular'],
+			twoProng => twoProng.circle.center
+		)!;
+		closestPerLoops.push(twoProng!);
+
+		console.log(twoProng);
+		
+		let n;
+		//for (let i=0; i<_debug_.generated.elems[type].length; i++) {
+		//	const twoProng_ = _debug_.generated.elems[type][i];
+		for (let i=0; i<_debug_.generated.elems['twoProng_regular'].length; i++) {
+			const twoProng_ = _debug_.generated.elems['twoProng_regular'][i];
+			if (twoProng_ === twoProng) {
+				n = i;
+				break;
+			}
+		}
+
+        if (showSpokes) {
+            drawSpokes(g, twoProng, showDelay)
+        }
+		
+		if (n !== undefined && showTrace) {
+			traceConvergence(g, twoProng, showDelay, scale);
 		}
 	}
-	
-	if (n !== undefined) { traceConvergence(g, n, true, showDelay); }
 }
 
 
 /**
- * @hidden
+ * @internal
  * @param n - The 2-prong's zero-based index.
  * @param range
  */
 function traceConvergence(
 		g: SVGGElement, 
-		n         : number, 
-		finalOnly : boolean,
+		twoProng: TwoProngForDebugging, 
 		showDelay = 1000,
-		range     : number[] = undefined, 
-		type      : ElemType_TwoProng = 'twoProng_regular') {
-
-	if (n === undefined) { return; }
+		scale = 1) {
 
-	const twoProngInfo = _debug_.generated.elems[type][n];
-	const xs = twoProngInfo.xs;
-	//let g = twoProngInfo.generated.g;
+	const xs = twoProng.xs;
 
-	console.log(twoProngInfo);
+	console.log(twoProng);
 	console.log(
-		twoProngInfo.xs.map(x => ({
+		twoProng.xs.map(x => ({
 				x: x.x,
 				y: x.y,
 				z: x.z, 
@@ -152,31 +170,25 @@ function traceConvergence(
 		)
 	);
 
+    console.log(xs.length)
 	for (let i=0; i<xs.length; i++) {
-		if (range && (i < range[0] || i >= range[1])) {
-			continue;
-		}
-		if (finalOnly && i !== xs.length-1) {
-			continue;
-		}
-
-		const x = twoProngInfo.xs[i];
+		const x = twoProng.xs[i];
 
 		const circle = { center: x.x, radius: distanceBetween(x.x, x.y.p) };
-		drawFs.crossHair(g, x.x, 'red thin10 nofill', undefined, showDelay);
+		drawFs.crossHair(g, x.x, 'red thin10 nofill', 0.002*scale, showDelay);
 		drawFs.circle(g, circle, 'blue thin10 nofill', showDelay);
 		if (x.z !== undefined) {
 			drawFs.crossHair(
-				g, x.z.p, 'yellow thin10 nofill', 2, showDelay
+				g, x.z.p, 'yellow thin10 nofill', 0.001*scale, showDelay
 			);
 		}
 	}
 
-	twoProngDebugFunctions.drawNormal(g, n, showDelay);
+	// twoProngDebugFunctions.drawNormal(g, twoProng, showDelay);
 }
 
 
-/** @hidden */
+/** @internal */
 const twoProngDebugFunctions: ITwoProngDebugFunctions = {
 	logδ,
 	log,

package/src/debug/three-prong-for-debugging.ts

@@ -1,11 +1,12 @@
-import { CpNode } from '../cp-node.js';
-import { posToHumanString, IPointOnShape } from '../point-on-shape.js';
-import { Circle } from '../circle.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { posToHumanString } from '../point-on-shape/pos-to-human-string.js';
+import { Circle } from '../geometry/circle.js';
 import { Generated } from './debug.js';
 
 
 /**
- * @hidden
+ * @internal
  * Used for debugging only. A three-prong is a maximally inscribed circle that
  * touches the shape boundary (tangentially) at 3 points.
  */
@@ -14,7 +15,7 @@ interface ThreeProngForDebugging {
     /** The best fit circle found for the 3-prong. */
     circle     : Circle;
     /** The best fit 3 points found for the 3-prong. */
-    poss       : IPointOnShape[];
+    poss       : PointOnShape[];
     /** The 3 boundary pieces on which the three prong points were found. */
     cp3ss      : CpNode[][];
     /** The boundary pieces that were used to search the three prong on. */
@@ -23,7 +24,7 @@ interface ThreeProngForDebugging {
     /** An array of 3-prongs, each of which may be a best fit 3-prong. */
     candidateThreeProngs : { 
         circle: Circle; 
-        ps: IPointOnShape[]; 
+        ps: PointOnShape[]; 
     }[];
     visitedCps : CpNode[];
     boundaries : number[][][][];
@@ -33,16 +34,16 @@ interface ThreeProngForDebugging {
 
 function createEmptyThreeProngForDebugging(): ThreeProngForDebugging {
     return {
-        generated  : undefined,
-        circle     : undefined,
-        poss       : undefined,
-        cp3ss      : undefined,
-        cpss       : undefined,
-        bestIndx   : undefined,
-        candidateThreeProngs : undefined,
-        visitedCps : undefined,
-        boundaries : undefined,
-        traces     : undefined,
+        generated  : undefined!,
+        circle     : undefined!,
+        poss       : undefined!,
+        cp3ss      : undefined!,
+        cpss       : undefined!,
+        bestIndx   : undefined!,
+        candidateThreeProngs : undefined!,
+        visitedCps : undefined!,
+        boundaries : undefined!,
+        traces     : undefined!,
     }
 }
 

package/src/debug/two-prong-for-debugging.ts

@@ -1,22 +1,22 @@
-import { CpNode } from '../cp-node.js';
-import { IPointOnShape } from '../point-on-shape.js';
-import { Circle } from '../circle.js';
+import { CpNode } from '../cp-node/cp-node.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { Circle } from '../geometry/circle.js';
 import { BezierPiece } from '../mat/bezier-piece.js';
 import { Generated } from './debug.js';
 
 
-/** @hidden */
+/** @internal */
 interface TwoProngForDebugging {
     generated: Generated;
     bezierPieces: BezierPiece[];
-    pos: IPointOnShape;
+    pos: PointOnShape;
     δ: CpNode[]; 
     z: number[];
     circle: Circle; 
     xs: { 
         x: number[]; 
-        y: IPointOnShape; 
-        z: IPointOnShape; 
+        y: PointOnShape; 
+        z: PointOnShape; 
         t: number; 
     }[]; 
     failed: boolean; 

package/src/error-analysis/gamma.ts

@@ -0,0 +1,41 @@
+const u = Number.EPSILON / 2;
+const uu = u*u;
+
+
+/**
+ * The canonical floating point error function, γ.
+ * 
+ * * roughly `=== n * (Number.EPSILON / 2)`
+ * * see e.g. [Algorithms for Accurate, Validated and Fast Polynomial Evaluation](https://hal.archives-ouvertes.fr/hal-00285603/document)
+ * @param n the parameter - typically a small positive integer, e.g. for 
+ * polynomial evaluation this === 2*d + 1, where d is the degree of the 
+ * polynomial
+ * 
+ * @doc
+ */
+function γ(n: number): number {
+    const nu = n*u;
+
+    return nu/(1-nu);
+}
+
+/**
+ * The canonical, once compensated (implying double-double precision), 
+ * floating point error function.
+ * 
+ * * roughly `=== n * (Number.EPSILON / 2)**2`
+ * * see e.g. [Algorithms for Accurate, Validated and Fast Polynomial Evaluation](https://hal.archives-ouvertes.fr/hal-00285603/document)
+ * @param n the parameter - typically a small positive integer, e.g. for 
+ * polynomial evaluation this === 2*d + 1, where d is the degree of the 
+ * polynomial
+ * 
+ * @doc
+ */
+function γγ(n: number): number {
+    const nuu = n*uu;
+    
+    return nuu/(1-nuu);
+}
+
+
+export { γ, γγ }

package/src/{mat/find-mat → find-2-prong}/add-1-prong.ts

@@ -2,12 +2,15 @@
 declare const _debug_: Debug; 
 
 import { LlRbTree } from 'flo-ll-rb-tree';
-import { Debug }   from '../../debug/debug.js';
-import { Loop } from '../../loop.js';
-import { getOsculatingCircle, calcPosOrder, isPosDullCorner, IPointOnShape } from '../../point-on-shape.js';
-import { CpNode } from '../../cp-node.js';
-import { addToCpGraph } from '../add-to-cp-graph.js';
-import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
+import { Debug }   from '../debug/debug.js';
+import { Loop } from 'flo-boolean';
+import { CpNode } from '../cp-node/cp-node.js';
+import { addToCpGraph } from '../mat/add-to-cp-graph.js';
+import { isAnotherCpCloseby } from '../mat/is-another-cp-closeby.js';
+import { PointOnShape } from '../point-on-shape/point-on-shape.js';
+import { isPosDullCorner } from '../point-on-shape/is-pos-dull-corner.js';
+import { calcPosOrder } from '../point-on-shape/calc-pos-order.js';
+import { Circle } from '../geometry/circle.js';
 
 
 /**
@@ -17,9 +20,10 @@ import { isAnotherCpCloseby } from '../is-another-cp-closeby.js';
  * @param pos 
  */
 function add1Prong(
-		maxOsculatingCircleRadius: number,
+		radius: number,
+        center: number[],
         cpGraphs: Map<Loop,LlRbTree<CpNode>>, 
-        pos: IPointOnShape) {
+        pos: PointOnShape) {
 
 	//if (PointOnShape.isDullCorner(pos)) {
     if (isPosDullCorner(pos)) {
@@ -37,29 +41,28 @@ function add1Prong(
 		//toRemove.push(posNode); // this!
 		
 		if (typeof _debug_ !== 'undefined') { 
-            _debug_.generated.elems.oneProngAtDullCorner.push(pos);
+            // _debug_.generated.elems.oneProngAtDullCorner.push(pos);
         }
 
 		return;
 	}
 	
-	//let circle = PointOnShape.getOsculatingCircle(maxOsculatingCircleRadius, pos);
-	const circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
+	// const circle = getOsculatingCircle(maxOsculatingCircleRadius, pos);
+    const circle: Circle = { radius, center };
 	
-	//const order = PointOnShape.calcOrder(circle, pos);
 	const order = calcPosOrder(circle, pos);
 	// Make sure there isn't already a ContactPoint close by - it can cause
 	// floating point stability issues.
-	if (isAnotherCpCloseby(cpGraphs, pos, circle, order, 0, 1000, 'magenta')) {
+	if (isAnotherCpCloseby(cpGraphs, pos, circle, order, 0, 1000)) {
 		return;
 	}
 
-    addToCpGraph(circle, [-0.5, +0.5], cpGraphs, [pos, pos]); 
+    const cpNodes = addToCpGraph(circle, [-0.5, +0.5], cpGraphs, [pos, pos]); 
 	
 	if (typeof _debug_ !== 'undefined') { 
-        _debug_.generated.elems.oneProng.push(pos);
+        _debug_.generated.elems.oneProng.push(cpNodes);
     }
 }
 
 
-export { add1Prong }
+export { add1Prong }