fable 3.1.55 → 3.1.58

package/example_applications/mathematical_playground/AppData.json

@@ -16,5 +16,8 @@
 			"X": 10,
 			"Y": 10
 		}
-	]
+	],
+
+	"BezierXValues": [0, 1, 2, 3, 4],
+	"BezierYValues": [0, 1, 4, 9, 16]
 }

package/example_applications/mathematical_playground/Equations.json

@@ -8,6 +8,7 @@
 			{ "Equation":"Result = 1 * sqrt(16)", "ExpectedResult":"4" },
 			{ "Equation":"Result = sqrt(100 * (C + 30)) + sin(Depth - Width) / 10", "ExpectedResult":"41.32965489638783839821" },
 			{ "Equation":"Result = 3.5 + 50 + 10 * 10 / 5 - 1.5", "ExpectedResult":"72" },
-			{ "Equation":"concataddr(Cities[].Name)", "ExpectedResult":"City1City2" }
+			{ "Equation":"concataddr(Cities[].Name)", "ExpectedResult":"City1City2" },
+			{ "Equation":"BezierMidpoint = BEZIERPOINT(0, 10, 20, 30, 0.5)", "ExpectedResult":"15" }
 		]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.55",
+  "version": "3.1.58",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {
@@ -50,21 +50,21 @@
   },
   "homepage": "https://github.com/stevenvelozo/fable",
   "devDependencies": {
-    "quackage": "^1.0.50"
+    "quackage": "^1.0.51"
   },
   "dependencies": {
     "async.eachlimit": "^0.5.2",
     "async.waterfall": "^0.5.2",
     "big.js": "^7.0.1",
-    "cachetrax": "^1.0.4",
-    "cookie": "^1.0.2",
+    "cachetrax": "^1.0.5",
+    "cookie": "^1.1.1",
     "data-arithmatic": "^1.0.7",
     "dayjs": "^1.11.19",
-    "fable-log": "^3.0.16",
-    "fable-serviceproviderbase": "^3.0.17",
-    "fable-settings": "^3.0.14",
-    "fable-uuid": "^3.0.11",
-    "manyfest": "^1.0.44",
+    "fable-log": "^3.0.17",
+    "fable-serviceproviderbase": "^3.0.18",
+    "fable-settings": "^3.0.15",
+    "fable-uuid": "^3.0.12",
+    "manyfest": "^1.0.46",
     "simple-get": "^4.0.1"
   }
 }

package/source/services/Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-FunctionMap.json

@@ -493,5 +493,14 @@
 	"stringgetsegments": {
 		"Name": "Get Segments from a String",
 		"Address": "fable.DataFormat.stringGetSegments"
+	},
+
+	"bezierpoint": {
+		"Name": "Evaluate a Point on a Cubic Bezier Curve at Parameter t",
+		"Address": "fable.Math.bezierPoint"
+	},
+	"beziercurvefit": {
+		"Name": "Fit a Cubic Bezier Curve to a Set of Data Points",
+		"Address": "fable.Math.bezierCurveFit"
 	}
 }

package/source/services/Fable-Service-Math.js

@@ -1863,6 +1863,185 @@ class FableServiceMath extends libFableServiceBase
 				return this.addPrecise(sum, this.multiplyPrecise(b, tmpIndependentVariableVector[i]));
 			}, pRegressionCoefficients[0]);
 	}
