fable 3.0.146 → 3.0.148

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

@@ -40,7 +40,8 @@ for (let i = 0; i < _Equations.Expressions.length; i++)
 	let tmpResultObject = {};
 	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, tmpResultObject, tmpManifest);
 	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
-	_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpResultObject);
+	console.log(`           Expected: ${_Equations.Expressions[i].ExpectedResult}`);
+	//_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpResultObject);
 
 	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
 	{
@@ -81,7 +82,7 @@ _ExpressionParser.substituteValuesInTokenizedObjects(tmpExpressionParseOutcome.P
 let tmpResultValue = _ExpressionParser.solvePostfixedExpression(tmpExpressionParseOutcome.PostfixSolveList, tmpSolverResultsObject, tmpExpressionParseOutcome, _FruitManifest);
 
 // Now that we have a solved expression and the mapped-in values, show the user the solution
-_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpExpressionParseOutcome);
+//_Fable.ExpressionParser.Messaging.logFunctionOutcome(tmpExpressionParseOutcome);
 
 // Step 6: Look at the results.
 console.log(`Outcome object: ${JSON.stringify(tmpSolverResultsObject)}`);

package/package.json

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

package/source/Fable.js

@@ -310,7 +310,27 @@ class Fable extends libFableServiceBase.CoreServiceProviderBase
 		}
 
 		return false;
-	}	
+	}
+
+	
+	/**
+	 * Generate a safe string to use in filenames for a date.  Useful for log file uniqueness and temporary outputs.
+	 *
+	 * @static
+	 * @param {Date} pDate - An optional javascript Date object to generate a datestamp for.
+	 * @returns {string} - A string formatted as YYYY-MM-DD-HH-MM-SS
+	 */
+	static generateFileNameDateStamp(pDate)
+	{
+		const tmpDate = pDate || new Date();
+		const tmpYear = tmpDate.getFullYear();
+		const tmpMonth = String(tmpDate.getMonth() + 1).padStart(2, '0');
+		const tmpDay = String(tmpDate.getDate()).padStart(2, '0');
+		const tmpHour = String(tmpDate.getHours()).padStart(2, '0');
+		const tmpMinute = String(tmpDate.getMinutes()).padStart(2, '0');
+		const tmpSecond = String(tmpDate.getSeconds()).padStart(2, '0');
+		return `${tmpYear}-${tmpMonth}-${tmpDay}-${tmpHour}-${tmpMinute}-${tmpSecond}`;
+	}
 }
 
 // This is for backwards compatibility

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

@@ -1,66 +1,171 @@
 const libFableServiceBase = require('fable-serviceproviderbase');
 
