fable 3.1.63 → 3.1.65

package/example_applications/mathematical_playground/Math-Solver-Harness.js

@@ -115,4 +115,219 @@ console.log(`  Intercept (baseline): ${tmpSlopeInterceptResults.TrendIntercept}`
 _ExpressionParser.solve('Month7Prediction = TrendIntercept + TrendSlope * 7', tmpSlopeInterceptResults, tmpSlopeInterceptResults, false, tmpSlopeInterceptResults);
 console.log(`  Predicted month 7 revenue: ${tmpSlopeInterceptResults.Month7Prediction}`);
 
+/* * * * * * * * * * * * * * * * *
+ *
+ * MULTIROWMAP: Multi-Row Lookback Series Solver
+ *
+ * MULTIROWMAP lets you iterate over an array of objects (rows) and reference
+ * values from the current row, previous rows, and even future rows.
+ *
+ * Syntax:
+ *   Result = MULTIROWMAP ROWS FROM <address>
+ *     [SERIESSTART <n>]
+ *     [SERIESSTEP <n>]
+ *     VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <value>]
+ *     ...
+ *     : <expression>
+ *
+ * OFFSET 0 (default) = current row
+ * OFFSET -1 = previous row, OFFSET -2 = two rows back, etc.
+ * OFFSET 1 = next row, OFFSET 2 = two rows ahead, etc.
+ * DEFAULT provides a fallback when the referenced row is out of bounds.
+ * SERIESSTART controls which row index to start iterating from (negative counts from end).
+ * SERIESSTEP controls the iteration step (default 1, use -1 to go backwards).
+ *
+ */
+_Fable.log.info(`Beginning MULTIROWMAP Exercises....`);
+
+let tmpMultiRowResults = {};
+
+// --- Example 1: Fibonacci Verification ---
+// Verify that each value in a Fibonacci sequence equals the sum of the two previous values
+_ExpressionParser.solve(
+	'FibCheck = MULTIROWMAP ROWS FROM FibonacciRows VAR Current FROM Fib VAR Prev1 FROM Fib OFFSET -1 DEFAULT 0 VAR Prev2 FROM Fib OFFSET -2 DEFAULT 0 : Current - (Prev1 + Prev2)',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nFibonacci verification (should be 0 from row 2 onward):`);
+console.log(`  FibCheck: [${tmpMultiRowResults.FibCheck.join(', ')}]`);
+
+// --- Example 2: Stock Price Day-over-Day Change ---
+// Calculate the daily price change for a stock
+_ExpressionParser.solve(
+	'DailyChange = MULTIROWMAP ROWS FROM StockPrices VAR Today FROM Close VAR Yesterday FROM Close OFFSET -1 DEFAULT 0 : Today - Yesterday',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nStock daily price change:`);
+console.log(`  DailyChange: [${tmpMultiRowResults.DailyChange.join(', ')}]`);
+
+// --- Example 3: 3-Period Moving Average ---
+// Compute a 3-day moving average of stock closing prices
+_ExpressionParser.solve(
+	'MA3 = MULTIROWMAP ROWS FROM StockPrices VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\n3-period moving average of stock prices:`);
+console.log(`  MA3: [${tmpMultiRowResults.MA3.join(', ')}]`);
+
+// --- Example 4: Forward-Looking (Next Row Reference) ---
+// For each temperature reading, compute the difference to the next reading
+_ExpressionParser.solve(
+	'TempChange = MULTIROWMAP ROWS FROM TemperatureReadings VAR Current FROM Temp VAR Next FROM Temp OFFSET 1 DEFAULT 0 : Next - Current',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature change to next reading (forward lookback):`);
+console.log(`  TempChange: [${tmpMultiRowResults.TempChange.join(', ')}]`);
+
+// --- Example 5: Central Difference (Both Directions) ---
+// Approximate the derivative using central difference: (next - prev) / 2
+_ExpressionParser.solve(
+	'TempDerivative = MULTIROWMAP ROWS FROM TemperatureReadings VAR Prev FROM Temp OFFSET -1 DEFAULT 0 VAR Next FROM Temp OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature central difference derivative:`);
+console.log(`  TempDerivative: [${tmpMultiRowResults.TempDerivative.join(', ')}]`);
+
+// --- Example 6: Second Derivative (Two-Row Lookback) ---
+// Approximate the second derivative: current - 2*prev + twoprev
+_ExpressionParser.solve(
+	'TempAcceleration = MULTIROWMAP ROWS FROM TemperatureReadings VAR Current FROM Temp VAR Prev FROM Temp OFFSET -1 DEFAULT 0 VAR TwoBack FROM Temp OFFSET -2 DEFAULT 0 : Current - 2 * Prev + TwoBack',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nTemperature second derivative (acceleration):`);
+console.log(`  TempAcceleration: [${tmpMultiRowResults.TempAcceleration.join(', ')}]`);
+
+// --- Example 7: SERIESSTART - Skip Initial Rows ---
+// Start the moving average from row 2 so all three periods have valid data
+_ExpressionParser.solve(
+	'MA3Valid = MULTIROWMAP ROWS FROM StockPrices SERIESSTART 2 VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\n3-period MA starting from row 2 (all periods valid):`);
+console.log(`  MA3Valid: [${tmpMultiRowResults.MA3Valid.join(', ')}]`);
+
+// --- Example 8: SERIESSTEP -1 - Iterate Backwards ---
+// Read stock prices in reverse chronological order
+_ExpressionParser.solve(
+	'ReversePrices = MULTIROWMAP ROWS FROM StockPrices SERIESSTART -1 SERIESSTEP -1 VAR Price FROM Close : Price + 0',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nStock prices in reverse order:`);
+console.log(`  ReversePrices: [${tmpMultiRowResults.ReversePrices.join(', ')}]`);
+
+// --- Example 9: SERIESSTEP 2 - Every Other Row ---
+// Sample every other temperature reading
+_ExpressionParser.solve(
+	'EveryOtherTemp = MULTIROWMAP ROWS FROM TemperatureReadings SERIESSTEP 2 VAR t FROM Temp : t + 0',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nEvery other temperature reading:`);
+console.log(`  EveryOtherTemp: [${tmpMultiRowResults.EveryOtherTemp.join(', ')}]`);
+
+// --- Example 10: Three-Row Lookback with Multiple Properties ---
+// Weighted volume change: compare current volume to 3 days ago, scaled by price ratio
+_ExpressionParser.solve(
+	'WeightedVolChange = MULTIROWMAP ROWS FROM StockPrices VAR CurVol FROM Volume VAR CurPrice FROM Close VAR OldVol FROM Volume OFFSET -3 DEFAULT 0 VAR OldPrice FROM Close OFFSET -3 DEFAULT 1 : (CurVol - OldVol) * (CurPrice / OldPrice)',
+	_AppData, {}, false, tmpMultiRowResults);
+console.log(`\nWeighted volume change (3-day lookback with price ratio):`);
+console.log(`  WeightedVolChange: [${tmpMultiRowResults.WeightedVolChange.join(', ')}]`);
+
 console.log('QED');
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * Third-Party Test Suite Runner
+ *
+ * Run with: node Math-Solver-Harness.js --test-suite <name>
+ * Valid names: identities, spreadsheet, precision, acidtest, all
+ *
+ */
+let SUITE_MAP =
+	{
+		'identities': 'TestSuite-Identities.json',
+		'spreadsheet': 'TestSuite-Spreadsheet.json',
+		'precision': 'TestSuite-Precision.json',
+		'acidtest': 'TestSuite-AcidTest.json'
+	};
+
+let tmpRequestedSuites = [];
+for (let i = 0; i < process.argv.length; i++)
+{
+	if (process.argv[i] === '--test-suite' && i + 1 < process.argv.length)
+	{
+		let tmpSuiteName = process.argv[i + 1].toLowerCase();
+		if (tmpSuiteName === 'all')
+		{
+			tmpRequestedSuites = Object.keys(SUITE_MAP);
+		}
+		else if (tmpSuiteName in SUITE_MAP)
+		{
+			tmpRequestedSuites.push(tmpSuiteName);
+		}
+		else
+		{
+			console.log(`\x1b[31mUnknown test suite: ${tmpSuiteName}\x1b[0m`);
+			console.log(`Valid suites: ${Object.keys(SUITE_MAP).join(', ')}, all`);
+		}
+		i++;
+	}
+}
+
+if (tmpRequestedSuites.length > 0)
+{
+	let tmpTotalPass = 0;
+	let tmpTotalFail = 0;
+	let tmpSuiteSummaries = [];
+
+	for (let s = 0; s < tmpRequestedSuites.length; s++)
+	{
+		let tmpSuiteKey = tmpRequestedSuites[s];
+		let tmpSuiteData = require(`./${SUITE_MAP[tmpSuiteKey]}`);
+		let tmpSuitePass = 0;
+		let tmpSuiteFail = 0;
+		let tmpCurrentCategory = '';
+
+		console.log(`\n\x1b[1m=== ${tmpSuiteData.Name} ===\x1b[0m`);
+		console.log(`${tmpSuiteData.Description}\n`);
+
+		for (let i = 0; i < tmpSuiteData.Expressions.length; i++)
+		{
+			let tmpTest = tmpSuiteData.Expressions[i];
+			if (tmpTest.Category && tmpTest.Category !== tmpCurrentCategory)
+			{
+				tmpCurrentCategory = tmpTest.Category;
+				console.log(`  \x1b[4m${tmpCurrentCategory}\x1b[0m`);
+			}
+
+			let tmpData = tmpTest.Data || _AppData;
+			let tmpResultObject = {};
+			let tmpResultValue;
+			try
+			{
+				tmpResultValue = _ExpressionParser.solve(tmpTest.Equation, tmpData, tmpResultObject, false);
+			}
+			catch (pError)
+			{
+				tmpResultValue = `ERROR: ${pError.message}`;
+			}
+
+			let tmpPassed = (String(tmpResultValue) === String(tmpTest.ExpectedResult));
+			if (tmpPassed)
+			{
+				tmpSuitePass++;
+				console.log(`    \x1b[32m PASS\x1b[0m ${tmpTest.Description}`);
+			}
+			else
+			{
+				tmpSuiteFail++;
+				console.log(`    \x1b[31m FAIL\x1b[0m ${tmpTest.Description}`);
+				console.log(`          Expected: ${tmpTest.ExpectedResult}`);
+				console.log(`          Got:      ${tmpResultValue}`);
+			}
+		}
+
+		tmpTotalPass += tmpSuitePass;
+		tmpTotalFail += tmpSuiteFail;
+		tmpSuiteSummaries.push({ Name: tmpSuiteData.Name, Pass: tmpSuitePass, Fail: tmpSuiteFail, Total: tmpSuitePass + tmpSuiteFail });
+	}
+
+	console.log(`\n\x1b[1m=== Test Suite Summary ===\x1b[0m`);
+	for (let i = 0; i < tmpSuiteSummaries.length; i++)
+	{
+		let tmpSummary = tmpSuiteSummaries[i];
+		let tmpColor = tmpSummary.Fail > 0 ? '\x1b[31m' : '\x1b[32m';
+		console.log(`  ${tmpColor}${tmpSummary.Pass}/${tmpSummary.Total}\x1b[0m ${tmpSummary.Name}`);
+	}
+	let tmpOverallColor = tmpTotalFail > 0 ? '\x1b[31m' : '\x1b[32m';
+	console.log(`\n  ${tmpOverallColor}Total: ${tmpTotalPass}/${tmpTotalPass + tmpTotalFail} passed\x1b[0m`);
+}

package/example_applications/mathematical_playground/TestSuite-AcidTest.json

@@ -0,0 +1,178 @@
+{
+	"Name": "Parser Acid Test",
+	"Description": "Stress tests for operator precedence, parenthesis handling, comparison operators, and ternary syntax. Catches common parser bugs.",
+	"Expressions":
+		[
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Multiplication before addition: 2 + 3*4 = 14",
+				"Equation": "Result = 2 + 3 * 4",
+				"ExpectedResult": "14"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Parentheses override: (2+3)*4 = 20",
+				"Equation": "Result = (2 + 3) * 4",
+				"ExpectedResult": "20"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Exponent before multiply: 2^3 * 4 = 32",
+				"Equation": "Result = 2^3 * 4",
+				"ExpectedResult": "32"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Mixed all precedences: 2^3 + 4*5 - 6/3 = 26",
+				"Equation": "Result = 2^3 + 4 * 5 - 6 / 3",
+				"ExpectedResult": "26"
+			},
+			{
+				"Category": "PEMDAS / Order of Operations",
+				"Description": "Division before subtraction: 100 - 50 / 5 = 90",
+				"Equation": "Result = 100 - 50 / 5",
+				"ExpectedResult": "90"
+			},
+			{
+				"Category": "Parenthesis Nesting",
+				"Description": "Deep nesting: ((((1+2)*3)-4)/5) = 1",
+				"Equation": "Result = ((((1 + 2) * 3) - 4) / 5)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Parenthesis Nesting",
+				"Description": "Redundant parentheses: ((((42)))) = 42",
+				"Equation": "Result = ((((42))))",
+				"ExpectedResult": "42"
+			},
+			{
+				"Category": "Left-to-Right Associativity",
+				"Description": "Subtraction is left-to-right: 10 - 3 - 2 = 5",
+				"Equation": "Result = 10 - 3 - 2",
+				"ExpectedResult": "5"
+			},
+			{
+				"Category": "Left-to-Right Associativity",
+				"Description": "Division is left-to-right: 20 / 4 / 5 = 1",
+				"Equation": "Result = 20 / 4 / 5",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Negative Numbers",
+				"Description": "(-3)^2 = 9 (parenthesized negative base)",
+				"Equation": "Result = (-3)^2",
+				"ExpectedResult": "9"
+			},
+			{
+				"Category": "Negative Numbers",
+				"Description": "Addition with negative: 4 + -3 = 1",
+				"Equation": "Result = 4 + -3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Exponentiation",
+				"Description": "2^3^2 = 64 (left-to-right in this parser)",
+				"Equation": "Result = 2^3^2",
+				"ExpectedResult": "64"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Greater than true: 5 > 3 = 1",
+				"Equation": "Result = 5 > 3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Greater than false: 3 > 5 = 0",
+				"Equation": "Result = 3 > 5",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Equal true: 5 == 5 = 1",
+				"Equation": "Result = 5 == 5",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Not equal false: 5 != 5 = 0",
+				"Equation": "Result = 5 != 5",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "GTE boundary: 3 >= 3 = 1",
+				"Equation": "Result = 3 >= 3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "LTE false: 3 <= 2 = 0",
+				"Equation": "Result = 3 <= 2",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Comparison Operators",
+				"Description": "Negative comparison: (-3) < 0 = 1",
+				"Equation": "Result = (-3) < 0",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Comparison Precedence",
+				"Description": "Arithmetic before comparison: 2+3 > 1+2 = 1",
+				"Equation": "Result = 2 + 3 > 1 + 2",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "True branch: 5>3 ? 10+20 :: 30+40 = 30",
+				"Equation": "Result = 5 > 3 ? 10 + 20 :: 30 + 40",
+				"ExpectedResult": "30"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "False branch: 3>5 ? 10+20 :: 30+40 = 70",
+				"Equation": "Result = 3 > 5 ? 10 + 20 :: 30 + 40",
+				"ExpectedResult": "70"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Nested ternary: 1>0 ? (2>3 ? 100 :: 200) :: 300 = 200",
+				"Equation": "Result = 1 > 0 ? (2 > 3 ? 100 :: 200) :: 300",
+				"ExpectedResult": "200"
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Ternary with variables (absolute value pattern)",
+				"Equation": "Result = X > 0 ? X :: 0 - X",
+				"ExpectedResult": "5",
+				"Data": { "X": -5 }
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Ternary with variables (positive input)",
+				"Equation": "Result = X > 0 ? X :: 0 - X",
+				"ExpectedResult": "5",
+				"Data": { "X": 5 }
+			},
+			{
+				"Category": "Ternary Operator",
+				"Description": "Equality comparison in ternary",
+				"Equation": "Result = 0 == 0 ? 1 :: 0",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Functions with Comparisons",
+				"Description": "Function result in comparison via variable",
+				"Equation": "Result = SUM(Vals) > 5",
+				"ExpectedResult": "1",
+				"Data": { "Vals": [1, 2, 3] }
+			},
+			{
+				"Category": "Complex Expressions",
+				"Description": "All arithmetic operators in one expression",
+				"Equation": "Result = (10 + 5) * 2 - 8 / 4 + 3^2 % 5",
+				"ExpectedResult": "37"
+			}
+		]
+}

package/example_applications/mathematical_playground/TestSuite-Identities.json

@@ -0,0 +1,147 @@
+{
+	"Name": "Mathematical Identities",
+	"Description": "Classic mathematical identities from NIST DLMF and standard references. Tests correctness of trig, logarithmic, and algebraic operations.",
+	"Expressions":
+		[
+			{
+				"Category": "Pythagorean Identity",
+				"Description": "sin^2(30) + cos^2(30) = 1",
+				"Equation": "Result = ROUND(sin(rad(30))^2 + cos(rad(30))^2, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Pythagorean Identity",
+				"Description": "sin^2(45) + cos^2(45) = 1",
+				"Equation": "Result = ROUND(sin(rad(45))^2 + cos(rad(45))^2, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Pythagorean Identity",
+				"Description": "sin^2(60) + cos^2(60) = 1",
+				"Equation": "Result = ROUND(sin(rad(60))^2 + cos(rad(60))^2, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Double Angle Formula",
+				"Description": "2*sin(30)*cos(30) = sin(60)",
+				"Equation": "Result = ROUND(2 * sin(rad(30)) * cos(rad(30)), 10)",
+				"ExpectedResult": "0.8660254038"
+			},
+			{
+				"Category": "Double Angle Formula",
+				"Description": "sin(60) directly for comparison",
+				"Equation": "Result = ROUND(sin(rad(60)), 10)",
+				"ExpectedResult": "0.8660254038"
+			},
+			{
+				"Category": "Tangent Identity",
+				"Description": "tan(45) = 1",
+				"Equation": "Result = ROUND(tan(rad(45)), 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "sqrt(x)^2 = x (within rounding)",
+				"Equation": "Result = ROUND(sqrt(7)^2, 10)",
+				"ExpectedResult": "7"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "sqrt(144) = 12 (perfect square)",
+				"Equation": "Result = sqrt(144)",
+				"ExpectedResult": "12"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "x^0 = 1 for any nonzero x",
+				"Equation": "Result = 5^0",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "x^1 = x",
+				"Equation": "Result = 7^1",
+				"ExpectedResult": "7"
+			},
+			{
+				"Category": "Power and Root",
+				"Description": "x^2 * x^3 = x^5 (exponent addition)",
+				"Equation": "Result = 2^2 * 2^3",
+				"ExpectedResult": "32"
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "(a+b)(a-b) = a^2 - b^2 (difference of squares)",
+				"Equation": "Result = (A + B) * (A - B)",
+				"ExpectedResult": "40",
+				"Data": { "A": 7, "B": 3 }
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "a^2 - b^2 directly for comparison",
+				"Equation": "Result = A^2 - B^2",
+				"ExpectedResult": "40",
+				"Data": { "A": 7, "B": 3 }
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "(a+b)^2 = a^2 + 2ab + b^2",
+				"Equation": "Result = (3 + 4)^2",
+				"ExpectedResult": "49"
+			},
+			{
+				"Category": "Algebraic Identity",
+				"Description": "a^2 + 2ab + b^2 directly for comparison",
+				"Equation": "Result = 3^2 + 2 * 3 * 4 + 4^2",
+				"ExpectedResult": "49"
+			},
+			{
+				"Category": "Reciprocal Identity",
+				"Description": "1/(1/x) = x (within rounding)",
+				"Equation": "Result = ROUND(1 / (1 / 7), 10)",
+				"ExpectedResult": "7"
+			},
+			{
+				"Category": "Constants",
+				"Description": "Pi starts with 3.14159265",
+				"Equation": "Result = ROUND(pi(), 8)",
+				"ExpectedResult": "3.14159265"
+			},
+			{
+				"Category": "Constants",
+				"Description": "Euler's number starts with 2.71828183",
+				"Equation": "Result = ROUND(euler(), 8)",
+				"ExpectedResult": "2.71828183"
+			},
+			{
+				"Category": "Logarithmic Identity",
+				"Description": "log(1) = 0",
+				"Equation": "Result = log(1)",
+				"ExpectedResult": "0.000000000"
+			},
+			{
+				"Category": "Logarithmic Identity",
+				"Description": "exp(0) = 1",
+				"Equation": "Result = exp(0)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Additive Identity",
+				"Description": "x + 0 = x",
+				"Equation": "Result = 42 + 0",
+				"ExpectedResult": "42"
+			},
+			{
+				"Category": "Multiplicative Identity",
+				"Description": "x * 1 = x",
+				"Equation": "Result = 42 * 1",
+				"ExpectedResult": "42"
+			},
+			{
+				"Category": "Multiplicative Zero",
+				"Description": "x * 0 = 0",
+				"Equation": "Result = 42 * 0",
+				"ExpectedResult": "0"
+			}
+		]
+}

package/example_applications/mathematical_playground/TestSuite-Precision.json

@@ -0,0 +1,127 @@
+{
+	"Name": "Numeric Precision Stress Tests",
+	"Description": "Tests that catch IEEE 754 floating-point errors. The expression parser uses big.js for arbitrary precision, so these should all pass cleanly.",
+	"Expressions":
+		[
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "0.1 + 0.2 = 0.3 (classic IEEE 754 failure)",
+				"Equation": "Result = 0.1 + 0.2",
+				"ExpectedResult": "0.3"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "0.3 - 0.1 = 0.2",
+				"Equation": "Result = 0.3 - 0.1",
+				"ExpectedResult": "0.2"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "0.7 + 0.1 = 0.8",
+				"Equation": "Result = 0.7 + 0.1",
+				"ExpectedResult": "0.8"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "-0.1 + -0.2 = -0.3",
+				"Equation": "Result = -0.1 + -0.2",
+				"ExpectedResult": "-0.3"
+			},
+			{
+				"Category": "IEEE 754 Traps",
+				"Description": "1.0 - 0.9 - 0.1 = 0 (catastrophic cancellation)",
+				"Equation": "Result = 1.0 - 0.9 - 0.1",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Large Numbers",
+				"Description": "Large integer multiplication",
+				"Equation": "Result = 99999999999999 * 99999999999999",
+				"ExpectedResult": "9.999999999999800000000000001e+27"
+			},
+			{
+				"Category": "Large Numbers",
+				"Description": "Large integer addition",
+				"Equation": "Result = 123456789012345 + 987654321098765",
+				"ExpectedResult": "1111111110111110"
+			},
+			{
+				"Category": "Large Numbers",
+				"Description": "2^53 exact (JavaScript MAX_SAFE_INTEGER + 1)",
+				"Equation": "Result = 2^53",
+				"ExpectedResult": "9007199254740992"
+			},
+			{
+				"Category": "Small Number Precision",
+				"Description": "Subtraction preserving small difference",
+				"Equation": "Result = 1000000.001 - 1000000",
+				"ExpectedResult": "0.001"
+			},
+			{
+				"Category": "Small Number Precision",
+				"Description": "Very small number multiplication",
+				"Equation": "Result = 0.000001 * 0.000001",
+				"ExpectedResult": "1e-12"
+			},
+			{
+				"Category": "Division Precision",
+				"Description": "1/3 * 3 approaches 1 (repeating decimal)",
+				"Equation": "Result = ROUND(1 / 3 * 3, 10)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Division Precision",
+				"Description": "Large number / same number = 1 (within rounding)",
+				"Equation": "Result = ROUND(1000000 / 7 * 7, 10)",
+				"ExpectedResult": "1000000"
+			},
+			{
+				"Category": "Division Precision",
+				"Description": "1 / 1000000 = 0.000001",
+				"Equation": "Result = 1 / 1000000",
+				"ExpectedResult": "0.000001"
+			},
+			{
+				"Category": "Chained Operations",
+				"Description": "Add then subtract should cancel exactly",
+				"Equation": "Result = ((((1 + 0.0001) - 0.0001) * 10000) / 10000)",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Modulus",
+				"Description": "10 % 3 = 1",
+				"Equation": "Result = 10 % 3",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Modulus",
+				"Description": "7.5 % 2.5 = 0 (exact division)",
+				"Equation": "Result = 7.5 % 2.5",
+				"ExpectedResult": "0"
+			},
+			{
+				"Category": "Power Precision",
+				"Description": "3^7 = 2187",
+				"Equation": "Result = 3^7",
+				"ExpectedResult": "2187"
+			},
+			{
+				"Category": "Power Precision",
+				"Description": "10^10 = 10000000000",
+				"Equation": "Result = 10^10",
+				"ExpectedResult": "10000000000"
+			},
+			{
+				"Category": "Negative Number Precision",
+				"Description": "(-1)^2 = 1",
+				"Equation": "Result = (-1)^2",
+				"ExpectedResult": "1"
+			},
+			{
+				"Category": "Negative Number Precision",
+				"Description": "(-2) * (-3) = 6",
+				"Equation": "Result = (-2) * (-3)",
+				"ExpectedResult": "6"
+			}
+		]
+}