fable 3.1.36 → 3.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.36",
+  "version": "3.1.38",
   "description": "A service dependency injection, configuration and logging library.",
   "main": "source/Fable.js",
   "scripts": {

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

@@ -404,6 +404,11 @@
 		"Address": "fable.Dates.dateFromParts"
 	},
 
+	"slice": {
+		"Name": "Slice Array",
+		"Address": "fable.Utility.slice"
+	},
+
 	"createvalueobjectbyhashes": {
 		"Name": "Create Value Object by Hashes",
 		"Address": "fable.Utility.createValueObjectByHashes"
@@ -441,5 +446,9 @@
 	"gaussianelimination": {
 		"Name": "Solve a System of Linear Equations using Gaussian Elimination",
 		"Address": "fable.Math.gaussianElimination"
+	},
+	"predict": {
+		"Name": "Predict Y Values from X Values using a Regression Model",
+		"Address": "fable.Math.predictFromRegressionModel"
 	}
 }

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

@@ -247,13 +247,14 @@ class FableServiceExpressionParser extends libFableServiceBase
 		this.lintTokenizedExpression(tmpResultsObject.RawTokens, tmpResultsObject);
 		this.buildPostfixedSolveList(tmpResultsObject.RawTokens, tmpResultsObject);
 
+		const tmpManifest = (typeof(pManifest) === 'object') ? pManifest : this.fable.newManyfest();
 		if (tmpResultsObject.SolverDirectives.Code == 'SERIES')
 		{
 			const [ tmpStep , tmpFrom, tmpTo] = this._prepareDirectiveParameters([
 				tmpResultsObject.SolverDirectives.Step,
 				tmpResultsObject.SolverDirectives.From,
 				tmpResultsObject.SolverDirectives.To,
-			], [ '1' ], tmpResultsObject, tmpDataSourceObject, pManifest);
+			], [ '1' ], tmpResultsObject, tmpDataSourceObject, tmpManifest);
 
 			if (isNaN(tmpFrom) || isNaN(tmpTo))
 			{
@@ -305,17 +306,19 @@ class FableServiceExpressionParser extends libFableServiceBase
 
 			for (let i = 0; i <= tmpIterations; i++)
 			{
-				let tmpCurrentValueOfN = this.fable.Math.addPrecise(tmpFrom, this.fable.Math.multiplyPrecise(tmpStep, i.toString()));
+				const tmpCurrentValueOfN = this.fable.Math.addPrecise(tmpFrom, this.fable.Math.multiplyPrecise(tmpStep, i.toString()));
+				const tmpPreviousValueOfN = (i == 0) ? 'false' : this.fable.Math.addPrecise(tmpFrom, this.fable.Math.multiplyPrecise(tmpStep, (i - 1).toString()));
 
 				// Jimmy up the data source with the current N value, stepIndex and all the other data from the source object
 				// This generates a data source object every time on purpose so we can remarshal in values that changed in the destination
 				let tmpSeriesStepDataSourceObject = Object.assign({}, tmpDataSourceObject);
 				tmpSeriesStepDataSourceObject.n = tmpCurrentValueOfN;
+				tmpSeriesStepDataSourceObject.prev_n = tmpPreviousValueOfN;
 				tmpSeriesStepDataSourceObject.stepIndex = i;
 
-				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpSeriesStepDataSourceObject, tmpResultsObject, pManifest);
+				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpSeriesStepDataSourceObject, tmpResultsObject, tmpManifest);
 
-				tmpValueArray.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, pManifest) );
+				tmpValueArray.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, tmpManifest) );
 
 				for (let j = 0; j < tmpMutatedValues.length; j++)
 				{
@@ -330,7 +333,6 @@ class FableServiceExpressionParser extends libFableServiceBase
 				tmpAssignmentManifestHash = tmpResultsObject.OriginalRawTokens[0];
 			}
 
-			let tmpManifest = (typeof(pManifest) === 'object') ? pManifest : this.fable.newManyfest();
 			tmpManifest.setValueByHash(tmpDataDestinationObject, tmpAssignmentManifestHash, tmpValueArray);
 
 			return tmpValueArray;
@@ -348,7 +350,7 @@ class FableServiceExpressionParser extends libFableServiceBase
 				const tmpVariableDescription = tmpDirectiveValues[tmpVariableKey];
 
 				// Get the actual value for this variable's address
