fable 3.1.35 → 3.1.37

package/test/ExpressionParser_tests.js

@@ -461,6 +461,68 @@ suite
 									Expect(parseFloat(tmpResult)).to.be.at.most(13.78);
 
 
+									return fDone();
+								}
+							);
+						test
+							(
+								'Test map operation',
+								(fDone) =>
+								{
+									let testFable = new libFable();
+									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+
+
+									let tmpManifest = testFable.newManyfest();
+									let tmpDataSourceObject = {};
+									tmpDataSourceObject.CitiesData = require('./data/Cities.json');
+									/* Records look like:
+[
+	{
+		"city": "New York", 
+		"growth_from_2000_to_2013": "4.8%", 
+		"latitude": 40.7127837, 
+		"longitude": -74.0059413, 
+		"population": "8405837", 
+		"rank": "1", 
+		"state": "New York"
+	}, 
+	{
+		"city": "Los Angeles", 
+		"growth_from_2000_to_2013": "4.8%", 
+		"latitude": 34.0522342, 
+		"longitude": -118.2436849, 
+		"population": "3884307", 
+		"rank": "2", 
+		"state": "California"
+	}, 
+									*/
+
+									tmpDataSourceObject.MapTest = {};
+									tmpDataSourceObject.MapTest.Values = [ 1, 2, 3, 4, 5 ];
+
+									let tmpDataDestinationObject = {};
+									let tmpParserResultsObject = {};
+
+									let tmpResult = _Parser.solve('SimpleMapResult = MAP VAR x FROM MapTest.Values : x + 100', tmpDataSourceObject, tmpParserResultsObject, tmpManifest, tmpDataDestinationObject);
+
+									// Should expect 101 -> 105
+									Expect(tmpDataDestinationObject.SimpleMapResult.length).to.equal(5);
+									Expect(tmpDataDestinationObject.SimpleMapResult[0]).to.equal("101");
+									Expect(tmpDataDestinationObject.SimpleMapResult[1]).to.equal("102");
+									Expect(tmpDataDestinationObject.SimpleMapResult[2]).to.equal("103");
+									Expect(tmpDataDestinationObject.SimpleMapResult[3]).to.equal("104");
+									Expect(tmpDataDestinationObject.SimpleMapResult[4]).to.equal("105");
+
+									let tmpComplexMapResult = _Parser.solve('ComplexMapResult = MAP VAR cityRecord FROM CitiesData VAR x FROM MapTest.Values : cityRecord.population + (x * 1000000000000000)', tmpDataSourceObject, tmpParserResultsObject, tmpManifest, tmpDataDestinationObject);
+
+									Expect(tmpDataDestinationObject.ComplexMapResult.length).to.equal(1000);
+									Expect(tmpDataDestinationObject.ComplexMapResult[0]).to.equal("1000000008405837");
+									Expect(tmpDataDestinationObject.ComplexMapResult[4]).to.equal("5000000001553165");
+									// We ran out of values 1-5 so now it's just population
+									Expect(tmpDataDestinationObject.ComplexMapResult[10]).to.equal("885400");
+									Expect(tmpDataDestinationObject.ComplexMapResult[400]).to.equal("81050");
+
 									return fDone();
 								}
 							);
