fable 3.1.64 → 3.1.66

package/docs/services/expression-parser-functions/README.md

@@ -84,6 +84,7 @@ Basic math operations with arbitrary precision:
 ### Value Access
 
 - [getvalue](./getvalue.md) - Get value from application state
+- [setvalue](./setvalue.md) - Set value to application state
 - [getvaluearray](./getvaluearray.md) - Get array of values
 - [getvalueobject](./getvalueobject.md) - Get value object
 - [createvalueobjectbyhashes](./createvalueobjectbyhashes.md) - Create object from hashes
@@ -110,6 +111,7 @@ Basic math operations with arbitrary precision:
 
 - [if](./if.md) - Conditional comparison
 - [when](./when.md) - Truthy check
+- [ternary](./ternary.md) - Numeric-aware ternary selection (`? ::` operator)
 
 ### Date Functions
 
@@ -143,6 +145,8 @@ Basic math operations with arbitrary precision:
 
 ### Regression and Matrix Functions
 
+- [slope](./slope.md) - Slope of linear regression line
+- [intercept](./intercept.md) - Y-intercept of linear regression line
 - [polynomialregression](./polynomialregression.md) - Polynomial regression
 - [leastsquares](./leastsquares.md) / [linest](./linest.md) - Least squares regression
 - [predict](./predict.md) - Predict from regression model
@@ -152,6 +156,11 @@ Basic math operations with arbitrary precision:
 - [matrixinverse](./matrixinverse.md) - Inverse matrix
 - [gaussianelimination](./gaussianelimination.md) - Gaussian elimination
 
+### Bezier Curves
+
+- [bezierpoint](./bezierpoint.md) - Evaluate point on cubic Bezier curve
+- [beziercurvefit](./beziercurvefit.md) - Fit cubic Bezier curve to data points
+
 ### Other Utilities
 
 - [generatearrayofobjectsfromsets](./generatearrayofobjectsfromsets.md) - Generate objects from sets

package/docs/services/expression-parser-functions/beziercurvefit.md

@@ -0,0 +1,57 @@
+# beziercurvefit
+
+Fits a cubic Bezier curve to a set of data points.
+
+## Syntax
+
+```
+beziercurvefit(dataPoints)
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `dataPoints` | Array | Array of numeric values to fit the curve to |
+
+## Returns
+
+Array - The four control points (P0, P1, P2, P3) of the fitted cubic Bezier curve.
+
+## Description
+
+The `beziercurvefit` function computes the four control points of a cubic Bezier curve that best fits the provided data points. This is useful for creating smooth curve approximations of discrete data.
+
+## Examples
+
+### Basic Usage
+
+```expression
+Curve = beziercurvefit(DataPoints)
+// Returns array of 4 control points defining the fitted Bezier curve
+```
+
+### With FLATTEN
+
+```expression
+Curve = beziercurvefit(FLATTEN(AppData.Measurements[].value))
+```
+
+### Using Fitted Curve
+
+```expression
+// First fit the curve
+ControlPoints = beziercurvefit(Data)
+
+// Then evaluate points along the fitted curve
+Point = bezierpoint(ENTRYINSET(ControlPoints, 0), ENTRYINSET(ControlPoints, 1), ENTRYINSET(ControlPoints, 2), ENTRYINSET(ControlPoints, 3), 0.5)
+```
+
+## Related Functions
+
+- [bezierpoint](./bezierpoint.md) - Evaluate point on cubic Bezier curve
+- [polynomialregression](./polynomialregression.md) - Polynomial curve fitting
+
+## Notes
+
+- Uses the Math service's `bezierCurveFit` method internally

package/docs/services/expression-parser-functions/bezierpoint.md

@@ -0,0 +1,55 @@
+# bezierpoint
+
+Evaluates a point on a cubic Bezier curve at a given parameter t.
+
+## Syntax
+
+```
+bezierpoint(p0, p1, p2, p3, t)
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `p0` | Number/String | Start point |
+| `p1` | Number/String | First control point |
+| `p2` | Number/String | Second control point |
+| `p3` | Number/String | End point |
+| `t` | Number/String | Parameter value (0 to 1) |
+
+## Returns
+
+String - The computed point on the cubic Bezier curve at parameter t.
+
+## Description
+
+The `bezierpoint` function evaluates the cubic Bezier curve defined by four control points at a given parameter value t. When t=0 the result is the start point, when t=1 the result is the end point, and values in between trace the curve.
+
+## Examples
+
+### Basic Usage
+
+```expression
+Result = bezierpoint(0, 0.25, 0.75, 1, 0.5)
+// Evaluate midpoint of a cubic Bezier curve
+```
+
+### Endpoint Values
+
+```expression
+Start = bezierpoint(10, 20, 80, 100, 0)
+// Result: "10" (t=0 returns start point)
+
+End = bezierpoint(10, 20, 80, 100, 1)
+// Result: "100" (t=1 returns end point)
+```
+
+## Related Functions
+
+- [beziercurvefit](./beziercurvefit.md) - Fit a cubic Bezier curve to data points
+
+## Notes
+
+- Uses the Math service's `bezierPoint` method internally
+- Parameter t should be between 0 and 1

