fable 3.1.23 → 3.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fable",
-  "version": "3.1.23",
+  "version": "3.1.24",
   "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

@@ -125,10 +125,20 @@
 	},
 
 	"cumulativesummation": {
-		"Name": "Count Set Elements in a Histogram or Value Map",
+		"Name": "Sum each value in a Histogram or Value Map cumulatively, creating or setting a property with the result on each row",
 		"Address": "fable.Math.cumulativeSummation"
 	},
 
+	"subtractingSummation": {
+		"Name": "Subtract each subsequent value in a Histogram or Value Map cumulatively (by default from the first row), creating or setting a property with the result on each row.",
+		"Address": "fable.Math.subtractingSummation"
+	},
+
+	"iterativeseries": {
+		"Name": "Perform an Iterative Series of Mathematical Operations on Set Elements",
+		"Address": "fable.Math.iterativeSeries"
+	},
+
 	"countsetelements": {
 		"Name": "Count Set Elements in a Histogram or Value Map",
 		"Address": "fable.Math.countSetElements"

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

@@ -1101,9 +1101,54 @@ class FableServiceMath extends libFableServiceBase
 	/**
 	 * Expects an array of objects, and an address in each object to sum.  Expects 
 	 * an address to put the cumulative summation as well.
-	 * @param {Array} pValueObjectSet 
+	 * 
+	 * @param {Array} pValueObjectSet - The array of objects to perform a cumulative summation on
+	 * @param {string} pValueAddress - The address of the column in each object to sum
+	 * @param {string} pCumulationResultAddress - The address in each object to put the cumulative summation result
+	 * @param {Object} pManifest - The manifest to use for value retrieval and setting
+	 * @returns {Array} The updated value object set with cumulative summation results.
 	 */
 	cumulativeSummation(pValueObjectSet, pValueAddress, pCumulationResultAddress, pManifest)
+	{
+		return this.iterativeSeries(pValueObjectSet, pValueAddress, pCumulationResultAddress, "1.0", "add", "0.0", true, pManifest);
+	}
+
+	/**
+	 * Expects an array of objects, and an address in each object to sum.  Expects 
+	 * an address to put the cumulative summation as well.
+	 * 
+	 * @param {Array} pValueObjectSet - The array of objects to perform a cumulative summation on
+	 * @param {string} pValueAddress - The address of the column in each object to sum
+	 * @param {string} pCumulationResultAddress - The address in each object to put the cumulative summation result
+	 * @param {string} pStartingValue - The (optional) address of the value to start with
+	 * @param {Object} pManifest - The manifest to use for value retrieval and setting
+	 * @returns {Array} The updated value object set with cumulative summation results.
+	 */
+	subtractingSummation(pValueObjectSet, pValueAddress, pCumulationResultAddress, pStartingValue, pManifest)
+	{
+		let tmpProcessFirstRow = true;
+		// If the starting value comes from somewhere else, we want to subtract the first row from it.
+		if (typeof (pStartingValue) === 'undefined' || pStartingValue === null)
+		{
+			tmpProcessFirstRow = false;
+		}
+		return this.iterativeSeries(pValueObjectSet, pValueAddress, pCumulationResultAddress, "1.0", "subtract", pStartingValue, tmpProcessFirstRow, pManifest);
+	}
+
+	/**
+	 * Expects an array of objects, and an address in each object to perform an iterative mathematical operation on.
+
+	 * @param {Array} pValueObjectSet - The array of objects to perform a cumulative summation on
+	 * @param {string} pValueAddress - The address of the column in each object to sum
+	 * @param {string} pValueMultiplier - The multiplier to apply to each value before summation
+	 * @param {string} pSummationOperation - The operation to perform for summation: +, -, *, / (and some textual equivalents)
+	 * @param {string} pCumulationResultAddress - The address in each object to put the cumulative summation result
+	 * @param {string} pStartingValue - The address of the value to process from; defaults to the first row
+	 * @param {boolean} pProcessFirstRowWithAValue - Whether to process the first row's value from all subsequent rows
+	 * @param {Object} pManifest - The manifest to 
+	 * @returns {Array} The updated value object set with cumulative summation results.
+	 */
+	iterativeSeries(pValueObjectSet, pValueAddress, pCumulationResultAddress, pValueMultiplier, pSummationOperation, pStartingValue, pProcessFirstRowWithAValue, pManifest)
 	{
 		if (!Array.isArray(pValueObjectSet))
 		{
@@ -1115,18 +1160,86 @@ class FableServiceMath extends libFableServiceBase
 			return pValueObjectSet;
 		}
 
-		let tmpSummationValue = '0.0';
+		// By default don't subtract the first row from the value
+		let tmpProcessFirstRow = (typeof(pProcessFirstRowWithAValue) === 'undefined') ? false : pProcessFirstRowWithAValue;
+
+		let tmpValueMultiplier;
+		if (pValueMultiplier && pValueMultiplier !== '')
+		{
+			tmpValueMultiplier = this.parsePrecise(pValueMultiplier);
+		}
+		if (isNaN(tmpValueMultiplier))
+		{
+			tmpValueMultiplier = this.parsePrecise("1.0");
+		}
+
+		// Default to start from the current value address
+		let tmpSummationValue;
+		// This logic ensures we don't default to 0 when pStartingValue is an empty string
+		if (pStartingValue || (pStartingValue !== ''))
+		{
+			tmpSummationValue = this.parsePrecise(pStartingValue);
+		}
+		if (isNaN(tmpSummationValue) || typeof(pStartingValue) === 'undefined' || pStartingValue === null)
+		{
+			tmpSummationValue = '';
+		}
+
 		for (let i = 0; i < pValueObjectSet.length; i++)
 		{
 			let tmpValue = this.parsePrecise(this.fable.Utility.getValueByHash(pValueObjectSet[i], pValueAddress, pManifest));
+			// Since summation might start on a row after the first, 
+			let tmpFirstRowWithValue = false;
+			if ((tmpSummationValue === '') && tmpValue && !isNaN(tmpSummationValue))
+			{
+				// Try to grab the summation value from the first row with a value
+				tmpSummationValue = tmpValue;
+				tmpFirstRowWithValue = true;
+			}
 
+			// Continue on with the values as they are if the current row doesn't have a change
 			if (isNaN(tmpValue))
 			{
 				this.fable.Utility.setValueByHash(pValueObjectSet[i], pCumulationResultAddress, tmpSummationValue, pManifest);
 				continue;
 			}
 
-			tmpSummationValue = this.addPrecise(tmpValue, tmpSummationValue);
+			tmpValue = this.multiplyPrecise(tmpValue, tmpValueMultiplier);
+
+			// Now perform the operation
+			if (!tmpFirstRowWithValue || tmpProcessFirstRow)
+			{
+				switch (pSummationOperation)
+				{
+					case '+':
+					case 'add':
+					case 'plus':
+					case 'addition':
+						tmpSummationValue = this.addPrecise(tmpSummationValue, tmpValue);
+						break;
+
+					case '-':
+					case 'sub':
+					case 'minus':
+					case 'subtract':
+						tmpSummationValue = this.subtractPrecise(tmpSummationValue, tmpValue);
+						break;
+
+					case '*':
+					case 'mul':
+					case 'times':
+					case 'multiply':
+						tmpSummationValue = this.multiplyPrecise(tmpSummationValue, tmpValue);
+						break;
+
+					case '-':
+					case 'div':
+					case 'over':
+					case 'divide':
+						tmpSummationValue = this.dividePrecise(tmpSummationValue, tmpValue);
+						break;
+				}
+			}
 			this.fable.Utility.setValueByHash(pValueObjectSet[i], pCumulationResultAddress, tmpSummationValue, pManifest);
 		}
 

package/test/ExpressionParser_tests.js

@@ -177,6 +177,30 @@ suite
 					}
 				);
 				test