@@ -519,8 +581,8 @@ suite
 								{
 									let testFable = new libFable();
 									let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
-
 									let tmpManifest = testFable.newManyfest();
+
 									let tmpDataSourceObject = {};
 									let tmpDataDestinationObject = {};
 									let tmpParserResultsObject = {};
@@ -532,6 +594,46 @@ suite
 									Expect(tmpResult).to.exist;
 									Expect(tmpResult.Samples.length).to.equal(1000);
 
+									// Rosenbrock function test (experimenting with non-deterministic test cases)
+									/* Interesting values:
+
+| Purpose                                   | (x)               | (y)               | (z)               | Notes                                                                           |
+| ----------------------------------------- | ----------------- | ----------------- | ----------------- | ------------------------------------------------------------------------------- |
+| **Exploration (broad view)**              | ([-3, 3])         | ([-1, 5])         | ([-1, 5])         | Shows how the function grows large and steep outside the valley.                |
+| **Focused optimization testing**          | ([0, 2])          | ([0, 2])          | ([0, 2])          | Focuses on region around the minimum — ideal for Monte Carlo convergence plots. |
+| **High-resolution contour visualization** | ([-1.5, 1.5])     | ([0, 2])          | ([0, 2])          | Best for plotting slices and seeing the curvature of the valley.                |
+| **Stress testing**                        | ([-2.048, 2.048]) | ([-2.048, 2.048]) | ([-2.048, 2.048]) | Tests the function's behavior over a wider range, useful for robustness checks. |
+*/
+									let tmpRosenbrockDataSourceObject = {};
+									let tmpRosenbrockDataDestinationObject = {};
+									let tmpRosenbrockParserResultsObject = {};
+									let tmpRosenbrockResult = _Parser.solve('RosenbrockResult = MONTECARLO SAMPLECOUNT 5000 VAR x PT x -3 PT x 3 VAR y PT y -1 PT y 5 VAR z PT z -1 PT z 5 : (1 - x)^2 + 100 * (y - x^2)^2 + (z - y)^2', tmpRosenbrockDataSourceObject, tmpRosenbrockParserResultsObject, tmpManifest, tmpRosenbrockDataDestinationObject);
+
+									Expect(tmpRosenbrockResult).to.exist;
+									Expect(tmpRosenbrockResult.Samples.length).to.equal(5000);
+
+									// Build a histogram of the results to see how many are near zero
+									let tmpHistogram = [];
+									for (let sampleIndex = 0; sampleIndex < tmpRosenbrockResult.Samples.length; sampleIndex++)
+									{
+										let tmpSample = tmpRosenbrockResult.Samples[sampleIndex];
+										let tmpValue = testFable.Math.roundPrecise(tmpSample, 0);
+										if (!tmpHistogram[tmpValue])
+											tmpHistogram[tmpValue] = 0;
+										tmpHistogram[tmpValue] = tmpHistogram[tmpValue] + 1;
+										// Log the output sample for visual inspection
+										testFable.log.info(`Rosenbrock Sample ${sampleIndex}: Value: ${tmpSample}, Rounded Value: ${tmpValue} --> Histogram Count: ${tmpHistogram[tmpValue]}`);
+									}
+									// Output the histogram for visual inspection
+									//testFable.ExpressionParser.Messaging.logMessage("Rosenbrock Histogram:");
+									let tmpHistogramKeys = Object.keys(tmpHistogram);
+									tmpHistogramKeys.sort((a, b) => parseFloat(a) - parseFloat(b));
+									for (let i = 0; i < tmpHistogramKeys.length; i++)
+									{
+										let key = tmpHistogramKeys[i];
+										testFable.log.info(`Value: ${key}, Count: ${tmpHistogram[key]}`);
+									}
+									
 									return fDone();
 								}
 							);
@@ -797,6 +899,234 @@ suite
 									testFable.log.info('Series From Coefficients Result:', testFable.AppData.SeriesFromCoefficients);
 									_Parser.solve('IntegratedSeries = SUM(FLATTEN(AppData.SeriesFromCoefficients))', testFable, testFable.AppData, false, testFable.AppData);
 									testFable.log.info('Integrated Series Result:', testFable.AppData.IntegratedSeries);
