fable 3.0.113 → 3.0.115

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "fable",
-    "version": "3.0.113",
-    "description": "An entity behavior management and API bundling library.",
+    "version": "3.0.115",
+    "description": "Anentity behavior management and API bundling library.",
     "main": "source/Fable.js",
     "scripts": {
         "start": "node source/Fable.js",

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

@@ -254,7 +254,7 @@ class DataFormat extends libFableServiceProviderBase
 	 * @param {*} pValue
 	 * @returns {string}
 	 */
-	formatterDollars (pValue)
+	formatterDollars (pValue, pPrecision, pRoundingMethod)
 	{
 		if (isNaN(pValue))
 		{
@@ -266,23 +266,9 @@ class DataFormat extends libFableServiceProviderBase
 			return this._Value_NaN_Currency;
 		}
 
-		let tmpDollarAmountArbitrary = this.fable.Utility.bigNumber(pValue);
-		let tmpDollarAmount = tmpDollarAmountArbitrary.toFixed(2);
-
-		if (isNaN(tmpDollarAmount))
-		{
-			// Try again and see if what was passed in was a dollars string.
-			if (typeof(pValue) == 'string')
-			{
-				// TODO: Better rounding function?  This is a hack to get rid of the currency symbol and commas.
-				tmpDollarAmount = parseFloat(pValue.replace(this._Value_MoneySign_Currency,'').replace(this._Regex_formatterDollarsRemoveCommas,'')).toFixed(2);
-			}
-			// If we didn't get a number, return the "not a number" string.
-			if (isNaN(tmpDollarAmount))
-			{
-				return this._Value_NaN_Currency;
-			}
-		}
+		let tmpDollarAmountArbitrary = this.fable.Math.parsePrecise(pValue);
+		let tmpPrecision = (typeof(pPrecision) == 'undefined') ? 2 : pPrecision;
+		let tmpDollarAmount = this.fable.Math.toFixedPrecise(tmpDollarAmountArbitrary, tmpPrecision, pRoundingMethod);
 
 		// TODO: Get locale data and use that for this stuff.
 		return `$${this.formatterAddCommasToNumber(tmpDollarAmount)}`;

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

@@ -3,7 +3,7 @@ const libFableServiceBase = require('fable-serviceproviderbase');
 /**
 * Arbitrary Precision Math Operations
 * @author      Steven Velozo <steven@velozo.com>
-* @description Simple functions that perform arbitrary precision math operations and return string resultant values.
+* @description Simple functions that perform arbitrary precision math operations and return string resultant values.  Wraps big.js
 */
 
 class FableServiceMath extends libFableServiceBase
@@ -15,22 +15,78 @@ class FableServiceMath extends libFableServiceBase
         this.serviceType = 'Math';
 	}
 
-	parsePrecise(pValue)
+
+/*
+	Rounding Methods:
+
+	Property	   Value   BigDecimal Equiv   Description
+	----------     -----   ----------------   -----------
+	roundDown      0       ROUND_DOWN         Rounds towards zero. (_I.e. truncate, no rounding._)
+	roundHalfUp    1       ROUND_HALF_UP      Rounds towards nearest neighbour. (_If equidistant, rounds away from zero._)
+	roundHalfEven  2       ROUND_HALF_EVEN    Rounds towards nearest neighbour. (_If equidistant, rounds towards even neighbour._)
+	roundUp        3       ROUND_UP           Rounds positively away from zero. (_Always round up._)
+*/
+	get roundDown() { return this.fable.Utility.bigNumber.roundDown; }
+	get roundHalfUp() { return this.fable.Utility.bigNumber.roundHalfUp; }
+	get roundHalfEven() { return this.fable.Utility.bigNumber.roundHalfEven; }
+	get roundUp() { return this.fable.Utility.bigNumber.roundUp; }
+
+	parsePrecise(pValue, pNonNumberValue)
 	{
-		let tmpNumber = "0.0";
+		let tmpNumber;
 
 		try
 		{
-		    tmpNumber = new this.fable.Utility.bigNumber(pValue);
+			tmpNumber = new this.fable.Utility.bigNumber(pValue);
 		}
 		catch(pError)
 		{
-		    console.log(`Error parsing number (type ${typeof(pValue)}): ${pError}`);
+			this.log.warn(`Error parsing number (type ${typeof(pValue)}): ${pError}`);
+			tmpNumber = (typeof(pNonNumberValue) === 'undefined') ? "0.0" : pNonNumberValue;
 		}
 
 		return tmpNumber.toString();
 	}
 
+	percentagePrecise(pIs, pOf)
+	{
+		let tmpLeftValue = isNaN(pIs) ? 0 : pIs;
+		let tmpRightValue = isNaN(pOf) ? 0 : pOf;
+
+		if (tmpRightValue == 0)
+		{
+			return '0';
+		}
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.div(tmpRightValue);
+		tmpResult = tmpResult.times(100);
+		return tmpResult.toString();
+	}
+
+	roundPrecise(pValue, pDecimals, pRoundingMethod)
+	{
+		let tmpValue = isNaN(pValue) ? 0 : pValue;
+		let tmpDecimals = isNaN(pDecimals) ? 0 : pDecimals;
+		let tmpRoundingMethod = (typeof(pRoundingMethod) === 'undefined') ? this.roundHalfUp : pRoundingMethod;
+
+		let tmpArbitraryValue = new this.fable.Utility.bigNumber(tmpValue);
+		let tmpResult = tmpArbitraryValue.round(tmpDecimals, tmpRoundingMethod);
+		return tmpResult.toString();
+	}
+
+	toFixedPrecise(pValue, pDecimals, pRoundingMethod)
+	{
+		let tmpValue = isNaN(pValue) ? 0 : pValue;
+		let tmpDecimals = isNaN(pDecimals) ? 0 : pDecimals;
+		let tmpRoundingMethod = (typeof(pRoundingMethod) === 'undefined') ? this.roundHalfUp : pRoundingMethod;
+
+		let tmpArbitraryValue = new this.fable.Utility.bigNumber(tmpValue);
+		let tmpResult = tmpArbitraryValue.toFixed(tmpDecimals, tmpRoundingMethod);
+	
+		return tmpResult.toString();
+	}
+
 	addPrecise(pLeftValue, pRightValue)
 	{
 		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
@@ -51,6 +107,16 @@ class FableServiceMath extends libFableServiceBase
 		return tmpResult.toString();
 	}
 
+	powerPrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		let tmpResult = tmpLeftArbitraryValue.pow(tmpRightValue);
+		return tmpResult.toString();
+	}
+
 	multiplyPrecise(pLeftValue, pRightValue)
 	{
 		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
@@ -71,21 +137,78 @@ class FableServiceMath extends libFableServiceBase
 		return tmpResult.toString();
 	}
 
