Hull Moving Average

1. Introduction & Hook

The Hull Moving Average (HMA) is a powerful tool for traders seeking to capture trends with minimal lag and maximum smoothness. In the fast-paced world of algorithmic trading, every edge counts. The HMA stands out for its ability to respond quickly to price changes while filtering out market noise. This article will guide you through the intricacies of the Hull Moving Average, from its mathematical foundation to advanced Pine Script implementations, and even cross-language integrations. Whether you are a beginner or a seasoned quant, you will find actionable insights and code examples to elevate your trading strategies.

2. What is Hull Moving Average?

The Hull Moving Average is a technical indicator developed by Alan Hull. Its primary goal is to reduce the lag associated with traditional moving averages, such as the Simple Moving Average (SMA) and Exponential Moving Average (EMA), while maintaining a smooth curve. The HMA achieves this by combining weighted moving averages in a unique way, making it highly responsive to price action. Traders use the HMA to identify trend direction, generate entry and exit signals, and filter out market noise.

3. Market Logic Behind the Strategy

Market participants rely on moving averages to discern trends and potential reversals. However, traditional moving averages often lag behind price, causing delayed signals. The Hull Moving Average addresses this issue by providing a more timely reflection of market sentiment. Its responsiveness allows traders to enter and exit positions closer to optimal points, reducing slippage and improving risk-reward ratios. The HMA is particularly effective in trending markets, where quick adaptation to price changes is crucial.

4. Mathematical Foundation & Formula

The Hull Moving Average is constructed using Weighted Moving Averages (WMA). The formula is as follows:

• Step 1: Calculate a WMA with period n/2 and multiply it by 2.
• Step 2: Subtract a WMA with period n.
• Step 3: Calculate a WMA of the result from Step 2, using period sqrt(n).

Mathematically:

HMA(n) = WMA(2 * WMA(price, n/2) - WMA(price, n), sqrt(n))

Where:

• WMA(price, period): Weighted Moving Average of price over the specified period.
• n: The chosen period for the HMA.

5. Step-by-Step Calculation Example

Let’s walk through a simplified example with n = 9 and a sample price series:

• Step 1: Calculate WMA of the price series with period 4.5 (rounded to 4 or 5).
• Step 2: Calculate WMA of the price series with period 9.
• Step 3: Multiply the WMA(4) by 2 and subtract WMA(9).
• Step 4: Calculate WMA of the result from Step 3 with period 3 (sqrt(9)).

This process results in a moving average that reacts quickly to price changes while remaining smooth.

6. Pine Script Implementation

Pine Script makes it straightforward to implement the Hull Moving Average. Below is a well-commented example:

//@version=6
indicator("Hull Moving Average", overlay=true)
length = input.int(21, minval=1, title="HMA Length")
halfLength = math.round(length / 2)
sqrtLength = math.round(math.sqrt(length))
wma1 = ta.wma(close, halfLength)
wma2 = ta.wma(close, length)
hmaRaw = 2 * wma1 - wma2
hma = ta.wma(hmaRaw, sqrtLength)
plot(hma, color=color.blue, linewidth=2, title="HMA")
// Buy and sell signals
longSignal = ta.crossover(close, hma)
shortSignal = ta.crossunder(close, hma)
plotshape(longSignal, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, title="Buy Signal")
plotshape(shortSignal, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, title="Sell Signal")

7. Parameters & Customization in Pine Script

Customizing the HMA in Pine Script involves adjusting the length parameter and integrating additional features:

• Length: Controls the sensitivity of the HMA. Shorter lengths react faster but may introduce noise.
• Source: You can use different price sources (close, open, high, low).
• Signal Generation: Combine with other indicators or add alerts for automation.

// Customizable HMA
length = input.int(34, minval=1, title="HMA Length")
source = input.source(close, title="Source")
halfLength = math.round(length / 2)
sqrtLength = math.round(math.sqrt(length))
wma1 = ta.wma(source, halfLength)
wma2 = ta.wma(source, length)
hmaRaw = 2 * wma1 - wma2
hma = ta.wma(hmaRaw, sqrtLength)
plot(hma, color=color.purple, linewidth=2, title="Custom HMA")

8. Python & FastAPI + NoSQL Implementation

For algorithmic traders and quants, implementing the HMA in Python enables integration with data pipelines and backtesting frameworks. Here’s a Python example using NumPy and Pandas, followed by a FastAPI endpoint and a NoSQL (MongoDB) storage snippet.