+
+									const tmpRawData =
+									{
+										"StandardSelector": "English",
+										"MaxDryDensityTable": [
+											{
+												"MaxDryDensityTable": {
+													"f": "4.19",
+													"g": "125.7",
+													"j": "0.19",
+													"l": "109.1",
+													"NTest": "",
+													"a": "",
+													"b": "",
+													"d": "13.51",
+													"e": "9.32",
+													"h": "1.44",
+													"i": "1.25",
+													"k": "15.2"
+												},
+												"MaxDryDensityTablec": "10.00"
+											},
+											{
+												"MaxDryDensityTable": {
+													"f": "4.01",
+													"g": "120.3",
+													"j": "0.16",
+													"l": "106.5",
+													"NTest": "",
+													"a": "",
+													"b": "",
+													"d": "13.34",
+													"e": "9.33",
+													"h": "1.39",
+													"i": "1.23",
+													"k": "13"
+												},
+												"MaxDryDensityTablec": "11.00"
+											},
+											{
+												"MaxDryDensityTable": {
+													"f": "4.19",
+													"g": "125.7",
+													"j": "0.22",
+													"l": "106",
+													"NTest": "",
+													"a": "",
+													"b": "",
+													"d": "13.51",
+													"e": "9.32",
+													"h": "1.40",
+													"i": "1.18",
+													"k": "18.6"
+												},
+												"MaxDryDensityTablec": "12.00"
+											}
+										],
+										"NuclearTable": [
+											{
+												"NuclearTable": {},
+												"NDD": "0",
+												"ADD": "0",
+												"NuclearPercentPR": "0"
+											}
+										],
+										"Pulverization": [
+											{
+												"PTestNo": "1"
+											}
+										],
+										"FMC": [
+											{
+												"MassOfWater": "0"
+											}
+										],
+										"MetaTemplate": {},
+										"Header": {},
+										"SM": {
+											"SF": "0",
+											"SI": "0",
+											"SJ": "0"
+										},
+										"NM": {},
+										"Chart": {
+											"Slope": "1.18181818181818181818",
+											"Intercept": "91.136363636363636363664",
+											"MCZeroAtDD": "21.830887491264849755",
+											"ShiftToParallel": "3.230887491264849755",
+											"WetSideY2": "0.84615384615384615385",
+											"WetSideY1": "-36.84746008708272859272",
+											"DomainBegin": "13",
+											"DomainEnd": "18.6",
+											"WetSideY0": "-6240",
+											"OptimalMoistureContent": "16.27122843513086489567",
+											"DryCount": 16,
+											"WetCount": "16",
+											"TotalCount": "32",
+											"StartPlot": "12",
+											"XValues": [
+												"13.2",
+												"13.4",
+												"13.6",
+												"13.8",
+												"14",
+												"14.2",
+												"14.4",
+												"14.6",
+												"14.8",
+												"15",
+												"15.2",
+												"15.4",
+												"15.6",
+												"15.8",
+												"16",
+												"16.2",
+												"16.4",
+												"16.6",
+												"16.8",
+												"17",
+												"17.2",
+												"17.4",
+												"17.6",
+												"17.8",
+												"18",
+												"18.2",
+												"18.4",
+												"18.6",
+												"18.8",
+												"19",
+												"19.2",
+												"19.4",
+											],
+											"PrimaryRoot": "110.3659972415182948767",
+											"WetCountIntermediate": "43",
+											"ValueLimit": "28"
+										},
+										"Result": "",
+										"FamilyOfCurvesZone": "0.99",
+										"MaxDryDensityEnglish": "0",
+										"MaxDryDensityMetric": "0",
+										"DryX": "15.2",
+										"DryY": "109.1",
+										"AsIsX": "13",
+										"AsIsY": "106.5",
+										"WetX": "18.6",
+										"WetY": "106",
+										"AverageMaxDryDensity": "11",
+										"OptimumMoistureOfTotalMaterial": "0.1",
+										"om": "0.0",
+										"pr": "0.0"
+									};
+
+									const tmpBaseMoistures = tmpRawData.Chart.XValues;
+									//TODO: compute this form above; 3 stages; dry, wet, combined
+									const tmpCombinedDensities = [ '106.7363636','106.9727273','107.2090909','107.4454545','107.6818182','107.9181818',
+										'108.1545455','108.3909091','108.6272727','108.8636364','109.1','109.3363636','109.5727273','109.8090909','110.0454545',
+										'110.2818182','110.1152028','109.7279363','109.3433842','108.9615182','108.5823101','108.2057322','107.8317574',
+										'107.4603587','107.0915096','106.7251839','106.3613559','106','105.6410912','105.2846046','104.9305159','104.5788009'
+									];
+									const tmpMatrix = [];
+									for (let i = 1; i <= 10; ++i)
+									{
+										const tmpPowArray = [];
+										for (let j = 0; j < tmpBaseMoistures.length; ++j)
+										{
+											tmpPowArray.push(testFable.Math.powerPrecise(tmpBaseMoistures[j], i));
+										}
+										tmpMatrix.push(tmpPowArray);
+									}
+									testFable.AppData.FitToDensities = tmpCombinedDensities;
+									testFable.AppData.MoistureMatrix = tmpMatrix;
+									testFable.log.info('Fit To Densities:', testFable.AppData.FitToDensities);
+									testFable.log.info('Moisture Matrix:', testFable.AppData.MoistureMatrix);
+									_Parser.solve('LinearRegressionHand = LINEST(AppData.MoistureMatrix, AppData.FitToDensities)', testFable, testFable.AppData, false, testFable.AppData);
+									testFable.log.info('Density Regression Coefficients:', testFable.AppData.LinearRegressionHand);
+
+									const tmpSolverInstructions =
+									[
+										'ChartDomainBegin = MaxDryDensityTable[0].MaxDryDensityTable.k - 2',
+										'ChartDomainEnd = ChartDomainBegin + (Chart.TotalCount - 1) * 0.2',
+										'XValues = SERIES FROM ChartDomainBegin TO ChartDomainEnd STEP 0.2 : n + 0',
+										'DryCount = MATCH(Chart.OptimalMoistureContent, XValues)',
+										'WetCountIntermediate = 60 - DryCount',
+										'WetCount = IF(DryCount, "<=", 30, DryCount, WetCountIntermediate)',
+										'TotalCount = DryCount + WetCount',
+										'StartPlot = DryCount - 5',
+										'ChartValueLimit = Chart.XValues.length - 1',
+										'DryValues = MAP VAR x FROM Chart.XValues : x * Chart.Slope + Chart.Intercept',
+										'WetValues = MAP VAR x FROM Chart.XValues : 6240 / (x + 100 / 2.7 + Chart.ShiftToParallel)',
+										'CombinedValues = MAP VAR dry FROM DryValues VAR wet FROM WetValues VAR x from XValues : IF(x, "LTE", Chart.OptimalMoistureContent, dry, wet)',
+										'FilteredXValues = MAP VAR x FROM XValues : IF(ABS(Chart.OptimalMoistureContent - x), "LT", 1, x, 0)',
+										'XValueMatrix = createarrayfromabsolutevalues(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)', // Create Placeholders
+										'XValueMatrix[0] = MAP VAR x FROM XValues : x + 0',
+										'XValueMatrix[1] = MAP VAR x FROM XValues : x^2',
+										'XValueMatrix[2] = MAP VAR x FROM XValues : x^3',
+										'XValueMatrix[3] = MAP VAR x FROM XValues : x^4',
+										'XValueMatrix[4] = MAP VAR x FROM XValues : x^5',
+										'XValueMatrix[5] = MAP VAR x FROM XValues : x^6',
+										'XValueMatrix[6] = MAP VAR x FROM XValues : x^7',
+										'XValueMatrix[7] = MAP VAR x FROM XValues : x^8',
+										'XValueMatrix[8] = MAP VAR x FROM XValues : x^9',
+										'XValueMatrix[9] = MAP VAR x FROM XValues : x^10',
+										'LinearRegression = LINEST(XValueMatrix, CombinedValues)',
+										'FilteredXValueVectors = MatrixTranspose(XValueMatrix)',
+										'FittedDensities = MAP VAR x FROM XValues VAR vector FROM FilteredXValueVectors : PREDICT(LinearRegression, vector)',
+										'FilteredDensities = MAP VAR x FROM FilteredXValues VAR prediction FROM FittedDensities : IF(x, "==", 0, 0, prediction)',
+									];
+									const tmpResultsObject = {};
+									for (const tmpInstruction of tmpSolverInstructions)
+									{
+										_Parser.solve(tmpInstruction, tmpRawData, tmpResultsObject, false, tmpRawData);
+										testFable.log.info(`After instruction: ${tmpInstruction}`, tmpRawData[tmpInstruction.split('=')[0].trim()]);
+									}
+
+									Expect(tmpRawData.FilteredDensities[10]).to.equal('0');
+									Expect(Number(tmpRawData.FilteredDensities[11])).to.be.closeTo(109.3, 0.1);
+									Expect(Number(tmpRawData.FilteredDensities[20])).to.be.closeTo(108.6, 0.1);
+									Expect(tmpRawData.FilteredDensities[21]).to.equal('0');
+
+									/*
+									testFable.log.info('linest payload (hand):', { MoistureMatrix: testFable.AppData.MoistureMatrix, FitToDensities: testFable.AppData.FitToDensities });
+									testFable.log.info('linest payload (solver):', { XValueMatrix: tmpRawData.XValueMatrix, CombinedValues: tmpRawData.CombinedValues });
+
+									testFable.log.info('coefficients (hand):', testFable.AppData.LinearRegressionHand);
+									testFable.log.info('coefficients (solver):', tmpRawData.LinearRegression);
+
+									testFable.log.info('filtered densities (solver):', tmpRawData.FilteredDensities);
+									*/
 								}
 							);
 					}