-				tmpVariableDescription.Value = pManifest.getValueByHash(tmpDataSourceObject, tmpVariableDescription.Address);
+				tmpVariableDescription.Value = tmpManifest.getValueByHash(tmpDataSourceObject, tmpVariableDescription.Address);
 			}
 
 			// If the first value doesn't have keys, don't do the map.
@@ -366,11 +368,12 @@ class FableServiceExpressionParser extends libFableServiceBase
 				// Jimmy up the data source with the current N value, stepIndex and all the other data from the source object
 				// This generates a data source object every time on purpose so we can remarshal in values that changed in the destination
 				let tmpSeriesStepDataSourceObject = Object.assign({}, tmpDataSourceObject);
+				tmpSeriesStepDataSourceObject.stepIndex = i;
 
 				for (let j = 0; j < tmpDirectiveValueKeys.length; j++)
 				{
 					const tmpVariableKey = tmpDirectiveValueKeys[j];
-					if (!Array.isArray(tmpDirectiveValues[tmpVariableKey].Value) || (tmpDirectiveValues[tmpVariableKey].Value.length <= j))
+					if (!Array.isArray(tmpDirectiveValues[tmpVariableKey].Value) || (tmpDirectiveValues[tmpVariableKey].Value.length <= i))
 					{
 						tmpSeriesStepDataSourceObject[tmpVariableKey] = 0;
 					}
@@ -378,11 +381,24 @@ class FableServiceExpressionParser extends libFableServiceBase
 					{
 						tmpSeriesStepDataSourceObject[tmpVariableKey] = tmpDirectiveValues[tmpVariableKey].Value[i];
 					}
+					const tmpPreviousValueKey = `prev_${tmpVariableKey}`;
+					if (!Array.isArray(tmpDirectiveValues[tmpVariableKey].Value) || (tmpDirectiveValues[tmpVariableKey].Value.length <= i))
+					{
+						tmpSeriesStepDataSourceObject[tmpPreviousValueKey] = 0;
+					}
+					else if (i == 0)
+					{
+						tmpSeriesStepDataSourceObject[tmpPreviousValueKey] = 'false';
+					}
+					else
+					{
+						tmpSeriesStepDataSourceObject[tmpPreviousValueKey] = tmpDirectiveValues[tmpVariableKey].Value[i - 1];
+					}
 				}
 
-				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpSeriesStepDataSourceObject, tmpResultsObject, pManifest);
+				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpSeriesStepDataSourceObject, tmpResultsObject, tmpManifest);
 
-				tmpValueArray.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, pManifest) );
+				tmpValueArray.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, tmpManifest) );
 
 				for (let j = 0; j < tmpMutatedValues.length; j++)
 				{
@@ -397,7 +413,6 @@ class FableServiceExpressionParser extends libFableServiceBase
 				tmpAssignmentManifestHash = tmpResultsObject.OriginalRawTokens[0];
 			}
 
-			let tmpManifest = (typeof(pManifest) === 'object') ? pManifest : this.fable.newManyfest();
 			tmpManifest.setValueByHash(tmpDataDestinationObject, tmpAssignmentManifestHash, tmpValueArray);
 
 			return tmpValueArray;