+/**
+ * FableServiceDataGeneration class provides various methods for generating random data.
+ * 
+ * @extends libFableServiceBase
+ */
 class FableServiceDataGeneration extends libFableServiceBase
 {
-	constructor(pFable, pOptions, pServiceHash)
-	{
-		super(pFable, pOptions, pServiceHash);
-
-		this.serviceType = 'DataGeneration';
-
-		this.defaultData = require('./Fable-Service-DataGeneration-DefaultValues.json');
-	}
-
-	// Return a random integer between pMinimum and pMaximum
-	randomIntegerBetween(pMinimum, pMaximum)
-	{
-		return Math.floor(Math.random() * (pMaximum - pMinimum)) + pMinimum;
-	}
-	// Return a random integer up to the passed-in maximum
-	randomIntegerUpTo(pMaximum)
-	{
-		return this.randomIntegerBetween(0, pMaximum);
-	}
-	// Return a random integer between 0 and 9999999
-	randomInteger()
-	{
-		return Math.floor(Math.random()*this.defaultData.DefaultIntegerMaximum);
-	}
-
-
-	randomNumericString(pLength, pMaxNumber)
-	{
-		let tmpLength = (typeof(pLength) === 'undefined') ? 10 : pLength;
-		let tmpMaxNumber = (typeof(pMaxNumber) === 'undefined') ? 9999999999 : pMaxNumber;
-
-		return this.services.DataFormat.stringPadStart(this.randomIntegerUpTo(tmpMaxNumber), pLength, '0');
-	}
-
-
-	randomMonth()
-	{
-		return this.defaultData.MonthSet[this.randomIntegerUpTo(this.defaultData.MonthSet.length-1)];
-	}
-	randomDayOfWeek()
-	{
-		return this.defaultData.WeekDaySet[this.randomIntegerUpTo(this.defaultData.WeekDaySet.length-1)];
-	}
-
-
-	randomColor()
-	{
-		return this.defaultData.ColorSet[this.randomIntegerUpTo(this.defaultData.ColorSet.length-1)];
-	}
-
-
-	randomName()
-	{
-		return this.defaultData.NameSet[this.randomIntegerUpTo(this.defaultData.NameSet.length-1)];
-	}
-	randomSurname()
-	{
-		return this.defaultData.SurNameSet[this.randomIntegerUpTo(this.defaultData.SurNameSet.length-1)];
-	}
+    constructor(pFable, pOptions, pServiceHash)
+    {
+        super(pFable, pOptions, pServiceHash);
+
+        this.serviceType = 'DataGeneration';
+
+        this.defaultData = require('./Fable-Service-DataGeneration-DefaultValues.json');
+    }
+
+    /**
+     * Generates a random integer between the specified minimum and maximum values.
+     * 
+     * @param {number} pMinimum - The minimum value (inclusive).
+     * @param {number} pMaximum - The maximum value (exclusive).
+     * @returns {number} A random integer between pMinimum and pMaximum.
+     */
+    randomIntegerBetween(pMinimum, pMaximum)
+    {
+        try
+        {
+            let tmpMinimum = parseInt(pMinimum, 10);
+            let tmpMaximum = parseInt(pMaximum, 10);
+            return Math.floor(Math.random() * (tmpMaximum - tmpMinimum)) + tmpMinimum;
+        }
+        catch (pError)
+        {
+            this.fable.log.error('Error in randomIntegerBetween', pError, { 'Minimum': pMinimum, 'Maximum': pMaximum });
+            return NaN;
+        }
+    }
+
+    /**
+     * Generates a random integer between 0 (inclusive) and the specified maximum value (exclusive).
+     * 
+     * @param {number} pMaximum - The maximum value (exclusive).
+     * @returns {number} A random integer between 0 and pMaximum.
+     */
+    randomIntegerUpTo(pMaximum)
+    {
+        return this.randomIntegerBetween(0, pMaximum);
+    }
+
+    /**
+     * Generates a random integer between 0 (inclusive) and the default maximum value.
+     * 
+     * @returns {number} A random integer between 0 and the default maximum value.
+     */
+    randomInteger()
+    {
+        return Math.floor(Math.random() * this.defaultData.DefaultIntegerMaximum);
+    }
+
+    /**
+     * Generates a random float between the specified minimum and maximum values.
+     * 
+     * @param {number} pMinimum - The minimum value (inclusive).
+     * @param {number} pMaximum - The maximum value (exclusive).
+     * @returns {number} A random float between pMinimum and pMaximum.
+     */
+    randomFloatBetween(pMinimum, pMaximum)
+    {
+        try
+        {
+            let tmpMinimum = parseFloat(pMinimum);
+            let tmpMaximum = parseFloat(pMaximum);
+            return this.fable.Math.addPrecise(this.fable.Math.multiplyPrecise(Math.random(), this.fable.Math.subtractPrecise(tmpMaximum, tmpMinimum)), tmpMinimum);
+        }
+        catch (pError)
+        {
+            this.fable.log.error('Error in randomFloatBetween', pError, { 'Minimum': pMinimum, 'Maximum': pMaximum });
+            return NaN;
+        }
+    }
+
+    /**
+     * Generates a random float between 0 (inclusive) and the specified maximum value (exclusive).
+     * 
+     * @param {number} pMaximum - The maximum value (exclusive).
+     * @returns {number} A random float between 0 and pMaximum.
+     */
+    randomFloatUpTo(pMaximum)
+    {
+        return this.randomFloatBetween(0, pMaximum);
+    }
+
+    /**
+     * Generates a random float between 0 (inclusive) and 1 (exclusive).
+     * 
+     * @returns {number} A random float between 0 and 1.
+     */
+    randomFloat()
+    {
+        return Math.random();
+    }
+
+    /**
+     * Generates a random numeric string of the specified length.
+     * 
+     * @param {number} pLength - The length of the numeric string.
+     * @param {number} pMaxNumber - The maximum number to generate.
+     * @returns {string} A random numeric string of the specified length.
+     */
+    randomNumericString(pLength, pMaxNumber)
+    {
+        let tmpLength = (typeof(pLength) === 'undefined') ? 10 : pLength;
+        let tmpMaxNumber = (typeof(pMaxNumber) === 'undefined') ? 9999999999 : pMaxNumber;
+
+        return this.services.DataFormat.stringPadStart(this.randomIntegerUpTo(tmpMaxNumber), pLength, '0');
+    }
+
+    /**
+     * Generates a random month from the default month set.
+     * 
+     * @returns {string} A random month.
+     */
+    randomMonth()
+    {
+        return this.defaultData.MonthSet[this.randomIntegerUpTo(this.defaultData.MonthSet.length - 1)];
+    }
+
+    /**
+     * Generates a random day of the week from the default week day set.
+     * 
+     * @returns {string} A random day of the week.
+     */
+    randomDayOfWeek()
+    {
+        return this.defaultData.WeekDaySet[this.randomIntegerUpTo(this.defaultData.WeekDaySet.length - 1)];
+    }
+
+    /**
+     * Generates a random color from the default color set.
+     * 
+     * @returns {string} A random color.
+     */
+    randomColor()
+    {
+        return this.defaultData.ColorSet[this.randomIntegerUpTo(this.defaultData.ColorSet.length - 1)];
+    }
+
+    /**
+     * Generates a random name from the default name set.
+     * 
+     * @returns {string} A random name.
+     */
+    randomName()
+    {
+        return this.defaultData.NameSet[this.randomIntegerUpTo(this.defaultData.NameSet.length - 1)];
+    }
+
+    /**
+     * Generates a random surname from the default surname set.
+     * 
+     * @returns {string} A random surname.
+     */
+    randomSurname()
+    {
+        return this.defaultData.SurNameSet[this.randomIntegerUpTo(this.defaultData.SurNameSet.length - 1)];
+    }
 }
 
 module.exports = FableServiceDataGeneration;

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