package/docs/services/expression-parser-functions/intercept.md

@@ -0,0 +1,59 @@
+# intercept
+
+Calculates the Y-intercept of a linear regression line from a set of X and Y values. Equivalent to Excel's INTERCEPT function.
+
+## Syntax
+
+```
+intercept(yValues, xValues)
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `yValues` | Array | The dependent data points (Y values) |
+| `xValues` | Array | The independent data points (X values) |
+
+## Returns
+
+String - The Y-intercept (b) of the least-squares regression line through the data points.
+
+## Description
+
+The `intercept` function computes the Y-intercept (b) of the best-fit linear regression line y = mx + b for a given set of data points. This is equivalent to Excel's INTERCEPT function. Uses arbitrary precision arithmetic.
+
+## Examples
+
+### Basic Usage
+
+```expression
+Result = intercept(YValues, XValues)
+// With YValues=[2, 4, 6, 8], XValues=[1, 2, 3, 4]
+// Result: "0" (line passes through origin)
+```
+
+### With FLATTEN for Internal Data
+
+```expression
+YIntercept = intercept(FLATTEN(AppData.Points[].y), FLATTEN(AppData.Points[].x))
+```
+
+### Combined with Slope
+
+```expression
+// Compute full regression: y = slope * x + intercept
+M = slope(YValues, XValues)
+B = intercept(YValues, XValues)
+```
+
+## Related Functions
+
+- [slope](./slope.md) - Slope of linear regression line
+- [linest](./linest.md) - Full least squares regression
+- [predict](./predict.md) - Predict from regression model
+
+## Notes
+
+- Both arrays must have the same length
+- Uses the Math service's `interceptPrecise` method internally

package/docs/services/expression-parser-functions/setvalue.md

@@ -0,0 +1,55 @@
+# setvalue
+
+Sets a value in application state or services (AppData, etc.).
+
+## Syntax
+
+```
+setvalue(address, value)
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `address` | String | The address path to set (e.g. `"AppData.Users[0].Name"`) |
+| `value` | Any | The value to set at the given address |
+
+## Returns
+
+The value that was set.
+
+## Description
+
+The `setvalue` function writes a value to an internal application state address. It is the counterpart to `getvalue`. The address is resolved using Manyfest path notation, allowing deep property access including array indexing.
+
+## Examples
+
+### Basic Usage
+
+```expression
+setvalue("AppData.CurrentUser", "Alice")
+// Sets fable.AppData.CurrentUser to "Alice"
+```
+
+### With Computed Values
+
+```expression
+setvalue("AppData.Total", X + Y)
+// With X=10, Y=20: sets AppData.Total to "30"
+```
+
+### Array Access
+
+```expression
+setvalue("AppData.Items[0].Price", 29.99)
+```
+
+## Related Functions
+
+- [getvalue](./getvalue.md) - Get value from application state
+
+## Notes
+
+- The first parameter is treated as an address string and resolved internally
+- Uses the Utility service's `setInternalValueByHash` method