package/test/Math_test.js

@@ -486,25 +486,33 @@ suite
 						testFable.log.info('Prediction for [2,1]:', predict(coeffs_1, [2.5]));
 
 						// Example: predict y from x1 and x2
+						/* Example from: https://mathforcollege.com/nm/mws/gen/06reg/mws_gen_reg_spe_multivariate.pdf
+							144 18 52
+							142 24 40
+							124 12 40
+							64 30 48
+							96 30 32
+							92 22 16
+						 */
 						const X = [
-							[1, 2],
-							[2, 0],
-							[3, 1],
-							[4, 3]
+							[ 18, 24, 12, 30, 30, 22 ],
+							[ 52, 40, 40, 48, 32, 16 ],
 						];
 
-						const y = [3, 2, 4, 5];
+						const y = [ 144, 142, 124, 64, 96, 92 ];
 
 						const coeffs = testFable.Math.leastSquares(X, y);
 						testFable.log.info('Coefficients:', coeffs);
+						Expect(coeffs.length).to.equal(3); // intercept + 2 variables
+						Expect(Number(coeffs[0])).to.be.closeTo(150.166, 0.01);
+						Expect(Number(coeffs[1])).to.be.closeTo(-2.731, 0.01);
+						Expect(Number(coeffs[2])).to.be.closeTo(0.581, 0.01);
 
-						testFable.log.info('Prediction for [1,2] (training value is 3):', predict(coeffs, [1, 2]));
-						testFable.log.info('Prediction for [2,0] (training value is 2):', predict(coeffs, [2, 0]));
-						testFable.log.info('Prediction for [3,1] (training value is 4):', predict(coeffs, [3, 1]));
-						Expect(Number(predict(coeffs, [3, 1]))).to.be.closeTo(4, 0.51);
-						testFable.log.info('Prediction for [4,3] (training value is 5):', predict(coeffs, [4, 3]));
-						Expect(Number(predict(coeffs, [4, 3]))).to.be.closeTo(5, 0.25);
-						testFable.log.info('Prediction for [2,1]:', predict(coeffs, [2, 1]));
+						testFable.log.info('Prediction for [18,52] (training value is 144):', predict(coeffs, [18, 52]));
+						Expect(Number(predict(coeffs, [18, 52]))).to.be.closeTo(144, 15);
+
+						testFable.log.info('Prediction for [22,16] (training value is 92):', predict(coeffs, [22, 16]));
+						Expect(Number(predict(coeffs, [22, 16]))).to.be.closeTo(92, 10);
 					}
 				);