fable 3.0.132 → 3.0.134

package/example_applications/data/Fruit-Manyfest.json

@@ -0,0 +1,56 @@
+{
+	"Scope": "FruitsOfTheWorld",
+	"Descriptors":
+	{
+		"FruityVice[].name":
+		{
+			"Name": "Fruit Name",
+			"Hash": "Name",
+			"DataType": "String",
+			"Default": "(unnamed fruit)"
+		},
+		"FruityVice[].family":
+		{
+			"Name": "Family",
+			"Hash": "Family",
+			"DataType": "String"
+		},
+		"FruityVice[].order":
+		{
+			"Name": "Order",
+			"Hash": "Order",
+			"DataType": "String"
+		},
+		"FruityVice[].genus":
+		{
+			"Name": "Genus",
+			"Hash": "Genus",
+			"DataType": "String"
+		},
+		"FruityVice[].nutritions.calories":
+		{
+			"Name": "Calories",
+			"Hash": "Calories"
+		},
+		"FruityVice[].nutritions.fat":
+		{
+			"Name": "Fat",
+			"Hash": "Fat"
+		},
+		"FruityVice[].nutritions.protein":
+		{
+			"Name": "Protein",
+			"Hash": "Protein"
+		},
+		"FruityVice[].nutritions.carbohydrates":
+		{
+			"Name": "Carbohydrates",
+			"Hash": "Carbohydrates"
+		},
+		"FruityVice[].nutritions.sugar":
+		{
+			"Name": "Sugar",
+			"Hash": "Sugar"
+		}
+	}
+}

package/example_applications/mathematical_playground/AppData.json

@@ -0,0 +1,8 @@
+{
+	"PR": 1.5,
+	"Z": "20.036237",
+	"C": -13,
+
+	"Depth": 100.203,
+	"Width": 10.5
+}

package/example_applications/mathematical_playground/Equations.json

@@ -0,0 +1,12 @@
+{
+	"Expressions":
+		[
+			{ "Equation":"Result = 5+3 - sqrt(75 / (3 + Depth) * Width)^ 3", "ExpectedResult":"-13.078386362213538715906797395732300153182132216343566001917247" },
+			{ "Equation":"Result = (160 * PR * Z) / (C / 100) * PR * Z + (160 * (1 - C / 100))", "ExpectedResult":"-1111529.088640468" },
+			{ "Equation":"1.5 * sqrt(8 * 2.423782342^2) / 10", "ExpectedResult":"1.02832375808904701855" },
+			{ "Equation":"Result = ((15000 * 2) / 4)^2 + 100 - 10 * (35 + 5)", "ExpectedResult":"562500" },
+			{ "Equation":"Result = 1 * sqrt(16)", "ExpectedResult":"4" },
+			{ "Equation":"Result = sqrt(100 * (C + 30)) + sin(Depth - Width) / 10", "ExpectedResult":"41.32965489638783839821" },
+			{ "Equation":"Result = 3.5 + 50 + 10 * 10 / 5 - 1.5", "ExpectedResult":"72" }
+		]
+}

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