package/docs/services/expression-parser-functions/slope.md

@@ -0,0 +1,51 @@
+# slope
+
+Calculates the slope of a linear regression line from a set of X and Y values. Equivalent to Excel's SLOPE function.
+
+## Syntax
+
+```
+slope(yValues, xValues)
+```
+
+## Parameters
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `yValues` | Array | The dependent data points (Y values) |
+| `xValues` | Array | The independent data points (X values) |
+
+## Returns
+
+String - The slope of the least-squares regression line through the data points.
+
+## Description
+
+The `slope` function computes the slope (m) of the best-fit linear regression line y = mx + b for a given set of data points. This is equivalent to Excel's SLOPE function. Uses arbitrary precision arithmetic.
+
+## Examples
+
+### Basic Usage
+
+```expression
+Result = slope(YValues, XValues)
+// With YValues=[2, 4, 6, 8], XValues=[1, 2, 3, 4]
+// Result: "2" (perfect linear relationship)
+```
+
+### With FLATTEN for Internal Data
+
+```expression
+Slope = slope(FLATTEN(AppData.Points[].y), FLATTEN(AppData.Points[].x))
+```
+
+## Related Functions
+
+- [intercept](./intercept.md) - Y-intercept of linear regression line
+- [linest](./linest.md) - Full least squares regression
+- [polynomialregression](./polynomialregression.md) - Polynomial regression
+
+## Notes
+
+- Both arrays must have the same length
+- Uses the Math service's `slopePrecise` method internally

package/docs/services/expression-parser-functions/ternary.md