@@ -406,7 +421,7 @@ class FableServiceExpressionParser extends libFableServiceBase
 		{
 			const [ tmpSampleCount ] = this._prepareDirectiveParameters([
 				tmpResultsObject.SolverDirectives.SampleCount
-			], [ '1' ], tmpResultsObject, tmpDataSourceObject, pManifest);
+			], [ '1' ], tmpResultsObject, tmpDataSourceObject, tmpManifest);
 
 			if (isNaN(tmpSampleCount))
 			{
@@ -424,7 +439,7 @@ class FableServiceExpressionParser extends libFableServiceBase
 			{
 				let tmpVariableKey = tmpVariableKeys[i];
 				let tmpVariableDescription = tmpMonteCarloOutput.Values[tmpVariableKey];
-				
+
 				// For each variable, generate its array of sampled values
 				tmpVariableDescription.Distribution = {};
 				tmpVariableDescription.ValueSequence = [];
@@ -437,7 +452,7 @@ class FableServiceExpressionParser extends libFableServiceBase
 					let tmpPointValue = this.fable.Math.parsePrecise(tmpPointToken, NaN);
 					if (isNaN(tmpPointValue) && typeof tmpPointToken === 'string' && tmpPointToken.length > 0)
 					{
-						tmpPointValue = pManifest.getValueByHash(tmpDataSourceObject, tmpPointToken);
+						tmpPointValue = tmpManifest.getValueByHash(tmpDataSourceObject, tmpPointToken);
 						if (!tmpPointValue || (tmpPointValue == null))
 						{
 							//TODO: Warn?
@@ -497,8 +512,8 @@ class FableServiceExpressionParser extends libFableServiceBase
 				// 	tmpPreviousDomainTranslationAmount = this.fable.Math.addPrecise(tmpPreviousDomainTranslationAmount, tmpVariableDescription.DomainLength);
 				// }
 			}
-				
-			for (let i = 0; i <= tmpSampleCount - 1; i++)
+
+			for (let i = 0; i <= Number(tmpSampleCount) - 1; i++)
 			{
 				// Jimmy up the data source with the current N value, stepIndex and all the other data from the source object
 				// This generates a data source object every time on purpose so we can remarshal in values that changed in the destination
@@ -528,8 +543,8 @@ class FableServiceExpressionParser extends libFableServiceBase
 					tmpPointManifest.Distribution[tmpDistributionPointValue] = tmpPointManifest.Distribution[tmpDistributionPointValue] + 1;
 				}
 
-				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpSeriesStepDataSourceObject, tmpResultsObject, pManifest);
-				tmpMonteCarloOutput.Samples.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, pManifest ) );
+				let tmpMutatedValues = this.substituteValuesInTokenizedObjects(tmpResultsObject.PostfixTokenObjects, tmpSeriesStepDataSourceObject, tmpResultsObject, tmpManifest);
+				tmpMonteCarloOutput.Samples.push( this.solvePostfixedExpression( tmpResultsObject.PostfixSolveList, tmpDataDestinationObject, tmpResultsObject, tmpManifest ) );
 
 				for (let j = 0; j < tmpMutatedValues.length; j++)
 				{
@@ -544,7 +559,6 @@ class FableServiceExpressionParser extends libFableServiceBase
 				tmpAssignmentManifestHash = tmpResultsObject.OriginalRawTokens[0];
 			}
 
-			let tmpManifest = (typeof(pManifest) === 'object') ? pManifest : this.fable.newManyfest();
 			tmpManifest.setValueByHash(tmpDataDestinationObject, tmpAssignmentManifestHash, tmpMonteCarloOutput);
 
 			return tmpMonteCarloOutput;

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

@@ -173,8 +173,8 @@ class FableServiceMath extends libFableServiceBase
 
 	/**
 	 * Adds two values precisely.
-	 * @param {number} pLeftValue - The left value to be added.
-	 * @param {number} pRightValue - The right value to be added.
+	 * @param {number|string} pLeftValue - The left value to be added.
+	 * @param {number|string} pRightValue - The right value to be added.
 	 * @returns {string} - The result of adding the two values as a string.
 	 */
 	addPrecise(pLeftValue, pRightValue)
@@ -190,8 +190,8 @@ class FableServiceMath extends libFableServiceBase
 	/**
 	 * Subtracts two values precisely.
 	 *
-	 * @param {number} pLeftValue - The left value to subtract.
-	 * @param {number} pRightValue - The right value to subtract.
+	 * @param {number|string} pLeftValue - The left value to subtract.
+	 * @param {number|string} pRightValue - The right value to subtract.
 	 * @returns {string} The result of the subtraction as a string.
 	 */
 	subtractPrecise(pLeftValue, pRightValue)
@@ -1556,7 +1556,7 @@ class FableServiceMath extends libFableServiceBase
 	 */
 	leastSquares(pIndependentVariableVectors, pDependentVariableVector)
 	{
-		const tmpIndependentVariableVectors = Array.isArray(pIndependentVariableVectors[0]) ? pIndependentVariableVectors : pIndependentVariableVectors.map(value => [value]);
+		const tmpIndependentVariableVectors = Array.isArray(pIndependentVariableVectors[0]) ? this.matrixTranspose(pIndependentVariableVectors) : pIndependentVariableVectors.map(value => [value]);
 		// Add bias term (intercept)
 		const tmpIndependentVariableMatrixWithBiasTerm = tmpIndependentVariableVectors.map(row => [1, ...row]);
 
@@ -1756,6 +1756,27 @@ class FableServiceMath extends libFableServiceBase
 				return this.addPrecise(pEasingConfiguration.DomainRangeStart, tmpScaledValue);
 		}
 	}