@@ -0,0 +1,89 @@
+const libFable = require('../../source/Fable.js');
+
+const _Fable = new libFable({"Product": "Ti"});
+// This instantiates the ExpressionParser service provider
+_Fable.instantiateServiceProviderIfNotExists('ExpressionParser');
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * Solve a basic math problem.
+ * 
+ */
+_Fable.log.info(`Beginning Basic Math Exercises....`);
+// Just type numbers and watch it go brrr
+_Fable.log.info(`One-liner solve is: ${_Fable.ExpressionParser.solve("Result = 73.5 * 28.8 * 200.5")}`);
+// Let's put it in a variable for easier exercises
+const _ExpressionParser = _Fable.ExpressionParser;
+// Look up somoe variables in an object
+_Fable.log.info(`One-liner solve with variables is: ${_ExpressionParser.solve("Volume = Width * Height * Depth", {"Width": 73.5, "Height": 28.8, "Depth": 200.5})}`);
+
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * A simple run through of some mathematical expressions
+ * 
+ */
+_Fable.log.info(`Beginning Run-through for Set of Test Expressions....`);
+// An array of equations with expected values
+let _Equations = require(`./Equations.json`);
+// The application state is a plain javascript object we pass into the solver to pull variables from
+let _AppData = require(`./AppData.json`);
+// The manifest is a Manyfest which describes hashes for complex addresses in the application state object
+// For example you can't use "Student[0].Age" as a variable in the expression
+// ...but you can use "Student[0].Age" as an address in the manifest with a hash of "StudentAge"
+// ...and then reference "StudentAge" in the expression.
+let tmpManifestConfiguration = { "Scope":"None", "Descriptors":[] };
+let tmpManifest = _Fable.newManyfest(tmpManifestConfiguration);
+// Run each expression in the Equations.json file through the expression parser.
+for (let i = 0; i < _Equations.Expressions.length; i++)
+{
+	let tmpResultValue = _ExpressionParser.solve(_Equations.Expressions[i].Equation, _AppData, {}, tmpManifest);
+	console.log(`Expression [${i}]: [${_Equations.Expressions[i].Equation}] ==> ${tmpResultValue}`);
+	if (tmpResultValue !== _Equations.Expressions[i].ExpectedResult)
+	{
+		console.log(`Error: Equation ${_Equations.Expressions[i].Equation} expected [${_Equations.Expressions[i].ExpectedResult}] but got [${tmpResultValue}]`);
+	}
+}
+
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * A manual run through of each phase of the expression parser
+ * 
+ */
+// Load up some fruit data to play around with
+let _FruitData = require(`../data/Fruit-Data.json`);
+let _FruitManifestDescription = require(`../data/Fruit-Manyfest.json`);
+let _FruitManifest = _Fable.newManyfest(_FruitManifestDescription);
+
+_Fable.log.info(`Beginning Manual Solve with Embedded Fruit Data....`);
+
+// The expression we pass into the solver is just a string
+let tmpExpression = 'HyperMax.HealthIndex = (SUM(Calories) / SUM(Sugar)) * MEDIAN(Fat) + (SQRT(AVG(Protein)) - (PI() + 99)';
+_Fable.log.info(`Solving tmpExpression: [${tmpExpression}]`);
+
+// This is an object where the parser will write out the results of each phase of the compiler/parser/solver
+let tmpExpressionParseOutcome = {};
+let tmpSolverResultsObject = {};
+
+// Step 1: Tokenize the expression
+let complexTokenizedResults = _ExpressionParser.tokenize(tmpExpression, tmpExpressionParseOutcome);
+// Step 2: Lint the tokenized expression (this is optional but very helpful for user feedback)
+let complexLintedResults = _ExpressionParser.lintTokenizedExpression(complexTokenizedResults, tmpExpressionParseOutcome);
+// Step 3: Parse the tokenized expression (this generates a postfix expression)
+let complexPostfixedResults = _ExpressionParser.buildPostfixedSolveList(complexTokenizedResults, tmpExpressionParseOutcome);
+// Step 4: Substitute the values references in the tokenized objects representing data within the postfixed expression
+_ExpressionParser.substituteValuesInTokenizedObjects(tmpExpressionParseOutcome.PostfixTokenObjects, _FruitData, tmpExpressionParseOutcome, _FruitManifest);
+// Now that we have a postfixed expression and the mapped-in values, show the user what the solution steps look like
+for (let i = 0; i < tmpExpressionParseOutcome.PostfixSolveList.length; i++)
+{
+	let tmpToken = tmpExpressionParseOutcome.PostfixSolveList[i];
+	console.log(`${i}: ${tmpToken.VirtualSymbolName} = (${tmpToken.LeftValue.Token}::${tmpToken.LeftValue.Value})  ${tmpToken.Operation.Token}  (${tmpToken.RightValue.Token}::${tmpToken.RightValue.Value}) `)
+}
+// Step 5: Solve the postfixed expression
+let tmpResultValue = _ExpressionParser.solvePostfixedExpression(tmpExpressionParseOutcome.PostfixSolveList, tmpSolverResultsObject, tmpExpressionParseOutcome, _FruitManifest);
+
+// Step 6: Look at the results.
+console.log(`Outcome object: ${JSON.stringify(tmpSolverResultsObject)}`);
+console.log(`Result of ${tmpExpression} solve: ${tmpResultValue}`);
+console.log('QED');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fable",
-    "version": "3.0.132",
+    "version": "3.0.134",
     "description": "A service dependency injection, configuration and logging library.",
     "main": "source/Fable.js",
     "scripts": {
@@ -50,7 +50,7 @@
     },
     "homepage": "https://github.com/stevenvelozo/fable",
     "devDependencies": {
-        "quackage": "^1.0.29"
+        "quackage": "^1.0.30"
     },
     "dependencies": {
         "async.eachlimit": "^0.5.2",
@@ -64,7 +64,7 @@
         "fable-serviceproviderbase": "^3.0.13",
         "fable-settings": "^3.0.10",
         "fable-uuid": "^3.0.7",
-        "manyfest": "^1.0.34",
+        "manyfest": "^1.0.35",
         "simple-get": "^4.0.1"
     }
 }

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