@@ -0,0 +1,180 @@
+# ternary
+
+Numeric-aware conditional selection. This is the function behind the `? ::` ternary operator syntax, and can also be called directly.
+
+## Ternary Operator Syntax
+
+The ternary operator provides inline if/else logic within expressions:
+
+```
+condition ? trueValue :: falseValue
+```
+
+This is syntactic sugar that gets rewritten to a `ternary()` function call before evaluation. The double colon `::` is used instead of a single `:` because `:` is already reserved for directive syntax (MAP, SERIES, etc.).
+
+### How It Works
+
+When the expression parser encounters `? ... ::`, it rewrites the expression into a function call:
+
+```
+Height > Width ? Height :: Width
+```
+
+Becomes:
+
+```
+ternary((Height > Width), Height, Width)
+```
+
+The condition is automatically wrapped in parentheses to ensure correct precedence when combined with arithmetic. This means **you never need to worry about operator precedence** in ternary conditions -- it just works.
+
+## Function Syntax
+
+```
+ternary(condition, onTrue)
+ternary(condition, onTrue, onFalse)
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `condition` | Any | required | Value to evaluate for truthiness |
+| `onTrue` | Any | required | Value returned if condition is truthy |
+| `onFalse` | Any | `""` | Value returned if condition is falsy |
+
+## Returns
+
+The `onTrue` value if `condition` is truthy, otherwise `onFalse`.
+
+## Truthiness
+
+The `ternary` function uses numeric-aware truthiness, designed to work correctly with comparison operators that return `"1"` and `"0"` as strings:
+
+### Falsy values
+- `false`, `null`, `undefined`, `NaN`
+- `0` (numeric zero)
+- `""` (empty string)
+- `"0"` (string zero -- this is the key difference from `when`)
+- `[]` (empty array)
+- `{}` (empty object)
+
+### Truthy values
+- `"1"` or any non-zero number/string
+- Any non-empty string (except `"0"`)
+- Any non-empty array or object
+
+## Examples
+
+### Basic Ternary
+
+```expression
+Result = 5 > 3 ? 100 :: 200
+// 5 > 3 evaluates to "1" (truthy)
+// Result: "100"
+
+Result = 3 > 5 ? 100 :: 200
+// 3 > 5 evaluates to "0" (falsy)
+// Result: "200"
+```
+
+### With Variables
+
+```expression
+Winner = Height > Width ? Height :: Width
+// With data: { Height: 10, Width: 5 }
+// 10 > 5 evaluates to "1" (truthy)
+// Result: "10"
+```
+
+### Arithmetic in Branches
+
+```expression
+Result = A > B ? A + 1 :: B + 1
+// With data: { A: 10, B: 5 }
+// A > B is truthy, so A + 1 = 11
+// Result: "11"
+```
+
+### Arithmetic in Condition
+
+```expression
+Result = 2 + 3 > 1 + 2 ? 100 :: 200
+// (2 + 3) > (1 + 2) => 5 > 3 => "1" (truthy)
+// Result: "100"
+```
+
+### With Assignment
+
+```expression
+SomeValue = Height > Width ? A :: B
+// With data: { Height: 10, Width: 5, A: 42, B: 99 }
+// Height > Width is truthy, selects A
+// SomeValue: "42"
+```
+
+### Equality Checks
+
+```expression
+Label = Score == 100 ? "Perfect" :: "Keep trying"
+// With data: { Score: 100 }
+// Result: "Perfect"
+```
+
+### Nested Ternary
+
+Use parentheses to nest ternary expressions:
+
+```expression
+Grade = Score >= 90 ? "A" :: (Score >= 80 ? "B" :: (Score >= 70 ? "C" :: "F"))
+// With data: { Score: 85 }
+// Score >= 90 is false, check inner: Score >= 80 is true
+// Result: "B"
+```
+
+### Inside MAP Expressions
+
+```expression
+Labels = MAP VAR x FROM Values : x > 0 ? "positive" :: "non-positive"
+// With data: { Values: [5, -3, 0, 10] }
+// Result: ["positive", "non-positive", "non-positive", "positive"]
+```
+
+## Comparison with `if` and `when`
+
+| Feature | `ternary` / `? ::` | `if()` | `when()` |
+|---------|---------------------|--------|----------|
+| Syntax style | Infix operator | Function call | Function call |
+| Condition | Truthiness check | Explicit comparison | Truthiness check |
+| `"0"` handling | Falsy | N/A (uses operators) | Truthy |
+| Parameters | 2-3 | 5 | 2-3 |
+| Best for | Inline conditionals | Comparing two values | Null/empty checking |
+
+### When to use each
+
+**Use `? ::`** for inline conditionals, especially with comparison operators:
+```expression
+Price = Quantity > 100 ? BulkPrice :: RetailPrice
+```
+
+**Use `if()`** when you need the comparison operator as a parameter (useful in MAP expressions with dynamic operators):
+```expression
+Result = If(Score, ">=", Threshold, "Pass", "Fail")
+```
+
+**Use `when()`** for simple existence/null checks where `"0"` should be truthy:
+```expression
+Name = When(UserName, UserName, "Anonymous")
+```
+
+## Notes
+
+- The `::` separator must be used (not `:`) to avoid conflicts with directive syntax
+- Comparison operators (`>`, `>=`, `<`, `<=`, `==`, `!=`) return `"1"` or `"0"`, which the ternary function interprets correctly
+- The ternary operator desugaring happens before expression evaluation, so it works seamlessly with all other expression features
+- Nested ternary expressions require parentheses around the inner ternary
+
+## Related Functions
+
+- [if](./if.md) - Conditional comparison with explicit operator
+- [when](./when.md) - Truthy check (treats `"0"` as truthy)

package/docs/services/expression-parser.md

@@ -64,6 +64,67 @@ parser.solve('Name ?= GETVALUE("AppData.Students[0]")', data, {}, false, dest);
 | `*` | Multiplication | `5 * 3` → `'15'` |
 | `/` | Division | `15 / 3` → `'5'` |
 | `^` | Power | `2 ^ 3` → `'8'` |
+| `%` | Modulus | `10 % 3` → `'1'` |
+
+### Comparison Operators
+
+Comparison operators evaluate to `'1'` (true) or `'0'` (false). They bind looser than arithmetic, so `2 + 3 > 1 + 2` evaluates the math first.
+
+| Operator | Description | Example |
+|----------|-------------|---------|
+| `>` | Greater than | `5 > 3` → `'1'` |
+| `>=` | Greater than or equal | `5 >= 5` → `'1'` |
+| `<` | Less than | `3 < 5` → `'1'` |
+| `<=` | Less than or equal | `3 <= 3` → `'1'` |
+| `==` | Equal | `5 == 5` → `'1'` |
+| `!=` | Not equal | `5 != 3` → `'1'` |
+
+```javascript
+parser.solve('Result = 5 > 3', {}, {}, false, dest);
+// dest.Result === '1'
+
+parser.solve('Result = 2 + 3 > 1 + 2', {}, {}, false, dest);
+// dest.Result === '1' (evaluates as (2+3) > (1+2), i.e. 5 > 3)
+
+parser.solve('Result = Height > Width', { Height: 10, Width: 5 }, {}, false, dest);
+// dest.Result === '1'
+```
+
+### Ternary Operator
+
+The ternary operator provides inline conditional expressions using `?` and `::` syntax:
+
+```
+condition ? trueValue :: falseValue
+```
+
+The condition is typically a comparison expression. If it evaluates to a truthy value (non-zero, non-empty), the true branch is returned; otherwise the false branch is returned.
+
+```javascript
+parser.solve('Result = 5 > 3 ? 100 :: 200', {}, {}, false, dest);
+// dest.Result === '100'
+
+parser.solve('Result = 3 > 5 ? 100 :: 200', {}, {}, false, dest);
+// dest.Result === '200'
+
+parser.solve('Winner = Height > Width ? Height :: Width',
+    { Height: 10, Width: 5 }, {}, false, dest);
+// dest.Winner === '10'
+
+// Arithmetic in branches
+parser.solve('Result = A > B ? A + 1 :: B + 1',
+    { A: 10, B: 5 }, {}, false, dest);
+// dest.Result === '11'
+
+// Nested ternary (use parentheses for inner ternary)
+parser.solve('Result = A > 0 ? (B > 0 ? 1 :: 2) :: 3',
+    { A: 1, B: 1 }, {}, false, dest);
+// dest.Result === '1'
+```
+
+The ternary operator uses `::` (double colon) instead of `:` for the false branch separator because `:` is already used as the Expression Begin token in directives like `MAP`, `SERIES`, etc.
+
+Internally, `condition ? trueValue :: falseValue` is desugared to `ternary((condition), trueValue, falseValue)` before evaluation. See the [ternary function documentation](./expression-parser-functions/ternary.md) for details.
 
 ### Order of Operations
 
@@ -152,6 +213,17 @@ parser.solve('NameList = STRINGGETSEGMENTS(Names, ",")', { Names: 'Jane,John' })
 
 ### Conditional Functions
 
+#### Ternary Operator (inline conditional)
+
+The preferred way to write inline conditionals is with the ternary operator:
+
+```javascript
+parser.solve('Label = Score >= 70 ? "Pass" :: "Fail"', { Score: 85 }, {}, false, dest);
+// dest.Label === 'Pass'
+```
+
+See [Ternary Operator](#ternary-operator) above and the [ternary function reference](./expression-parser-functions/ternary.md).
+
 #### When (truthy check)
 
 ```javascript

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

