Diamond Top/Bottom

1. Introduction & Hook

The Diamond Top/Bottom strategy is a fascinating and powerful approach in technical analysis. It is designed to identify major market reversals by detecting unique geometric patterns on price charts. Traders and quantitative analysts alike are drawn to this strategy for its ability to signal significant turning points, often before the broader market recognizes them. In this comprehensive guide, we will explore every facet of the Diamond Top/Bottom strategy, from its theoretical underpinnings to practical implementation in Pine Script, Python, Node.js, and more. Whether you are a seasoned trader or a developer seeking to automate trading signals, this article will equip you with the knowledge and tools to master the Diamond Top/Bottom strategy.

2. What is Diamond Top/Bottom?

The Diamond Top/Bottom pattern is a rare but highly reliable chart formation. It signals a potential reversal in the prevailing trend. The pattern gets its name from its diamond-like shape, which forms as price action creates a broadening followed by a narrowing structure. A Diamond Top typically appears at the end of an uptrend, indicating a bearish reversal. Conversely, a Diamond Bottom forms at the end of a downtrend, suggesting a bullish reversal.

Key characteristics of the pattern include:

• Symmetrical structure with two distinct peaks (tops) or troughs (bottoms).
• Broadening phase followed by a contracting phase.
• Volume often increases during the formation and peaks at the breakout.

Traders use this pattern to anticipate significant price moves, entering trades as the pattern completes and price breaks out of the diamond structure.

3. Market Logic Behind the Strategy

The logic behind the Diamond Top/Bottom strategy is rooted in market psychology. During the broadening phase, volatility increases as buyers and sellers battle for control. This phase reflects uncertainty and indecision. As the pattern contracts, the market consolidates, and a consensus begins to form. The breakout from the diamond signals that one side has gained dominance, often leading to a sharp move in the direction of the breakout.

For Diamond Tops, the pattern suggests that bullish momentum is waning, and sellers are gaining strength. For Diamond Bottoms, it indicates that selling pressure is exhausted, and buyers are poised to take control. This transition is what makes the pattern a powerful reversal signal.

4. Mathematical Foundation & Formula

While the Diamond Top/Bottom pattern is primarily visual, its detection can be formalized mathematically. The pattern consists of four trendlines:

• Two upper trendlines: one sloping upward (broadening), one sloping downward (contracting).
• Two lower trendlines: one sloping downward (broadening), one sloping upward (contracting).

To mathematically define the pattern:

• Identify a sequence of swing highs and swing lows.
• Fit linear regressions or connect the swing points to form the four trendlines.
• Check for symmetry and convergence/divergence of the trendlines.
• Confirm with volume analysis and breakout direction.

The formula for the trendlines can be expressed as:

// Upper Broadening Trendline: y = m1 * x + c1
// Upper Contracting Trendline: y = m2 * x + c2
// Lower Broadening Trendline: y = m3 * x + c3
// Lower Contracting Trendline: y = m4 * x + c4

Where m is the slope and c is the intercept, calculated from the swing points.

5. Step-by-Step Calculation Example

Let’s walk through a simplified example of detecting a Diamond Top pattern:

1. Identify five key swing points: A (start), B (first peak), C (trough), D (second peak), E (end).
2. Draw trendlines connecting A-B-D (upper) and A-C-E (lower).
3. Check that the distance between B and D is roughly equal to the distance between C and E.
4. Ensure the pattern broadens from A to B/C, then contracts from B/C to D/E.
5. Confirm a breakout below the lower trendline with increased volume.

This process can be automated using code to scan for the geometric relationships and breakout conditions.

6. Pine Script Implementation

Pine Script is the scripting language for TradingView, making it ideal for implementing the Diamond Top/Bottom strategy. Below is a well-commented Pine Script example that detects potential Diamond Top/Bottom patterns and signals breakouts:

