# Core Indicators

This page describes core indicators supported by Algorum

# Indicators

## Accumulation/Distribution Line (AD)

Accumulation/distribution is a cumulative indicator that uses volume and price to assess whether a stock is being accumulated or distributed.

This provides insight into how strong a trend is. If the price is rising but the indicator is falling this indicates that buying or accumulation volume may not be enough to support the price rise and a price decline could be forthcoming.

```
public async Task<double> ADAsync( double period )
```

```
def ad(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If Period is 0, Default Value of 14 will be used. |

Return: | double | unbounded |

## Average Directional Index (ADX)

The average directional index (ADX) is a technical analysis indicator used by some traders to determine the strength of a trend. The trend can be either up or down, and this is shown by two accompanying indicators, the Negative Directional Indicator (-DI) and the Positive Directional Indicator (+DI).

```
public async Task<double> ADXAsync( double period )
```

```
def adx(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If Period is 0, Default Value of 14 will be used. |

Return: | double (floating point value) | 1-100 |

## Awesome Oscillator (AO)

Awesome Oscillator (AO) is an indicator that is non-limiting oscillator, providing insight into the weakness or the strength of a stock.

The Awesome Oscillator is used to measure market momentum and to affirm trends or to anticipate possible reversals. It does this by effectively comparing the recent market momentum, with the general momentum over a wider frame of reference.

```
public async Task<double> AOAsync( double period )
```

```
def ao(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If this parameter value is 0, then default value of 14 will be used. |

Return: | double (floating point value) | 0-1 |

## Absolute Price Oscillator (APO)

The Absolute Price Oscillator displays the difference between two exponential moving averages of a security's price and is expressed as an absolute value. It rates the trends strength in relation to the moving between the two moving averages with short-term momentum being the catalyst.

```
public async Task<double> APOAsync( double shortPeriod, double longPeriod )
```

```
def apo(self, short_period: float, long_period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

shortPeriod | double (floating point value) | 1-200 | If this parameter value is 0, the a default value of 10 will be used. |

longPeriod | double (floating point value) | 1-200 | If this parameter value is 0, the a default value of 26 will be used. |

Return: | double (floating point value) | -ve unbounded TO +ve unbounded |

## Aroon Down (AROONDOWN)

The Aroon indicator is a technical indicator that is used to identify trend changes in the price of an asset, as well as the strength of that trend. In essence, the indicator measures the time between highs and the time between lows over a time period.

The "Aroon down" line, which measures the strength of the downtrend.

```
public async Task<double> AROONDOWNAsync( double period )
```

```
def aroon_down(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, then a default value of 25 will be used. |

Return: | double (floating point value) | Unbounded |

## Aroon Oscillator (AROONOSC)

The Aroon Oscillator is a trend-following indicator that uses aspects of the Aroon Indicator (Aroon Up and Aroon Down) to gauge the strength of a current trend and the likelihood that it will continue. Readings above zero indicate that an uptrend is present, while readings below zero indicate that a downtrend is present.

```
public async Task<double> AROONOSCAsync( double period )
```

```
def aroon_osc(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 25 will be used. |

Return: | double (floating point value) | -100 TO 100 |

## Aroon Up (AROONUP)

The Aroon indicator is a technical indicator that is used to identify trend changes in the price of an asset, as well as the strength of that trend. In essence, the indicator measures the time between highs and the time between lows over a time period.

The "Aroon up" line, which measures the strength of the uptrend.

```
public async Task<double> AROONUPAsync( double period )
```

```
def aroon_up(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 25 will be used. |

Return: | double (floating point value) | Unbounded |

## Average True Range (ATR)

Average true range (ATR) is a technical indicator measuring market volatility. It is typically derived from the 14-day moving average of a series of true range indicators.

```
public async Task<double> ATRAsync( double period )
```

```
def atr(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | Unbounded |

## Lower Bollinger Band (BBANDLOWER)

A Bollinger Band is a technical analysis tool defined by a set of trendlines plotted two standard deviations (positively and negatively) away from a simple moving average (SMA) of a security's price, but which can be adjusted to user preferences.

There are three lines that compose Bollinger Bands: A simple moving average (middle band) and an upper and lower band. The upper and lower bands are typically 2 standard deviations +/- from a 20-day simple moving average, but can be modified.

```
public async Task<double> BBANDLOWERAsync( double period, double stddev )
```

```
def bband_lower(self, period: float, stddev: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

stddev | double (floating point value) | 1-10 | If the stddev value is 0, a default value of 2 will be used. |

Return: | double (floating point value) | Unbounded |

## Mid Bollinger Band (BBANDMID)

A Bollinger Band is a technical analysis tool defined by a set of trendlines plotted two standard deviations (positively and negatively) away from a simple moving average (SMA) of a security's price, but which can be adjusted to user preferences.

There are three lines that compose Bollinger Bands: A simple moving average (middle band) and an upper and lower band. The upper and lower bands are typically 2 standard deviations +/- from a 20-day simple moving average, but can be modified.

```
public async Task<double> BBANDMIDAsync( double period, double stddev )
```

```
def bband_mid(self, period: float, stddev: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

stddev | double (floating point value) | 1-10 | If the stddev value is 0, a default value of 2 will be used. |

Return: | double (floating point value) | Unbounded |

## Upper Bollinger Band (BBANDUP)

A Bollinger Band is a technical analysis tool defined by a set of trendlines plotted two standard deviations (positively and negatively) away from a simple moving average (SMA) of a security's price, but which can be adjusted to user preferences.

There are three lines that compose Bollinger Bands: A simple moving average (middle band) and an upper and lower band. The upper and lower bands are typically 2 standard deviations +/- from a 20-day simple moving average, but can be modified.

```
public async Task<double> BBANDUPAsync( double period, double stddev )
```

```
def bband_up(self, period: float, stddev: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

stddev | double (floating point value) | 1-10 | If the stddev value is 0, a default value of 2 will be used. |

Return: | double (floating point value) | Unbounded |

## Commodity Channel Index (CCI)

the Commodity Channel Index (CCI) is a momentum-based oscillator used to help determine when an investment vehicle is reaching a condition of being overbought or oversold. It is also used to assess price trend direction and strength. This information allows traders to determine if they want to enter or exit a trade, refrain from taking a trade, or add to an existing position.

```
public async Task<double> CCIAsync( double period )
```

```
def cci(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | +ve to -ve Unbounded |

## Double Exponential Moving Average (DEMA)

The DEMA uses two exponential moving averages (EMAs) to eliminate lag, as some traders view lag as a problem. The DEMA is used in a similar way to traditional moving averages (MA).

The average helps confirm uptrends when the price is above the average, and helps confirm downtrends when the price is below the average. When the price crosses the average that may signal a trend change. Moving averages are also used to indicate areas of support or resistance.

```
public async Task<double> DEMAAsync( double period )
```

```
def dema(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Exponential Moving Average (EMA)

An exponential moving average (EMA) is a type of moving average (MA) that places a greater weight and significance on the most recent data points. The exponential moving average is also referred to as the exponentially weighted moving average.

An exponentially weighted moving average reacts more significantly to recent price changes than a simple moving average (SMA), which applies an equal weight to all observations in the period.

```
public async Task<double> EMAAsync( double period )
```

```
def ema(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Hull Moving Average (HMA)

The Hull Moving Average (HMA), developed by Alan Hull, is an extremely fast and smooth moving average. In fact, the HMA almost eliminates lag altogether and manages to improve smoothing at the same time.

A longer period HMA may be used to identify trend. If the HMA is rising, the prevailing trend is rising, indicating it may be better to enter long positions. If the HMA is falling, the prevailing trend is also falling, indicating it may be better to enter short positions.

```
public async Task<double> HMAAsync( double period )
```

```
def hma(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Kaufman Adaptive Moving Average (KAMA)

Kaufman’s Adaptive Moving Average is an intelligent moving average tool developed on the EMA (Exponential Moving Average), which is responsive to trend volatility. It follows the prices when the price fluctuations are insignificant, and the noise is low.

KAMA will automatically adjust when the prices fluctuate in large scale and follow the prices keeping a safe distance. Like other moving averages, KAMA can use to visualize the trend, understand price movements and time fluctuation points.

The Kaufman Adaptive Moving Average indicator is commonly using to build moving averages that have low reactivity to price series noises, and the minimal lag characterizes it for trend detection as smart trading.

```
public async Task<double> KAMAAsync( double period )
```

```
def kama(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Moving Average Convergence/Divergence (MACD)

Moving Average Convergence Divergence (MACD) is a trend-following momentum indicator that shows the relationship between two moving averages of a security’s price. The MACD is calculated by subtracting the 26-period Exponential Moving Average (EMA) from the 12-period EMA.

MACD triggers technical signals when it crosses above (to buy) or below (to sell) its signal line. The speed of crossovers is also taken as a signal of a market is overbought or oversold.

MACD helps investors understand whether the bullish or bearish movement in the price is strengthening or weakening.

```
public async Task<double> MACDAsync( double shortPeriod, double longPeriod, double signalPeriod )
```

```
def macd(self, short_period: float, long_period: float, signal_period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

shortPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 12 will be used. |

longPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 26 will be used. |

signalPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 9 will be used. |

Return: | double (floating point value) | Unbounded |

## Moving Average Convergence/Divergence Signal (MACDSIGNAL)

A Moving Average Convergence Divergence signal line is created with a 9 period EMA of the MACD line.

When the MACD line crosses from below to above the signal line, the indicator is considered bullish. The further below the zero line the stronger the signal. When the MACD line crosses from above to below the signal line, the indicator is considered bearish. The further above the zero line the stronger the signal.

```
public async Task<double> MACDSIGNALAsync( double shortPeriod, double longPeriod, double signalPeriod )
```

```
def macd_signal(self, short_period: float, long_period: float, signal_period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

shortPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 12 will be used. |

longPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 26 will be used. |

signalPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 9 will be used. |

Return: | double (floating point value) | Unbounded |

## Mean Deviation Over Period (MD)

The Mean Deviation Over Period indicator calculates the absolute mean deviation over a period.

```
public async Task<double> MDAsync( double period )
```

```
def md(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Money Flow Index (MFI)

The Money Flow Index (MFI) is a technical oscillator that uses price and volume data for identifying overbought or oversold signals in an asset. It can also be used to spot divergences which warn of a trend change in price. The oscillator moves between 0 and 100.

An MFI reading above 80 is considered overbought and an MFI reading below 20 is considered oversold, although levels of 90 and 10 are also used as thresholds. A divergence between the indicator and price is noteworthy. For example, if the indicator is rising while the price is falling or flat, the price could start rising.

```
public async Task<double> MFIAsync( double period )
```

```
def mfi(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | 0-100 |

## Negative DMI (MINUSDMI)

The Directional Movement Index (DMI) is composed of two lines, and an optional one, showing selling pressure (-DI), showing buying pressure (+DI), and a third DX line showing the difference between the former positive and negative lines.

A +DI line above the -DI line means there is more upward movement than downward movement. A -DI line above the +DI line means there is more downward movement than upward movement.

Crossovers can be used to signal emerging trends. For example, the +DI crossing above the -DI may signal the start of an uptrend in price. The larger the spread between the two lines, the stronger the price trend. If +DI is way above -DI the price trend is strongly up. If -DI is way above +DI then the price trend is strongly down.

```
public async Task<double> MINUSDMIAsync( double period )
```

```
def minus_dmi(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | Unbounded |

## Momentum (MOM)

Indicator that compares the current price of an asset with prices from previous periods to calculate the momentum. Momentum Indicator (MOM) compares the current price of an asset with prices from previous periods to calculate the momentum.

A horizontal line is drawn at the central point of the indicator. The MOM line being situated above the central line suggests an uptrend, while seeing MOM line move beneath the central line can identify a downtrend.

Divergences also reflect bullish or bearish conditions: we can consider it bearish if the asset’s price increases more than the MOM (e.g. reaching a new high while the indicator doesn’t), while it would be bullish to see the asset’s price decreasing more than the MOM does.

```
public async Task<double> MOMAsync( double period )
```

```
def mom(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 12 will be used. |

Return: | double (floating point value) | Unbounded |

## Normalized Average True Range (NATR)

Normalized Average True Range is a measure of volatility. Because Normalized Average True Range is normalized, it can be more useful than Average True Range when comparing across different price levels.

```
public async Task<double> NATRAsync( double period )
```

```
def natr(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | Unbounded |

## On Balance Volume (OBV)

On-balance volume (OBV) is a technical trading momentum indicator that uses volume flow to predict changes in stock price. On-balance volume (OBV) is a technical indicator of momentum, using volume changes to make price predictions. OBV shows crowd sentiment that can predict a bullish or bearish outcome.

Comparing relative action between price bars and OBV generates more actionable signals than the green or red volume histograms commonly found at the bottom of price charts.

```
public async Task<double> OBVAsync( double period )
```

```
def obv(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Positive DMI (PLUSDMI)

The Directional Movement Index (DMI) is composed of two lines, and an optional one, showing selling pressure (-DI), showing buying pressure (+DI), and a third DX line showing the difference between the former positive and negative lines.

A +DI line above the -DI line means there is more upward movement than downward movement. A -DI line above the +DI line means there is more downward movement than upward movement.

Crossovers can be used to signal emerging trends. For example, the +DI crossing above the -DI may signal the start of an uptrend in price. The larger the spread between the two lines, the stronger the price trend. If +DI is way above -DI the price trend is strongly up. If -DI is way above +DI then the price trend is strongly down.

```
public async Task<double> PLUSDMIAsync( double period )
```

```
def plus_dmi(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | Unbounded |

## Percentage Price Oscillator (PPO)

Percentage Price Oscillator measures momentum. The percentage price oscillator is simply the nine-day exponential moving average, decreased and then divided by the 26-day exponential moving average. It's a dimensionless quantity, a pure number that isn't fixed to a value such as the price of the underlying stock or other security.

The percentage price oscillator compares two exponential moving averages, it lets the user compare movements through different time frames.

```
public async Task<double> PPOAsync( double shortPeriod, double longPeriod )
```

```
def ppo(self, short_period: float, long_period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

shortPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 12 will be used. |

longPeriod | double (floating point value) | 1-200 | If the period value is 0, a default value of 26 will be used. |

Return: | double (floating point value) | -ve Unbounded to +ve Unbounded |

## Parabolic SAR (PSAR)

The parabolic SAR is a technical indicator used to determine the price direction of an asset, as well as draw attention to when the price direction is changing.

The technical indicator uses a trailing stop and reverse method called "SAR," or stop and reverse, to identify suitable exit and entry points.

```
public async Task<double> PSARAsync( double period, double acclFactorStep, double acclFactorMax )
```

```
def psar(self, period: float, accl_factor_step: float, accl_factor_max: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

acclFactorStep | double (floating point value) | 0-1 | If the period value is 0, a default value of 0.2 will be used. |

acclFactorMax | double (floating point value) | 1-10 | If the period value is 0, a default value of 2 will be used. |

Return: | double (floating point value) | Unbounded |

## Rate of Change (ROC)

The Rate of Change (ROC) oscillator is an unbounded momentum indicator used in technical analysis set against a zero-level midpoint. A rising ROC above zero typically confirms an uptrend while a falling ROC below zero indicates a downtrend.

When the price is consolidating, the ROC will hover near zero. In this case, it is important traders watch the overall price trend since the ROC will provide little insight except for confirming the consolidation.

```
public async Task<double> ROCAsync( double period )
```

```
def roc(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | Unbounded |

## Relative Strength Index (RSI)

The relative strength index (RSI) is a momentum indicator used in technical analysis that measures the magnitude of recent price changes to evaluate overbought or oversold conditions in the price of a stock or other asset.

The RSI provides technical traders signals about bullish and bearish price momentum, and it is often plotted beneath the graph of an asset's price. An asset is usually considered overbought when the RSI is above 70% and oversold when it is below 30%.

```
public async Task<double> RSIAsync( double period )
```

```
def rsi(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | 0-100 |

## Simple Moving Average (SMA)

A simple moving average (SMA) calculates the average of a selected range of prices, usually closing prices, by the number of periods in that range. A simple moving average is a technical indicator that can aid in determining if an asset price will continue or if it will reverse a bull or bear trend.

```
public async Task<double> SMAAsync( double period )
```

```
def sma(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Standard Deviation Over Period (STDDEV)

The Standard Deviation Over Period is an indicator that measures the size of recent price moves of an asset, to predict how volatile the price may be in future. It can help decide whether the volatility of the price is likely to increase or decrease.

The Standard Deviation Over Period indicator compares the current price movement and its historical price movement.

```
public async Task<double> STDDEVAsync( double period )
```

```
def stddev(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 50 will be used. |

Return: | double (floating point value) | Unbounded |

## Stochastic Slow Moving Line (STOCHD)

A stochastic oscillator is a momentum indicator comparing a particular closing price of a security to a range of its prices over a certain period of time. The sensitivity of the oscillator to market movements is reducible by adjusting that time period or by taking a moving average of the result. It is used to generate overbought and oversold trading signals, utilizing a 0-100 bounded range of values.

```
public async Task<double> STOCHDAsync( double period )
```

```
def stoch_d(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | 0-100 |

## Stochastic Fast Moving Line (STOCHK)

A stochastic oscillator is a momentum indicator comparing a particular closing price of a security to a range of its prices over a certain period of time. The sensitivity of the oscillator to market movements is reducible by adjusting that time period or by taking a moving average of the result. It is used to generate overbought and oversold trading signals, utilizing a 0-100 bounded range of values.

The Fast Moving line is an average of 3 period moving average.

```
public async Task<double> STOCHKAsync( double period )
```

```
def stoch_k(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | 0-100 |

## Sum Over Period (SUM)

The Sum Over Period indicator simply returns the sum of the last N bars.

```
public async Task<double> SUMAsync( double period )
```

```
def sum(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 50 will be used. |

Return: | double (floating point value) | Unbounded |

## Triple Exponential Moving Average (TEMA)

The triple exponential moving average was designed to smooth price fluctuations, thereby making it easier to identify trends without the lag associated with traditional moving averages (MA). It does this by taking multiple exponential moving averages (EMA) of the original EMA and subtracting out some of the lag.

```
public async Task<double> TEMAAsync( double period )
```

```
def tema(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Triangular Moving Average (TRIMA)

The Triangular Moving Average (TRIMA) represents an average of prices, but places weight on the middle prices of the time period. The calculations double-smooth the data using a window width that is one-half the length of the series.

```
public async Task<double> TRIMAAsync( double period )
```

```
def trima(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Triple Exponential Average (TRIX)

The triple exponential average (TRIX) indicator is an oscillator used to identify oversold and overbought markets, and it can also be used as a momentum indicator. Like many oscillators, TRIX oscillates around a zero line. When it is used as an oscillator, a positive value indicates an overbought market while a negative value indicates an oversold market.

```
public async Task<double> TRIXAsync( double period )
```

```
def trix(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 12 will be used. |

Return: | double (floating point value) | -ve Unbounded to +ve Unbounded |

## Variance Over Period (VAR)

The Variance Over Period indicator calculates the variance of the input over a moving window.

```
public async Task<double> VARAsync( double period )
```

```
def var(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 12 will be used. |

Return: | double (floating point value) | Unbounded |

## Annualized Historical Volatility (VOLATILITY)

The Annualized Historical Volatility indicator calculates the volatility over a moving window.

```
public async Task<double> VOLATILITYAsync( double period )
```

```
def volatility(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

## Volume Weighted Moving Average (VWMA)

Volume Weighted Moving Average (VWMA) is one type of moving averages. In addition to closing prices, VWMA incorporates volume into the calculation.

```
public async Task<double> VWMAAsync( double period )
```

```
def vwma(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 50 will be used. |

Return: | double (floating point value) | Unbounded |

## Williams %R (WILLR)

Williams %R, also known as the Williams Percent Range, is a type of momentum indicator that moves between 0 and -100 and measures overbought and oversold levels. The Williams %R may be used to find entry and exit points in the market. The indicator is very similar to the Stochastic oscillator and is used in the same way.

```
public async Task<double> WILLRAsync( double period )
```

```
def will_r(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | 0-100 |

## Weighted Moving Average (WMA)

A Weighted Moving Average puts more weight on recent data and less on past data. This is done by multiplying each bar’s price by a weighting factor. Because of its unique calculation, WMA will follow prices more closely than a corresponding Simple Moving Average.

Weighted moving averages assign a heavier weighting to more current data points since they are more relevant than data points in the distant past. The sum of the weighting should add up to 1 (or 100 percent).

```
public async Task<double> WMAAsync( double period )
```

```
def wma(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 14 will be used. |

Return: | double (floating point value) | Unbounded |

## Zero-Lag Exponential Moving Average (ZLEMA)

The Zero Lag Exponential Moving Average or better known by its name ZLEMA is a type of Exponential Moving Average. The technical indicator was developed by John Ehlers and Rick Way in 2010. It can help to reduce the lag from the EMA to track price swings and price averages more precisely. Hence the name, Zero Lag.

```
public async Task<double> ZLEMAAsync( double period )
```

```
def zlema(self, period: float):
```

Parameter | Parameter Type | Expected Values | Remarks |
---|---|---|---|

period | double (floating point value) | 1-200 | If the period value is 0, a default value of 20 will be used. |

Return: | double (floating point value) | Unbounded |

Updated about 2 years ago