WcciPatterns_v1Alert

#property copyright "(C)2005, Yuri Ershtad"
#property link      "http://www.metaquotes.net"

#property indicator_chart_window
#property indicator_buffers 8
#property indicator_color1 MediumSeaGreen
#property indicator_color2 OrangeRed
#property indicator_color3 DeepSkyBlue
#property indicator_color4 IndianRed
#property indicator_color5 Tomato
#property indicator_color6 LimeGreen
#property indicator_color7 Coral
#property indicator_color8 Red

// Makes code easier to read
// and allows for different sounds for different patterns
#define ZLR 1
#define SHAMU 2
#define TLB 3
#define VEGAS 4
#define GHOST 5
#define REVDEV 6
#define HFE 7
#define EXIT8 8
//////////////////////////////////////////////////////////////////////
// Ïàðåìåòû
//////////////////////////////////////////////////////////////////////
extern bool POP_UP_Box_Alert = false;
extern bool Sound_Alert = false;

extern int Pattern     = 0;
extern int fastPeriod  = 6;
extern int slowPeriod  = 14;
extern int BarsNum     = 0;

//////////////////////////////////////////////////////////////////////
// Áóôåðû äàííûõ
//////////////////////////////////////////////////////////////////////
 
double ZlrBuffer[];     // 1. Zero-line Reject (ZLR)      -- trend 
double ShamuBuffer[];   // 2. Shamu Trade                 -- counter
double TlbBuffer[];     // 3. Trend Line Break (TLB/HTLB) -- both
double VegasBuffer[];   // 4. Vegas Trade (VT)			    -- counter
double GhostBuffer[];   // 5. Ghost Trade                 -- counter
double RevdevBuffer[];  // 6. Reverse Divergence          -- trend
double HooksBuffer[];   // 7. Hook from Extremes (HFE)    -- counter
double ExitBuffer[];    // 8. Exit signals

//////////////////////////////////////////////////////////////////////
// Èíèöèàëèçàöèÿ
//////////////////////////////////////////////////////////////////////

int init()
{
   string short_name;
   IndicatorBuffers(8);
   IndicatorDigits(MarketInfo(Symbol(),MODE_DIGITS));
   ///////////////////////////////////////////////////////////////
   // Ñèãíàëû îáîçíà÷àþòüñÿ öèôðàìè îò 1 äî 8.  
   // Äëÿ ñèãíàëîâ ê òîðãîâëå ïî òðåíäó èñïîëüçóåòñÿ çåëåíàÿ ãàììà, 
   // ïðîòèâ òðåíäà êðàñíàÿ, ñèíÿÿ - äëÿ TLB è HTLB
   // ----
   short_name="Woodies CCI Paterns ("+fastPeriod+","+slowPeriod+")";
   IndicatorShortName(short_name);
   // Zero-line Reject (ZLR), trend
   SetIndexStyle(0, DRAW_ARROW, EMPTY, 3);
   SetIndexBuffer(0, ZlrBuffer);    
   SetIndexArrow(0, 140);
   SetIndexLabel(0,"Zero-line Reject (ZLR), trend");
   SetIndexEmptyValue(0, EMPTY_VALUE);      
   SetIndexDrawBegin(0, slowPeriod);
   // Shamu Trade, counter-trend
   SetIndexStyle(1, DRAW_ARROW, EMPTY, 1);
   SetIndexBuffer(1, ShamuBuffer);    
   SetIndexArrow(1, 141);
   SetIndexLabel(1,"Shamu Trade, counter-trend");
   SetIndexEmptyValue(1, EMPTY_VALUE);      
   SetIndexDrawBegin(1, slowPeriod);
   // Trend Line Break (TLB), both
   SetIndexStyle(2, DRAW_ARROW, EMPTY, 3);
   SetIndexBuffer(2, TlbBuffer);    
   SetIndexArrow(2, 142);
   SetIndexLabel(2,"Trend Line Break (TLB), both");
   SetIndexEmptyValue(2, EMPTY_VALUE);      
   SetIndexDrawBegin(2, slowPeriod);
   // Vegas Trade (VT), counter-trend
   SetIndexStyle(3, DRAW_ARROW, EMPTY, 1);
   SetIndexBuffer(3, VegasBuffer);    
   SetIndexArrow(3, 143);
   SetIndexLabel(3,"Vegas Trade (VT), counter-trend");
   SetIndexEmptyValue(3, EMPTY_VALUE);      
   SetIndexDrawBegin(3, slowPeriod);
   // Ghost Trade, counter-trend
   SetIndexStyle(4, DRAW_ARROW, EMPTY, 1);
   SetIndexBuffer(4, GhostBuffer);    
   SetIndexArrow(4, 144);
   SetIndexLabel(4,"Ghost Trade, counter-trend");
   SetIndexEmptyValue(4, EMPTY_VALUE);      
   SetIndexDrawBegin(4, slowPeriod);
   // Reverse Divergence, trend
   SetIndexStyle(5, DRAW_ARROW, EMPTY, 2);
   SetIndexBuffer(5, RevdevBuffer);    
   SetIndexArrow(5, 145);
   SetIndexLabel(5,"Reverse Divergence, trend");
   SetIndexEmptyValue(5, EMPTY_VALUE);      
   SetIndexDrawBegin(5, slowPeriod);
   // Hook from Extremes (HFE), counter-trend
   SetIndexStyle(6, DRAW_ARROW, EMPTY, 2);
   SetIndexBuffer(6, HooksBuffer);    
   SetIndexArrow(6, 146);
   SetIndexLabel(6,"Hook from Extremes (HFE), counter-trend");
   SetIndexEmptyValue(6, EMPTY_VALUE);      
   SetIndexDrawBegin(6, slowPeriod);
   // Exit signal
   SetIndexStyle(7, DRAW_ARROW, EMPTY, 1);
   SetIndexBuffer(7, ExitBuffer);    
   SetIndexArrow(7, 251);
   SetIndexLabel(7,"Exit signal");
   SetIndexEmptyValue(7, EMPTY_VALUE);      
   SetIndexDrawBegin(7, slowPeriod);
   //----
   return(0);
}
  
//////////////////////////////////////////////////////////////////////
// Custor indicator deinitialization function                       
//////////////////////////////////////////////////////////////////////

int deinit()
{
   // TODO: add your code here
   return(0);
}

// You can change each sound for different patterns
void SoundAnAlert(int mPattern)
{
   if(Sound_Alert==true)
   {
     switch (mPattern)
     {
     case ZLR    : PlaySound("alert2.wav");
                   break;
     case SHAMU  : PlaySound("alert2.wav");
                   break;
     case TLB    : PlaySound("alert2.wav");
                   break;
     case VEGAS  : PlaySound("alert2.wav");
                   break;
     case GHOST  : PlaySound("alert2.wav");
                   break;
     case REVDEV : PlaySound("alert2.wav");
                   break;
     case HFE    : PlaySound("alert2.wav");
                   break;
     case EXIT8  : PlaySound("alert2.wav");
     
     }
   }
   if(POP_UP_Box_Alert==true)
   {
     switch (mPattern)
     {
     case ZLR    : Alert ("ZLR  " ,Symbol()," ",Period());
                   break;
     case SHAMU  : Alert ("Shamu  " ,Symbol()," ",Period());
                   break;
     case TLB    : Alert ("TLB  " ,Symbol()," ",Period());
                   break;
     case VEGAS  : Alert ("Vegas  " ,Symbol()," ",Period());
                   break;
     case GHOST  : Alert ("Ghost  " ,Symbol()," ",Period());
                   break;
     case REVDEV : Alert ("RevDev  " ,Symbol()," ",Period());
                   break;
     case HFE    : Alert ("HFE  " ,Symbol()," ",Period());
                   break;
     case EXIT8  : Alert ("Exit  " ,Symbol()," ",Period());
     
     }
   }
}

//////////////////////////////////////////////////////////////////////
// Custom indicator iteration function                              
//////////////////////////////////////////////////////////////////////