//@version=6
// Diamond Top/Bottom Pattern Detector
indicator("Diamond Top/Bottom Detector", overlay=true)

// --- Parameters ---
length = input.int(20, title="Pattern Length")
threshold = input.float(0.02, title="Symmetry Threshold (%)")

// --- Helper Functions ---
// Find local maxima/minima
isHigh(idx) =>
    high[idx] > high[idx+1] and high[idx] > high[idx-1]
isLow(idx) =>
    low[idx] < low[idx+1] and low[idx] < low[idx-1]

// --- Pattern Detection ---
var float[] highs = array.new_float()
var float[] lows = array.new_float()
var int[] high_idx = array.new_int()
var int[] low_idx = array.new_int()

for i = 1 to length
    if isHigh(i)
        array.unshift(highs, high[i])
        array.unshift(high_idx, i)
    if isLow(i)
        array.unshift(lows, low[i])
        array.unshift(low_idx, i)

// Require at least 2 highs and 2 lows
if array.size(highs) >= 2 and array.size(lows) >= 2
    // Calculate symmetry
    high_diff = math.abs(array.get(highs, 0) - array.get(highs, 1)) / array.get(highs, 0)
    low_diff = math.abs(array.get(lows, 0) - array.get(lows, 1)) / array.get(lows, 0)
    if high_diff < threshold and low_diff < threshold
        // Draw diamond shape
        line.new(bar_index - array.get(high_idx, 0), array.get(highs, 0), bar_index - array.get(high_idx, 1), array.get(highs, 1), color=color.red)
        line.new(bar_index - array.get(low_idx, 0), array.get(lows, 0), bar_index - array.get(low_idx, 1), array.get(lows, 1), color=color.green)
        // Signal breakout
        if close < array.get(lows, 1)
            label.new(bar_index, low, "Diamond Top Breakout", color=color.red, style=label.style_label_down)
        if close > array.get(highs, 1)
            label.new(bar_index, high, "Diamond Bottom Breakout", color=color.green, style=label.style_label_up)

This script scans for symmetrical highs and lows, draws the diamond, and signals breakouts. You can adjust length and threshold for sensitivity.

7. Parameters & Customization in Pine Script

Customization is crucial for adapting the strategy to different markets and timeframes. Key parameters include:

• Pattern Length: Number of bars to scan for the pattern.
• Symmetry Threshold: How closely the highs/lows must match for symmetry.
• Volume Filter: Minimum volume required for breakout confirmation.
• Breakout Confirmation: Number of bars to wait after breakout before signaling.

Example of adding a volume filter:

// Add volume filter
min_vol = input.int(100000, title="Min Volume for Breakout")
if close < array.get(lows, 1) and volume > min_vol
    label.new(bar_index, low, "Diamond Top Breakout (Vol)", color=color.red)

8. Python & FastAPI + NoSQL Implementation

For algorithmic trading and backtesting, Python is a popular choice. Here’s how you can implement Diamond Top/Bottom detection using Python, FastAPI for API access, and a NoSql Database (e.g., MongoDB) for storing signals.

import numpy as np
from fastapi import FastAPI
from pymongo import MongoClient

app = FastAPI()
client = MongoClient('mongodb://localhost:27017/')
db = client['trading']
signals = db['diamond_signals']

def find_diamond_pattern(prices, window=20, threshold=0.02):
    highs = []
    lows = []
    for i in range(1, window-1):
        if prices[i] > prices[i-1] and prices[i] > prices[i+1]:
            highs.append((i, prices[i]))
        if prices[i] < prices[i-1] and prices[i] < prices[i+1]:
            lows.append((i, prices[i]))
    if len(highs) >= 2 and len(lows) >= 2:
        high_diff = abs(highs[0][1] - highs[1][1]) / highs[0][1]
        low_diff = abs(lows[0][1] - lows[1][1]) / lows[0][1]
        if high_diff < threshold and low_diff < threshold:
            return True, highs, lows
    return False, highs, lows