-	percentagePrecise(pIs, pOf)
+	modPrecise(pLeftValue, pRightValue)
 	{
-		let tmpLeftValue = isNaN(pIs) ? 0 : pIs;
-		let tmpRightValue = isNaN(pOf) ? 0 : pOf;
-
-		if (tmpRightValue == 0)
-		{
-			return '0';
-		}
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
 
 		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
-		let tmpResult = tmpLeftArbitraryValue.div(tmpRightValue);
-		tmpResult = tmpResult.times(100);
+		let tmpResult = tmpLeftArbitraryValue.mod(tmpRightValue);
+		return tmpResult.toString();
+	}
+
+	sqrtPrecise(pValue)
+	{
+		let tmpValue = isNaN(pValue) ? 0 : pValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpValue);
+		let tmpResult = tmpLeftArbitraryValue.sqrt();
+		return tmpResult.toString();
+	}
+
+	absPrecise(pValue)
+	{
+		let tmpValue = isNaN(pValue) ? 0 : pValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpValue);
+		let tmpResult = tmpLeftArbitraryValue.abs();
 		return tmpResult.toString();
 	}
+
+	comparePrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		return tmpLeftArbitraryValue.cmp(tmpRightValue);
+	}
+
+	gtPrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		return tmpLeftArbitraryValue.gt(tmpRightValue);
+	}
+
+	gtePrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		return tmpLeftArbitraryValue.gte(tmpRightValue);
+	}
+
+	ltPrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		return tmpLeftArbitraryValue.lt(tmpRightValue);
+	}
+
+	ltePrecise(pLeftValue, pRightValue)
+	{
+		let tmpLeftValue = isNaN(pLeftValue) ? 0 : pLeftValue;
+		let tmpRightValue = isNaN(pRightValue) ? 0 : pRightValue;
+
+		let tmpLeftArbitraryValue = new this.fable.Utility.bigNumber(tmpLeftValue);
+		return tmpLeftArbitraryValue.lt(tmpRightValue);
+	}
 }
 
 module.exports = FableServiceMath;

package/test/Math_test.js

@@ -38,6 +38,27 @@ suite
 						Expect(testFable.Math.multiplyPrecise(1, 1)).to.equal('1');
 						Expect(testFable.Math.dividePrecise(1, 1)).to.equal('1');
 						Expect(testFable.Math.percentagePrecise(1, 1)).to.equal('100');
+						Expect(testFable.Math.percentagePrecise(1, 0)).to.equal('0');
+						Expect(testFable.Math.percentagePrecise(0, 1)).to.equal('0');
+						Expect(testFable.Math.percentagePrecise(0, 0)).to.equal('0');
+						Expect(testFable.Math.percentagePrecise(500, 100)).to.equal('500');
+						Expect(testFable.Math.percentagePrecise(100, 500)).to.equal('20');
+
+						Expect(testFable.Math.powerPrecise(4,4)).to.equal('256');
+						Expect(testFable.Math.powerPrecise(5,2)).to.equal('25');
+						Expect(testFable.Math.powerPrecise(50,7)).to.equal('781250000000');
+						Expect(testFable.Math.sqrtPrecise(4)).to.equal('2');
+
+						Expect(testFable.Math.gtPrecise(4, 5)).to.equal(false);
+						Expect(testFable.Math.gtePrecise(1000, 5)).to.equal(true);
+						Expect(testFable.Math.ltePrecise(1000, 5)).to.equal(false);
+						Expect(testFable.Math.ltPrecise(4, 5)).to.equal(true);
+
+						Expect(testFable.Math.comparePrecise(4, 5)).to.equal(-1);
+						
+						Expect(testFable.Math.modPrecise(4.939323, 4)).to.equal('0.939323');
+
+						Expect(testFable.Math.absPrecise('-492')).to.equal('492');
 						
 						return fDone();
 					}