+
+	/**
+	 * Evaluate a point on a cubic bezier curve at parameter t.
+	 *
+	 * B(t) = (1-t)^3*P0 + 3*(1-t)^2*t*P1 + 3*(1-t)*t^2*P2 + t^3*P3
+	 *
+	 * @param {number|string} pP0 - First control point value
+	 * @param {number|string} pP1 - Second control point value
+	 * @param {number|string} pP2 - Third control point value
+	 * @param {number|string} pP3 - Fourth control point value
+	 * @param {number|string} pT - Parameter t in [0,1]
+	 *
+	 * @return {string} - The bezier curve value at parameter t
+	 */
+	bezierPoint(pP0, pP1, pP2, pP3, pT)
+	{
+		let tmpT = this.parsePrecise(pT, 0);
+		let tmpOneMinusT = this.subtractPrecise(1, tmpT);
+
+		// (1-t)^3 * P0
+		let tmpTerm0 = this.multiplyPrecise(this.powerPrecise(tmpOneMinusT, 3), pP0);
+		// 3 * (1-t)^2 * t * P1
+		let tmpTerm1 = this.multiplyPrecise(this.multiplyPrecise(this.multiplyPrecise(3, this.powerPrecise(tmpOneMinusT, 2)), tmpT), pP1);
+		// 3 * (1-t) * t^2 * P2
+		let tmpTerm2 = this.multiplyPrecise(this.multiplyPrecise(this.multiplyPrecise(3, tmpOneMinusT), this.powerPrecise(tmpT, 2)), pP2);
+		// t^3 * P3
+		let tmpTerm3 = this.multiplyPrecise(this.powerPrecise(tmpT, 3), pP3);
+
+		return this.addPrecise(this.addPrecise(tmpTerm0, tmpTerm1), this.addPrecise(tmpTerm2, tmpTerm3));
+	}
+
+	/**
+	 * Fit a cubic bezier curve to a set of data points using least-squares optimization.
+	 *
+	 * Given arrays of X and Y values representing data points, this function finds the four
+	 * control points (P0, P1, P2, P3) of a cubic bezier curve that best fits the data.
+	 *
+	 * The first and last control points are pinned to the first and last data points.
+	 * The interior control points (P1, P2) are found by least-squares minimization of
+	 * the squared distances between the data points and the curve.
+	 *
+	 * Parameter t values are assigned by chord-length parameterization: each data point
+	 * gets a t value proportional to its cumulative distance along the polyline.
+	 *
+	 * @param {Array<number|string>} pXValues - Array of x coordinates
+	 * @param {Array<number|string>} pYValues - Array of y coordinates
+	 *
+	 * @return {Array<Array<string>>} - Four control points as [[x0,y0], [x1,y1], [x2,y2], [x3,y3]]
+	 */
+	bezierCurveFit(pXValues, pYValues)
+	{
+		if (!Array.isArray(pXValues) || !Array.isArray(pYValues))
+		{
+			this.log.warn('bezierCurveFit: pXValues and pYValues must be arrays');
+			return [[0, 0], [0, 0], [0, 0], [0, 0]];
+		}
+
+		let tmpN = Math.min(pXValues.length, pYValues.length);
+
+		if (tmpN < 2)
+		{
+			this.log.warn('bezierCurveFit: need at least 2 data points');
+			return [[0, 0], [0, 0], [0, 0], [0, 0]];
+		}
+
+		// Pin P0 and P3 to the first and last data points
+		let tmpP0x = this.parsePrecise(pXValues[0], 0);
+		let tmpP0y = this.parsePrecise(pYValues[0], 0);
+		let tmpP3x = this.parsePrecise(pXValues[tmpN - 1], 0);
+		let tmpP3y = this.parsePrecise(pYValues[tmpN - 1], 0);
+
+		if (tmpN === 2)
+		{
+			// With only two points, place control points at 1/3 and 2/3 along the line
+			let tmpP1x = this.addPrecise(tmpP0x, this.dividePrecise(this.subtractPrecise(tmpP3x, tmpP0x), 3));
+			let tmpP1y = this.addPrecise(tmpP0y, this.dividePrecise(this.subtractPrecise(tmpP3y, tmpP0y), 3));
+			let tmpP2x = this.addPrecise(tmpP0x, this.multiplyPrecise(this.dividePrecise(this.subtractPrecise(tmpP3x, tmpP0x), 3), 2));
+			let tmpP2y = this.addPrecise(tmpP0y, this.multiplyPrecise(this.dividePrecise(this.subtractPrecise(tmpP3y, tmpP0y), 3), 2));
+			return [
+				[tmpP0x.toString(), tmpP0y.toString()],
+				[tmpP1x.toString(), tmpP1y.toString()],
+				[tmpP2x.toString(), tmpP2y.toString()],
+				[tmpP3x.toString(), tmpP3y.toString()]
+			];
+		}
+
+		// Compute chord-length parameterization for t values
+		let tmpDistances = [0];
+		for (let i = 1; i < tmpN; i++)
+		{
+			let tmpDx = this.subtractPrecise(pXValues[i], pXValues[i - 1]);
+			let tmpDy = this.subtractPrecise(pYValues[i], pYValues[i - 1]);
+			let tmpDist = this.sqrtPrecise(this.addPrecise(this.multiplyPrecise(tmpDx, tmpDx), this.multiplyPrecise(tmpDy, tmpDy)));
+			tmpDistances.push(this.addPrecise(tmpDistances[i - 1], tmpDist));
+		}
+
+		let tmpTotalLength = tmpDistances[tmpN - 1];
+		let tmpTValues = [];
+		for (let i = 0; i < tmpN; i++)
+		{
+			if (this.comparePrecise(tmpTotalLength, 0) == 0)
+			{
+				tmpTValues.push(this.dividePrecise(i, tmpN - 1));
+			}
+			else
+			{
+				tmpTValues.push(this.dividePrecise(tmpDistances[i], tmpTotalLength));
+			}
+		}
+
+		// Build the least-squares system for interior control points P1 and P2.
+		// For each data point i with parameter t_i:
+		//   B(t_i) = (1-t)^3*P0 + 3*(1-t)^2*t*P1 + 3*(1-t)*t^2*P2 + t^3*P3
+		//
+		// We want to minimize sum of |DataPoint_i - B(t_i)|^2 over P1 and P2.
+		// Let A1(t) = 3*(1-t)^2*t and A2(t) = 3*(1-t)*t^2.
+		// Then: A1(t)*P1 + A2(t)*P2 = DataPoint - (1-t)^3*P0 - t^3*P3
+		//
+		// This gives a 2x2 linear system (solved independently for x and y).
+
+		let tmpC11 = 0, tmpC12 = 0, tmpC22 = 0;
+		let tmpRx1 = 0, tmpRx2 = 0;
+		let tmpRy1 = 0, tmpRy2 = 0;
+
+		for (let i = 0; i < tmpN; i++)
+		{
+			let tmpT = tmpTValues[i];
+			let tmpOneMinusT = this.subtractPrecise(1, tmpT);
+
+			// Basis functions for P1 and P2
+			let tmpA1 = this.multiplyPrecise(this.multiplyPrecise(3, this.powerPrecise(tmpOneMinusT, 2)), tmpT);
+			let tmpA2 = this.multiplyPrecise(this.multiplyPrecise(3, tmpOneMinusT), this.powerPrecise(tmpT, 2));
+
+			// Build normal equations: C * [P1; P2] = R
+			tmpC11 = this.addPrecise(tmpC11, this.multiplyPrecise(tmpA1, tmpA1));
+			tmpC12 = this.addPrecise(tmpC12, this.multiplyPrecise(tmpA1, tmpA2));
+			tmpC22 = this.addPrecise(tmpC22, this.multiplyPrecise(tmpA2, tmpA2));
+
+			// Right-hand side: DataPoint - (1-t)^3*P0 - t^3*P3
+			let tmpB0 = this.powerPrecise(tmpOneMinusT, 3);
+			let tmpB3 = this.powerPrecise(tmpT, 3);
+
+			let tmpResidualX = this.subtractPrecise(this.subtractPrecise(pXValues[i], this.multiplyPrecise(tmpB0, tmpP0x)), this.multiplyPrecise(tmpB3, tmpP3x));
+			let tmpResidualY = this.subtractPrecise(this.subtractPrecise(pYValues[i], this.multiplyPrecise(tmpB0, tmpP0y)), this.multiplyPrecise(tmpB3, tmpP3y));
+
+			tmpRx1 = this.addPrecise(tmpRx1, this.multiplyPrecise(tmpA1, tmpResidualX));
+			tmpRx2 = this.addPrecise(tmpRx2, this.multiplyPrecise(tmpA2, tmpResidualX));
+			tmpRy1 = this.addPrecise(tmpRy1, this.multiplyPrecise(tmpA1, tmpResidualY));
+			tmpRy2 = this.addPrecise(tmpRy2, this.multiplyPrecise(tmpA2, tmpResidualY));
+		}
+
+		// Solve the 2x2 system: [[C11, C12], [C12, C22]] * [P1, P2] = [R1, R2]
+		let tmpDet = this.subtractPrecise(this.multiplyPrecise(tmpC11, tmpC22), this.multiplyPrecise(tmpC12, tmpC12));
+
+		let tmpP1x, tmpP1y, tmpP2x, tmpP2y;
+
+		if (this.comparePrecise(this.absPrecise(tmpDet), '1e-20') < 0)
+		{
+			// Degenerate case: place control points at 1/3 and 2/3 along the line
+			tmpP1x = this.addPrecise(tmpP0x, this.dividePrecise(this.subtractPrecise(tmpP3x, tmpP0x), 3));
+			tmpP1y = this.addPrecise(tmpP0y, this.dividePrecise(this.subtractPrecise(tmpP3y, tmpP0y), 3));
+			tmpP2x = this.addPrecise(tmpP0x, this.multiplyPrecise(this.dividePrecise(this.subtractPrecise(tmpP3x, tmpP0x), 3), 2));
+			tmpP2y = this.addPrecise(tmpP0y, this.multiplyPrecise(this.dividePrecise(this.subtractPrecise(tmpP3y, tmpP0y), 3), 2));
+		}
+		else
+		{
+			tmpP1x = this.dividePrecise(this.subtractPrecise(this.multiplyPrecise(tmpC22, tmpRx1), this.multiplyPrecise(tmpC12, tmpRx2)), tmpDet);
+			tmpP1y = this.dividePrecise(this.subtractPrecise(this.multiplyPrecise(tmpC22, tmpRy1), this.multiplyPrecise(tmpC12, tmpRy2)), tmpDet);
+			tmpP2x = this.dividePrecise(this.subtractPrecise(this.multiplyPrecise(tmpC11, tmpRx2), this.multiplyPrecise(tmpC12, tmpRx1)), tmpDet);
+			tmpP2y = this.dividePrecise(this.subtractPrecise(this.multiplyPrecise(tmpC11, tmpRy2), this.multiplyPrecise(tmpC12, tmpRy1)), tmpDet);
+		}
+
+		return [
+			[tmpP0x.toString(), tmpP0y.toString()],
+			[tmpP1x.toString(), tmpP1y.toString()],
+			[tmpP2x.toString(), tmpP2y.toString()],
+			[tmpP3x.toString(), tmpP3y.toString()]
+		];
+	}
 }
 
 module.exports = FableServiceMath;