@@ -99,16 +99,43 @@ class ExpressionTokenizer extends libExpressionParserOperationBase
 			}
 
 			// [ TOKENS ]
-			if (tmpCharacter in this.ExpressionParser.tokenMap)
+			if (tmpCharacter in this.ExpressionParser.tokenRadix)
 			{
-				if (tmpCurrentToken.length > 0)
+				let tmpTokenRadix = this.ExpressionParser.tokenRadix[tmpCharacter];
+				// If the token is a literal and has only one entry, it is a single character token and we can just safely add it.
+				if (tmpTokenRadix.TokenCount == 1 && tmpTokenRadix.Literal)
 				{
-					tmpResults.RawTokens.push(tmpCurrentToken);
+					if (tmpCurrentToken.length > 0)
+					{
+						tmpResults.RawTokens.push(tmpCurrentToken);
+					}
+					tmpCurrentToken = '';
+					tmpCurrentTokenType = false;
+					tmpResults.RawTokens.push(tmpCharacter);
+					continue;
+				}
+				else
+				{
+					// This one has multiple options, so literals don't matter.  We need to check the token map.
+					// The token radix TokenKeys array is sorted longest to shortest
+					for (let j = 0; j < tmpTokenRadix.TokenKeys.length; j++)
+					{
+						let tmpTokenKey = tmpTokenRadix.TokenKeys[j];
+						if (pExpression.substr(i, tmpTokenKey.length) == tmpTokenKey)
+						{
+							if (tmpCurrentToken.length > 0)
+							{
+								tmpResults.RawTokens.push(tmpTokenKey);
+							}
+							tmpCurrentToken = '';
+							tmpCurrentTokenType = false;
+							tmpResults.RawTokens.push(tmpTokenKey);
+							i += tmpTokenKey.length - 1;
+							break;
+						}
+					}
+					continue;
 				}
-				tmpCurrentToken = '';
-				tmpCurrentTokenType = false;
-				tmpResults.RawTokens.push(tmpCharacter);
-				continue;
 			}
 
 			// If it's not an operator, it's a number or address.

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

@@ -83,8 +83,38 @@
 		"Name": "Round",
 		"Address": "fable.Math.roundPrecise"
 	},
-	"valuemapcount": {
-		"Name": "Histogram Count Value Map",
-		"Address": "fable.Math.valueMapCountPrecise"
+	"countSetElements": {
+		"Name": "Count Set Elements in a Histogram or Value Map",
+		"Address": "fable.Math.countSetElements"
+	},
+
+	"getvalue": {
+		"Name": "Get Value from Application State or Services (AppData, etc.)",
+		"Address": "fable.Utility.getValue"
+	},
+
+	"randominteger": {
+		"Name": "Random Integer",
+		"Address": "fable.DataGeneration.randomInteger"
+	},
+	"randomintegerbetween": {
+		"Name": "Random Integer Between Two Numbers",
+		"Address": "fable.DataGeneration.randomIntegerBetween"
+	},
+	"randomintegerupto": {
+		"Name": "Random Integer",
+		"Address": "fable.DataGeneration.randomIntegerUpTo"
+	},
+	"randomfloat": {
+		"Name": "Random Float",
+		"Address": "fable.DataGeneration.randomFloat"
+	},
+	"randomfloatbetween": {
+		"Name": "Random Float",
+		"Address": "fable.DataGeneration.randomFloatBetween"
+	},
+	"randomfloatupto": {
+		"Name": "Random Float",
+		"Address": "fable.DataGeneration.randomFloatUpTo"
 	}
 }

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