@app.post("/detect-diamond/")
def detect_diamond(prices: list):
    found, highs, lows = find_diamond_pattern(prices)
    if found:
        signals.insert_one({"pattern": "diamond", "highs": highs, "lows": lows})
    return {"found": found, "highs": highs, "lows": lows}

This API receives price data, detects the pattern, and stores signals in MongoDB for further analysis or trading automation.

9. Node.js / JavaScript Implementation

Node.js is ideal for real-time applications and web integrations. Here’s a JavaScript function to detect the Diamond Top/Bottom pattern:

// Diamond Top/Bottom Detector in JavaScript
function findDiamondPattern(prices, window = 20, threshold = 0.02) {
  let highs = [];
  let lows = [];
  for (let i = 1; i < window - 1; i++) {
    if (prices[i] > prices[i - 1] && prices[i] > prices[i + 1]) {
      highs.push({ idx: i, price: prices[i] });
    }
    if (prices[i] < prices[i - 1] && prices[i] < prices[i + 1]) {
      lows.push({ idx: i, price: prices[i] });
    }
  }
  if (highs.length >= 2 && lows.length >= 2) {
    let highDiff = Math.abs(highs[0].price - highs[1].price) / highs[0].price;
    let lowDiff = Math.abs(lows[0].price - lows[1].price) / lows[0].price;
    if (highDiff < threshold && lowDiff < threshold) {
      return { found: true, highs, lows };
    }
  }
  return { found: false, highs, lows };
}

This function can be integrated into trading bots, web dashboards, or serverless functions for real-time pattern detection.

10. Backtesting & Performance Insights

Backtesting is essential to validate the effectiveness of the Diamond Top/Bottom strategy. By applying the detection algorithm to historical data, traders can assess:

• Win rate and risk-reward ratio
• Average profit per trade
• Drawdown and volatility
• Optimal parameter settings

Example Python pseudocode for backtesting:

for symbol in symbols:
    prices = get_historical_prices(symbol)
    for i in range(window, len(prices)):
        found, highs, lows = find_diamond_pattern(prices[i-window:i])
        if found:
            # Simulate entry and exit
            entry = prices[i]
            exit = prices[i+5]  # Example: exit after 5 bars
            profit = exit - entry
            record_trade(symbol, entry, exit, profit)

Performance metrics can be visualized and analyzed to refine the strategy further.

11. Risk Management Integration

Risk management is critical for long-term trading success. The Diamond Top/Bottom strategy should be combined with robust risk controls:

• Position Sizing: Calculate trade size based on account equity and risk tolerance.
• Stop-Loss: Place stop-loss orders just outside the diamond pattern to limit losses.
• Take-Profit: Set profit targets based on the pattern’s height or a fixed risk-reward ratio.

Example Pine Script for automated exits:

// Position sizing and exits
risk_pct = input.float(1.0, title="Risk % per Trade")
account_size = input.float(10000, title="Account Size")
pattern_height = math.abs(array.get(highs, 0) - array.get(lows, 0))
stop_loss = array.get(lows, 1) - pattern_height * 0.1

if close < array.get(lows, 1)
    qty = (account_size * risk_pct / 100) / (close - stop_loss)
    strategy.entry("Short", strategy.short, qty)
    strategy.exit("TP/SL", "Short", stop=stop_loss, limit=close - pattern_height)

This ensures each trade risks only a fixed percentage of capital and automates exits.

12. Combining with Other Indicators

The Diamond Top/Bottom strategy can be enhanced by combining it with other technical indicators:

• Moving Averages: Confirm trend direction and filter false signals.
• RSI/MACD: Validate overbought/oversold conditions at the breakout.
• Bollinger Bands: Assess volatility and breakout strength.

Example Pine Script snippet:

// Combine with RSI
rsi = ta.rsi(close, 14)
if close < array.get(lows, 1) and rsi > 70
    label.new(bar_index, low, "Diamond Top + RSI Overbought", color=color.red)

13. Multi-Timeframe & Multi-Asset Usage

The Diamond Top/Bottom strategy is versatile and can be applied across multiple timeframes and asset classes:

• Timeframes: 1-minute, 15-minute, daily, weekly charts.
• Assets: Equities, forex, cryptocurrencies, options, commodities.

To implement multi-timeframe analysis in Pine Script:

// Multi-timeframe detection
htf_high = request.security(syminfo.tickerid, "D", ta.highest(high, length))
htf_low = request.security(syminfo.tickerid, "D", ta.lowest(low, length))
if close < htf_low
    label.new(bar_index, low, "HTF Diamond Bottom Breakout", color=color.green)

This approach increases the robustness of signals and adapts the strategy to various trading styles.

14. AI/ML Enhancements

Artificial Intelligence and Machine Learning can take the Diamond Top/Bottom strategy to the next level:

• Feature Engineering: Use pattern detection as an input feature for ML models.
• Parameter Optimization: Employ reinforcement learning (RL) agents to optimize detection thresholds and trade management rules.

Example pseudocode for RL agent optimization:

# RL agent for optimizing pattern parameters
for episode in range(num_episodes):
    params = agent.select_parameters()
    reward = backtest_strategy(params)
    agent.update_policy(reward)

This enables adaptive strategies that evolve with changing market conditions.

15. Automation with Playwright/Jest

Automated testing ensures the reliability of strategy scripts. playwright and Jest are powerful tools for end-to-end and unit testing:

• Playwright: Automate browser-based testing of trading dashboards.
• Jest: Unit test pattern detection logic in JavaScript/TypeScript.

Example Jest unit test:

const { findDiamondPattern } = require('./diamond');
test('detects diamond pattern', () => {
  const prices = [1,2,3,2,1,2,3,2,1];
  const result = findDiamondPattern(prices, 9, 0.5);
  expect(result.found).toBe(true);
});

This ensures your detection logic works as expected before deploying to production.

16. Advanced Variations

Advanced traders may experiment with variations of the Diamond Top/Bottom strategy:

• Partial Diamonds: Patterns with incomplete symmetry but strong breakouts.
• Volume-Weighted Diamonds: Require volume confirmation at each swing point.
• Multi-Leg Diamonds: Patterns with more than two peaks/troughs for added confirmation.

These variations can be coded by adjusting detection criteria and adding new filters.

17. Common Pitfalls & Misconceptions

Despite its power, the Diamond Top/Bottom strategy is not foolproof. Common pitfalls include:

• Overfitting: Tweaking parameters to fit historical data too closely.
• Ignoring Volume: Breakouts without volume confirmation are prone to failure.
• Pattern Subjectivity: Visual patterns can be interpreted differently by different traders or algorithms.
• Choppy Markets: The pattern is less reliable in sideways or low-volatility markets.

To avoid these issues, combine the strategy with other indicators and robust risk management.

18. Conclusion & Key Takeaways

The Diamond Top/Bottom strategy is a sophisticated tool for detecting major market reversals. By understanding its geometric structure, market logic, and mathematical foundation, traders can harness its power across multiple platforms and asset classes. Automation, AI enhancements, and rigorous testing further increase its effectiveness. Remember to combine the strategy with sound risk management and other indicators for best results.

Glossary of Key Terms

• Diamond Top/Bottom: A chart pattern signaling a potential reversal, shaped like a diamond.
• Breakout: Price movement outside the pattern, indicating a new trend.
• Symmetry Threshold: Parameter defining how closely swing highs/lows must match.
• Volume Confirmation: Increased trading volume validating the breakout.
• Reinforcement Learning: AI technique for optimizing strategy parameters.
• Backtesting: Testing a strategy on historical data to assess performance.

Comparison Table