@@ -1,22 +1,82 @@
 {
-	"sqrt":
-		{
-			"Name": "Square Root",
-			"Address": "fable.Math.sqrtPrecise"
-		},
-	"abs":
-		{
-			"Name": "Absolute Value",
-			"Address": "fable.Math.absPrecise"
-		},
-	"rad":
-		{
-			"Name": "Degrees to Radians",
-			"Address": "fable.Math.radPrecise"
-		},
-	"sin":
-		{
-			"Name": "Sine",
-			"Address": "fable.Math.sin"
-		}
+	"sqrt": {
+		"Name": "Square Root",
+		"Address": "fable.Math.sqrtPrecise"
+	},
+
+	"abs": {
+		"Name": "Absolute Value",
+		"Address": "fable.Math.absPrecise"
+	},
+
+	"rad": {
+		"Name": "Degrees to Radians",
+		"Address": "fable.Math.radPrecise"
+	},
+
+	"pi": {
+		"Name": "Pi",
+		"Address": "fable.Math.piPrecise"
+	},
+	"sin": {
+		"Name": "Sine",
+		"Address": "fable.Math.sin"
+	},
+	"cos": {
+		"Name": "Cosine",
+		"Address": "fable.Math.cos"
+	},
+	"tan": {
+		"Name": "Tangent",
+		"Address": "fable.Math.tan"
+	},
+
+	"count": {
+		"Name": "Count Set Elements",
+		"Address": "fable.Math.countSetElements"
+	},
+
+	"sortset": {
+		"Name": "Sort Set",
+		"Address": "fable.Math.sortSetPrecise"
+	},
+	"bucketset": {
+		"Name": "Bucket Set",
+		"Address": "fable.Math.bucketSetPrecise"
+	},
+	"sorthistogram": {
+		"Name": "Sort Histogram",
+		"Address": "fable.Math.sortHistogramPrecise"
+	},
+
+	"max": {
+		"Name": "Maximum",
+		"Address": "fable.Math.maxPrecise"
+	},
+	"min": {
+		"Name": "Minimum",
+		"Address": "fable.Math.minPrecise"
+	},
+
+	"sum": {
+		"Name": "Sum",
+		"Address": "fable.Math.sumPrecise"
+	},
+
+	"avg": {
+		"Name": "Average",
+		"Address": "fable.Math.averagePrecise"
+	},
+	"mean": {
+		"Name": "Mean",
+		"Address": "fable.Math.meanPrecise"
+	},
+	"median": {
+		"Name": "Median",
+		"Address": "fable.Math.medianPrecise"
+	},
+	"mode": {
+		"Name": "Mode",
+		"Address": "fable.Math.modePrecise"
+	}
 }