import numpy as np
import pandas as pd

def wma(series, period):
    weights = np.arange(1, period + 1)
    return series.rolling(period).apply(lambda prices: np.dot(prices, weights) / weights.sum(), raw=True)

def hma(series, period):
    half_length = int(period / 2)
    sqrt_length = int(np.sqrt(period))
    wma_half = wma(series, half_length)
    wma_full = wma(series, period)
    hma_raw = 2 * wma_half - wma_full
    return wma(hma_raw, sqrt_length)

# Example usage
prices = pd.Series([100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110])
hma_values = hma(prices, 9)
print(hma_values)

FastAPI endpoint for HMA calculation:

from fastapi import FastAPI, Query
from pydantic import BaseModel
import pandas as pd

app = FastAPI()

class PriceData(BaseModel):
    prices: list
    period: int

@app.post("/hma")
def calculate_hma(data: PriceData):
    series = pd.Series(data.prices)
    result = hma(series, data.period)
    return {"hma": result.tolist()}

Storing HMA results in MongoDB (NoSQL):

from pymongo import MongoClient
client = MongoClient("mongodb://localhost:27017/")
db = client["trading"]
collection = db["hma_results"]
collection.insert_one({"hma": hma_values.tolist(), "period": 9})

9. Node.js / JavaScript Implementation

Node.js is popular for building trading bots and web dashboards. Here’s a JavaScript implementation of the HMA:

function wma(values, period) {
  let result = [];
  for (let i = 0; i < values.length; i++) {
    if (i + 1 < period) {
      result.push(null);
      continue;
    }
    let weights = 0, sum = 0;
    for (let j = 0; j < period; j++) {
      weights += (j + 1);
      sum += values[i - j] * (j + 1);
    }
    result.push(sum / weights);
  }
  return result;
}

function hma(values, period) {
  let half = Math.floor(period / 2);
  let sqrt = Math.floor(Math.sqrt(period));
  let wma_half = wma(values, half);
  let wma_full = wma(values, period);
  let hma_raw = wma_half.map((val, idx) => val !== null && wma_full[idx] !== null ? 2 * val - wma_full[idx] : null);
  return wma(hma_raw, sqrt);
}

// Example usage
const prices = [100,101,102,103,104,105,106,107,108,109,110];
console.log(hma(prices, 9));

10. Backtesting & Performance Insights

Backtesting is essential to validate the effectiveness of the HMA strategy. In Pine Script, you can use the strategy functions to simulate trades:

//@version=6
strategy("HMA Backtest", overlay=true)
length = input.int(21)
halfLength = math.round(length / 2)
sqrtLength = math.round(math.sqrt(length))
wma1 = ta.wma(close, halfLength)
wma2 = ta.wma(close, length)
hmaRaw = 2 * wma1 - wma2
hma = ta.wma(hmaRaw, sqrtLength)
longSignal = ta.crossover(close, hma)
shortSignal = ta.crossunder(close, hma)
if longSignal
    strategy.entry("Long", strategy.long)
if shortSignal
    strategy.entry("Short", strategy.short)

Performance metrics to analyze include:

• Win rate
• Profit factor
• Maximum drawdown
• Sharpe ratio

Backtesting in Python can be done using libraries like Backtrader or Zipline, integrating the HMA logic as a custom indicator.

11. Risk Management Integration

Effective risk management is crucial for long-term trading success. Integrate position sizing, stop-loss, and take-profit mechanisms with your HMA strategy.

• Position Sizing: Use a fixed percentage of equity or volatility-based sizing.
• Stop-Loss: Place stops below/above recent swing points or a multiple of ATR.
• Take-Profit: Set targets based on risk-reward ratios or trailing stops.

// Pine Script example with risk management
risk = input.float(1, title="Risk %", minval=0.1)
stopLossATR = input.float(2, title="Stop Loss ATR Multiplier")
takeProfitATR = input.float(3, title="Take Profit ATR Multiplier")
atr = ta.atr(14)
longSignal = ta.crossover(close, hma)
shortSignal = ta.crossunder(close, hma)
if longSignal
    strategy.entry("Long", strategy.long)
    strategy.exit("TP/SL", from_entry="Long", stop=close - stopLossATR * atr, limit=close + takeProfitATR * atr)
if shortSignal
    strategy.entry("Short", strategy.short)
    strategy.exit("TP/SL", from_entry="Short", stop=close + stopLossATR * atr, limit=close - takeProfitATR * atr)