@@ -223,3 +223,111 @@ console.log(`\nWeighted volume change (3-day lookback with price ratio):`);
 console.log(`  WeightedVolChange: [${tmpMultiRowResults.WeightedVolChange.join(', ')}]`);
 
 console.log('QED');
+
+/* * * * * * * * * * * * * * * * *
+ *
+ * Third-Party Test Suite Runner
+ *
+ * Run with: node Math-Solver-Harness.js --test-suite <name>
+ * Valid names: identities, spreadsheet, precision, acidtest, all
+ *
+ */
+let SUITE_MAP =
+	{
+		'identities': 'TestSuite-Identities.json',
+		'spreadsheet': 'TestSuite-Spreadsheet.json',
+		'precision': 'TestSuite-Precision.json',
+		'acidtest': 'TestSuite-AcidTest.json'
+	};
+
+let tmpRequestedSuites = [];
+for (let i = 0; i < process.argv.length; i++)
+{
+	if (process.argv[i] === '--test-suite' && i + 1 < process.argv.length)
+	{
+		let tmpSuiteName = process.argv[i + 1].toLowerCase();
+		if (tmpSuiteName === 'all')
+		{
+			tmpRequestedSuites = Object.keys(SUITE_MAP);
+		}
+		else if (tmpSuiteName in SUITE_MAP)
+		{
+			tmpRequestedSuites.push(tmpSuiteName);
+		}
+		else
+		{
+			console.log(`\x1b[31mUnknown test suite: ${tmpSuiteName}\x1b[0m`);
+			console.log(`Valid suites: ${Object.keys(SUITE_MAP).join(', ')}, all`);
+		}
+		i++;
+	}
+}
+
+if (tmpRequestedSuites.length > 0)
+{
+	let tmpTotalPass = 0;
+	let tmpTotalFail = 0;
+	let tmpSuiteSummaries = [];
+
+	for (let s = 0; s < tmpRequestedSuites.length; s++)
+	{
+		let tmpSuiteKey = tmpRequestedSuites[s];
+		let tmpSuiteData = require(`./${SUITE_MAP[tmpSuiteKey]}`);
+		let tmpSuitePass = 0;
+		let tmpSuiteFail = 0;
+		let tmpCurrentCategory = '';
+
+		console.log(`\n\x1b[1m=== ${tmpSuiteData.Name} ===\x1b[0m`);
+		console.log(`${tmpSuiteData.Description}\n`);
+
+		for (let i = 0; i < tmpSuiteData.Expressions.length; i++)
+		{
+			let tmpTest = tmpSuiteData.Expressions[i];
+			if (tmpTest.Category && tmpTest.Category !== tmpCurrentCategory)
+			{
+				tmpCurrentCategory = tmpTest.Category;
+				console.log(`  \x1b[4m${tmpCurrentCategory}\x1b[0m`);
+			}
+
+			let tmpData = tmpTest.Data || _AppData;
+			let tmpResultObject = {};
+			let tmpResultValue;
+			try
+			{
+				tmpResultValue = _ExpressionParser.solve(tmpTest.Equation, tmpData, tmpResultObject, false);
+			}
+			catch (pError)
+			{
+				tmpResultValue = `ERROR: ${pError.message}`;
+			}
+
+			let tmpPassed = (String(tmpResultValue) === String(tmpTest.ExpectedResult));
+			if (tmpPassed)
+			{
+				tmpSuitePass++;
+				console.log(`    \x1b[32m PASS\x1b[0m ${tmpTest.Description}`);
+			}
+			else
+			{
+				tmpSuiteFail++;
+				console.log(`    \x1b[31m FAIL\x1b[0m ${tmpTest.Description}`);
+				console.log(`          Expected: ${tmpTest.ExpectedResult}`);
+				console.log(`          Got:      ${tmpResultValue}`);
+			}
+		}
+
+		tmpTotalPass += tmpSuitePass;
+		tmpTotalFail += tmpSuiteFail;
+		tmpSuiteSummaries.push({ Name: tmpSuiteData.Name, Pass: tmpSuitePass, Fail: tmpSuiteFail, Total: tmpSuitePass + tmpSuiteFail });
+	}
+
+	console.log(`\n\x1b[1m=== Test Suite Summary ===\x1b[0m`);
+	for (let i = 0; i < tmpSuiteSummaries.length; i++)
+	{
+		let tmpSummary = tmpSuiteSummaries[i];
+		let tmpColor = tmpSummary.Fail > 0 ? '\x1b[31m' : '\x1b[32m';
+		console.log(`  ${tmpColor}${tmpSummary.Pass}/${tmpSummary.Total}\x1b[0m ${tmpSummary.Name}`);
+	}
+	let tmpOverallColor = tmpTotalFail > 0 ? '\x1b[31m' : '\x1b[32m';
+	console.log(`\n  ${tmpOverallColor}Total: ${tmpTotalPass}/${tmpTotalPass + tmpTotalFail} passed\x1b[0m`);
+}