## Function Prototype

```
/* Kaufman Adaptive Moving Average */
/* Type: overlay */
/* Input arrays: 1 Options: 1 Output arrays: 1 */
/* Inputs: real */
/* Options: period */
/* Outputs: kama */
int ti_kama_start(TI_REAL const *options);
int ti_kama(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 Kaufman Adaptive Moving Average tries to adjust it's smoothing to match the current market condition. It adapts to a fast moving average when prices are moving steadily in one direction and a slow moving average when the market exhibits a lot of noise.

It takes one parameter, the efficiency ratio period `n`

.

Kaufman Adaptive Moving Average first calculates the efficiency ratio over the period
`n`

as:

The efficiency ratio `e`

is a low value when the market contains a lot of noise, and it is a
larger value when the market is moving consistently in one direction.

A scalar, `a`

is then calculated as:

Finally Kaufman Adaptive Moving Average can be calculated as:

## See Also

## References

- Kaufman, Perry J. (2013) Trading Systems and Methods
- Ehlers, John F. (2001) Rocket Science For Traders

## Example Usage

### Calling From C

```
/* Example usage of Kaufman Adaptive 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]; /* kama */
/* Determine how large the output size is for our options. */
const int out_size = in_size - ti_kama_start(options);
/* Allocate memory for output. */
outputs[0] = malloc(sizeof(TI_REAL) * out_size); assert(outputs[0] != 0); /* kama */
/* Run the actual calculation. */
const int ret = ti_kama(in_size, inputs, options, outputs);
assert(ret == TI_OKAY);
```

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

```
-- Example usage of Kaufman Adaptive Moving Average
kama = ti.kama(input, 5)
```

## Example Calculation

period = 5

date | input | kama |
---|---|---|

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 | 83.61 |

2005-11-08 | 83.15 | 83.56 |

2005-11-09 | 82.84 | 83.45 |

2005-11-10 | 83.99 | 83.51 |

2005-11-11 | 84.55 | 83.65 |

2005-11-14 | 84.36 | 83.69 |

2005-11-15 | 85.53 | 84.13 |

2005-11-16 | 86.54 | 85.03 |

2005-11-17 | 86.89 | 85.69 |

2005-11-18 | 87.77 | 86.45 |

2005-11-21 | 87.29 | 86.67 |

## Chart

## Other Indicators

Previous indicator: Hull Moving Average

Next indicator: Klinger Volume Oscillator

Random indicator: Vector Base-10 Log