package/test/ExpressionParser_tests.js

@@ -746,6 +746,50 @@ suite
 								}
 							);
 						test
+							(
+								'Bezier Curve Functions',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+
+									let tmpResultsObject = {};
+									let tmpDestinationObject = {};
+
+									// Test bezierPoint through the expression parser
+									// bezierPoint(P0, P1, P2, P3, t) at t=0 should return P0
+									_Parser.solve('PointAtZero = BEZIERPOINT(0, 10, 20, 30, 0)', testFable, tmpResultsObject, false, tmpDestinationObject);
+									Expect(tmpDestinationObject.PointAtZero).to.equal('0');
+
+									// bezierPoint at t=1 should return P3
+									_Parser.solve('PointAtOne = BEZIERPOINT(0, 10, 20, 30, 1)', testFable, tmpResultsObject, false, tmpDestinationObject);
+									Expect(tmpDestinationObject.PointAtOne).to.equal('30');
+
+									// bezierPoint at t=0.5 for a linear distribution P0=0, P1=10, P2=20, P3=30
+									_Parser.solve('PointAtHalf = BEZIERPOINT(0, 10, 20, 30, 0.5)', testFable, tmpResultsObject, false, tmpDestinationObject);
+									Expect(tmpDestinationObject.PointAtHalf).to.equal('15');
+
+									// Test bezierCurveFit through the expression parser with data arrays
+									testFable.AppData =
+									{
+										XValues: [0, 1, 2, 3],
+										YValues: [0, 1, 2, 3]
+									};
+
+									_Parser.solve('FitResult = BEZIERCURVEFIT(AppData.XValues, AppData.YValues)', testFable, tmpResultsObject, false, tmpDestinationObject);
+									Expect(tmpDestinationObject.FitResult).to.be.an('array');
+									Expect(tmpDestinationObject.FitResult.length).to.equal(4);
+									// P0 should be [0, 0]
+									Expect(tmpDestinationObject.FitResult[0][0]).to.equal('0');
+									Expect(tmpDestinationObject.FitResult[0][1]).to.equal('0');
+									// P3 should be [3, 3]
+									Expect(tmpDestinationObject.FitResult[3][0]).to.equal('3');
+									Expect(tmpDestinationObject.FitResult[3][1]).to.equal('3');
+
+									return fDone();
+								}
+							);
+						test
 							(
 								'plumbing histogram into aggregation',
 								() =>

package/test/Math_test.js

@@ -600,6 +600,99 @@ suite
 						return fDone();
 					}
 				);
