Abandoned Baby

1. Introduction & Hook

The world of trading is filled with patterns, signals, and strategies. Among these, the Abandoned Baby stands out as a rare but powerful reversal pattern. Traders who master its nuances can spot market turning points with precision. This article dives deep into the Abandoned Baby strategy, exploring its logic, mathematics, and implementation across Pine Script, Python, Node.js, and more. Whether you are a beginner or a seasoned algorithmic trader, this comprehensive guide will equip you with the knowledge to leverage the Abandoned Baby for consistent trading success.

2. What is Abandoned Baby?

The Abandoned Baby is a three-candle reversal pattern found on price charts. It signals a potential change in trend direction, typically from bullish to bearish or vice versa. The pattern consists of:

• A strong trend candle (bullish or bearish)
• A doji candle that gaps away from the previous candle
• A third candle that moves in the opposite direction of the first

This pattern is rare due to the gap required between the doji and its neighbors. Its rarity increases its reliability as a reversal signal.

3. Market Logic Behind the Strategy

The Abandoned Baby pattern reflects a sudden shift in market sentiment. The first candle confirms the prevailing trend. The doji, isolated by gaps, shows indecision and a lack of follow-through. The third candle, closing in the opposite direction, confirms the reversal. This sequence often marks exhaustion of the current trend and the start of a new one.

4. Mathematical Foundation & Formula

To programmatically detect the Abandoned Baby, we define:

• Gap Up (Bullish): The low of the doji is higher than the high of the previous candle, and the low of the third candle is higher than the high of the doji.
• Gap Down (Bearish): The high of the doji is lower than the low of the previous candle, and the high of the third candle is lower than the low of the doji.
• Doji: The open and close are nearly equal (within a small threshold).

Mathematically:

• Doji: |open - close| <= doji_threshold * (high - low)
• Bullish Abandoned Baby: candle1.close < candle1.open AND doji_gap_up AND candle3.close > candle3.open
• Bearish Abandoned Baby: candle1.close > candle1.open AND doji_gap_down AND candle3.close < candle3.open

5. Step-by-Step Calculation Example

Suppose we have the following three candles:

• Candle 1: Open 100, Close 90, High 105, Low 89
• Candle 2 (Doji): Open 91, Close 91.2, High 92, Low 90.8
• Candle 3: Open 92.5, Close 97, High 98, Low 92.2

1. Check if Candle 2 is a doji: |91 - 91.2| = 0.2. If doji_threshold = 0.1, high - low = 1.2, 0.2 <= 0.12 (false), so increase threshold or check for near-doji.
2. Check for gap: Candle 2 low (90.8) > Candle 1 high (105)? No. So not a bullish abandoned baby. Adjust for real-world data and thresholds.

In practice, thresholds are tuned for asset volatility and timeframe.

6. Pine Script Implementation

Below is a Pine Script implementation of the Abandoned Baby strategy. This code identifies both bullish and bearish patterns and plots signals on the chart.

// Abandoned Baby Strategy in Pine Script 
//@version=6 
strategy("Abandoned Baby Strategy", overlay=true) 
 
// Parameters 
doji_threshold = input.float(0.1, title="Doji Threshold (%)", minval=0.01, step=0.01) 
gap_size = input.float(0.01, title="Gap Size (%)", minval=0.001, step=0.001) 
 
// Helper functions 
is_doji(open, close, high, low, threshold) => 
    math.abs(open - close) <= threshold * (high - low) 
 
// Detect patterns 
bullish_abandoned_baby = is_doji(open[1], close[1], high[1], low[1], doji_threshold) and 
    low[1] > high[2] + gap_size * high[2] and 
    low > high[1] + gap_size * high[1] and 
    close > open and 
    close[2] < open[2] 
 
bearish_abandoned_baby = is_doji(open[1], close[1], high[1], low[1], doji_threshold) and 
    high[1] < low[2] - gap_size * low[2] and 
    high < low[1] - gap_size * low[1] and 
    close < open and 
    close[2] > open[2] 
 
// Plot signals 
plotshape(bullish_abandoned_baby, style=shape.triangleup, location=location.belowbar, color=color.green, size=size.small, title="Bullish Abandoned Baby") 
plotshape(bearish_abandoned_baby, style=shape.triangledown, location=location.abovebar, color=color.red, size=size.small, title="Bearish Abandoned Baby") 
 