+
+	/**
+	 * Predicts the dependent variable using a regression model.
+	 *
+	 * @param {Array<number|string>} pRegressionCoefficients - The regression coefficients [b0, b1, ..., bn].
+	 * @param {Array<number|string>|number|string} pIndependentVariableVector - The independent variable values [x1, x2, ..., xn] or single value for single variable.
+	 *
+	 * @return {number|string} - The predicted dependent variable value.
+	 */
+	predictFromRegressionModel(pRegressionCoefficients, pIndependentVariableVector)
+	{
+		let tmpIndependentVariableVector = pIndependentVariableVector;
+		if (!Array.isArray(pIndependentVariableVector))
+		{
+			tmpIndependentVariableVector = [ pIndependentVariableVector ];
+		}
+		return pRegressionCoefficients.slice(1).reduce((sum, b, i) =>
+			{
+				return this.addPrecise(sum, this.multiplyPrecise(b, pIndependentVariableVector[i]));
+			}, pRegressionCoefficients[0]);
+	}
 }
 
 module.exports = FableServiceMath;

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

@@ -190,9 +190,21 @@ class FableServiceUtility extends libFableServiceBase
 		return tmpValueArray;
 	}
 
+	slice(pValueArray, pStartIndex, pEndIndex)
+	{
+		if (!Array.isArray(pValueArray))
+		{
+			this.fable.log.error('Fable.Math.slice called with non-array value', { pValueArray });
+			return [];
+		}
+		const tmpStartIndex = Number(this.fable.Math.parsePrecise(pStartIndex, '0'));
+		const tmpEndIndex = Number(this.fable.Math.parsePrecise(pEndIndex, pValueArray.length.toString()));
+		return pValueArray.slice(tmpStartIndex, tmpEndIndex);
+	}
+
 	/**
 	 * Get a value array by hash/address list from the internal fable/pict state
-	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {string} pValueHashes - The manyfest hash/address of the value to get
 	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
 	 * @returns {Array} - The value array built from the hash list
 	 */
@@ -215,7 +227,7 @@ class FableServiceUtility extends libFableServiceBase
 	/**
 	 * Get a value object from a list of hash/addressese
 	 * @param {object} pObject - The object to get the value from
-	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 * @param {string} pValueHashes - The manyfest hash/address of the value to get
 	 * @param {object} [pManifest] - The manyfest object to use; constructs one inline if not provided
 	 * @returns {object} - The value object built from the hash list
 	 */

package/test/ExpressionParser_tests.js

@@ -188,6 +188,9 @@ suite
 									Expect(tmpDestinationObject.EGS).to.equal(tmpDestinationObject.EGSR);
 									testFable.ExpressionParser.Messaging.logFunctionSolve(tmpResultObject);
 									Expect(tmpDestinationObject.EGS).to.equal("0.0061");
+									_Parser.solve('MATH_DP=ROUND(1.2345, 5 - 2)',
+										tmpDataObject, tmpResultObject, false, tmpDestinationObject);
+									Expect(tmpDestinationObject.MATH_DP).to.equal("1.235");
 
 									tmpDataObject.EJBinderGb1 = '15.5';
 									tmpDataObject.EKPctBinderPb2 = '2.55555';
@@ -475,7 +478,7 @@ suite
 
 									let tmpManifest = testFable.newManyfest();
 									let tmpDataSourceObject = {};
-									tmpDataSourceObject.CitiesData = require('./data/Cities.json');
+									tmpDataSourceObject.CitiesData = require('./data/cities.json');
 									/* Records look like:
 [
 	{
@@ -873,6 +876,9 @@ suite
 
 									_Parser.solve('PreciseEquals = If("1.0000000001", "===", "1", "yes", "no")', testFable, tmpResultsObject, false, tmpDestinationObject);
 									Expect(tmpDestinationObject.PreciseEquals).to.equal('no');
+
+									_Parser.solve('Computed = If(AppData.Cities[0].latitude, "<", "50", AppData.Cities[0].latitude - 25, AppData.Cities[0].latitude + 25)', testFable, tmpResultsObject, false, tmpDestinationObject);
+									Expect(tmpDestinationObject.Computed).to.equal(testFable.AppData.Cities[0].latitude - 25);
 								}
 							);
 
@@ -899,6 +905,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);
 					}
 				);