+				(
+					'Test iterative series',
+					(fDone)=>
+					{
+						let testFable = new libFable();
+						let _Parser = testFable.instantiateServiceProviderIfNotExists('ExpressionParser');
+
+						let tmpResult = _Parser.solve('Result = ITERATIVESERIES(Values, "Value", "Resultant", 1, "add")',
+							{
+								Values: [
+									{Value: 10},
+									{Value: 20},
+									{Value: 5}
+								]
+							});
+
+						Expect(tmpResult[0].Resultant).to.equal("10");
+						Expect(tmpResult[1].Resultant).to.equal("30");
+						Expect(tmpResult[2].Resultant).to.equal("35");
+
+						return fDone();
+					}
+				)
+				test
 				(
 					'Exercise End-to-End Expression Parsing',
 					(fDone)=>

package/test/Math_test.js

@@ -113,6 +113,100 @@ suite
 						Expect(tmpTestValueSet[4].RunningTotal).to.equal('18.95');
 						Expect(tmpTestValueSet[5].RunningTotal).to.equal('20.44');
 
+						tmpTestValueSet = (
+							[
+								{ Item: 'NoCost', Quantity: 2 },
+								...tmpTestValueSet
+							]);
+
+						testFable.Math.cumulativeSummation(tmpTestValueSet, 'Price', 'RunningTotal');
+
+						Expect(tmpTestValueSet[0].RunningTotal).to.equal('0');
+						Expect(tmpTestValueSet[1].RunningTotal).to.equal('7.99');
+						Expect(tmpTestValueSet[2].RunningTotal).to.equal('11.98');
+						Expect(tmpTestValueSet[3].RunningTotal).to.equal('13.97');
+						Expect(tmpTestValueSet[4].RunningTotal).to.equal('16.96');
+						Expect(tmpTestValueSet[5].RunningTotal).to.equal('18.95');
+						Expect(tmpTestValueSet[6].RunningTotal).to.equal('20.44');
+
+						return fDone();
+					}
+				);
+
+				test
+				(
+					'Subtractive Summation',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						let tmpTestValueSet = (
+							[
+								{ Item: 'GroceryBag', Volume: '150.00' },
+
+								{ Item: 'Lettuce', Volume: '80' },
+								{ Item: 'Tomato', Volume: '30.17' },
+								{ Item: 'Onion', Volume: '10.9' },
+								{ Item: 'Cucumber', Volume: '15.032' }
+							]);
+
+						testFable.Math.subtractingSummation(tmpTestValueSet, 'Volume', 'SpaceLeftInBag');
+
+						Expect(tmpTestValueSet[0].SpaceLeftInBag).to.equal('150');
+						Expect(tmpTestValueSet[1].SpaceLeftInBag).to.equal('70');
+						Expect(tmpTestValueSet[2].SpaceLeftInBag).to.equal('39.83');
+						Expect(tmpTestValueSet[3].SpaceLeftInBag).to.equal('28.93');
+						Expect(tmpTestValueSet[4].SpaceLeftInBag).to.equal('13.898');
+
+						return fDone();
+					}
+				);
+
+				test
+				(
+					'Iterative Series Operations',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						let tmpTestValueSet = (
+							[
+								{ Item: 'FirstSplit', Amount: '8' },
+								{ Item: 'SecondSplit', Amount: '2' },
+								{ Item: 'ThirdSplit', Amount: '4' },
+								{ Item: 'FourthSplit', Amount: '2' }
+							]);
+
+						testFable.Math.iterativeSeries(tmpTestValueSet, 'Amount', 'RAMLeft', '1.25', 'divide', '1024', true);
+						Expect(tmpTestValueSet[0].RAMLeft).to.equal('102.4');
+						Expect(tmpTestValueSet[1].RAMLeft).to.equal('40.96');
+						Expect(tmpTestValueSet[2].RAMLeft).to.equal('8.192');
+						Expect(tmpTestValueSet[3].RAMLeft).to.equal('3.2768');
+
+						testFable.Math.iterativeSeries(tmpTestValueSet, 'Amount', 'RAMLeft', '1.0', 'divide', '1024', true);
+						Expect(tmpTestValueSet[0].RAMLeft).to.equal('128');
+						Expect(tmpTestValueSet[1].RAMLeft).to.equal('64');
+						Expect(tmpTestValueSet[2].RAMLeft).to.equal('16');
+						Expect(tmpTestValueSet[3].RAMLeft).to.equal('8');
+
+						testFable.Math.iterativeSeries(tmpTestValueSet, 'Amount', 'RAMLeft', '0.7512', 'mul', '1024', true);
+						Expect(tmpTestValueSet[0].RAMLeft).to.equal('6153.8304');
+						Expect(tmpTestValueSet[1].RAMLeft).to.equal('9245.51479296');
+						Expect(tmpTestValueSet[2].RAMLeft).to.equal('27780.922849886208');
+						Expect(tmpTestValueSet[3].RAMLeft).to.equal('41738.0584896690388992');
+
+						testFable.Math.iterativeSeries(tmpTestValueSet, 'Amount', 'RAMLeft', null, 'sub');
+						Expect(tmpTestValueSet[0].RAMLeft).to.equal('8');
+						Expect(tmpTestValueSet[1].RAMLeft).to.equal('6');
+						Expect(tmpTestValueSet[2].RAMLeft).to.equal('2');
+						Expect(tmpTestValueSet[3].RAMLeft).to.equal('0');
+
+						testFable.Math.iterativeSeries(tmpTestValueSet, 'Amount', 'RAMLeft', undefined, 'sub', 1100);
+						Expect(tmpTestValueSet[0].RAMLeft).to.equal('1092');
+						Expect(tmpTestValueSet[1].RAMLeft).to.equal('1090');
+						Expect(tmpTestValueSet[2].RAMLeft).to.equal('1086');
+						Expect(tmpTestValueSet[3].RAMLeft).to.equal('1084');
+
 						return fDone();
 					}
 				);
@@ -128,6 +222,7 @@ suite
 						// 3.3333333333333333333333333333333 in the current node.js implementation collapses to 3.3333333333333335
 						Expect(testFable.Math.parsePrecise('4.3333333333333333333333333333333')).to.equal('4.3333333333333333333333333333333');
 						Expect(testFable.Math.parsePrecise(undefined)).to.equal('0.0');
+						Expect(testFable.Math.parsePrecise('')).to.equal('0.0');
 
 						return fDone();
 					}