utter_up_dn

Author: Copyright � 2011, RMM
Miscellaneous
Implements a curve of type %1
0 Views
0 Downloads
0 Favorites
utter_up_dn
//+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
//|                                                                                                                                                        utter_up_dn.mq4 |
//|                                                                                                                                                  Copyright © 2011, RMM |
//+------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
#property copyright "Copyright © 2011, RMM"
#property link      "rmm@nm.ru"
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Blue
#property indicator_color2 Red
double Up[];
double Dn[]; 
double Up_tmp;
double Dn_tmp;
int review=20;
extern string ñ2= "Ãëóáèíà ïðîñìîòðà èñòîðèè â áàðàõ";
extern int QuantityOfBars=1000;
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//| Custom indicator initialization function                         
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int init()
  {
   IndicatorBuffers(2);
   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,217);
   SetIndexBuffer(0,Up);               //ïàðàìåòð ïðè âûçîâå ôóíêöèåé iCustom  mode=0
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,218);
   SetIndexBuffer(1,Dn);               //ïàðàìåòð ïðè âûçîâå ôóíêöèåé iCustom  mode=1 
   return(0);
  }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//| Custom indicator deinitialization function                       
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int deinit()
   {return(0);}
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//| Custom indicator iteration function                              
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int start()
  {
   bool actual_back, actual_forward;
   int i,j, TypeDuo;
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
   if(QuantityOfBars>Bars)QuantityOfBars=Bars;
   for(i=QuantityOfBars;i>1;i--)                                                                                     //îñíîâíàÿ èòåðàöèÿ
      {
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Íàéäåí âåðõíèé ýêñòðåìóì, îòñóòñòâóåò íèæíèé ýêñòðåìóì
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         if(ExistUp(i)&&!ExistDn(i))                                                                     //åñëè íàéäåí âåðõíèé ýêñòðåìóì                                            
            {                                                            
               actual_back=false;                                                                        //îáíóëÿåì ôëàã îêåéíîñòè ïðè ïðîñìîòðå íàçàä ïî èñòîðèè
               j=i;                                                                                      //çàïîìèíàåì áàð íà êîòîðîì íàøëè âåðõíèé ýêñòðåìóì
               while(j<i+review)                                                                         //õîòèì ïðîáåæàòü ïî áàðàì íàçàä ïî èñòîðèè íà âåëè÷èíó review 
                  {
                     j++;                                                                                //íàðàùèâàåì ñ÷åò÷èê õîäà íàçàä ïî èñòîðèè
                     if(ExistUp(j)&&!ExistDn(j)&&High[j]>=High[i]) {actual_back=false; break;}           //åñëè åñòü âåðõíèé ýêñòðåìóì è îí âûøå èëè ðàâåí òåêóùåìó, òî íàø âåðõíèé íå äåéñòâèòåëüíûé
                     if(ExistDn(j)&&!ExistUp(j)&&Low [j]< High[i]) {actual_back=true;  break;}           //åñëè íàõîäèì íèæíèé ýêñòðåìóì è îí íèæå òåêóùåãî, òî íàø âåðõíèé èìååò ïðàâî æèòü
                     if(ExistDn(j)&&ExistUp(j))                                                          //åñëè íàõîäèì è íèæíèé è âåðõíèé ýêñòðåìóì 
                        {
                           TypeDuo=IdentDualExtr(j);
                           switch(TypeDuo)
                              {
                                 case 1:
                                    actual_back=true;
                                    break;
                                 case 2:
                                    actual_back=true;
                                    break;
                                 case 3:
                                    actual_back=true;
                                    break;
                                 case 4:
                                    actual_back=true;
                                    break;
                                 case 5:
                                    actual_back=true;
                                    break;
                                 case 6:
                                    actual_back=true;
                                    break;
                                 case 7:
                                    actual_back=true;
                                    break;
                                 case 8:
                                    actual_back=true;
                                    break;
                                 case 9:
                                    actual_back=true;
                                    break;
                                 case 10:
                                    actual_back=true;
                                    break;
                                 case 11:
                                    actual_back=true;
                                    break;
                                 case 12:
                                    actual_back=true;
                                    break;
                                 case 13:
                                    actual_back=true;
                                    break;
                                 case 14:
                                    actual_back=true;
                                    break;
                                 case 15:
                                    actual_back=true;
                                    break;
                                 case 16:
                                    actual_back=true;
                                    break;
                                 case 17:
                                    actual_back=true;
                                    break;
                                 case 18:
                                    actual_back=true;
                                    break;
                                 case 19:
                                    actual_back=true;
                                    break;
                                 case 20:
                                    actual_back=true;
                                    break;
                                 case 21:
                                    actual_back=true;
                                    break;
                                 case 22:
                                    actual_back=true;
                                    break;
                                 case 23:
                                    actual_back=false;
                                    break;
                                 case 24:
                                    actual_back=false;
                                    break;
                                 case 25:
                                    actual_back=true;
                                    break;
                                 case 26:
                                    actual_back=true;
                                    break;
                                 case 27:
                                    actual_back=true;
                                    break;
                                 case 28:
                                    actual_back=true;
                                    break;
                                 case 29:
                                    actual_back=true;
                                    break;
                                 case 30:
                                    actual_back=true;
                                    break;
                                 case 31:
                                    actual_back=true;
                                    break;
                                 case 32:
                                    actual_back=true;
                                    break;
                                    
                              }
                           break; 
                        }
                  }  
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
               actual_forward=false;                                                                     //îáíóëÿåì ôëàã îêåéíîñòè ïðè ïðîñìîòðå âïåðåä ïî èñòîðèè
               j=i;                                                                                      //çàïîìèíàåì áàð íà êîòîðîì íàøëè âåðõíèé ýêñòðåìóì
               while(j>i-review)                                                                         //õîòèì ïðîáåæàòü ïî áàðàì âïåðåä ïî èñòîðèè íà âåëè÷èíó review 
                  {
                  j--;                                                                                   //íàðàùèâàåì ñ÷åò÷èê õîäà âïåðåä ïî èñòîðèè
                     if(ExistUp(j)&&!ExistDn(j)&&High[j]>High[i]) {actual_forward=false; break;}         //åñëè íàõîäèì âåðõíèé ýêñòðåìóì è îí âûøå òåêóùåãî, òî íàø âåðõíèé íå äåéñòâèòåëüíûé 
                     if(ExistDn(j)&&!ExistUp(j)&&Low [j]<High[i]) {actual_forward=true; break;}          //åñëè íàõîäèì íèæíèé ýêñòðåìóì è îí íèæå òåêóùåãî, òî íàø âåðõíèé èìååò ïðàâî æèòü
                     if(ExistDn(j)&&ExistUp(j))                                                          //åñëè íàõîäèì è íèæíèé è âåðõíèé ýêñòðåìóì 
                        {
                           TypeDuo=IdentDualExtr(j);
                           switch(TypeDuo)
                              {
                                 case 1:
                                    actual_forward=true;
                                    break;
                                 case 2:
                                    actual_forward=false;
                                    break;
                                 case 3:
                                    actual_forward=false;
                                    break;
                                 case 4:
                                    actual_forward=true;
                                    break;
                                 case 5:
                                    actual_forward=true;
                                    break;
                                 case 6:
                                    actual_forward=true;
                                    break;
                                 case 7:
                                    actual_forward=true;
                                    break;
                                 case 8:
                                    actual_forward=true;
                                    break;
                                 case 9:
                                    actual_forward=true;
                                    break;
                                 case 10:
                                    actual_forward=true;
                                    break;
                                 case 11:
                                    actual_forward=true;
                                    break;
                                 case 12:
                                    actual_forward=true;
                                    break;
                                 case 13:
                                    actual_forward=true;
                                    break;
                                 case 14:
                                    actual_forward=true;
                                    break;
                                 case 15:
                                    actual_forward=true;
                                    break;
                                 case 16:
                                    actual_forward=true;
                                    break;
                                 case 17:
                                    actual_forward=true;
                                    break;
                                 case 18:
                                    actual_forward=true;
                                    break;
                                 case 19:
                                    actual_forward=true;
                                    break;
                                 case 20:
                                    actual_forward=true;
                                    break;
                                 case 21:
                                    actual_forward=true;
                                    break;
                                 case 22:
                                    actual_forward=true;
                                    break;
                                 case 23:
                                    actual_forward=true;
                                    break;
                                 case 24:
                                    actual_forward=true;
                                    break;
                                 case 25:
                                    actual_forward=true;
                                    break;
                                 case 26:
                                    actual_forward=true;
                                    break;
                                 case 27:
                                    actual_forward=false;
                                    break;
                                 case 28:
                                    actual_forward=false;
                                    break;
                                 case 29:
                                    actual_forward=true;
                                    break;
                                 case 30:
                                    actual_forward=true;
                                    break;
                                 case 31:
                                    actual_forward=true;
                                    break;
                                 case 32:
                                    actual_forward=true;
                              }
                           break; 
                        }
                  }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
               if(actual_back&&actual_forward)                                                           //åñëè ïîçàäè è âïåðåäè âñ¸ ÎÊ
                  {
                     Up_tmp=High[i];                                                                     //çàïîëíÿåì ìàññèâ Up ÷åðåç ïåðåìåííóþ Up_tmp
                  }
               else Up_tmp=0;                                                                            //åñëè ýêñòðåìóì íå äåéñòâèòåëüíûé, òî îáíóëÿåì ìàññèâ ÷åðåç ïåðåìåííóþ Up_tmp
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            }                                                                                            //âûïîëíåíî âñ¸ â ñëó÷àå åñëè íàéäåí âåðõíèé ýêñòðåìóì  
            else Up_tmp=0;                                                                               //åñëè âåðõíåãî ýêñòðåìóìà íå áûëî, òî îáíóëÿåì ìàññèâ ÷åðåç ïåðåìåííóþ Up_tmp            
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Íàéäåí íèæíèé ýêñòðåìóì, îòñóòñòâóåò âåðõíèé ýêñòðåìóì
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            if(ExistDn(i)&&!ExistUp(i))                                                                  //åñëè íàéäåí íèæíèé ýêñòðåìóì                                            
            {                                                            
               actual_back=false;                                                                        //îáíóëÿåì ôëàã îêåéíîñòè ïðè ïðîñìîòðå íàçàä ïî èñòîðèè
               j=i;                                                                                      //çàïîìèíàåì áàð íà êîòîðîì íàøëè íèæíèé ýêñòðåìóì
               while(j<i+review)                                                                         //õîòèì ïðîáåæàòü ïî áàðàì íàçàä ïî èñòîðèè íà âåëè÷èíó depth_review 
                  {
                     j++;                                                                                //íàðàùèâàåì ñ÷åò÷èê õîäà íàçàä ïî èñòîðèè
                     if(ExistDn(j)&&!ExistUp(j)&&Low [j]<=Low[i]) {actual_back=false;  break;}           //åñëè íàõîäèì íèæíèé ýêñòðåìóì è îí íèæå èëè ðàâåí òåêóùåìó, òî íàø íèæíèé íå äåéñòâèòåëüíûé
                     if(ExistUp(j)&&!ExistDn(j)&&High[j]> Low[i]) {actual_back=true; break;}             //åñëè íàõîäèì âåðõíèé ýêñòðåìóì è îí âûøå òåêóùåãî, òî íàø íèæíèé èìååò ïðàâî æèòü
                     if(ExistDn(j)&&ExistUp(j))                                                          //åñëè íàõîäèì è íèæíèé è âåðõíèé ýêñòðåìóì 
                        {
                           TypeDuo=IdentDualExtr(j);
                           switch(TypeDuo)
                              {
                                 case 1:
                                    actual_back=true;
                                    break;
                                 case 2:
                                    actual_back=true;
                                    break;
                                 case 3:
                                    actual_back=true;
                                    break;
                                 case 4:
                                    actual_back=true;
                                    break;
                                 case 5:
                                    actual_back=true;
                                    break;
                                 case 6:
                                    actual_back=true;
                                    break;
                                 case 7:
                                    actual_back=true;
                                    break;
                                 case 8:
                                    actual_back=true;
                                    break;
                                 case 9:
                                    actual_back=true;
                                    break;
                                 case 10:
                                    actual_back=true;
                                    break;
                                 case 11:
                                    actual_back=true;
                                    break;
                                 case 12:
                                    actual_back=true;
                                    break;
                                 case 13:
                                    actual_back=true;
                                    break;
                                 case 14:
                                    actual_back=true;
                                    break;
                                 case 15:
                                    actual_back=true;
                                    break;
                                 case 16:
                                    actual_back=true;
                                    break;
                                 case 17:
                                    actual_back=true;
                                    break;
                                 case 18:
                                    actual_back=true;
                                    break;
                                 case 19:
                                    actual_back=true;
                                    break;
                                 case 20:
                                    actual_back=true;
                                    break;
                                 case 21:
                                    actual_back=true;
                                    break;
                                 case 22:
                                    actual_back=true;
                                    break;
                                 case 23:
                                    actual_back=true;
                                    break;
                                 case 24:
                                    actual_back=true;
                                    break;
                                 case 25:
                                    actual_back=true;
                                    break;
                                 case 26:
                                    actual_back=false;
                                    break;
                                 case 27:
                                    actual_back=true;
                                    break;
                                 case 28:
                                    actual_back=false;
                                    break;
                                 case 29:
                                    actual_back=true;
                                    break;
                                 case 30:
                                    actual_back=true;
                                    break;
                                 case 31:
                                    actual_back=true;
                                    break;
                                 case 32:
                                    actual_back=true;
                              }
                           break; 
                        }
                  }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
               actual_forward=false;                                                                     //îáíóëÿåì ôëàã îêåéíîñòè ïðè ïðîñìîòðå âïåðåä ïî èñòîðèè
               j=i;                                                                                      //çàïîìèíàåì áàð íà êîòîðîì íàøëè íèæíèé ýêñòðåìóì
               while(j>i-review)                                                                         //õîòèì ïðîáåæàòü ïî áàðàì âïåðåä ïî èñòîðèè íà âåëè÷èíó review 
                  {
                     j--;                                                                                //íàðàùèâàåì ñ÷åò÷èê õîäà âïåðåä ïî èñòîðèè
                     if(ExistDn(j)&&!ExistUp(j)&&Low [j]<Low[i]) {actual_forward=false; break;}          //åñëè íàõîäèì íèæíèé ýêñòðåìóì è îí íèæå òåêóùåãî, òî íàø íèæíèé íå äåéñòâèòåëüíûé
                     if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[i]) {actual_forward=true; break;}           //åñëè íàõîäèì âåðõíèé ýêñòðåìóì è îí âûøå òåêóùåãî, òî íàø íèæíèé èìååò ïðàâî æèòü
                     if(ExistDn(j)&&ExistUp(j))                                                          //åñëè íàõîäèì è íèæíèé è âåðõíèé ýêñòðåìóì
                        {
                           TypeDuo=IdentDualExtr(j);
                           switch(TypeDuo)
                              {
                                 case 1:
                                    actual_forward=true;
                                    break;
                                 case 2:
                                    actual_forward=true;
                                    break;
                                 case 3:
                                    actual_forward=true;
                                    break;
                                 case 4:
                                    actual_forward=true;
                                    break;
                                 case 5:
                                    actual_forward=true;
                                    break;
                                 case 6:
                                    actual_forward=true;
                                    break;
                                 case 7:
                                    actual_forward=true;
                                    break;
                                 case 8:
                                    actual_forward=true;
                                    break;
                                 case 9:
                                    actual_forward=true;
                                    break;
                                 case 10:
                                    actual_forward=true;
                                    break;
                                 case 11:
                                    actual_forward=true;
                                    break;
                                 case 12:
                                    actual_forward=true;
                                    break;
                                 case 13:
                                    actual_forward=true;
                                    break;
                                 case 14:
                                    actual_forward=false;
                                    break;
                                 case 15:
                                    actual_forward=true;
                                    break;
                                 case 16:
                                    actual_forward=false;
                                    break;
                                 case 17:
                                    actual_forward=true;
                                    break;
                                 case 18:
                                    actual_forward=true;
                                    break;
                                 case 19:
                                    actual_forward=true;
                                    break;
                                 case 20:
                                    actual_forward=true;
                                    break;
                                 case 21:
                                    actual_forward=true;
                                    break;
                                 case 22:
                                    actual_forward=false;
                                    break;
                                 case 23:
                                    actual_forward=true;
                                    break;
                                 case 24:
                                    actual_forward=false;
                                    break;
                                 case 25:
                                    actual_forward=true;
                                    break;
                                 case 26:
                                    actual_forward=true;
                                    break;
                                 case 27:
                                    actual_forward=true;
                                    break;
                                 case 28:
                                    actual_forward=true;
                                    break;
                                 case 29:
                                    actual_forward=true;
                                    break;
                                 case 30:
                                    actual_forward=true;
                                    break;
                                 case 31:
                                    actual_forward=true;
                                    break;
                                 case 32:
                                    actual_forward=true;
                              }
                           break; 
                        }
                  }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
               if(actual_back&&actual_forward)                                                           //åñëè ïîçàäè è âïåðåäè âñ¸ ÎÊ
                  {
                     Dn_tmp=Low[i];                                                                      //çàïîëíÿåì ìàññèâ Dn ÷åðåç ïåðåìåííóþ Dn_tmp
                  }
               else Dn_tmp=0;                                                                            //åñëè ýêñòðåìóì íå äåéñòâèòåëüíûé, òî îáíóëÿåì ìàññèâ ÷åðåç ïåðåìåííóþ Dn_tmp
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            }                                                                                            //âûïîëíåíî âñ¸ â ñëó÷àå åñëè íàéäåí íèæíèé ýêñòðåìóì 
            else Dn_tmp=0;                                                                               //åñëè íèæíåãî ýêñòðåìóìà íå áûëî, òî îáíóëÿåì ìàññèâ ÷åðåç ïåðåìåííóþ Dn_tmp             
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Íàéäåí íèæíèé ýêñòðåìóì, íàéäåí âåðõíèé ýêñòðåìóì
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            if(ExistDn(i)&&ExistUp(i))                                                                   //åñëè íàéäåí è âåðõíèé è íèæíèé ýêñòðåìóì
               {
                  TypeDuo=IdentDualExtr(i);         
                  switch(TypeDuo)
                     {
                        case 1:
                           Up_tmp=0;
                           Dn_tmp=Low[i];
                           break;
                        case 2:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 3:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 4:
                           Up_tmp=0;
                           Dn_tmp=Low[i];
                           break;
                        case 5:
                           Up_tmp=0;
                           Dn_tmp=Low[i];
                           break;
                        case 6:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 7:
                           Up_tmp=0;
                           Dn_tmp=Low[i];
                           break;
                        case 8:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break; 
                        case 9:
                           Up_tmp=High[i];
                           Dn_tmp=0;
                           break;
                        case 10:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 11:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 12:
                           Up_tmp=High[i];
                           Dn_tmp=0;
                           break;
                        case 13:
                           Up_tmp=High[i];
                           Dn_tmp=0;
                           break;
                        case 14:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 15:
                           Up_tmp=High[i];
                           Dn_tmp=0;
                           break;
                        case 16:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;                     
                        case 17:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 18:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 19:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 20:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 21:
                           Up_tmp=0;
                           Dn_tmp=0;
                           break;
                        case 22:
                           Up_tmp=0;
                           Dn_tmp=Low[i];
                           break;
                        case 23:
                           Up_tmp=High[i];
                           Dn_tmp=0;
                           break;
                        case 24:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;                     
                        case 25:
                           Up_tmp=0;
                           Dn_tmp=0;
                           break;
                        case 26:
                           Up_tmp=0;
                           Dn_tmp=Low[i];
                           break;
                        case 27:
                           Up_tmp=High[i];
                           Dn_tmp=0;
                           break;
                        case 28:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 29:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 30:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 31:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;
                        case 32:
                           Up_tmp=High[i];
                           Dn_tmp=Low[i];
                           break;                     
                                               
                     }
               }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
            if(!ExistDn(i)&&!ExistUp(i))                                                                 //åñëè íå íàéäåíû è âåðõíèé è íèæíèé ýêñòðåìóì
               {
                  Up_tmp=0;
                  Dn_tmp=0;
               }            
            
            Up[i]=Up_tmp+2*Point;                                                                                // Çàïîëíÿåòñÿ íåïîñðåäñòâåííî ìàññèâ Up
            Dn[i]=Dn_tmp-2*Point;                                                                                // Çàïîëíÿåòñÿ íåïîñðåäñòâåííî ìàññèâ Dn
         }                                                                                                              
      return(0);
  }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Âîçâðàùàåò ôëàã ñóùåñòâîâàíèÿ âåðõíåãî ýêñòðåìóìà
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
bool ExistUp(int NumberBar)
   {
      if(High[NumberBar+1]<High[NumberBar]&&High[NumberBar]>=High[NumberBar-1]) return(true);
      return(false);
   }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Âîçâðàùàåò ôëàã ñóùåñòâîâàíèÿ íèæíåãî ýêñòðåìóìà
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
bool ExistDn(int NumberBar)
   {
      if(Low[NumberBar+1]>=Low[NumberBar]&&Low[NumberBar]<=Low[NumberBar-1]) return(true);
      return(false);
   }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Âîçâðàùàåò òèï ïàòòåðíà ïðè íàëè÷èè íà ñâå÷å è âåðõíåãî è íèæíåãî ýêñòðåìóìîâ
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
int IdentDualExtr(int NumberBar)
   {
            int j, type;
            bool up_back, dn_back, up_forward, dn_forward;
            string direction;
            j=NumberBar;                                                                                 //çàïîìèíàåì áàð íà êîòîðîì íàøëè íèæíèé ýêñòðåìóì
            if(Open[NumberBar]<Close[NumberBar]) direction="up";
            if(Open[NumberBar]>Close[NumberBar]) direction="dn";
            while(j<NumberBar+review)                                                                    //õîòèì ïðîáåæàòü ïî áàðàì íàçàä ïî èñòîðèè íà âåëè÷èíó review 
               {
                  j++;                                                                                   //íàðàùèâàåì ñ÷åò÷èê õîäà íàçàä ïî èñòîðèè
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]>High[NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_back=true; dn_back=false; direction="dn"; break;}
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]<High[NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_back=false; dn_back=false; direction="dn"; break;}
                  
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]>High[NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_back=true; dn_back=false; direction="up"; break;}
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]<High[NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_back=true; dn_back=false; direction="up"; break;}
                  
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]>High[NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_back=true; dn_back=false; direction="up"; break;}
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]<High[NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_back=false; dn_back=false; direction="up"; break;}


                                    
                  if(ExistDn(j)&&!ExistUp(j)&&Low [j]<Low [NumberBar]&&Low [j]<High [NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_back=false; dn_back=true; direction="dn"; break;}
                  if(ExistDn(j)&&!ExistUp(j)&&Low [j]>Low [NumberBar]&&Low [j]<High [NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_back=false; dn_back=true; direction="dn"; break;}
                  
                  if(ExistDn(j)&&!ExistUp(j)&&Low [j]<Low [NumberBar]&&Low [j]<High [NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_back=false; dn_back=true; direction="up"; break;}
                  if(ExistDn(j)&&!ExistUp(j)&&Low [j]>Low [NumberBar]&&Low [j]<High [NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_back=false; dn_back=false; direction="up"; break;}
                  
                  if(ExistDn(j)&&!ExistUp(j)&&Low [j]<High [NumberBar]&&Low [j]<Low [NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_back=false; dn_back=true; direction="up"; break;}
                  if(ExistDn(j)&&!ExistUp(j)&&Low [j]<High [NumberBar]&&Low [j]>Low [NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_back=false; dn_back=true; direction="up"; break;}

               }              
            j=NumberBar;                                                                                 //çàïîìèíàåì áàð íà êîòîðîì íàøëè íèæíèé ýêñòðåìóì
            while(j>NumberBar-review)                                                                    //õîòèì ïðîáåæàòü ïî áàðàì âïåðåä ïî èñòîðèè íà âåëè÷èíó review 
               {
                  j--;                                                                                   //íàðàùèâàåì ñ÷åò÷èê õîäà âïåðåä ïî èñòîðèè
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]>High[NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_forward=true; dn_forward=false; direction="dn"; break;}
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]<High[NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_forward=true; dn_forward=false; direction="dn"; break;}
                  
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]>High[NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_forward=true; dn_forward=false; direction="up"; break;}
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]<High[NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_forward=false; dn_forward=false; direction="up"; break;}
                  
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]>High[NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_forward=true; dn_forward=false; direction="up"; break;}
                  if(ExistUp(j)&&!ExistDn(j)&&High[j]>Low[NumberBar]&&High[j]<High[NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_forward=true; dn_forward=false; direction="up"; break;}

                  
                  if(ExistDn(j)&&!ExistUp(j)&&Low[j]<High [NumberBar]&&Low[j]<Low [NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_forward=false; dn_forward=true; direction="dn"; break;}
                  if(ExistDn(j)&&!ExistUp(j)&&Low[j]<High [NumberBar]&&Low[j]>Low [NumberBar]&&Open[NumberBar]>Close[NumberBar]){up_forward=false; dn_forward=false; direction="dn"; break;}

                  if(ExistDn(j)&&!ExistUp(j)&&Low[j]<High [NumberBar]&&Low[j]<Low [NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_forward=false; dn_forward=true; direction="up"; break;}
                  if(ExistDn(j)&&!ExistUp(j)&&Low[j]<High [NumberBar]&&Low[j]>Low [NumberBar]&&Open[NumberBar]<Close[NumberBar]){up_forward=false; dn_forward=true; direction="up"; break;}

                  if(ExistDn(j)&&!ExistUp(j)&&Low[j]<High [NumberBar]&&Low[j]<Low [NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_forward=false; dn_forward=true; direction="up"; break;}
                  if(ExistDn(j)&&!ExistUp(j)&&Low[j]<High [NumberBar]&&Low[j]>Low [NumberBar]&&Open[NumberBar]==Close[NumberBar]){up_forward=false; dn_forward=true; direction="up"; break;}

               }
            if( up_back&& up_forward&&direction=="dn") type=1;
            if(!up_back&& up_forward&&direction=="dn") type=2;
            if(!up_back&& up_forward&&direction=="dn") type=3;
            if( up_back&& up_forward&&direction=="dn") type=4;
            
            if( up_back&& up_forward&&direction=="up") type=5;
            if( up_back&& up_forward&&direction=="up") type=6;
            if( up_back&& up_forward&&direction=="up") type=7;
            if( up_back&& up_forward&&direction=="up") type=8;
            
            if( dn_back&& dn_forward&&direction=="dn") type=9;
            if( dn_back&& dn_forward&&direction=="dn") type=10;
            if( dn_back&& dn_forward&&direction=="dn") type=11;
            if( dn_back&& dn_forward&&direction=="dn") type=12;
            
            if( dn_back&& dn_forward&&direction=="up") type=13;
            if(!dn_back&& dn_forward&&direction=="up") type=14;
            if( dn_back&& dn_forward&&direction=="up") type=15;
            if(!dn_back&& dn_forward&&direction=="up") type=16;
            
            if( dn_back&& up_forward&&direction=="dn") type=17;
            if( dn_back&& up_forward&&direction=="dn") type=18;
            if( dn_back&& up_forward&&direction=="dn") type=19;
            if( dn_back&& up_forward&&direction=="dn") type=20;
            
            if( dn_back&& up_forward&&direction=="up") type=21;
            if(!dn_back&& up_forward&&direction=="up") type=22;
            if( dn_back&&!up_forward&&direction=="up") type=23;
            if(!dn_back&&!up_forward&&direction=="up") type=24;
            
            if( up_back&& dn_forward&&direction=="dn") type=25;
            if( up_back&&!dn_forward&&direction=="dn") type=26;
            if(!up_back&& dn_forward&&direction=="dn") type=27;
            if(!up_back&&!dn_forward&&direction=="dn") type=28;
            
            if( up_back&& dn_forward&&direction=="up") type=29;
            if( up_back&& dn_forward&&direction=="up") type=30;
            if( up_back&& dn_forward&&direction=="up") type=31;
            if( up_back&& dn_forward&&direction=="up") type=32;
            
      return(type);           
   }
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element Markdown Syntax
Heading # H1
## H2
### H3
Bold **bold text**
Italic *italicized text*
Link [title](https://www.example.com)
Image ![alt text](image.jpg)
Code `code`
Code Block ```
code block
```
Quote > blockquote
Unordered List - Item 1
- Item 2
Ordered List 1. First item
2. Second item
Horizontal Rule ---