## Function Prototype

```
/* Triangular Moving Average */
/* Type: overlay */
/* Input arrays: 1 Options: 1 Output arrays: 1 */
/* Inputs: real */
/* Options: period */
/* Outputs: trima */
int ti_trima_start(TI_REAL const *options);
int ti_trima(int size,
TI_REAL const *const *inputs,
TI_REAL const *options,
TI_REAL *const *outputs);
```

## Description

This documentation is still a work in progress. It has omissions, and it probably has errors too. If you see any issues, or have any general feedback, please get in touch.

The Triangular Moving Average is similar to the Simple Moving Average but instead places more weight on middle portion of the smoothing period and less weight on the newest and oldest bars in the period.

It takes one parameter, the period `n`

. Larger values for `n`

will have a
greater smoothing effect on the input data.

It is calculated for each bar as the weighted arithmetic mean of the previous
`n`

bars. For example, the weights `w`

for an `n`

of 4 are: 1, 2, 2, 1. The
weights `w`

for a `n`

of 7 are: 1, 2, 3, 4, 3, 2, 1. It's easy to see why it's
called the Triangular Moving Average.

Once the weights `w`

are know, the calculation is as follows.

The calculation can also be expressed in terms of two Simple Moving Averages with adjusted
periods `n`

.

The above equivalency is correct. It's part of the TI test suite. I've
seen *several* other sources that get it subtly wrong.

## See Also

## References

## Example Usage

### Calling From C

```
/* Example usage of Triangular Moving Average */
/* Assuming that 'input' is a pre-loaded array of size 'in_size'. */
TI_REAL *inputs[] = {input};
TI_REAL options[] = {5}; /* period */
TI_REAL *outputs[1]; /* trima */
/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_trima_start(options);
/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* trima */
/* Run the actual calculation. */
const int ret = ti_trima(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

### Calling From Lua (with Tulip Chart bindings)

```
-- Example usage of Triangular Moving Average
trima = ti.trima(input, 5)
```

## Example Calculation

period = 5

date | input | trima |
---|---|---|

2005-11-01 | 81.59 | |

2005-11-02 | 81.06 | |

2005-11-03 | 82.87 | |

2005-11-04 | 83.00 | |

2005-11-07 | 83.61 | 82.44 |

2005-11-08 | 83.15 | 82.91 |

2005-11-09 | 82.84 | 83.20 |

2005-11-10 | 83.99 | 83.26 |

2005-11-11 | 84.55 | 83.44 |

2005-11-14 | 84.36 | 83.81 |

2005-11-15 | 85.53 | 84.30 |

2005-11-16 | 86.54 | 84.86 |

2005-11-17 | 86.89 | 85.54 |

2005-11-18 | 87.77 | 86.29 |

2005-11-21 | 87.29 | 86.90 |

## Chart

## Other Indicators

Previous indicator: True Range

Next indicator: Trix

Random indicator: Average Directional Movement Index