सेटअप
हमें निम्नलिखित चीज़ों की आवश्यकता होगी:
- 1 ज़िगज़ैग प्लॉट
- 2 डेटा बफ़र, एक उच्च के लिए और एक निम्न के लिए
- इनपुट पैरामीटर
- एक सेट सिस्टम वेरिएबल जो संकेतक के पुनः गणना करते समय रीसेट हो जाते हैं
यहां एक कोड है जो हमारी ज़िगज़ैग सेटअप को दर्शाता है:
#property indicator_buffers 2 #property indicator_plots 1 input double retracement=23.6; // पुनः संख्या input double minSizeInAtrUnits=0.0; // एटीआर यूनिट्स में लहरों का न्यूनतम आकार input int rollingAtrPeriod=14; // रोलिंग एटीआर अवधि input color Color=clrDodgerBlue; // लहर का रंग input int Width=3; // लहर की चौड़ाई input ENUM_LINE_STYLE Style=STYLE_SOLID; // लहर की शैली //--- अप वेव और डाउन वेव्स double upWaves[], dwWaves[];
upWaves एरे उच्च को स्टोर करेगा और dwWaves एरे निम्न को स्टोर करेगा।
सिस्टम वेरिएबल:
हमें अंतिम लहर के प्रकार, यह कहाँ से शुरू हुई, कहाँ समाप्त हुई, और प्रारंभ और अंत के बीच के बारों की दूरी पता होनी चाहिए।
//--- ज़िगज़ैग को ट्रैक करना int wave_type=0; double wave_start_price=0.0; double wave_end_price=0.0; int wave_start_distance=0; int wave_end_distance=0; double high_mem=0.0; int distance_from_high=0; double low_mem=0.0; int distance_from_low=0; double rollingAtr=0.0; int rollingAtrs=0;
आखिरकार, रोलिंग एटीआर यूनिट और कितने कैलकुलेट किए गए हैं।
अब हम एक सिस्टम रीसेट फ़ंक्शन बनाएंगे:
void resetSystem() {
ArrayFill(upWaves, 0, ArraySize(upWaves), 0.0);
ArrayFill(dwWaves, 0, ArraySize(dwWaves), 0.0);
wave_type=0;
wave_start_price=0.0;
wave_end_price=0.0;
wave_start_distance=0;
wave_end_distance=0;
high_mem=0.0;
low_mem=0.0;
distance_from_high=0;
distance_from_low=0;
rollingAtr=0.0;
rollingAtrs=0;
} यह सामान्य चीजें हैं, एरेज़ को ज़ीरो से भरें और सिस्टम वेरिएबल्स को रीसेट करें।
OnInit में, हम बफर सेट करते हैं, प्लॉट करते हैं, और पहली बार रीसेट कॉल करते हैं:
SetIndexBuffer(0, upWaves, INDICATOR_DATA); SetIndexBuffer(1, dwWaves, INDICATOR_DATA); PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, 0.0); PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_ZIGZAG); PlotIndexSetInteger(0, PLOT_LINE_COLOR, 0, Color); PlotIndexSetInteger(0, PLOT_LINE_WIDTH, Width); PlotIndexSetInteger(0, PLOT_LINE_STYLE, Style); resetSystem();
तो चलिए गणना में कूदते हैं।
पहली चीज़ जो हमें देखनी है वह है रोलिंग एटीआर।
जब तक हमने एटीआर अवधि से अधिक बार इकट्ठा नहीं किए, हम कुछ और नहीं करेंगे।
रोलिंग एटीआर प्रबंधन का हिस्सा इस प्रकार है:
- अगर हमने अवधि से अधिक बार इकट्ठा नहीं किया है, तो वर्तमान बार्स की रेंज को जोड़ते रहें
- जब हम अवधि पर पहुँचते हैं, तो हम पहली बार विभाजन (औसत) करते हैं
- इसके बाद, हम रोलिंग एटीआर का एक हिस्सा काटते हैं, जो एटीआर/अवधि है, और फिर एक नया हिस्सा जोड़ते हैं जो बार की रेंज/अवधि है
हम अंतिम भाग को पहले रखेंगे क्योंकि यह अधिक बार होगा और हमें 2 if स्टेटमेंट्स को एक्सेस करने की आवश्यकता नहीं होगी
rollingAtrs++;
if(rollingAtrs > rollingAtrPeriod) {
double new_portion = ((high[i] - low[i])/_Point) / ((double)rollingAtrPeriod);
rollingAtr = (rollingAtr) - (rollingAtr / ((double)rollingAtrPeriod)) + new_portion;
} else if(rollingAtrs <= rollingAtrPeriod) {
rollingAtr += (high[i] - low[i])/_Point;
if(rollingAtrs == rollingAtrPeriod) {
rollingAtr /= ((double)rollingAtrs);
high_mem = high[i];
low_mem = low[i];
distance_from_high=0;
distance_from_low=0;
}
} बढ़िया, अब एक और समस्या है।
ज़िगज़ैग का आधार एक पुनः संख्या है।
लेकिन पुनः संख्या होने के लिए कम से कम एक लहर होनी चाहिए।
लेकिन पहली लहर क्या पुनः संख्या करेगी?
इसलिए हम निम्नलिखित करेंगे:
- जैसे ही एटीआर भरता है (एटीआर इकट्ठा = अवधि), हम अपने सिस्टम वेरिएबल में उच्च और निम्न को लेंगे
- जो भी पक्ष एक लहर बनाने में सक्षम होता है जो एटीआर यूनिट्स में मान्य आकार रखता है, और एक नई उच्च (अप वेव) या एक नई निम्न (डाउन वेव) बनाता है, वह जीतता है
इस तरह, हमारे पास एक प्रारंभिक लहर के रूप में पुनः संख्या नहीं होती है, लेकिन हमें किसी न किसी तरह अनुक्रम शुरू करना है।
ध्यान दें: हम केवल पहली लहर के लिए एक क्लासिक फ्रैक्टल दृष्टिकोण को भी चुन सकते थे और फिर पुनः संख्याओं के साथ आगे बढ़ सकते थे।
यह वह है जो हम तब करते हैं जब हमारे पास कोई लहर नहीं है:
else {
if(high[i] > high_mem && low[i] >= low_mem) {
double new_wave_size_in_atr_units = ((high[i] - low_mem) / _Point) / rollingAtr;
if(new_wave_size_in_atr_units >= minSizeInAtrUnits) {
wave_type=1;
wave_start_price=low_mem;
wave_start_distance=distance_from_low;
wave_end_price=high[i];
wave_end_distance=0;
dwWaves[i - wave_start_distance] = low_mem;
upWaves[i] = high[i];
high_mem = high[i];
distance_from_high=0;
low_mem=low[i];
distance_from_low=0;
}
}
else if(low[i] < low_mem && high[i] <= high_mem) {
double new_wave_size_in_atr_units = ((high_mem - low[i]) / _Point) / rollingAtr;
if(new_wave_size_in_atr_units >= minSizeInAtrUnits) {
wave_type=-1;
wave_start_price=high_mem;
wave_start_distance=distance_from_high;
wave_end_price=low[i];
wave_end_distance=0;
upWaves[i - wave_start_distance] = high_mem;
dwWaves[i] = low[i];
high_mem = high[i];
distance_from_high=0;
low_mem=low[i];
distance_from_low=0;
}
}
else if(low[i] < low_mem && high[i] > high_mem) {
high_mem = high[i];
low_mem = low[i];
distance_from_high=0;
distance_from_low=0;
}
} बढ़िया। अब अंतिम टुकड़ा।
अगर हमारे पास एक अप वेव है:
- अगर एक नई उच्च बनती है, तो ज़िगज़ैग को पिछले उच्च स्थिति से नई उच्च स्थिति पर ले जाएं, जिसे हम बार की दूरी बनाए रखकर कर सकते हैं।
- अगर एक नई निम्न बनती है, या, एक नई निम्न सेट होती है, तो हम पीक से निम्न तक की दूरी की गणना करते हैं और उसे लहर के आकार से विभाजित करते हैं।
इसके लिए कोड यहाँ है:
if(wave_type==1) {
if(high[i] > wave_end_price) {
upWaves[i - wave_end_distance] = 0.0;
upWaves[i] = high[i];
wave_end_price = high[i];
wave_end_distance = 0;
high_mem = high[i];
distance_from_high=0;
low_mem=low[i];
distance_from_low=0;
}
if(low[i] < low_mem || distance_from_low==0) {
low_mem=low[i];
distance_from_low=0;
double size_of_wave=(wave_end_price-wave_start_price)/_Point;
double size_of_retracement=(wave_end_price-low_mem)/_Point;
if(size_of_wave > 0.0) {
double retraced=(size_of_retracement/size_of_wave)*100.0;
double new_wave_size_in_atr_units=((wave_end_price-low_mem)/_Point)/rollingAtr;
if(new_wave_size_in_atr_units >= minSizeInAtrUnits) {
if(retraced >= retracement) {
wave_type=-1;
wave_start_price=high[i - distance_from_high];
wave_start_distance=distance_from_high;
wave_end_price=low[i];
wave_end_distance=0;
upWaves[i - wave_start_distance] = high_mem;
dwWaves[i] = low[i];
high_mem = high[i];
distance_from_high=0;
low_mem=low[i];
distance_from_low=0;
}
}
}
} जब हमारे पास डाउन वेव होती है, तो हम विपरीत करते हैं।
और हम तैयार हैं, हमारी पुनः संख्या ज़िगज़ैग तैयार है।
यहाँ ज़िगज़ैग है जिसमें 23.6% पुनः संख्या और 0.0 एटीआर यूनिट्स में लहरों का न्यूनतम आकार है:
और यहाँ वही ज़िगज़ैग है जिसमें 3 एटीआर यूनिट्स में लहरों का न्यूनतम आकार है:
आशा है कि यह जानकारी आपके ट्रेडिंग में सहायक होगी!