fable 3.1.63 → 3.1.65

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
@@ -264,6 +336,65 @@ parser.solve('Result = MONTECARLO SAMPLECOUNT 5000 VAR x PT x -3 PT x 3 VAR y PT
     {}, {}, manifest, dest);
 ```
 
+### MULTIROWMAP Expressions
+
+Iterate over an array of objects (rows) with multi-row lookback and lookahead. Each variable can reference the current row or any row at a relative offset, with configurable defaults for out-of-bounds access.
+
+```javascript
+// Syntax:
+// Result = MULTIROWMAP ROWS FROM <address>
+//   [SERIESSTART <n>] [SERIESSTEP <n>]
+//   VAR <name> FROM <property> [OFFSET <n>] [DEFAULT <value>]
+//   ... : <expression>
+
+// Basic: compute area from each row's Width and Height
+parser.solve('Areas = MULTIROWMAP ROWS FROM Rows VAR w FROM Width VAR h FROM Height : w * h',
+    { Rows: [{Width:10,Height:20}, {Width:30,Height:40}] }, {}, manifest, dest);
+// dest.Areas === ['200', '1200']
+
+// Previous row lookback (day-over-day change)
+parser.solve('Change = MULTIROWMAP ROWS FROM Prices VAR Today FROM Close VAR Yesterday FROM Close OFFSET -1 DEFAULT 0 : Today - Yesterday',
+    data, {}, manifest, dest);
+
+// Two-row lookback (Fibonacci verification)
+parser.solve('Check = MULTIROWMAP ROWS FROM FibRows VAR Cur FROM Fib VAR P1 FROM Fib OFFSET -1 DEFAULT 0 VAR P2 FROM Fib OFFSET -2 DEFAULT 0 : Cur - (P1 + P2)',
+    data, {}, manifest, dest);
+
+// Forward lookback (next row reference)
+parser.solve('NextDiff = MULTIROWMAP ROWS FROM Rows VAR Cur FROM Value VAR Next FROM Value OFFSET 1 DEFAULT 0 : Next - Cur',
+    data, {}, manifest, dest);
+
+// Central difference (both directions)
+parser.solve('Deriv = MULTIROWMAP ROWS FROM Rows VAR Prev FROM Value OFFSET -1 DEFAULT 0 VAR Next FROM Value OFFSET 1 DEFAULT 0 : (Next - Prev) / 2',
+    data, {}, manifest, dest);
+
+// SERIESSTART: skip initial rows (start from row 2)
+parser.solve('MA = MULTIROWMAP ROWS FROM Prices SERIESSTART 2 VAR c0 FROM Close VAR c1 FROM Close OFFSET -1 DEFAULT 0 VAR c2 FROM Close OFFSET -2 DEFAULT 0 : (c0 + c1 + c2) / 3',
+    data, {}, manifest, dest);
+
+// Negative SERIESSTART: start from 2 rows before end
+parser.solve('LastTwo = MULTIROWMAP ROWS FROM Rows SERIESSTART -2 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+
+// SERIESSTEP -1: iterate backwards
+parser.solve('Reversed = MULTIROWMAP ROWS FROM Rows SERIESSTART -1 SERIESSTEP -1 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+
+// SERIESSTEP 2: every other row
+parser.solve('Sampled = MULTIROWMAP ROWS FROM Rows SERIESSTEP 2 VAR v FROM Value : v + 0',
+    data, {}, manifest, dest);
+```
+
+**Available variables in MULTIROWMAP expressions:**
+- `stepIndex` — iteration counter (0, 1, 2, ...)
+- `rowIndex` — actual array index of the current row
+- Any VAR-mapped variable names
+
+**OFFSET values:**
+- `0` (default) — current row
+- `-1` — previous row, `-2` — two rows back, `-3` — three back, etc.
+- `1` — next row, `2` — two ahead, etc.
+
 ### ITERATIVESERIES
 
 Run cumulative computations over arrays:

package/example_applications/mathematical_playground/AppData.json

@@ -22,5 +22,40 @@
 	"BezierYValues": [0, 1, 4, 9, 16],
 
 	"SalesMonths": [1, 2, 3, 4, 5, 6],
-	"SalesRevenue": [150, 200, 250, 310, 350, 400]
+	"SalesRevenue": [150, 200, 250, 310, 350, 400],
+
+	"FibonacciRows": [
+		{ "Fib": 0 },
+		{ "Fib": 1 },
+		{ "Fib": 1 },
+		{ "Fib": 2 },
+		{ "Fib": 3 },
+		{ "Fib": 5 },
+		{ "Fib": 8 },
+		{ "Fib": 13 },
+		{ "Fib": 21 },
+		{ "Fib": 34 }
+	],
+
+	"StockPrices": [
+		{ "Date": "2025-01-01", "Close": 100.00, "Volume": 5000 },
+		{ "Date": "2025-01-02", "Close": 102.50, "Volume": 6200 },
+		{ "Date": "2025-01-03", "Close": 101.00, "Volume": 4800 },
+		{ "Date": "2025-01-06", "Close": 105.00, "Volume": 7100 },
+		{ "Date": "2025-01-07", "Close": 108.50, "Volume": 8300 },
+		{ "Date": "2025-01-08", "Close": 107.00, "Volume": 5500 },
+		{ "Date": "2025-01-09", "Close": 110.00, "Volume": 6800 },
+		{ "Date": "2025-01-10", "Close": 112.50, "Volume": 7200 }
+	],
+
+	"TemperatureReadings": [
+		{ "Hour": 0, "Temp": 58.0 },
+		{ "Hour": 3, "Temp": 55.5 },
+		{ "Hour": 6, "Temp": 54.0 },
+		{ "Hour": 9, "Temp": 60.5 },
+		{ "Hour": 12, "Temp": 68.0 },
+		{ "Hour": 15, "Temp": 72.5 },
+		{ "Hour": 18, "Temp": 67.0 },
+		{ "Hour": 21, "Temp": 61.5 }
+	]
 }