# fold

## Syntax

`def <result> = fold <index> = <start> to <end> [ with <variable> [ = <init> ] ] [ while <condition> ] do <expression>; `

## Description

The `fold` operator allows you to perform iterated calculations. The list below explains the operator's logic (variable names are taken from the sample syntax above):

1. The purpose of the `fold` operator is to perform an iterated calculation and assign the final value to the `result` variable.

2. The `index` variable serves as a loop counter.

3. With each iteration, the `index` value increases by `1`; the initial value of `index` is set by the `start` parameter.

4. Iterated calculations will be performed while the `index` value is less than the `end` parameter. Once the `index` value becomes equal to the `end` parameter, the loop is terminated without calculation.

5. Within each iteration, the operator calculates the `expression` and assigns the result to the `variable`. In the `expression`, you are free to use the value of `index` and also reference the previous value of the `variable`.` `The initial value of the `variable` can be specified with the `init` parameter. If none is specified, then the `variable` is assigned a value of `0` before the first iteration.

6. The `variable` value is thus re-written after each iteration; after the last iteration, its final value is assigned to the `result` variable.

7. You can also add a condition within the `while` block of the operator. If this condition is violated, the `resul``t` is assigned the last known value of `variable` and the loop is terminated.

## Example 1

`input n = 10;plot factorial = fold index = 1 to n + 1 with p = 1 do p * index;`

This example script calculates the factorial of a number.

Here, the `factorial` variable stores the result value of the calculation; `index` is the counter and its values are increased by `1` from `1` through `n+1`. The `p` is the variable whose value is re-written over iterations; its initial value is set to `1`. The expression is the product of `p` and `index`. After the first iteration, `p` is `1*1=1`. After the second iteration, it is equal to its current value (`1`) multiplied by current `index` (`2`), i.e., `2`. After the third iteration, its current value (`2`) is multiplied by current `index` (`3`), yielding `6`. Since the input `n` is set to `10`, there will be 10 iterations (the loop is terminated when the `index` becomes equal to `n+1=11`), so the last value of `p` will be equal to `3,628,800` (a product of all numbers from 1 through 10). This is the value that is assigned to the `factorial` variable after the loop is complete.

## Example 2

`input price = close;input length = 9;plot SMA = (fold n = 0 to length with s do s + getValue(price, n, length - 1)) / length;`

This example script calculates a simple moving average using `fold`.

## Example 3

`plot NextHigh = fold i = 0 to 100 with price = Double.NaN while IsNaN(price) do if getValue(high, -i, -99) > 40 then getValue(high, -i, -99) else Double.NaN;`

This example script plots the closest high price value greater than 40 out of the next 100 bars.