// Strategy orders 
if bullish_abandoned_baby 
    strategy.entry("Long", strategy.long) 
if bearish_abandoned_baby 
    strategy.entry("Short", strategy.short) 

7. Parameters & Customization in Pine Script

Key parameters for customization:

• Doji Threshold: Controls sensitivity to doji detection. Lower values require a tighter open-close range.
• Gap Size: Sets the minimum gap between candles. Adjust for asset volatility.
• Lookback Period: You can expand detection to more candles for confirmation.

Example of parameter customization:

// Customizable parameters 
doji_threshold = input.float(0.08, title="Doji Threshold (%)") 
gap_size = input.float(0.015, title="Gap Size (%)") 

8. Python & FastAPI + NoSQL Implementation

Python is ideal for backtesting and integrating with APIs. Below is a simplified Python implementation using FastAPI and a NoSQL (MongoDB) backend for storing detected patterns.

# Abandoned Baby detection in Python with FastAPI and MongoDB 
from fastapi import FastAPI 
from pydantic import BaseModel 
from typing import List 
from pymongo import MongoClient 
 
app = FastAPI() 
client = MongoClient("mongodb://localhost:27017/") 
db = client["trading"] 
collection = db["abandoned_baby_signals"] 
 
class Candle(BaseModel): 
    open: float 
    close: float 
    high: float 
    low: float 
 
def is_doji(candle, threshold=0.1): 
    return abs(candle.open - candle.close) <= threshold * (candle.high - candle.low) 
 
def detect_abandoned_baby(candles: List[Candle], doji_threshold=0.1, gap_size=0.01): 
    signals = [] 
    for i in range(2, len(candles)): 
        c1, c2, c3 = candles[i-2], candles[i-1], candles[i] 
        if is_doji(c2, doji_threshold): 
            # Bullish 
            if c2.low > c1.high * (1 + gap_size) and c3.low > c2.high * (1 + gap_size) and c3.close > c3.open and c1.close < c1.open: 
                signals.append({"type": "bullish", "index": i}) 
                collection.insert_one({"type": "bullish", "index": i}) 
            # Bearish 
            if c2.high < c1.low * (1 - gap_size) and c3.high < c2.low * (1 - gap_size) and c3.close < c3.open and c1.close > c1.open: 
                signals.append({"type": "bearish", "index": i}) 
                collection.insert_one({"type": "bearish", "index": i}) 
    return signals 
 
@app.post("/detect") 
def detect(candles: List[Candle]): 
    return detect_abandoned_baby(candles) 

9. Node.js / JavaScript Implementation

Node.js is popular for real-time trading bots. Here is a JavaScript function to detect the Abandoned Baby pattern in an array of candle objects:

// Abandoned Baby detection in JavaScript 
function isDoji(candle, threshold = 0.1) { 
    return Math.abs(candle.open - candle.close) <= threshold * (candle.high - candle.low); 
} 
 
function detectAbandonedBaby(candles, dojiThreshold = 0.1, gapSize = 0.01) { 
    const signals = []; 
    for (let i = 2; i < candles.length; i++) { 
        const c1 = candles[i - 2]; 
        const c2 = candles[i - 1]; 
        const c3 = candles[i]; 
        if (isDoji(c2, dojiThreshold)) { 
            // Bullish 
            if (c2.low > c1.high * (1 + gapSize) && c3.low > c2.high * (1 + gapSize) && c3.close > c3.open && c1.close < c1.open) { 
                signals.push({ type: 'bullish', index: i }); 
            } 
            // Bearish 
            if (c2.high < c1.low * (1 - gapSize) && c3.high < c2.low * (1 - gapSize) && c3.close < c3.open && c1.close > c1.open) { 
                signals.push({ type: 'bearish', index: i }); 
            } 
        } 
    } 
    return signals; 
} 

10. Backtesting & Performance Insights

Backtesting is crucial to validate the Abandoned Baby strategy. In Pine Script, use strategy.* functions to simulate trades. In Python, use historical data and track performance metrics like win rate, average return, and drawdown.

• Win Rate: Percentage of profitable trades
• Risk-Reward Ratio: Average profit per trade vs. average loss
• Drawdown: Largest peak-to-trough equity decline

