MA Deviation Suite [InvestorUnknown]

This indicator combines advanced moving average techniques with multiple deviation metrics to offer traders a versatile tool for analyzing market trends and volatility.

Moving Average Types:

• SMA, EMA, HMA, DEMA, FRAMA, VWMA: Standard moving averages with different characteristics for smoothing price data.
  
• Corrective MA: This method corrects the MA by considering the variance, providing a more responsive average to price changes.
  

f_cma(float src, simple int length) =>
    ma     = ta.sma(src, length)
    v1      = ta.variance(src, length)
    v2      = math.pow(nz(ma[1], ma) - ma, 2)
    v3      = v1 == 0 or v2 == 0 ? 1 : v2 / (v1 + v2)
       
    var tolerance = math.pow(10, -5)
    float err   = 1
       
    // Gain Factor
    float kPrev = 1
    float k     = 1
       
    for i = 0 to 5000 by 1
        if err > tolerance
            k := v3 * kPrev * (2 - kPrev)
            err := kPrev - k
            kPrev := k
            kPrev            
    ma      := nz(ma[1], src) + k * (ma - nz(ma[1], src))

• Fisher Least Squares MA: Aims to reduce lag by using a Fisher Transform on residuals.
  

f_flsma(float src, simple int len) =>
    ma = src
    e = ta.sma(math.abs(src - nz(ma[1])), len)
    z = ta.sma(src - nz(ma[1], src), len) / e
    r = (math.exp(2 * z) - 1) / (math.exp(2 * z) + 1)
    a = (bar_index - ta.sma(bar_index, len)) / ta.stdev(bar_index, len) * r
    ma := ta.sma(src, len) + a * ta.stdev(src, len)

• Sine-Weighted MA & Cosine-Weighted MA: These give more weight to middle bars, creating a smoother curve; Cosine weights are shifted for a different focus.
  

Deviation Metrics:

• Average Absolute Deviation (AAD) and Median Absolute Deviation (MAD): AAD calculates the average of absolute deviations from the MA, offering a measure of volatility. MAD uses the median, which can be less sensitive to outliers.
  
• Standard Deviation (StDev): Measures the dispersion of prices from the mean.
  
• Average True Range (ATR): Reflects market volatility by considering the day's range.
  
• Average Deviation (adev): The average of previous deviations.
  

// Calculate deviations
float aad                           = f_aad(src, dev_len, ma) * dev_mul
float mad                           = f_mad(src, dev_len, ma) * dev_mul
float stdev                         = ta.stdev(src, dev_len)      * dev_mul
float atr                           = ta.atr(dev_len)             * dev_mul
float avg_dev                       = math.avg(aad, mad, stdev, atr)

// Calculated Median with +dev and -dev
float aad_p                         = ma + aad
float aad_m                         = ma - aad

float mad_p                         = ma + mad
float mad_m                         = ma - mad

float stdev_p                       = ma + stdev
float stdev_m                       = ma - stdev

float atr_p                         = ma + atr
float atr_m                         = ma - atr

float adev_p                        = ma + avg_dev
float adev_m                        = ma - avg_dev

// upper and lower
float upper                         = f_max4(aad_p, mad_p, stdev_p, atr_p)
float upper2                        = f_min4(aad_p, mad_p, stdev_p, atr_p)
float lower                         = f_min4(aad_m, mad_m, stdev_m, atr_m)
float lower2                        = f_max4(aad_m, mad_m, stdev_m, atr_m)

Determining Trend
The indicator generates trend signals by assessing where price stands relative to these deviation-based lines. It assigns a trend score by summing individual signals from each deviation measure. For instance, if price crosses above the MAD-based upper line, it contributes a bullish point; crossing below an ATR-based lower line contributes a bearish point.
When the aggregated trend score crosses above zero, it suggests a shift towards a bullish environment; crossing below zero indicates a bearish bias.

// Define Trend scores
var int aad_t                       = 0
if ta.crossover(src, aad_p)
    aad_t         := 1
if ta.crossunder(src, aad_m)
    aad_t         := -1


var int mad_t                       = 0
if ta.crossover(src, mad_p)
    mad_t         := 1
if ta.crossunder(src, mad_m)
    mad_t         := -1


var int stdev_t                     = 0
if ta.crossover(src, stdev_p)
    stdev_t         := 1
if ta.crossunder(src, stdev_m)
    stdev_t         := -1


var int atr_t                       = 0
if ta.crossover(src, atr_p)
    atr_t         := 1
if ta.crossunder(src, atr_m)
    atr_t         := -1


var int adev_t                      = 0
if ta.crossover(src, adev_p)
    adev_t         := 1
if ta.crossunder(src, adev_m)
    adev_t         := -1


int upper_t                         = src > upper ? 3 : 0
int lower_t                         = src < lower ? 0 : -3
int upper2_t                        = src > upper2 ? 1 : 0
int lower2_t                        = src < lower2 ? 0 : -1


float trend                         = aad_t + mad_t + stdev_t + atr_t + adev_t + upper_t + lower_t + upper2_t + lower2_t

var float sig                       = 0


if ta.crossover(trend, 0)
    sig     := 1


else if ta.crossunder(trend, 0)
    sig     := -1

Backtesting and Performance Metrics
The code integrates with a backtesting library that allows traders to:

• Evaluate the strategy historically
  
• Compare the indicator’s signals with a simple buy-and-hold approach
  
• Generate performance metrics (e.g., mean returns, Sharpe Ratio, Sortino Ratio) to assess historical effectiveness.
  

Practical Usage and Calibration
Default settings are not optimized: The given parameters serve as a starting point for demonstration. Users should adjust:

• len: Affects how smooth and lagging the moving average is.
  
• dev_len and dev_mul: Influence the sensitivity of the deviation measures. Larger multipliers widen the bands, potentially reducing false signals but introducing more lag. Smaller multipliers tighten the bands, producing quicker signals but potentially more whipsaws.
  

This flexibility allows the trader to tailor the indicator for various markets (stocks, forex, crypto) and time frames.

Disclaimer

• No guaranteed results: Historical performance does not guarantee future outcomes. Market conditions can vary widely.
  
• User responsibility: Traders should combine this indicator with other forms of analysis, appropriate risk management, and careful calibration of parameters.