12. Combining with Other Indicators

The HMA can be combined with other indicators for confirmation and enhanced signal quality. Popular combinations include:

• Relative Strength Index (RSI): Filter trades based on overbought/oversold conditions.
• MACD: Confirm trend direction and momentum.
• Bollinger Bands: Identify volatility and potential breakout points.

// Example: HMA + RSI filter
rsi = ta.rsi(close, 14)
longSignal = ta.crossover(close, hma) and rsi > 50
shortSignal = ta.crossunder(close, hma) and rsi < 50

13. Multi-Timeframe & Multi-Asset Usage

The HMA is versatile and can be applied across various timeframes and asset classes:

• Multi-Timeframe: Use the HMA on 1-minute, 15-minute, daily, or weekly charts. For confirmation, combine signals from higher and lower timeframes.
• Multi-Asset: Apply the HMA to equities, forex, cryptocurrencies, and options. Adjust the length parameter based on the asset’s volatility and trading style.

// Multi-timeframe HMA in Pine Script
hmaHigher = request.security(syminfo.tickerid, "D", hma)
plot(hmaHigher, color=color.orange, linewidth=1, title="Daily HMA")

14. AI/ML Enhancements

Machine learning can enhance the HMA strategy by optimizing parameters and generating adaptive signals. Feature engineering with HMA values, slopes, and crossovers can feed into supervised or reinforcement learning models.

• Feature Engineering: Use HMA values, crossovers, and slopes as features for ML models.
• Reinforcement Learning: Train an RL agent to optimize HMA parameters for maximum reward.

# Example: RL agent optimizing HMA length (pseudocode)
for episode in range(num_episodes):
    hma_length = agent.select_action()
    rewards = backtest_hma_strategy(hma_length)
    agent.update_policy(rewards)

15. Automation with Playwright/Jest

Automated testing ensures the reliability of your HMA scripts. Use playwright for end-to-end browser tests or Jest for unit testing in JavaScript environments.

// Jest unit test for HMA function
const { hma } = require('./hma');
test('HMA returns correct length', () => {
  const prices = [100,101,102,103,104,105,106,107,108,109,110];
  const result = hma(prices, 9);
  expect(result.length).toBe(prices.length);
});

// Playwright e2e test (pseudocode)
import { test, expect } from '@playwright/test';
test('HMA indicator loads on chart', async ({ page }) => {
  await page.goto('http://localhost:3000/chart');
  await page.click('button#add-hma');
  const hmaLine = await page.$('svg .hma-line');
  expect(hmaLine).not.toBeNull();
});

16. Advanced Variations

Advanced traders may experiment with:

• Adaptive HMA: Adjust length based on volatility.
• Double HMA: Use two HMAs with different lengths for crossovers.
• HMA Bands: Create upper and lower bands around the HMA for breakout strategies.

// Double HMA crossover
hmaFast = ta.wma(2 * ta.wma(close, 9/2) - ta.wma(close, 9), math.round(math.sqrt(9)))
hmaSlow = ta.wma(2 * ta.wma(close, 21/2) - ta.wma(close, 21), math.round(math.sqrt(21)))
longSignal = ta.crossover(hmaFast, hmaSlow)
shortSignal = ta.crossunder(hmaFast, hmaSlow)

17. Common Pitfalls & Misconceptions

• Overfitting: Avoid optimizing HMA length solely on historical data.
• Choppy Markets: The HMA may generate false signals in sideways markets.
• Ignoring Risk: Always integrate robust risk management.
• Parameter Selection: Test different lengths across assets and timeframes.

18. Conclusion & Key Takeaways

The Hull Moving Average is a versatile and responsive indicator that can enhance any trading strategy. Its unique construction minimizes lag and maximizes smoothness, making it ideal for trend identification and signal generation. By integrating the HMA with robust risk management, multi-timeframe analysis, and even AI/ML enhancements, traders can gain a significant edge in the markets. Always backtest thoroughly and adapt your approach to changing market conditions.

Glossary of Key Terms

• HMA: Hull Moving Average, a fast and smooth moving average.
• WMA: Weighted Moving Average, assigns more weight to recent prices.
• Lag: Delay between price movement and indicator response.
• Backtesting: Simulating a strategy on historical data.
• ATR: Average True Range, measures market volatility.
• Reinforcement Learning: Machine learning technique for optimizing actions.

Comparison Table