Example Python pseudocode for backtesting:

# Pseudocode for backtesting 
for signal in signals: 
    entry_price = data[signal['index']].close 
    exit_price = ... # define exit logic 
    profit = exit_price - entry_price 
    # Track stats 

11. Risk Management Integration

Risk management is essential. Integrate position sizing, stop-loss, and take-profit rules into your strategy.

• Position Sizing: Risk a fixed percentage of capital per trade
• Stop-Loss: Place below/above the doji or recent swing
• Take-Profit: Use fixed ratio or trailing stop

// Pine Script: Automated exits 
stop_loss = input.float(1.5, title="Stop Loss (%)") / 100 
take_profit = input.float(3.0, title="Take Profit (%)") / 100 
 
if bullish_abandoned_baby 
    strategy.entry("Long", strategy.long) 
    strategy.exit("TP/SL", from_entry="Long", stop=close * (1 - stop_loss), limit=close * (1 + take_profit)) 
if bearish_abandoned_baby 
    strategy.entry("Short", strategy.short) 
    strategy.exit("TP/SL", from_entry="Short", stop=close * (1 + stop_loss), limit=close * (1 - take_profit)) 

12. Combining with Other Indicators

Enhance the Abandoned Baby by combining it with:

• Moving Averages: Confirm trend direction
• RSI: Filter overbought/oversold conditions
• Volume: Confirm breakout strength

// Pine Script: Combine with RSI 
rsi = ta.rsi(close, 14) 
if bullish_abandoned_baby and rsi < 30 
    strategy.entry("Long", strategy.long) 

13. Multi-Timeframe & Multi-Asset Usage

The Abandoned Baby can be applied across timeframes and assets:

• Timeframes: 1m, 15m, daily, weekly
• Assets: Equities, forex, crypto, options

// Pine Script: Multi-timeframe confirmation 
higher_tf = input.timeframe("D", title="Higher Timeframe") 
bullish_abandoned_baby_htf = request.security(syminfo.tickerid, higher_tf, bullish_abandoned_baby) 
if bullish_abandoned_baby and bullish_abandoned_baby_htf 
    strategy.entry("Long", strategy.long) 

14. AI/ML Enhancements

Machine learning can optimize parameters and signal filtering. Feature engineering includes:

• Pattern frequency
• Gap size statistics
• Doji body-to-range ratio

# Python: RL agent optimizing parameters 
import gym 
class AbandonedBabyEnv(gym.Env): 
    def __init__(self, data): 
        ... 
    def step(self, action): 
        # action: adjust doji_threshold, gap_size 
        # reward: trading performance 
        ... 

15. Automation with Playwright/Jest

Automate testing of your strategy scripts using playwright or Jest.

// Jest: Unit test for pattern detection 
test('detects bullish abandoned baby', () => { 
    const candles = [...]; // mock data 
    const signals = detectAbandonedBaby(candles); 
    expect(signals.some(s => s.type === 'bullish')).toBe(true); 
}); 

16. Advanced Variations

Advanced traders may:

• Require volume confirmation
• Use ATR-based gap thresholds
• Combine with other reversal patterns

// Pine Script: ATR-based gap 
atr = ta.atr(14) 
gap_size_atr = input.float(1.0, title="Gap ATR Multiplier") 
gap = gap_size_atr * atr 

17. Common Pitfalls & Misconceptions

• Ignoring Market Context: The pattern is less reliable in choppy markets.
• Overfitting Parameters: Excessive tuning may reduce robustness.
• Neglecting Volume: Low-volume signals are weaker.

18. Conclusion & Key Takeaways

The Abandoned Baby is a potent reversal pattern when used with proper risk management and confirmation. Its rarity makes it valuable, but traders must avoid overfitting and always consider market context. With robust implementation in Pine Script, Python, and JavaScript, and enhancements via AI/ML, the Abandoned Baby can be a cornerstone of a disciplined trading strategy.

Glossary of Key Terms

• Doji: A candle with nearly equal open and close
• Gap: Price difference between candles with no overlap
• Reversal Pattern: Chart formation signaling trend change
• Backtesting: Simulating strategy on historical data
• Risk Management: Techniques to control losses

Comparison Table