@@ -57,6 +78,79 @@ suite
 						return fDone();
 					}
 				);
+
+				test
+				(
+					'Round Numbers',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						Expect(testFable.Math.roundPrecise(1.123456789, 2)).to.equal('1.12');
+						Expect(testFable.Math.roundPrecise(1.123456789, 4)).to.equal('1.1235');
+						Expect(testFable.Math.roundPrecise(1.123456789, 8)).to.equal('1.12345679');
+						Expect(testFable.Math.roundPrecise(1.123456789, 10)).to.equal('1.123456789');
+						Expect(testFable.Math.roundPrecise(1.123456789, 12)).to.equal('1.123456789');
+						Expect(testFable.Math.roundPrecise(1.123456789, 14)).to.equal('1.123456789');
+
+						Expect(testFable.Math.roundPrecise(undefined, 2)).to.equal('0');
+
+						try
+						{
+							testFable.Math.roundPrecise(null, 2, testFable.Math.roundHalfUp)
+						}
+						catch(pError)
+						{
+							Expect(pError).to.be.an.instanceof(Error);
+							Expect(pError.message).to.equal('[big.js] Invalid number');
+						}
+
+						Expect(testFable.Math.roundPrecise('867530999999999.71263219214217312', 15, testFable.Math.roundDown)).to.equal('867530999999999.712632192142173');
+						Expect(testFable.Math.roundPrecise('867530999999999.71263519214217312', 5, testFable.Math.roundUp)).to.equal('867530999999999.71264');
+						Expect(testFable.Math.roundPrecise('867530999999999.71263519214217312', 5, testFable.Math.roundHalfUp)).to.equal('867530999999999.71264');
+						Expect(testFable.Math.roundPrecise('867530999999999.71263519214217312', 5, testFable.Math.roundHalfEven)).to.equal('867530999999999.71264');
+						Expect(testFable.Math.roundPrecise('867530999999999.71663519214217312', 2, testFable.Math.roundHalfEven)).to.equal('867530999999999.72');
+						Expect(testFable.Math.roundPrecise('867530999999999.71263519214217312', 4, testFable.Math.roundHalfEven)).to.equal('867530999999999.7126');
+
+						return fDone();
+					}
+				);
+				test
+				(
+					'Cast To Fixed Numbers',
+					function(fDone)
+					{
+						let testFable = new libFable();
+
+						Expect(testFable.Math.toFixedPrecise(1.123456789, 2)).to.equal('1.12');
+						Expect(testFable.Math.toFixedPrecise(1.123456789, 4)).to.equal('1.1235');
+						Expect(testFable.Math.toFixedPrecise(1.123456789, 8)).to.equal('1.12345679');
+						Expect(testFable.Math.toFixedPrecise(1.123456789, 10)).to.equal('1.1234567890');
+						Expect(testFable.Math.toFixedPrecise(1.123456789, 12)).to.equal('1.123456789000');
+						Expect(testFable.Math.toFixedPrecise(1.123456789, 14)).to.equal('1.12345678900000');
+
+						Expect(testFable.Math.toFixedPrecise(undefined, 2)).to.equal('0.00');
+
+						try
+						{
+							testFable.Math.toFixedPrecise(null, 2, testFable.Math.roundHalfUp)
+						}
+						catch(pError)
+						{
+							Expect(pError).to.be.an.instanceof(Error);
+							Expect(pError.message).to.equal('[big.js] Invalid number');
+						}
+
+						Expect(testFable.Math.toFixedPrecise('867530999999999.71263219214217312', 15, testFable.Math.roundDown)).to.equal('867530999999999.712632192142173');
+						Expect(testFable.Math.toFixedPrecise('867530999999999.71263519214217312', 5, testFable.Math.roundUp)).to.equal('867530999999999.71264');
+						Expect(testFable.Math.toFixedPrecise('867530999999999.71263519214217312', 5, testFable.Math.roundHalfUp)).to.equal('867530999999999.71264');
+						Expect(testFable.Math.toFixedPrecise('867530999999999.71263519214217312', 5, testFable.Math.roundHalfEven)).to.equal('867530999999999.71264');
+						Expect(testFable.Math.toFixedPrecise('867530999999999.71663519214217312', 2, testFable.Math.roundHalfEven)).to.equal('867530999999999.72');
+						Expect(testFable.Math.toFixedPrecise('867530999999999.71', 4, testFable.Math.roundHalfEven)).to.equal('867530999999999.7100');
+
+						return fDone();
+					}
+				);
 			}
 		);
 	}