@@ -103,14 +103,14 @@ class ExpressionParserLinter extends libExpressionParserOperationBase
 		let tmpEqualityAssignmentIndex = false;
 		for (let i = 0; i < pTokenizedExpression.length; i++)
 		{
-			if (pTokenizedExpression[i] === '=')
+			if ((this.ExpressionParser.tokenMap[pTokenizedExpression[i]]) && (this.ExpressionParser.tokenMap[pTokenizedExpression[i]].Type === 'Assignment'))
 			{
 				tmpEqualityAssignmentCount++;
 				tmpEqualityAssignmentIndex = i;
 
 				if (tmpEqualityAssignmentCount > 1)
 				{
-					tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.lintTokenizedExpression found multiple equality assignments in the tokenized expression; equality assignment #${tmpEqualityAssignmentCount} at token index ${i}.`);
+					tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.lintTokenizedExpression found multiple equality assignments in the tokenized expression; equality assignment #${tmpEqualityAssignmentCount} operator '${pTokenizedExpression[i]}' at token index ${i}.`);
 					tmpResults.LinterResults.push(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
 					this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
 				}

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

@@ -70,6 +70,7 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 		let tmpResults = (typeof(pResultObject) === 'object') ? pResultObject : { ExpressionParserLog: [] };
 
 		tmpResults.PostfixedAssignmentAddress = 'Result'
+		tmpResults.PostfixedAssignmentOperator = this.ExpressionParser.tokenMap['=']; // This is the default assignment operator
 		tmpResults.PostfixTokenObjects = [];
 		tmpResults.PostfixSolveList = [];
 
@@ -84,16 +85,19 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 		let tmpEqualsIndex = -1;
 		for (let i = 0; i < pTokenizedExpression.length; i++)
 		{
-			if ((pTokenizedExpression[i] === '=') && (tmpEqualsIndex < 0))
+			if ((this.ExpressionParser.tokenMap[pTokenizedExpression[i]]) && (this.ExpressionParser.tokenMap[pTokenizedExpression[i]].Type === 'Assignment'))
 			{
-				tmpEqualsIndex = i;
-			}
-			// If there are two equality assignments, error and bail out.
-			else if (pTokenizedExpression[i] === '=')
-			{
-				tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.buildPostfixedSolveList found multiple equality assignments in the tokenized expression; equality assignment #${tmpEqualsIndex} at token index ${i}.`);
-				this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
-				return tmpResults.PostfixTokenObjects;
+				if (tmpEqualsIndex < 0)
+				{
+					tmpEqualsIndex = i;
+					tmpResults.PostfixedAssignmentOperator = this.ExpressionParser.tokenMap[pTokenizedExpression[i]];
+				}
+				else
+				{
+					tmpResults.ExpressionParserLog.push(`ERROR: ExpressionParser.buildPostfixedSolveList found multiple assignment operators in the tokenized expression; assignment operator '${pTokenizedExpression[i]}' #${tmpEqualsIndex} at token index ${i}.`);
+					this.log.error(tmpResults.ExpressionParserLog[tmpResults.ExpressionParserLog.length-1]);
+					return tmpResults.PostfixTokenObjects;
+				}
 			}
 		}
 
@@ -563,6 +567,7 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 			// If this is a layer with one value, presume it's an assignment.
 			if (tmpSolveLayerTokens.length === 1)
 			{
+				// TODO: I think this is correct but with the addition of multiple assignment operators it's less clear.
 				let tmpAbstractAssignToken = this.getTokenContainerObject('=');
 				tmpAbstractAssignToken.VirtualSymbolName = tmpResults.PostfixLayerstackMap[tmpSolveLayerTokens[0].SolveLayerStack];
 				// If this doesn't have a matching solvelayerstack, get the virtual symbol name from the parenthesis group it's in
@@ -637,7 +642,7 @@ class ExpressionParserPostfix extends libExpressionParserOperationBase
 		}
 
 		// 7. Lastly set the assignment address.
-		let tmpAbstractAssignToken = this.getTokenContainerObject('=');
+		let tmpAbstractAssignToken = ('PostfixedAssignmentOperator' in tmpResults) ? this.getTokenContainerObject(tmpResults.PostfixedAssignmentOperator.Token) : this.getTokenContainerObject('=');
 		// The address we are assigning to
 		tmpAbstractAssignToken.VirtualSymbolName = tmpResults.PostfixedAssignmentAddress;
 		// The address it's coming from

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

@@ -178,8 +178,22 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 		{
 			if (pPostfixedExpression[i].RightValue.Type === 'Token.SolverMarshal')
 			{
+				// Set the result in the virtual symbols
 				tmpManifest.setValueAtAddress(tmpResults.VirtualSymbols, pPostfixedExpression[i].VirtualSymbolName, tmpSolverResultValue);
-				tmpManifest.setValueByHash(tmpDataDestinationObject, pPostfixedExpression[i].VirtualSymbolName, tmpSolverResultValue);
+				// Set the value in the destination object
+				if (pPostfixedExpression[i].Operation.Descriptor.OnlyEmpty)
+				{
+					// If it is only on "empty" values, check if the value is empty before assigning
+					if (this.fable.Utility.addressIsNullOrEmpty(tmpDataDestinationObject, pPostfixedExpression[i].VirtualSymbolName))
+					{
+						tmpManifest.setValueByHash(tmpDataDestinationObject, pPostfixedExpression[i].VirtualSymbolName, tmpSolverResultValue);
+					}
+				}
+				else
+				{
+					// Otherwise, just assign it.
+					tmpManifest.setValueByHash(tmpDataDestinationObject, pPostfixedExpression[i].VirtualSymbolName, tmpSolverResultValue);
+				}
 			}
 		}
 		tmpResults.RawResult = tmpSolverResultValue;
@@ -190,7 +204,14 @@ class ExpressionParserSolver extends libExpressionParserOperationBase
 			delete tmpResults.fable;
 		}
 
-		return tmpSolverResultValue.toString();
+		if (typeof(tmpSolverResultValue) !== 'undefined')
+		{
+			return tmpSolverResultValue.toString();
+		}
+		else
+		{
+			return tmpSolverResultValue;
+		}
 	}
 }
 

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

