बूम इंडेक्स स्पाइक पैटर्न: मेटाट्रेडर 5 के लिए इंडिकेटर

बुलिश स्पाइक पैटर्न पहचान

• 3-कैंडल पैटर्न:

  • 1st कैंडल: हरा और बड़ा (बुलिश स्पाइक).

  • 2nd कैंडल: लाल (पुलबैक).

  • 3rd कैंडल: हरा और बड़ा (बुलिश स्पाइक).

• जब यह पैटर्न दिखाई देता है, तो एक जोन बनता है.

जोन निर्माण

• 3 कैंडल की उच्च/निम्न सीमा से एक नीला आयत खींचा जाता है.

• दूसरी (2nd) कैंडल के ओपन प्राइस पर एक चूना हरा क्षैतिज एंट्री लाइन खींची जाती है.

• यह लाइन भविष्य की ओर बहुत दूर तक फैली रहती है जब तक कि प्राइस वापस नहीं आती.

• 
  

इनपुट्स की व्याख्या

mq5
input color BoxColor = clrBlue; // 3-कैंडल पैटर्न बॉक्स का रंग
input color EntryLineColor = clrLime; // एंट्री लाइन का रंग
input ENUM_LINE_STYLE EntryLineStyle = STYLE_SOLID; // एंट्री लाइन का स्टाइल
input int BoxWidth = 2; // बॉक्स बॉर्डर की चौड़ाई
input int EntryLineWidth = 2; // एंट्री लाइन की चौड़ाई
input int EntryLineLength = 200; // माइटिगेशन लाइन कितनी दूर तक फैलेगी

मुख्य विचार

हम 3-कैंडल बुलिश पैटर्न की तलाश करते हैं:

1. पहली कैंडल – मजबूत बुलिश (स्पाइक)

2. दूसरी कैंडल – बेयरिश रिट्रेसमेंट

3. तीसरी कैंडल – फिर से मजबूत बुलिश स्पाइक

जब यह पैटर्न दिखाई देता है, तो हम:

- पैटर्न के चारों ओर एक बॉक्स खींचते हैं

- दूसरी कैंडल की ओपन पर एक क्षैतिज लाइन (एंट्री पॉइंट) खींचते हैं

जब प्राइस उस लाइन पर वापस आती है ("माइटिगेशन"), तो हम लाइन को छोटा कर देते हैं और इसे फिर से नहीं खींचते.

struct PatternInfo {
    datetime time; // पैटर्न का समय
    double entry;   // एंट्री प्राइस (2nd कैंडल का ओपन)
    double high;    // 3 कैंडल की उच्चतम हाई
    double low;     // 3 कैंडल की न्यूनतम लो
    bool mitigated; // क्या प्राइस एंट्री लेवल पर वापस आई है?
};

CArrayObj activePatterns;

ऑन इनिट फंक्शन

int OnInit() {
    IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
    ArrayInitialize(activePatterns, 0);
    return INIT_SUCCEEDED;
}

पैटर्न पहचान (प्रत्येक टिक पर)

for (int i = limit - 3; i >= 0; i--) {

if (isBullish(i+2) && isBearish(i+1) && isBullish(i)) {

double high = MathMax(MathMax(High[i], High[i+1]), High[i+2]);
double low = MathMin(MathMin(Low[i], Low[i+1]), Low[i+2]);
double entry = Open[i+1];

PatternInfo *pattern = new PatternInfo;
pattern.time = Time[i];
pattern.entry = entry;
pattern.high = high;
pattern.low = low;
pattern.mitigated = false;

बॉक्स और लाइन खींचें

string boxName = "Box_" + IntegerToString(Time[i]);
ObjectCreate(0, boxName, OBJ_RECTANGLE, 0, Time[i+2], high, Time[i], low);

string lineName = "EntryLine_" + IntegerToString(Time[i]);
ObjectCreate(0, lineName, OBJ_TREND, 0, Time[i], entry, Time[i] + PeriodSeconds() * EntryLineLength, entry);

माइटिगेशन चेक (प्रत्येक टिक पर)

for (int p = 0; p < activePatterns.Total(); p++) {
    PatternInfo *pt = (PatternInfo*)activePatterns.At(p);

हम सभी पैटर्न के माध्यम से लूप करते हैं:

if (!pt.mitigated && Low[0] <= pt.entry) {

अगर वर्तमान प्राइस एंट्री लेवल पर पहुँचती है:

pt.mitigated = true;
ObjectDelete("EntryLine_" + IntegerToString(pt.time));

मूल लंबी लाइन को हटा दें.

ObjectCreate(0, "MitigatedLine_" + IntegerToString(pt.time), OBJ_TREND, 0, pt.time, pt.entry, Time[0], pt.entry);

जहां माइटिगेशन हुआ है, वहां एक छोटी लाइन बनाएं.

मददगार फंक्शंस

bool isBullish(int i) {
    return Close[i] > Open[i];
}

bool isBearish(int i) {
    return Close[i] < Open[i];
}

यह इंडिकेटर सरल लेकिन शक्तिशाली है:

• बूम में वास्तविक स्पाइक व्यवहार का पता लगाता है
• स्मार्ट मनी एंट्री का दृश्य बनाता है
• स्वचालित रूप से माइटिगेशन का पता लगाता है

आप अब इसे बूम 500 या बूम 1000 पर लाइव टेस्ट कर सकते हैं.