+
+				test
+				(
+					'Bezier Point Evaluation',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						// At t=0, should return P0
+						Expect(testFable.Math.bezierPoint(0, 10, 20, 30, 0)).to.equal('0');
+						// At t=1, should return P3
+						Expect(testFable.Math.bezierPoint(0, 10, 20, 30, 1)).to.equal('30');
+						// At t=0.5 for a symmetric curve P0=0, P1=10, P2=20, P3=30 (this is actually a line)
+						Expect(testFable.Math.bezierPoint(0, 10, 20, 30, '0.5')).to.equal('15');
+
+						// A known cubic bezier: P0=0, P1=0, P2=100, P3=100 at t=0.5
+						// B(0.5) = 0.125*0 + 0.375*0 + 0.375*100 + 0.125*100 = 50
+						Expect(testFable.Math.bezierPoint(0, 0, 100, 100, '0.5')).to.equal('50');
+
+						// Non-symmetric: P0=1, P1=2, P2=4, P3=5 at t=0.25
+						// B(0.25) = (0.75)^3*1 + 3*(0.75)^2*0.25*2 + 3*0.75*(0.25)^2*4 + (0.25)^3*5
+						// = 0.421875*1 + 3*0.5625*0.25*2 + 3*0.75*0.0625*4 + 0.015625*5
+						// = 0.421875 + 0.84375 + 0.5625 + 0.078125 = 1.90625
+						Expect(testFable.Math.bezierPoint(1, 2, 4, 5, '0.25')).to.equal('1.90625');
+
+						return fDone();
+					}
+				);
+
+				test
+				(
+					'Bezier Curve Fit',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						// Fit a straight line: should get control points roughly on the line
+						let tmpLineResult = testFable.Math.bezierCurveFit([0, 1, 2, 3], [0, 1, 2, 3]);
+						Expect(tmpLineResult).to.be.an('array');
+						Expect(tmpLineResult.length).to.equal(4);
+						// P0 should be [0, 0]
+						Expect(tmpLineResult[0][0]).to.equal('0');
+						Expect(tmpLineResult[0][1]).to.equal('0');
+						// P3 should be [3, 3]
+						Expect(tmpLineResult[3][0]).to.equal('3');
+						Expect(tmpLineResult[3][1]).to.equal('3');
+						// Interior control points should be roughly on the line too
+						Expect(Number(tmpLineResult[1][0])).to.be.closeTo(1, 0.5);
+						Expect(Number(tmpLineResult[1][1])).to.be.closeTo(1, 0.5);
+						Expect(Number(tmpLineResult[2][0])).to.be.closeTo(2, 0.5);
+						Expect(Number(tmpLineResult[2][1])).to.be.closeTo(2, 0.5);
+
+						// Two-point degenerate case: should place P1, P2 at 1/3 and 2/3
+						let tmpTwoPointResult = testFable.Math.bezierCurveFit([0, 9], [0, 9]);
+						Expect(tmpTwoPointResult[0][0]).to.equal('0');
+						Expect(tmpTwoPointResult[0][1]).to.equal('0');
+						Expect(tmpTwoPointResult[3][0]).to.equal('9');
+						Expect(tmpTwoPointResult[3][1]).to.equal('9');
+						Expect(tmpTwoPointResult[1][0]).to.equal('3');
+						Expect(tmpTwoPointResult[1][1]).to.equal('3');
+						Expect(tmpTwoPointResult[2][0]).to.equal('6');
+						Expect(tmpTwoPointResult[2][1]).to.equal('6');
+
+						// Bad input: not arrays
+						let tmpBadResult = testFable.Math.bezierCurveFit('bad', 'input');
+						Expect(tmpBadResult).to.be.an('array');
+						Expect(tmpBadResult.length).to.equal(4);
+
+						// Bad input: too few points
+						let tmpSingleResult = testFable.Math.bezierCurveFit([1], [1]);
+						Expect(tmpSingleResult).to.be.an('array');
+						Expect(tmpSingleResult.length).to.equal(4);
+
+						// Curved data: a parabola y = x^2 from 0 to 4
+						let tmpXValues = [0, 1, 2, 3, 4];
+						let tmpYValues = [0, 1, 4, 9, 16];
+						let tmpCurveResult = testFable.Math.bezierCurveFit(tmpXValues, tmpYValues);
+						// P0 should be [0, 0], P3 should be [4, 16]
+						Expect(tmpCurveResult[0][0]).to.equal('0');
+						Expect(tmpCurveResult[0][1]).to.equal('0');
+						Expect(tmpCurveResult[3][0]).to.equal('4');
+						Expect(tmpCurveResult[3][1]).to.equal('16');
+						// The fitted curve should approximate the data at the midpoint
+						let tmpMidX = testFable.Math.bezierPoint(tmpCurveResult[0][0], tmpCurveResult[1][0], tmpCurveResult[2][0], tmpCurveResult[3][0], '0.5');
+						let tmpMidY = testFable.Math.bezierPoint(tmpCurveResult[0][1], tmpCurveResult[1][1], tmpCurveResult[2][1], tmpCurveResult[3][1], '0.5');
+						// At the midpoint parameter, the curve should be somewhere reasonable
+						// Note: bezier parameter t=0.5 does not correspond to the geometric midpoint for non-linear data
+						Expect(Number(tmpMidX)).to.be.closeTo(2, 1);
+						Expect(Number(tmpMidY)).to.be.closeTo(4, 5);
+
+						return fDone();
+					}
+				);
 			}
 		);
 	}