@@ -1,13 +1,23 @@
 {
 	"=":
 		{
-			"Name": "Equals",
+			"Name": "Assign Value",
 			"Token": "=",
 			"Function": "fable.Math.assignValue",
 			"Precedence": 0,
 			"Type": "Assignment"
 		},
 
+	"?=":
+		{
+			"Name": "Null or Empty Coalescing Assign Value",
+			"Token": "?=",
+			"Function": "fable.Math.assignValue",
+			"OnlyEmpty": true,
+			"Precedence": 0,
+			"Type": "Assignment"
+		},
+
 	"(":
 		{
 			"Name": "Left Parenthesis",

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

@@ -39,8 +39,47 @@ class FableServiceExpressionParser extends libFableServiceBase
 
 		// The configuration for tokens that the solver recognizes, with precedence and friendly names.
 		this.tokenMap = require('./Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-TokenMap.json');
-		// This precedence is higher than defined in our token map.  We could make this value dynamic
-		this.tokenMaxPrecedence = 10;
+
+		// Keep track of maximum token precedence
+		this.tokenMaxPrecedence = 4;
+		// This isn't exactly a radix tree but close enough.  It's a map of the first character of the token to the token.
+		this.tokenRadix = {};
+		let tmpTokenKeys = Object.keys(this.tokenMap);
+		for (let i = 0; i < tmpTokenKeys.length; i++)
+		{
+			let tmpTokenKey = tmpTokenKeys[i];
+			let tmpToken = this.tokenMap[tmpTokenKey];
+
+			tmpToken.Token = tmpTokenKey;
+			tmpToken.Length = tmpTokenKey.length;
+
+			let tmpTokenStartCharacter = tmpToken.Token[0];
+			if (!(tmpTokenStartCharacter in this.tokenRadix))
+			{
+				// With a token count of 1 and a literal of true, we can assume it being in the radix is the token.
+				this.tokenRadix[tmpTokenStartCharacter] = (
+					{
+						TokenCount: 0,
+						Literal: false,
+						TokenKeys: [],
+						TokenMap: {}
+					});
+			}
+
+			this.tokenRadix[tmpTokenStartCharacter].TokenCount++;
+			if (tmpTokenKey == tmpTokenStartCharacter)
+			{
+				this.tokenRadix[tmpTokenStartCharacter].Literal = true;
+			}
+			this.tokenRadix[tmpTokenStartCharacter].TokenMap[tmpToken.Token] = tmpToken;
+			this.tokenRadix[tmpTokenStartCharacter].TokenKeys.push(tmpTokenKey);
+			this.tokenRadix[tmpTokenStartCharacter].TokenKeys.sort((pLeft, pRight) => pRight.length - pLeft.length);
+
+			if (this.tokenMaxPrecedence < tmpToken.Precedence)
+			{
+				this.tokenMaxPrecedence = tmpToken.Precedence;
+			}
+		}
 
 		// The configuration for which functions are available to the solver.
 		this.functionMap = require('./Fable-Service-ExpressionParser/Fable-Service-ExpressionParser-FunctionMap.json');

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

@@ -126,7 +126,7 @@ class FableServiceMath extends libFableServiceBase
 	{
 		let tmpValue = isNaN(pValue) ? 0 : pValue;
 		let tmpDecimals = isNaN(pDecimals) ? 0 : parseInt(pDecimals, 10);
-		let tmpRoundingMethod = (typeof (pRoundingMethod) === 'undefined') ? this.roundHalfUp : pRoundingMethod;
+		let tmpRoundingMethod = (typeof (pRoundingMethod) === 'undefined') ? this.roundHalfUp : parseInt(pRoundingMethod, 10);
 
 		let tmpArbitraryValue = new this.fable.Utility.bigNumber(tmpValue);
 		let tmpResult = tmpArbitraryValue.round(tmpDecimals, tmpRoundingMethod);
@@ -561,27 +561,6 @@ class FableServiceMath extends libFableServiceBase
 		return this.bucketSetPrecise(pValueSet);
 	}
 
-	/**
-	 * 
-	 * @param {Array<Object>} pValueSet - An array of objects
-	 * @param {string} pValueMapAddress - The address in each object to find the value to count in the histogram.  Undefined will be 'Unknown'.
-	 */
-	valueMapCountPrecise(pValueSet, pValueMapAddress)
-	{
-		let tmpHistogram = {};
-
-		this.log.info(`ValueSet is a ${typeof(pValueSet)}`);
-		this.log.info(`ValueMapAddress is ${pValueMapAddress}`);
-
-		return tmpHistogram;
-	}
-
-	valueMapSumPrecise(pValueSet, pValueMapAddress, pValueMapAmount)
-	{
-
-	}
-
-
 	/**
 	 * Sorts the histogram object in ascending order based on the frequencies of the buckets.
 	 * 
@@ -601,7 +580,6 @@ class FableServiceMath extends libFableServiceBase
 		}
 
 		return tmpSortedHistogram;
-
 	}
 
 	/**

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

@@ -92,6 +92,51 @@ class FableServiceUtility extends libFableServiceBase
 
 		return tmpChunkCache;
 	}
+	
+	/**
+	 * Get a value from fable/pict by hash/address
+	 * @param {string} pValueAddress - The manyfest hash/address of the value to get
+	 */
+	getValue(pValueAddress)
+	{
+		// Lazily create a manifest if it doesn't exist
+		if (!this.manifest)
+		{
+			this.manifest = this.fable.newManyfest();
+		}
+
+		// Get the value from the internal manifest and return it
+		return this.manifest.getValueByHash(this.fable, pValueAddress);
+	}
+	
+	/**
+	 * Check if a value is null or empty
+	 * @param {object} pObject - The object to check
+	 * @param {string} pValueAddress - The manyfest hash/address to check
+	 */
+	addressIsNullOrEmpty(pObject, pValueAddress)
+	{
+		// Lazily create a manifest if it doesn't exist
+		if (!this.manifest)
+		{
+			this.manifest = this.fable.newManyfest();
+		}
+
+		// If it doesn't exist, it is null or empty.
+		if (!this.manifest.checkAddressExists(pObject, pValueAddress))
+		{
+			return true;
+		}
+
+		// Get the value from the internal manifest and return it
+		let tmpValue = this.manifest.getValueByHash(pObject, pValueAddress);
+		if (tmpValue === null || tmpValue === '')
+		{
+			return true;
+		}
+
+		return false;
+	}
 
 	// Convert an ISO string to a javascript date object
 	// Adapted from https://stackoverflow.com/a/54751179