int start()
{
   string symbolName;
   int i, shift, checksum, counted_bars=IndicatorCounted();
   if( BarsNum > 0) int bars = BarsNum; else bars = Bars; 
   if (bars<slowPeriod) return(0); 
   // check for possible errors
   if (counted_bars<0) return(-1);
   // last counted bar will be recounted
   if (counted_bars>0) counted_bars++;
   int limit=bars-slowPeriod-counted_bars;
   if (counted_bars<1 || checksum!=(fastPeriod+slowPeriod+Period()) || symbolName!=Symbol())
   {
      // Ïàðàìåòðû èçìåíåíû, ïðîâîäèì ðåèíèöèàëèçàöèþ 
      for(i=1;i<=slowPeriod;i++) ZlrBuffer[bars-i]=EMPTY_VALUE;
      for(i=1;i<=slowPeriod;i++) ShamuBuffer[bars-i]=EMPTY_VALUE;
      for(i=1;i<=slowPeriod;i++) TlbBuffer[bars-i]=EMPTY_VALUE;  
      for(i=1;i<=slowPeriod;i++) VegasBuffer[bars-i]=EMPTY_VALUE;
      for(i=1;i<=slowPeriod;i++) GhostBuffer[bars-i]=EMPTY_VALUE;
      for(i=1;i<=slowPeriod;i++) RevdevBuffer[bars-i]=EMPTY_VALUE;
      for(i=1;i<=slowPeriod;i++) HooksBuffer[bars-i]=EMPTY_VALUE;
      for(i=1;i<=slowPeriod;i++) ExitBuffer[bars-i]=EMPTY_VALUE;      
      checksum = fastPeriod+slowPeriod+Period(); 
      symbolName=Symbol();
      limit=bars-slowPeriod; 
   }
   for (shift=limit; shift>=0; shift--)
   {
      ///////////////////////////////////////////////////////////////
      //	Çàïîëíåíèå ìàññèâà òî÷åê è îïðåäåëåíèå òðåíäà
      ///////////////////////////////////////////////////////////////

      int delta=25,level=100;
      double slowCCI[20], fastCCI[20];        
      int a, up=0, dn=0, upnt=5,dpnt=5;
      for (a=0;a<20;a++)
      {  
         fastCCI[a]=iCCI(NULL,0,fastPeriod,PRICE_TYPICAL,shift+a);       
         slowCCI[a]=iCCI(NULL,0,slowPeriod,PRICE_TYPICAL,shift+a);      
         if (a<8) {
            if (slowCCI[a]>0) up++;
            if (slowCCI[a]<=0) dn++;
         }
		}
	   
      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 1 - Îòñêîê îò íóëåâîé ëèíèè (ZLR)
      // -----------------------------------------------------------
      // Ïàòòåðí "Îòñêîê îò íóëåâîé ëèíèè" (ZLR)" ïðåäñòàâëÿåò ñîáîé 
      // ñèëüíûé îòñêîê CCI îò íóëåâîé ëèíèè (ZL) èëè îò óðîâíÿ, 
      // íàõîäÿùåãîñÿ áëèçêî ê íåé. Ïðè ýòîì CCI ìîæåò îòñêàêèâàòü îò 
      // çíà÷åíèé â ïðåäåëàõ îò +100 äî -100  êàê  äëÿ  äëèííûõ,  
      // òàê è äëÿ êîðîòêèõ ïîçèöèé. Íåêîòîðûå òðåéäåðû ëþáÿò ñóæàòü 
      // äèàïàçîí äî +/-50, ñ÷èòàÿ, ÷òî îí ìîæåò îáåñïå÷èòü ëó÷øèé 
      // îòñêîê. Ïîçèöèÿ îòêðûâàåòñÿ íà ïåðâîì áàðå, êîòîðûé îòêëîíÿåòñÿ 
      // èëè îòñêàêèâàåò îò íóëåâîé ëèíèè.
      // Ðûíî÷íàÿ ïñèõîëîãèÿ â èñïîëüçîâàíèè ïàòòåðíà ZLR ñèñòåìîé 
      // Woodies CCI ñîñòîèò â òîì, ÷òî ýòîò ïàòòåðí ïîçâîëÿåò òðåéäåðàì 
      // ïîêóïàòü ïðè ïàäåíèè è ïðîäàâàòü íà ïîäúåìå. Íè îäèí èç 
      // èíäèêàòîðîâ, èñïîëüçóåìûõ ïðè òîðãîâëå, íå ìîæåò ýòîãî ñäåëàòü, 
      // êðîìå CCI.
      // Äëÿ áîëüøåé ýôôåêòèâíîñòè, ÷òîáû óñèëèòü ñèãíàë íà âõîä, 
      // Âû ìîæåòå îáúåäèíèòü èñïîëüçîâàíèå ïàòòåðíà ZLR ñ ïàòòåðíîì 
      // "Ïðîáîé Ëèíèè Òðåíäà (TLB)". Ïðè èñïîëüçîâàíèè ZLR ñîâìåñòíî 
      // ñ TLB äëÿ îòêðûòèÿ ïîçèöèè Âû æäåòå ïåðåñå÷åíèÿ êðèâîé CCI 
      // ïàòòåðíà TLB. Òîðãîâëÿ ñ èñïîëüçîâàíèåì ïàòòåðíà 
      // ZLR - òîðãîâëÿ ïî òðåíäó. Ôàêòè÷åñêè ýòîò ñïîñîá òîðãîâëè 
      // ìîæåò áûòü åäèíñòâåííûì òîðãîâûì ïàòòåðíîì ñèñòåìû Woodies CCI, 
      // êîòîðûé èñïîëüçóåòñÿ òðåéäåðîì, äàâàÿ ïðè ýòîì ïðåâîñõîäíóþ 
      // ïðèáûëü.
      // ----
      delta=20;  // ôèëüòð áèåíèÿ (|ÑÑI[1]-ÑÑI[2]|>delta)
      level=80; // ìîäóëü ãðàíèöû ïàòåðíà
      ZlrBuffer[shift]=EMPTY_VALUE;
      // ---- ZLR â íèñõîäÿùåì òðåíäå
      if ( dn>=6 && 
      slowCCI[0]<slowCCI[1] && slowCCI[2]<slowCCI[1] && 
      MathAbs(slowCCI[0])<level && MathAbs(slowCCI[1])<level &&
      MathAbs(slowCCI[1]-slowCCI[2])>delta 
      && (Pattern==0 || Pattern==1))
	   {
         ZlrBuffer[shift]=High[shift]+upnt*Point; 
         upnt=upnt+5;
         if (shift == 0) SoundAnAlert(ZLR);
	   }
	   // ZLR â âîñõîäÿùåì òðåíäå
      if ( up>=6 	   
      && slowCCI[0]>slowCCI[1] && slowCCI[2]>slowCCI[1] && 
      MathAbs(slowCCI[0])<level && MathAbs(slowCCI[1])<level &&
      MathAbs(slowCCI[1]-slowCCI[2])>delta 
	   && (Pattern==0 || Pattern==1))
	   {
         ZlrBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;
         if (shift == 0) SoundAnAlert(ZLR);
	   }	   

      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 2 - Øàìó (shamu trade) 
      // -----------------------------------------------------------      
      // Ïàòòåðí "Øàìó (shamu trade)" ôîðìèðóåòñÿ, êîãäà CCI ïåðåñåêàåò 
      // íóëåâóþ ëèíèþ (ZL), çàòåì ðàçâîðà÷èâàåòñÿ íàçàä è ñíîâà 
      // ïåðåñåêàåò íóëåâóþ ëèíèþ (ZL) â ïðîòèâîïîëîæíîì íàïðàâëåíèè, 
      // çàòåì åùå ðàç ðàçâîðà÷èâàåòñÿ è ïåðåñåêàåò íóëåâóþ ëèíèþ, 
      // ïðîäîëæàÿ äâèæåíèå â ïåðâîíà÷àëüíîì íàïðàâëåíèè. 
      // Ýòî - âèä çèãçàãîîáðàçíîãî ïàòòåðíà âîêðóã ZL. 
      // Îí íå îáÿçàòåëüíî âîçíèêàåò íåïîñðåäñòâåííî íà íóëåâîé ëèíèè, 
      // íî ëó÷øèå ïàòòåðíû Øàìó ôîðìèðóþòñÿ ïðè âîçíèêíîâåíèè çèãçàãà 
      // CCI â ïðåäåëàõ çíà÷åíèé +/-50.
      // Òîðãîâûé ïàòòåðí Øàìó - ýòî íåóäàâøèéñÿ ïàòòåðí ZLR. 
      // Ïåðâîíà÷àëüíî ýòî áûë ïàòòåðí ZLR. Íî ZLR ðàçâåðíóëñÿ â 
      // ïðîòèâîïîëîæíîì íàïðàâëåíèè è íå ñôîðìèðîâàëñÿ, òàê ÷òî ìû 
      // äîëæíû âûõîäèòü. Âîò ïî÷åìó Âû íå æäåòå ðàçâîðîòà â íàäåæäå íà òî, 
      // ÷òî òîðãîâëÿ âåðíåòñÿ â íóæíîå ðóñëî. Åñëè âî âñåõ ýòèõ òîðãîâûõ 
      // ñëó÷àÿõ Âû èçíà÷àëüíî îòêðûâàåòå ïîçèöèþ ïî ïàòòåðíó ZLR, 
      // òî çàâèñèò îò Âàñ, è åñëè Âû âîâðåìÿ íå âûøëè, òî ìîæåòå ïîíåñòè 
      // ïîòåíöèàëüíî áîëüøèå ïîòåðè. 
      // Òîðãîâëÿ ñ èñïîëüçîâàíèåì ïàòòåðíà Øàìó - ïî ñóòè ÿâëÿåòñÿ 
      // ïðîòèâîòðåíäîâîé, è áûëà ðàçâèòà êàê ñïîñîá òîðãîâëè ïî ïðèíöèïó 
      // stop-and-reverse (SAR) ê íåóäàâøåìóñÿ ZLR. Íîâè÷êè, òîëüêî 
      // íà÷àâøèå èçó÷àòü ñèñòåìó Woodies CCI, íå äîëæíû èñïîëüçîâàòü 
      // ýòîò ñïîñîá òîðãîâëè. Îäíàêî îáðàòèòå íà íåãî âíèìàíèå è 
      // èçó÷àéòå ïî ìåðå ïðîäâèæåíèÿ â îñâîåíèè ñèñòåìû.
      // ----
      delta=15; level=50;
      ShamuBuffer[shift]=EMPTY_VALUE;
      // øàìó â íèñõîäÿùåì òðåíäå
      if (dn>=6 &&
	   slowCCI[0]>slowCCI[1]+delta && 
	   slowCCI[1]<slowCCI[2] && slowCCI[2]>slowCCI[3] && 
	   slowCCI[1]<=level && slowCCI[1]>=-level && 
	   slowCCI[2]<=level && slowCCI[2]>=-level
	   && (Pattern==0 || Pattern==2)) 
	   {
         ShamuBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;
         if (shift == 0) SoundAnAlert(SHAMU);
	   }
	   // øàìó â âîñõîäÿùåì òðåíäå
	   if (up>=6 && 
	   slowCCI[0]<slowCCI[1]-delta && 
	   slowCCI[1]>slowCCI[2] && slowCCI[2]<slowCCI[3] && 
	   slowCCI[1]>=-level && slowCCI[1]<=level && 
	   slowCCI[2]>=-level && slowCCI[2]<=level
	   && (Pattern==0 || Pattern==2))
	   {
         ShamuBuffer[shift]=High[shift]+upnt*Point; 
         upnt=upnt+5;
         if (shift == 0) SoundAnAlert(SHAMU);
	   }

      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 3 - Ïðîáîé Ëèíèè Òðåíäà (TLB)
      // -----------------------------------------------------------  
      // Ïàòòåðí "Ïðîáîé Ëèíèè Òðåíäà (TLB)" èñïîëüçóåò äâà èëè áîëåå 
      // ïðèëè÷íûõ ðàçìåðîâ ïèêà èëè âïàäèíû, îáðàçóåìûõ CCI èëè TCCI 
      // äëÿ òîãî, ÷òîáû ïðîâåñòè ÷åðåç íèõ ëèíèþ òðåíäà. Ïðè ïåðåñå÷åíèè 
      // èëè ïðîáèòèè CCI ýòîé ëèíèè òðåíäà (tl), âîçíèêàåò ñèãíàë äëÿ 
      // îòêðûòèÿ ïîçèöèè. Ïðè ýòîì, ÷òîáû ñèãíàë áûë äåéñòâèòåëüíûì, 
      // îäèí êîíåö ëèíèè òðåíäà äîëæåí ðàñïîëàãàòüñÿ íà óðîâíå +/-100 
      // CCI èëè áîëåå. ×åì áîëüøå òî÷åê êàñàíèÿ èìååò òàêàÿ ëèíèÿ òðåíäà, 
      // òåì áîëåå çíà÷èìîé îíà ÿâëÿåòñÿ. Èñïîëüçîâàíèå òîëüêî äâóõ òî÷åê 
      // êàñàíèÿ ÿâëÿåòñÿ íîðìàëüíûì è ñîçäàåò îòëè÷íî äåéñòâóþùèé 
      // ïàòòåðí TLB. Òàêæå âîçìîæíî ñîâìåñòíîå èñïîëüçîâàíèå êàñàíèé 
      // CCI è TCCI äëÿ êàæäîé ëèíèè òðåíäà. Ýòîò ïàòòåðí òàêæå èñïîëüçóåòñÿ 
      // êàê îäèí èç ñèãíàëîâ âûõîäà èëè êàê CCI ñèãíàë ïîäòâåðæäåíèÿ. 
      // Ýòî âåñüìà óäîáíî è øèðîêî èñïîëüçóåòñÿ â ñèñòåìå Woodies CCI.
      // Òîðãîâëÿ ñ èñïîëüçîâàíèåì ïàòòåðíà TLB ìîæåò ïðîâîäèòüñÿ êàê 
      // ïî òðåíäó, òàê è ïðîòèâ òðåíäà. Íîâè÷êè, èñïîëüçóþùèå ñèñòåìó 
      // Woodies CCI, äîëæíû òîðãîâàòü ñ ïîìîùüþ ïàòòåðíà TLB òîëüêî ïî 
      // òðåíäó. Îäíàêî ïðèñìîòðèòåñü ê íåìó è èçó÷àéòå åãî ïî ìåðå 
      // ïðîäâèæåíèÿ â îñâîåíèè ñèñòåìû.
      // Âû ìîæåòå êîìáèíèðîâàòü èñïîëüçîâàíèå ïàòòåðíà "Îòêàò îò 
      // íóëåâîé ëèíèè (ZLR)" è ïàòòåðíà "Îáðàòíàÿ äèâåðãåíöèÿ (rev diver)" 
      // ñ ïàòòåðíîì "Ïðîáîé Ëèíèè Òðåíäà (TLB)" äëÿ óñèëåíèÿ ñèãíàëà è 
      // áîëüøåé âåðîÿòíîñòè óñïåõà. Ïðè èõ ñîâìåñòíîì èñïîëüçîâàíèè Âû 
      // îòêðûâàåòå ïîçèöèþ ïðè ïðîðûâå ëèíèè òðåíäà, ïîñêîëüêó ýòî 
      // ïðîèçîéäåò â ïîñëåäíþþ î÷åðåäü.
      // Äðóãîé ìåòîä âõîäà â òîðãîâëþ ïî TLB ñîñòîèò â èñïîëüçîâàíèè 
      // ñèãíàëà ïîäòâåðæäåíèÿ îò CCI, - ïåðåñå÷åíèå èì óðîâíÿ +/-100. 
      // Ýòî äàåò áîëüøèé øàíñ óñïåøíîñòè ñäåëêè. Âû ìîæåòå íå èñïîëüçîâàòü 
      // ýòîò ìåòîä è, òåì íå ìåíåå, ïîëó÷èòü áîëüøóþ ïðèáûëü ïðè òîðãîâëå 
      // ïî TLB, åñëè Âû âõîäèòå çàäîëãî äî ýòîãî óðîâíÿ. Îäíàêî åñëè Âû 
      // íå äîáàâèòå ïîäòâåðæäåíèå CCI â âèäå ïåðåñå÷åíèÿ èì óðîâíÿ +/-100, 
      // òîãäà âàøà òîðãîâëÿ ïî TLB ìîæåò ÷àñòî íå ñðàáàòûâàòü. Âûáåðèòå 
      // ñïîñîá âõîäà è ïðèäåðæèâàéòåñü åãî. Íå ìåíÿéòå åãî åæåäíåâíî.
      // Âû î÷åíü ÷àñòî áóäåòå íàõîäèòü âîçíèêàþùèìè ñîâìåñòíî ïàòòåðíû TLB è 
      // ZLR. Èíîãäà âìåñòå ñ íèìè áóäåò òàêæå ïîÿâëÿòüñÿ ïàòòåðí "rev diver". 
      // Âû äîëæíû íà÷àòü ðàçëè÷àòü, êîãäà CCI ïàòòåðíû ñëåäóþò îäèí çà äðóãèì, 
      // à êîãäà ôîðìèðóþòñÿ âìåñòå, ÷òî óñèëèâàåò ñèãíàëû. Ïóñòü Âàñ ýòî íå 
      // ñìóùàåò. Âàì íåîáõîäèì òîëüêî îäèí CCI ïàòòåðí, ÷òîáû îòêðûòü ïîçèöèþ. 
      // Îäíàêî åñëè âîçíèêàåò êîìáèíàöèÿ èç íåñêîëüêèõ ñèãíàëîâ, òî âåðîÿòíîñòü 
      // óñïåõà ýòîé ñäåëêè óâåëè÷èâàåòñÿ.
      // -----------------------------------------------------------        
      // Ïðîáîé Ãîðèçîíòàëüíîé Ëèíèè Òðåíäà (HTLB)
      // -----------------------------------------------------------        
      // Ïðè òîðãîâëå íà ïðîáîå ãîðèçîíòàëüíîé ëèíèè òðåíäà (HTLB) - 
      // ëèíèÿ òðåíäà ïðîâîäèòñÿ ãîðèçîíòàëüíî ÷åðåç âåðøèíû îòñêîêîâ 
      // CCI è TCCI îò íóëåâîé ãîðèçîíòàëüíîé ëèíèè, êîòîðûå âûñòðàèâàþòñÿ 
      // â õîðîøèé ïðÿìîé ðÿä, íî íàèáîëåå ÷àñòî â ýòèõ ïàòòåðíàõ 
      // èñïîëüçóåòñÿ CCI.
      // Ëèíèþ òðåíäà ìîæíî ïðîâåñòè ÷åðåç âíóòðåííèå èëè âíåøíèå òî÷êè 
      // îòêàòà ïî ëþáóþ ñòîðîíó îò íóëåâîé ëèíèè. Îäíàêî âñå òî÷êè îòêàòà 
      // äîëæíû ðàñïîëàãàòüñÿ íà îäíîé ñòîðîíå îò íóëåâîé ëèíèè. Ëó÷øèé 
      // ðåçóëüòàò ìîæåò áûòü äîñòèãíóò ïðè ïðîáîå ãîðèçîíòàëüíîé 
      // ëèíèè òðåíäà, ðàñïîëîæåííîé â ïðåäåëàõ +/-50.
      //  èäåàëå ãîðèçîíòàëüíàÿ ëèíèÿ òðåíäà ñòðîèòñÿ ÷åðåç òðè è áîëåå 
      // òî÷êè îòêàòà, íî ìîæåò áûòü ïðîâåäåíà è ÷åðåç äâå òî÷êè. 
      // Êàæäûé îòêàò íà îäèí è òîò æå ãîðèçîíòàëüíûé óðîâåíü ïîêàçûâàåò, 
      // ÷òî â ýòîé îáëàñòè ðàñïîëàãàåòñÿ ñâîåãî ðîäà çîíà ïîääåðæêè èëè 
      // ñîïðîòèâëåíèÿ. Ïðè ïðîðûâå ýòîé ëèíèè ìîæíî îæèäàòü ñèëüíîå 
      // äâèæåíèå è, ñîîòâåòñòâåííî, õîðîøóþ ïðèáûëü. Ýòîò ïàòòåðí ÷àñòî 
      // ìîæíî âñòðåòèòü íà êîíñîëèäèðóþùåìñÿ ðûíêå. 
      // Òîðãîâëÿ íà ïðîáîå ãîðèçîíòàëüíîé ëèíèè òðåíäà ìîæåò âåñòèñü 
      // êàê ïî òðåíäó, òàê è ïðîòèâ òðåíäà. Ñèãíàëû íà âûõîä òå æå ñàìûå, 
      // ÷òî è ïðè ëþáîì äðóãîì ñïîñîáå òîðãîâëè. 
      // ----           
      
      delta=25; level=100;
      // ----
      TlbBuffer[shift]=EMPTY_VALUE;      
      int min1=0,min2=0,min3=0,max1=0,max2=0,max3=0;        // çíà÷åíèÿ ìèí/ìàõ 
      int tmin1=0,tmin2=0,tmin3=0,tmax1=0,tmax2=0,tmax3=0;  // âðåìÿ ìèí/ìàõ
      double kmin=0,kmax=0; // ëèíåéíûé êîýôôèöèåíò
      double line; 
      //	Îïðåäåëåíèå ìèí/ìàêñ è ïîñòðîåíèå ëèíèè òðåíäà
      for (a=0;a<=17;a++)
      { 
         // îïðåäåëåíèå ìàêñèìóìîâ
         if (slowCCI[a]<=slowCCI[a+1] && slowCCI[a+1]>=slowCCI[a+2])
			{
            if (max1!=0 && max2==0)
				{
					max2=slowCCI[a+1];
					tmax2=Time[a+1+shift];
					kmax=100*(max2-max1)/(tmax2-tmax1);
				}
				if (max1==0)
				{
					max1=slowCCI[a+1];
					tmax1=Time[a+1+shift];
				}
			}
         // îïðåäåëåíèå ìèíèìóìîâ
         if (slowCCI[a]>=slowCCI[a+1] && slowCCI[a+1]<=slowCCI[a+2])
			{
				if (min1!=0 && min2==0)
				{
					min2=slowCCI[a+1];
					tmin2=Time[a+1+shift];
					kmin=100*(min2-min1)/(tmin2-tmin1);
				}
				if (min1==0)
				{
					min1=slowCCI[a+1];
					tmin1=Time[a+1+shift];
				}
			}
      }

      // TLB ctr â íèñõîäÿùåì òðåíäå
      if (kmax!=0 && dn>=6 && (max1<-level || max2<-level)&& (Pattern==0 || Pattern==3 || Pattern==8))
      {
		   line=(Time[shift]-tmax1)*kmax/100+max1;
		   if (slowCCI[1]<line && slowCCI[0]>=line) 
		   {
		      TlbBuffer[shift]=Low[shift]-dpnt*Point;
            dpnt=dpnt+5;
            if (shift == 0) SoundAnAlert(TLB);
		   }
      }
      //  TLB ctr â âîñõîäÿùåì òðåíäå
      if (kmin!=0 && up>=6 && (min1>level || min2>level)&& (Pattern==0 || Pattern==3 || Pattern==8))	
      {
		   line=(Time[shift]-tmin1)*kmin/100+min1;
         if (slowCCI[1]>line && slowCCI[0]<=line) 
         {
            TlbBuffer[shift]=High[shift]+upnt*Point;
            upnt=upnt+5;
            if (shift == 0) SoundAnAlert(TLB);
         }
      }
      // TLB tr â íèñõîäÿùåì òðåíäå
	   if (kmin!=0 && dn >=6 && (min1<-level || min2<-level) && (Pattern==0 || Pattern==3))
      {
         line=(Time[shift]-tmin1)*kmin/100+min1;
         if (slowCCI[1]>line && slowCCI[0]<line) 
         {
            TlbBuffer[shift]=High[shift]+upnt*Point;
            upnt=upnt+5;
            if (shift == 0) SoundAnAlert(TLB);
         }
		}	
      //  TLB tr â âîñõîäÿùåì òðåíäå
      if (kmax!=0 && up>=6 && (max1>level || max2>level) && (Pattern==0 || Pattern==3))
      {
		   line=(Time[shift]-tmax1)*kmax/100+max1;
         if (slowCCI[1]<line && slowCCI[0]>line) 
         {
            TlbBuffer[shift]=Low[shift]-dpnt*Point;
            dpnt=dpnt+5;
            if (shift == 0) SoundAnAlert(TLB);
         }
      } 
      
      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 4 - Âåãàñ (VT)
      // -----------------------------------------------------------  
      // Ïàòòåðí Âåãàñ (VT) ÿâëÿåòñÿ êîìáèíàöèåé íåñêîëüêèõ âåùåé. 
      // Âî-ïåðâûõ, äîëæåí âîçíèêíóòü CCI ïàòòåðí "Ýêñòðåìàëüíûé Êðþê (HFE)", 
      // ïîñëå ýòîãî äîëæåí ïîÿâèòüñÿ íàáîð CCI áàðîâ â âèäå ÷àñòè÷íî 
      // çàêðóãëåííîãî èëè îêðóãëîãî ïàòòåðíà. Òàêèõ îêðóãëûõ áàðîâ äîëæíî 
      // áûòü êàê ìèíèìóì 3 áàðà ïî íàïðàâëåíèþ ê íóëåâîé ëèíèè èëè îò íåå. 
      // Äðóãèìè ñëîâàìè, çàêðóãëåíèå ìîæåò áûòü â ëþáîì íàïðàâëåíèè â 
      // çàâèñèìîñòè îò òîãî, íà êàêîé ñòîðîíå îò íóëåâîé ëèíèè (ZL) ôîðìèðóåòñÿ 
      // âõîäíîé ïàòòåðí. Îäíàêî âõîäíîé ïàòòåðí VT äîëæåí ñôîðìèðîâàòüñÿ 
      // òîëüêî íà îäíîé ñòîðîíå îò íóëåâîé ëèíèè. Ýòî îçíà÷àåò, ÷òî ïåðâàÿ 
      // ÷àñòü (îò êðþêà CCI) êîëåáàíèÿ ïàòòåðíà high/low íå ÿâëÿåòñÿ çàêðóãëåííîé 
      // ÷àñòüþ ïàòòåðíà. Áîëåå ñèëüíûé ñèãíàë âîçíèêàåò, êîãäà êîëåáàíèå 
      // ïàòòåðíà high/low ñòàíîâèòñÿ çàêðóãëåííîé ÷àñòüþ. Òàêæå ïàòòåðí ìîæåò 
      // èìåòü íåñêîëüêî êîëåáàíèé high/low. Çàêðóãëåíèå î÷åíü âàæíî äëÿ 
      // ïàòòåðíà â öåëîì è óêàçûâàåò íà áîðüáó, êîòîðàÿ âïîëíå ìîæåò ïðèâåñòè 
      // ê ñèëüíîìó ðàçâîðîòó òðåíäà.
      // Ïîñëåäíÿÿ ÷àñòü ïàòòåðíà - ëèíèÿ òðåíäà, ïðîâåäåííàÿ ïðÿìî ÷åðåç 
      // âåðõ èëè íèç íåäàâíåãî êîëåáàíèÿ. Ïðîðûâ ââåðõ èëè âíèç ýòîãî óðîâíÿ - 
      // íàø âõîä â òîðãîâëþ.
      // ----
      // Îáû÷íî ïîëíûé ïàòòåðí "Âåãàñ (VT)" ôîðìèðóåòñÿ ãäå-íèáóäü çà ïåðèîä 
      // îò 8 äî 12 áàðîâ è áîëåå, íî åñëè îí ñòàíîâèòñÿ ñëèøêîì øèðîêèì äî 
      // ïîÿâëåíèÿ ñèãíàëà íà âõîä, òîãäà âåðîÿòíîñòü óñïåõà ñíèæàåòñÿ, è ñèëà 
      // äâèæåíèÿ ìîæåò áûòü ìåíüøå. Ïàòòåðí "Âåãàñ (VT)"  óêàçûâàåò íà 
      // ïîòåíöèàëüíóþ âîçìîæíîñòü î÷åíü ñèëüíîãî èçìåíåíèÿ òðåíäà.
      // Woodie íàñòîÿòåëüíî ðåêîìåíäóåò èñïîëüçîâàòü 25-lsma èíäèêàòîð 
      // êàê äîïîëíèòåëüíûé êðèòåðèé âõîäà ïî ïàòòåðíó "Âåãàñ (VT)". 
      // Êîãäà 25-lsma èíäèêàòîð ïîêàçûâàåò, ÷òî öåíà íàõîäèòñÿ íà ñòîðîíå 
      // íàïðàâëåíèÿ âõîäà ïî ïàòòåðíó "Âåãàñ (VT)", ñóùåñòâóåò áîëüøàÿ 
      // âåðîÿòíîñòü òîãî, ÷òî òîðãîâëÿ áóäåò óñïåøíîé. Àááðåâèàòóðà 
      // ñêîëüçÿùåé ñðåäíåé LSMA îçíà÷àåò Least Squares Moving Average, 
      // è òàêàÿ ñêîëüçÿùàÿ ñðåäíÿÿ ìîæåò áûòü íàéäåíà â íåêîòîðûõ 
      // ãðàôè÷åñêèõ ïàêåòàõ ïîä èìåíåì "Êðèâàÿ ëèíåéíîé ðåãðåññèè" 
      // (Linear Regression Curve).
      // Äðóãèìè ñëîâàìè, åñëè ïàòòåðí "Âåãàñ (VT)" ôîðìèðóåòñÿ äëÿ 
      // äëèííîãî âõîäà, íåîáõîäèìî, ÷òîáû öåíà áûëà âûøå 25-lsma èíäèêàòîðà 
      // è, ïî âîçìîæíîñòè, 25-lsma òàêæå áûë íàïðàâëåí ââåðõ. Åñëè ïàòòåðí 
      // VT ôîðìèðóåòñÿ äëÿ êîðîòêîãî âõîäà, íåîáõîäèìî, ÷òîáû öåíà áûëà 
      // íèæå 25-lsma è, æåëàòåëüíî, ÷òîáû 25-lsma òàêæå áûë íàïðàâëåí âíèç. 
      // Òàê êàê ìû íå èñïîëüçóåì öåíû, ÷òîáû òîðãîâàòü ïî ñèñòåìå Woodies CCI, 
      // òî ðåêîìåíäóåòñÿ íà ãðàôèêå öåíû îòîáðàæàòü òîëüêî 25-lsma èíäèêàòîð. 
      // À ëó÷øå èñïîëüçîâàòü 25-lsma èíäèêàòîð, ðàçìåùåííûé íà îäíîì ãðàôèêå 
      // ñ CCI, ÷òîáû îòäåëüíûì öâåòîì ïîêàçàòü ýòè ÷åòûðå óñëîâèÿ.
      // Òîðãîâëÿ ñ èñïîëüçîâàíèåì ïàòòåðíà "Âåãàñ" ïî ñóòè - òîðãîâëÿ 
      // ïðîòèâ òðåíäà. 
      // ----      
      delta=10; limit=200;
      // ----  
      max1=0; max2=0; tmax1=0; tmax2=0;
      min1=0; min2=0; tmin1=0; tmin2=0;
      VegasBuffer[shift]=EMPTY_VALUE;        
      // îïðåäåëåíèå òî÷åê
      if  (dn>=6)
      {
         for (a=13;a>=1;a--)
         {
            if (slowCCI[a]<=slowCCI[a+1] && slowCCI[a+1]>=slowCCI[a+2] && 
            min1!=0 && max1==0)
            {
               max1=slowCCI[a+1];
					tmax1=a+1;
			   }
            if (slowCCI[a]>=slowCCI[a+1] && slowCCI[a+1]<=slowCCI[a+2] &&
             min1==0 && slowCCI[a+1]<=-limit && a+1>=5)
            {				
					min1=slowCCI[a+1];
					tmin1=a+1;
            }
         }
	   }
      //  Îïðåäåëåíèå òî÷åê.
      if (up>=6) 
      {
         for (a=13;a>=1;a--)
         {
			   if (slowCCI[a]>=slowCCI[a+1] && slowCCI[a+1]<=slowCCI[a+2] && 
			   min2!=0 && max2==0)
            {
					min2=slowCCI[a+1];
					tmin2=a+1;
            }
            if (slowCCI[a]<=slowCCI[a+1] && slowCCI[a+1]>=slowCCI[a+2] && 
            max2==0 && slowCCI[a+1]>=limit && a+1>=5)
            {				
               max2=slowCCI[a+1];
               tmax2=a+1;
            }
         }
      }      

      // Vegas â íèñõîäÿùåì òðåíäå
      if (dn>=6 && max1!=0 && slowCCI[1]<max1 && slowCCI[0]>=max1 && 
      slowCCI[0]-delta>slowCCI[1] /* && slowCCI[0]>slowCCI[1] && !(slowCCI[1]-delta>slowCCI[2]) */
      && (Pattern==0 || Pattern==4))
      {
		   VegasBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;	
         if (shift == 0) SoundAnAlert(VEGAS);
      }
      //  Vegas â âîñõîäÿùåì òðåíäå
      if (up >=6 && min2!=0 && slowCCI[1]>min2 && slowCCI[0]<=min2 &&
      slowCCI[0]+delta<slowCCI[1] 
		/* && slowCCI[0]<slowCCI[1] && !(slowCCI[1]+delta<slowCCI[2]) */
		&& (Pattern==0 || Pattern==4))
      {
			VegasBuffer[shift]=High[shift]+upnt*Point;
         upnt=upnt+5;			
         if (shift == 0) SoundAnAlert(VEGAS);
      }
      
      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 5 - Ïðèçðàê (Ghost)
      // -----------------------------------------------------------  
      // Ïàòòåðí "Ïðèçðàê" ôîðìèðóåòñÿ 3 âåðøèíàìè, êîòîðûå ïîñëåäîâàòåëüíî 
      // îáðàçóþò: îäíó ðóêó, ãîëîâó è çàòåì äðóãóþ ðóêó. (Íàâåðíîå, 
      // òî÷íåå áóäåò ñêàçàòü: "Ãîëîâà è ïëå÷è"). Ýòè ôèãóðû ìîãóò áûòü 
      // ñôîðìèðîâàíû êàê CCI, òàê è TCCI. Òåì íå ìåíåå, áîëüøèíñòâî 
      // òðåéäåðîâ èñïîëüçóþò CCI äëÿ îïðåäåëåíèÿ ýòîãî ïàòòåðíà. 
      // Æåëàòåëüíî, ÷òîáû ãîëîâà áûëà áîëüøå ïëå÷. Äëÿ îïðåäåëåíèÿ 
      // òî÷êè âõîäà ïî íèæíèì òî÷êàì ïàòòåðíà "Ïðèçðàê" - ëèíèè 
      // øåè - ïðîâîäèòñÿ ëèíèÿ òðåíäà.
      // Âû ìîæåòå ðàññ÷èòàòü îæèäàåìîå äâèæåíèå CCI äëÿ ïàòòåðíà "Ïðèçðàê", 
      // èçìåðÿÿ ðàññòîÿíèå îò âåðøèíû ãîëîâû äî ëèíèè øåè, è îíî áóäåò 
      // ðàâíî ðàññòîÿíèþ îò ëèíèè øåè äî ãîëîâû â ïðîòèâîïîëîæíîì 
      // íàïðàâëåíèè.  ïðèíöèïå Âû ìîæåòå íå âûñ÷èòûâàòü âîçìîæíîå 
      // ïîòåíöèàëüíîå äâèæåíèå CCI îò ëèíèè øåè, òàê êàê Âû äîëæíû 
      // çàêðûòü ïîçèöèþ, êàê òîëüêî CCI äàñò ñèãíàë íà âûõîä. Âñå, 
      // ÷òî Âû äîëæíû äåëàòü - ñëåäîâàòü çà ñèãíàëàìè âûõîäà, 
      // îïðåäåëåííûìè ñèñòåìîé Woodies CCI.
      // Çàìåòüòå, ÷òî, êîãäà Âû ïðîâîäèòå ëèíèþ øåè (ëèíèÿ òðåíäà) 
      // íà ïàòòåðíå "Ïðèçðàê", Âû îáúåäèíÿåòå ïàòòåðí "Ïðîðûâ ëèíèè 
      // òðåíäà (TLB)" ñ ïàòòåðíîì "Ïðèçðàê", ÷òî óñèëèâàåò ñèãíàë è 
      // óâåëè÷èâàåò âåðîÿòíîñòü óñïåõà. Èíîãäà ëèíèÿ øåè íàêëîíåíà 
      // ïî íàïðàâëåíèþ ê íóëåâîé ëèíèè. Ýòî - áîëåå ïðåäïî÷òèòåëüíûé 
      // âàðèàíò ïàòòåðíà "Ïðèçðàê" ïî ñðàâíåíèþ ñ òåì, ïðè êîòîðîì 
      // ëèíèÿ øåè îòêëîíÿåòñÿ îò íóëåâîé ëèíèè.  ëþáîì ñëó÷àå îáà 
      // âàðèàíòà ìîãóò áûòü èñïîëüçîâàíû äëÿ òîðãîâëè.
      // Òîðãîâëÿ ñ èñïîëüçîâàíèåì ïàòòåðíà "Ïðèçðàê" ïî ñóòè - òîðãîâëÿ 
      // ïðîòèâ òðåíäà. 
      // -----
      delta=15; level=50;
      max1=0; max2=0; max3=0; tmax1=0; tmax2=0; tmax3=0;
      min1=0; min2=0; min3=0; tmin1=0; tmin2=0; tmin3=0;
      // -----  
      GhostBuffer[shift]=EMPTY_VALUE;        
      // îïðåäåëåíèå ìàêñèìóìîâ
      if (up>=6) for (a=0;a<=17;a++)
      { 
         if (slowCCI[a]<=slowCCI[a+1] && slowCCI[a+1]>=slowCCI[a+2])
			{
				if (max2!=0 && max3==0) max3=slowCCI[a+1];
				if (max1!=0 && max2==0) max2=slowCCI[a+1];
				if (max1==0) max1=slowCCI[a+1];
			}
      }
      // îïðåäåëåíèå ìèíèìóìîâ
      if (dn>=6) for (a=0;a<=17;a++) 
      {     
         if (slowCCI[a]>=slowCCI[a+1] && slowCCI[a+1]<=slowCCI[a+2])
			{
				if (min2!=0 && min3==0) min3=slowCCI[a+1];
				if (min1!=0 && min2==0) min2=slowCCI[a+1];
				if (min1==0) min1=slowCCI[a+1];
			}
      }
      // Ghost â íèñõîäÿùåì òðåíäå
	   if (dn>=6 && 
	   min3!=0 && min1>min2 && min3>min2+delta && min1<0 &&
		slowCCI[0]-delta>min1 && slowCCI[0]>slowCCI[1] && 
   /* min3<0 && max1<=0 && max1>=-level && max2<=level && max2>=-level */
      !(slowCCI[1]-delta>min1) && (Pattern==0 || Pattern==5))
      {		
		   GhostBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;			
         if (shift == 0) SoundAnAlert(GHOST);
      }
      // Ghost â âîñõîäÿùåì òðåíäå
      if (up>=6 && 
      max3!=0 && max1<max2 && max3<max2-delta && max1>0 && 
      slowCCI[0]+delta<max1 && slowCCI[0]<slowCCI[1] && 
   /* max3>0 && min1<=level && min1>=0 && min2<=level && min2>=-level */
		!(slowCCI[1]+delta<max1) && (Pattern==0 || Pattern==5))
      {
         GhostBuffer[shift]=High[shift]+upnt*Point;
         upnt=upnt+5;			
         if (shift == 0) SoundAnAlert(GHOST);
      }

      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 6 - Ðàçâîðîòíàÿ äèâåðãåíöèÿ Woodies CCI (Rev Diver)
      // -----------------------------------------------------------  
      // Ðàçâîðîòíàÿ äèâåðãåíöèÿ Woodies CCI (Rev Diver) - î÷åíü ïðîñòîé 
      // ïàòòåðí òîðãîâëè ïî òðåíäó, êîòîðûé îïðåäåëÿåòñÿ äâóìÿ 
      // îòñêîêàìè CCI, ïîñëåäíèé èç êîòîðûõ íàõîäèòñÿ áëèæå ê íóëåâîé ëèíèè. 
      // Ïîä ñëîâîì îòñêîê ìû ïîäðàçóìåâàåì ïèêè è âïàäèíû, îáðàçóåìûå 
      // äâèæåíèåì CCI ââåðõ è âíèç. Ìû ãîâîðèì âíóòðåííèå îòñêîêè, 
      // èìåÿ â âèäó ïèêè è âïàäèíû, êîòîðûå ðàñïîëîæåíû áëèæå ê íóëåâîé ëèíèè. 
      // Ìû íèêîãäà íå èñïîëüçóåì ýêñòðåìóìû, ÷òîáû îïðåäåëèòü ïàòòåðí Rev Diver.
      // ---- 
      // Ñëåäóþùèå äâà ïðàâèëà - ýòî âñå, ÷òî íåîáõîäèìî äëÿ îïðåäåëåíèÿ 
      // ïàòòåðíà Rev Diver:
      // * Rev Diver íà ïîêóïêó - CCI âûøå íóëåâîé ëèíèè â òå÷åíèå ïîñëåäíèõ 
      //   6 è áîëåå áàðîâ, äâà èç êîòîðûõ - ïîíèæàþùèåñÿ ïèêîâûå âïàäèíû
      // * Rev Diver íà ïðîäàæó - CCI íèæå íóëåâîé ëèíèè â òå÷åíèå ïîñëåäíèõ 
      //   6 è áîëåå áàðîâ, äâà èç êîòîðûõ - ïîâûøàþùèåñÿ ïèêè ê íóëåâîé ëèíèè
      // ---- 
      // Ïàòòåðí "Ðàçâîðîòíàÿ äèâåðãåíöèÿ" - ïàòòåðí òîðãîâëè ïî òðåíäó. 
      // Âû ìîæåòå îáúåäèíèòü òîðãîâëþ ñ èñïîëüçîâàíèåì Rev Diver ñ ïàòòåðíàìè 
      // "Îòñêîê îò íóëåâîé ëèíèè (ZLR)" èëè "Ïðîáîé ëèíèè òðåíäà (TLB)" 
      // äëÿ óâåðåííîñòè è ïîëó÷åíèÿ áîëüøåé ïðèáûëüíîñòè ñäåëêè. Âû ïðàêòè÷åñêè 
      // âñåãäà áóäåòå íàõîäèòü ñî÷åòàíèå ïàòòåðíà ZLR ñ ïàòòåðíîì Rev Diver. 
      // Ôàêòè÷åñêè ó Âàñ îáû÷íî áóäåò äâà ïàòòåðíà ZLR, êîòîðûå îáðàçóþò Rev Diver, 
      // òàê êàê îáû÷íî ïèêè èëè âïàäèíû îáðàçóþòñÿ â ïðåäåëàõ +/-100  øêàëû CCI. 
      // Âíóòðåííèå ïèêè èëè âïàäèíû ôàêòè÷åñêè ïðåäñòàâëÿþò ïàòòåðí CCI ZLR. 
      // Ïîñìîòðèòå ãðàôèêè âíèìàòåëüíî, è Âû óâèäèòå èõ îáà íà êàæäîì ãðàôèêå.
      // ---- 
      delta=20; level=70;
      // ----       
      max1=0; max2=0; tmax1=0; tmax2=0;
      min1=0; min2=0; tmin1=0; tmin2=0;
      // -----  
      RevdevBuffer[shift]=EMPTY_VALUE;        
      // îïðåäåëåíèå ìàêñèìóìîâ
      if (dn>=6) for (a=0;a<=17;a++)
      { 
         if (slowCCI[a]<=slowCCI[a+1] && slowCCI[a+1]>=slowCCI[a+2])
			{
				if (max1!=0 && tmax1<3 && max2==0)
				{
					max2=slowCCI[a+1];
					tmax2=a+1;
				}
				if (max1==0)
				{
					max1=slowCCI[a+1];
					tmax1=a+1;
				}
			}
      }
      // îïðåäåëåíèå ìèíèìóìîâ
      if (up>=6) for (a=0;a<=17;a++) 
      {     
         if (slowCCI[a]>=slowCCI[a+1] && slowCCI[a+1]<=slowCCI[a+2])
			{
				if (min1!=0 && tmin1<3 && min2==0)
				{
					min2=slowCCI[a+1];
					tmin2=a+1;
				}
				if (min1==0)
				{
					min1=slowCCI[a+1];
					tmin1=a+1;
				}
			}
      }
      // Revdiv â íèñõîäÿùåì òðåíäå
	   if (dn>=6 && 
	   max1<=0 && max2!=0 && max1>max2 && max1>=-level && tmax2-tmax1>=3 &&
   /* max2<=level && max2>=-level && */
	   slowCCI[0]+delta<max1 && slowCCI[0]<slowCCI[1] && !(slowCCI[1]+delta<max1) 
	   && (Pattern==0 || Pattern==6))
      {
         RevdevBuffer[shift]=High[shift]+upnt*Point;
         upnt=upnt+5;			
         if (shift == 0) SoundAnAlert(REVDEV);
      }
      // Revdiv â âîñõîäÿùåì òðåíäå
	   if (up>=6 && 
	   min1>=0 && min2!=0 && min1<min2 && min1<=level && tmin2-tmin1>=3 &&
   /* pmn2<=level && pmn2>=-level && */
      slowCCI[0]-delta>min1 && slowCCI[0]>slowCCI[1] && !(slowCCI[1]-delta>min1) 
      && (Pattern==0 || Pattern==6))
      {	
         RevdevBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;
         if (shift == 0) SoundAnAlert(REVDEV);
      }

      ///////////////////////////////////////////////////////////////
      // Ïàòòåðí ¹ 7 - Ýêñòðåìàëüíûé Êðþê (HFE)
      // -----------------------------------------------------------        
      // Ýòîò ïàòòåðí ôîðìèðóåòñÿ, êîãäà CCI óõîäèò çà ïðåäåëû +/-200, 
      // à çàòåì ðàçâîðà÷èâàåòñÿ íàçàä ê íóëåâîé ëèíèè. Ýòà - î÷åíü 
      // òðóäíûé ñïîñîá òîðãîâëè. Ïàòòåðí HFE ÿâëÿåòñÿ òàêæå îäíèì èç 
      // Woodies CCI ñèãíàëîâ âûõîäà.
      // ----      
      // Òîðãîâëÿ ïî ýòîìó ïàòòåðíó ïðîèñõîäèò î÷åíü áûñòðî. Êàê òîëüêî 
      // êðþê ðàçâîðà÷èâàåòñÿ íàçàä ê íóëåâîé ëèíèè, âõîäèòå. Óñòàíîâèòå 
      // áëèçêèå îðäåðà ñòîï-ëîññ ñðàçó æå ïðè âõîäå â ðûíîê, ïîñêîëüêó 
      // òîðãîâûé ñèãíàë ìîæåò ðàçâåðíóòüñÿ î÷åíü áûñòðî. Êàê òîëüêî 
      // ïîÿâèëñÿ ñèãíàë ê âûõîäó - âûõîäèòå íåìåäëåííî.
      // Òîðãîâëÿ áóäåò îñòàíàâëèâàòüñÿ ÷àñòî, è ýòî ìîæåò ñëó÷èòüñÿ, 
      // äàæå åñëè íåò CCI ñèãíàëà íà âûõîä. Âåðîÿòíîñòü óñïåøíîé 
      // òîðãîâëè ñîñòàâëÿåò ïðèáëèçèòåëüíî 50%, åñëè òîðãîâàòü ïðè 
      // êàæäîì ñèãíàëå HFE. Îäíàêî ïîòåíöèàëüíàÿ ïðèáûëü áóäåò áîëüøå 
      // óáûòêîâ, åñëè Âû áóäåòå èñïîëüçîâàòü áëèçêèå ñòîï-ëîññ îðäåðà.
      // Òîðãîâëÿ ïðè ðàçâîðîòå îò ýêñòðåìóìîâ ïî ñóòè ÿâëÿåòñÿ 
      // ïðîòèâîòðåíäîâîé, ïîýòîìó ñ îñòîðîæíîñòüþ îòíîñèòåñòü ê 
      // ýòîìó ïàòòåðíó. 
      // ----      
      // Äëÿ áîëüøåé ýôôåêòèâíîñòè Âû ìîæåòå îáúåäèíèòü òîðãîâëþ ïî 
      // HFE-ïàòòåðíó ñ ïðîðûâîì ëèíèè òðåíäà èëè ñ ïåðåñå÷åíèåì CCI 
      // óðîâíÿ +/-100, êîòîðûå ÿâëÿþòñÿ ñèãíàëàìè ïîäòâåðæäåíèÿ. 
      // ----
      delta=10; level=200;
      HooksBuffer[shift]=EMPTY_VALUE;        
      // HFE â íèñõîäÿùåì òðåíäå
      if (dn>=6 && 
      slowCCI[1]<=-level && slowCCI[0]>-level && slowCCI[1]<slowCCI[0]-delta
      && (Pattern==0 || Pattern==7))
      {
         HooksBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;
         if (shift == 0) SoundAnAlert(HFE);
      }
      // HFE âîñõîäÿùåì òðåíäå
      if (up>=6 && 
      slowCCI[1]>=level && slowCCI[0]<level && slowCCI[1]>slowCCI[0]-delta
      && (Pattern==0 || Pattern==7))
      {
         HooksBuffer[shift]=High[shift]+upnt*Point;
         upnt=upnt+5;
         if (shift == 0) SoundAnAlert(HFE);
      } 
     
      ///////////////////////////////////////////////////////////////
      // Ñèãíàë íà âûõîä
      // -----------------------------------------------------------
      // 1. Ðàçâîðîò (CCI(14) îáðàçóåò êðþê) èëè ïëîñêîå äâèæåíèå CCI	
      // 2. Ïðîáîé CCI ëèíèè òðåíäà (TLB)		
      // 3. CCI(6) ïåðåñåêàåò CCI(14) âîâíóòðü		
      // 4. CCI ïåðåñåêàåò íóëåâóþ ëèíèþ (ZLC).
      // 5. Êîãäà CCI 14 îáðàçóåò êðþê îêîëî óðîâíÿ +/-200 èëè çà íèì
      // 6. CCI (áåç äâèæåíèÿ íåò óñïåõà)
      // -----------------------------------------------------------

      // 1. Ðàçâîðîò (CCI(14) îáðàçóåò êðþê) èëè ïëîñêîå äâèæåíèå CCI
	   if (HooksBuffer[shift]!=EMPTY_VALUE && (Pattern==0 || Pattern==8))
      { 	
         if (up>=6)
	      { 
		      ExitBuffer[shift]=High[shift]+upnt*Point;
            upnt=upnt+5;
            if (shift == 0) SoundAnAlert(EXIT8);
		   }
	      if (dn>=6)
	      { 
		      ExitBuffer[shift]=Low[shift]-dpnt*Point;
            dpnt=dpnt+5;
            if (shift == 0) SoundAnAlert(EXIT8);
		   }
		}
      // 2. Ïðîáîé CCI ëèíèè òðåíäà (ïðîòèâ òðåíäà)
      if (TlbBuffer[shift]!=EMPTY_VALUE && (Pattern==0 || Pattern==8)) 
      { 	
         if (up>=6 && TlbBuffer[shift]>High[shift])
	      { 
		      ExitBuffer[shift]=High[shift]+upnt*Point;
            upnt=upnt+5;
            if (shift == 0) SoundAnAlert(EXIT8);
		   }
	      if (dn>=6 && TlbBuffer[shift]<Low[shift])
	      { 
		      ExitBuffer[shift]=Low[shift]-dpnt*Point;
            dpnt=dpnt+5;
            if (shift == 0) SoundAnAlert(EXIT8);
		   }
		}
		/*
      // 3. CCI(6) ïåðåñåêàåò CCI(14) âîâíóòðü	
      if (up>=6 && fastCCI[1]>=slowCCI[1] && fastCCI[0]<=slowCCI[0])
	   { 
		   ExitBuffer[shift]=High[shift]+upnt*Point;
         upnt=upnt+5;
         if (shift == 0) SoundAnAlert(EXIT8);
		}
	   if (dn>=6 && TlbBuffer[shift]<Low[shift])
	   { 
		   ExitBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;
         if (shift == 0) SoundAnAlert(EXIT8);
		} */     
      
/*
      delta=10; level=100;
      // ----
      ExitBuffer[shift]=EMPTY_VALUE;  
      min1=0; max1=0; // çíà÷åíèÿ ìèí/ìàõ 
      //	Îïðåäåëåíèå ìèí/ìàêñ è ïîñòðîåíèå ëèíèè òðåíäà
      for (a=0;a<=17;a++)
      { 
         // îïðåäåëåíèå ìàêñèìóìîâ
         if (slowCCI[a]<=slowCCI[a+1] && slowCCI[a+1]>=slowCCI[a+2])
			{
				if (max1==0) max1=slowCCI[a+1];
			}
         // îïðåäåëåíèå ìèíèìóìîâ
         if (slowCCI[a]>=slowCCI[a+1] && slowCCI[a+1]<=slowCCI[a+2])
			{
				if (min1==0) min1=slowCCI[a+1];
			}
      }
      // âûõîä â íèñõîäÿùåì òðåíäå
	   if (min1!=0 && slowCCI[0]-delta>min1 && !(slowCCI[1]-delta>min1) && MathAbs(slowCCI[0])>level)
      {
		   ExitBuffer[shift]=Low[shift]-dpnt*Point;
         dpnt=dpnt+5;
         if (shift == 0) SoundAnAlert(EXIT8);
	   }
      // âûõîä â âîñõîäÿùåì òðåíäå
      if (max1!=0 && slowCCI[0]+delta<max1 && !(slowCCI[1]+delta<max1) && MathAbs(slowCCI[0])>level) 
      {
		   ExitBuffer[shift]=High[shift]+upnt*Point;
         upnt=upnt+5;
         if (shift == 0) SoundAnAlert(EXIT8);
      }
*/
   }    
   return(0);
}