Navigation:Home > Content >

PriceAction_Statistic.mq4

Time: 2011-09-15 | Download file:PriceAction_Statistic.mq4

#property copyright "Scriptong"
#property link "http://autograf.dp.ua"

#property indicator_chart_window                   // Отображение в окне графика цен
#property indicator_buffers 1                      // Состоит из шести буферов
#property indicator_color1 Black                   // Цвет 1-го буфера

extern string A0 = "======= Статистика паттернов PriceAction ==============";
extern string A0_1 = "Включить или отключить ведение статистики";
extern bool   useStatistic = true;
extern string A0_2 = "Профит позиций в пунктах";
extern int    statisticTP = 50;
extern string A0_3 = "Отступ стопа от границы паттерна в пунктах";
extern int    statisticSL = 30;
extern string A0_4 = "Угол отображения информационного табло (0-3)";
extern int    corner = 1;
extern string A0_5 = "Цвет шрифта статистики";
extern color  statisticColor = Yellow;
extern string A0_6 = "Величина спреда в пунктах (-1 - использовать фактический)";
extern int    statisticSpread = -1;
extern string A0_7 = "=======================================================";
extern string A0_8 = "======= Режим совета ==================================";
extern string A0_9 = "Включить режим совета";
extern bool   useAdviceMode = true;
extern string A0_10 = "Значения стопа и профита от спреда и до.., пп.";
extern int    maxSLTP = 200;
extern string A0_11 = "Шаг изменения стопа и профита, пп";
extern int    stepSLTP = 2;
extern string A0_13 = "=======================================================";
extern string A1 = "======= Общие настройки для подписи паттернов =========";
extern string A1_1 = "Отображать ли текстовую надпись";
extern bool   showPatternDescription = true;
extern string A2 = "Размер текста надписи";
extern int    textSize = 7;
extern string A3 = "Цвет текста надписи";
extern color  textColor = White;
extern string A4 = "Имя шрифта надписи";
extern string fontName = "Tahoma";
extern string A5 = "=======================================================";
extern string A6 = "======= Паттерн Внутренний бар =========";
extern string A7 = "Включение/выключение поиска паттерна";
extern bool   showIBpattern = true;
extern string A8 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertIBpattern = true;
extern string soundIBpattern = "AG_SoundLevel_1.wav";
extern string A9 = "Цвет паттерна IB";
extern color  colorIBBulls = DarkSlateBlue;
extern color  colorIBBears = DarkOrchid;
extern string A10 = "=======================================================";
extern string A11 = "======= Паттерны DBHLC и DBLHC =========";
extern string A12 = "Включение/выключение поиска паттерна";
extern bool   showDBpattern = true;
extern string A13 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertDBpattern = true;
extern string soundDBpattern = "AG_SoundLevel_2.wav";
extern string A14 = "Пределы в пунктах, считающихся равными";
extern int    equalPipsDB = 3;
extern string A15 = "Цвета бычьего и медвежьего паттернов DB";
extern color  colorDBLHC = Blue;
extern color  colorDBHLC = Red;
extern string A16 = "=======================================================";
extern string A17 = "======= Паттерны TBH И TBL =========";
extern string A18 = "Включение/выключение поиска паттерна";
extern bool   showTBpattern = true;
extern string A19 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertTBpattern = true;
extern string soundTBpattern = "AG_SoundLevel_3.wav";
extern string A20 = "Пределы в пунктах, считающихся равными";
extern int    equalPipsTB = 3;
extern string A21 = "Цвета бычьего и медвежьего паттернов TB";
extern color  colorTBL = Goldenrod;
extern color  colorTBH = Goldenrod;
extern string A22 = "=======================================================";
extern string A23 = "======= Паттерн Рельсы ==============";
extern string A24 = "Включение/выключение поиска паттерна";
extern bool   showRAILSpattern = true;
extern string A25 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertRAILSpattern = true;
extern string soundRAILSpattern = "AG_SoundLevel_4.wav";
extern string A26 = "Максимальное превосходство тел одной из свечей, в %";
extern double bodyGreatPercents = 10;
extern string A27 = "Минимальная доля тела свечи в общей высоте свечи, в %";
extern double bodyToHeightPercents = 20;
extern string A28 = "Цвета бычьего и медвежьего паттернов Рельсы";
extern color  colorBullsRails = DodgerBlue;
extern color  colorBearsRails = FireBrick;
extern string A29 = "=======================================================";
extern string A30 = "======= Паттерны BUOVB и BEOVB ==============";
extern string A31 = "Включение/выключение поиска паттерна";
extern bool   showOVBpattern = true;
extern string A32 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertOVBpattern = true;
extern string soundOVBpattern = "AG_SoundLevel_5.wav";
extern string A33 = "Цвета паттернов BUOVB и BEOVB";
extern color  colorBUOVB = RoyalBlue;
extern color  colorBEOVB = Crimson;
extern string A34 = "=======================================================";
extern string A35 = "======= Паттерн PPR ==============";
extern string A36 = "Включение/выключение поиска паттерна";
extern bool   showPPRpattern = true;
extern string A37 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertPPRpattern = true;
extern string soundPPRpattern = "AG_SoundLevel_6.wav";
extern string A38 = "Цвета бычьего и медвежьего паттернов PPR";
extern color  colorBullsPPR = DeepSkyBlue;
extern color  colorBearsPPR = MediumVioletRed;
extern string A39 = "=======================================================";
extern string A40 = "======= Паттерн HR ==============";
extern string A41 = "Включение/выключение поиска паттерна";
extern bool   showHRpattern = true;
extern string A42 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertHRpattern = true;
extern string soundHRpattern = "AG_SoundLevel_7.wav";
extern string A43 = "Близость цен закрытия и открытия к мин и макс, в пунктах";
extern int    openCloseToHighLowPointsHR = 3;
extern string A44 = "Цвета бычьего и медвежьего паттернов HR";
extern color  colorBullsHR = MediumTurquoise;
extern color  colorBearsHR = Maroon;
extern string A45 = "=======================================================";
extern string A46 = "======= Паттерн CPR ==============";
extern string A47 = "Включение/выключение поиска паттерна";
extern bool   showCPRpattern = true;
extern string A48 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertCPRpattern = true;
extern string soundCPRpattern = "AG_TimeNews.wav";
extern string A49 = "Близость цен закрытия и открытия к мин и макс, в пунктах";
extern int    openCloseToHighLowPoints = 3;
extern string A50 = "Минимальная величина гепа, в пунктах";
extern int    gapPoints = 2;
extern string A51 = "Цвета бычьего и медвежьего паттернов CPR";
extern color  colorBullsCPR = SkyBlue;
extern color  colorBearsCPR = IndianRed;
extern string A52 = "=======================================================";
extern string A53 = "======= Паттерн Pin Bar ==============";
extern string A54 = "Включение/выключение поиска паттерна";
extern bool   showPINBARpattern = true;
extern string A55 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertPINBARpattern = true;
extern string soundPINBARpattern = "AG_Sound.wav";
extern string A56 = "Близость цены закрытия к мин или макс, в пунктах";
extern int    closeToHighLowPoints = 3;
extern string A57 = "Минимальное отношение тени (носа) к телу свечи";
extern double shadowToBodyKoef = 3.0;
extern string A58 = "Минимальная часть носа, выступающая за предыдущий бар, в %";
extern double noseOutsidePercent = 75.0;
extern string A59 = "Цвета бычьего и медвежьего паттернов Pin Bar";
extern color  colorBullsPINBAR = CadetBlue;
extern color  colorBearsPINBAR = Tomato;
extern string A60 = "=======================================================";
extern string A61 = "======= Паттерн MCM ==============";
extern string A62 = "Включение/выключение поиска паттерна";
extern bool   showMCMpattern = true;
extern string A63 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertMCMpattern = true;
extern string soundMCMpattern = "AG_Transform.wav";
extern string A64 = "Близость цен закрытия и открытия первой свечи к мин или макс, в пунктах";
extern int    openCloseToHighLowPointsMCM = 3;
extern string A65 = "Максимальное отношение высоты сигнальной свечи к первой, в %";
extern double signalToFirstPercents = 35.0;
extern string A66 = "Цвета бычьего и медвежьего паттернов MCM";
extern color  colorBullsMCM = PaleTurquoise;
extern color  colorBearsMCM = Plum;
extern string A68 = "=======================================================";
extern string A69 = "======= Паттерн Island Reversal ==============";
extern string A70 = "Включение/выключение поиска паттерна";
extern bool   showIRpattern = true;
extern string A71 = "Включение/выключение звукового сигнала при нахождении паттерна";
extern bool   alertIRpattern = true;
extern string soundIRpattern = "AG_Tuning.wav";
extern string A72 = "Величина первого (слева по графику) гепа в пунктах";
extern int    firstGap = 1;
extern string A73 = "Величина второго (справа по графику) гепа в пунктах";
extern int    secondGap = 1;
extern string A74 = "Цвета бычьего и медвежьего паттернов Island Reversal";
extern color  colorBullsIR = LightSeaGreen;
extern color  colorBearsIR = PaleVioletRed;
extern string A75 = "=======================================================";

extern string Z1 = "Количество баров отображения индикатора. Все - 0";
extern int    indBarsCount = 5000;


string typesOfPatterns[] = {"DB_PATTERN_",         // Названия типов паттернов
                            "TB_PATTERN_",
                            "RAILS_PATTERN",
                            "CPR_PATTERN",
                            "IB_PATTERN",
                            "HR_PATTERN",
                            "OVB_PATTERN",
                            "PPR_PATTERN",
                            "PINBAR_PATTERN",
                            "MCM_PATTERN",
                            "IR_PATTERN"};                      

#define PREFIX          "PRIACT_"                  // Префикс имен графических объектов
#define SUMMARY_SIGN    "SUMMARY_ROW_"             // Признак принадлежности объекта к..
                                                   // ..информационному табло

#define DB_INDEX        0                          // Индекс строкового представления..
                                                   // ..типа паттерна DB в массиве..
                                                   // ..typesOfPatterns
#define TB_INDEX        1                          // Индекс строкового представления..
                                                   // ..типа паттерна TB в массиве..
                                                   // ..typesOfPatterns

#define RAILS_INDEX     2                          // Индекс строкового представления..
                                                   // ..типа паттерна Рельсы в массиве..
                                                   // ..typesOfPatterns

#define CPR_INDEX       3                          // Индекс строкового представления..
                                                   // ..типа паттерна CPR в массиве..
                                                   // ..typesOfPatterns

#define IB_INDEX        4                          // Индекс строкового представления..
                                                   // ..типа паттерна IB в массиве..
                                                   // ..typesOfPatterns

#define HR_INDEX        5                          // Индекс строкового представления..
                                                   // ..типа паттерна HR в массиве..
                                                   // ..typesOfPatterns

#define OVB_INDEX       6                          // Индекс строкового представления..
                                                   // ..типа паттерна OVB в массиве..
                                                   // ..typesOfPatterns

#define PPR_INDEX       7                          // Индекс строкового представления..
                                                   // ..типа паттерна PPR в массиве..
                                                   // ..typesOfPatterns

#define PINBAR_INDEX    8                          // Индекс строкового представления..
                                                   // ..типа паттерна Pin Bar в массиве..
                                                   // ..typesOfPatterns

#define MCM_INDEX       9                          // Индекс строкового представления..
                                                   // ..типа паттерна MCM в массиве..
                                                   // ..typesOfPatterns

#define IR_INDEX        10                         // Индекс строкового представления..
                                                   // ..типа паттерна IR в массиве..
                                                   // ..typesOfPatterns

#define BULL_BAR        1                          // Идентификатор бычьих баров
#define BEAR_BAR        -1                         // Идентификатор медвежьих баров

#define PATTERN_NO      0                          // Идентификатор отсутствия паттерна
#define PATTERN_BULL    1                          // Идентификатор наличия бычьего..
                                                   // ..паттерна
#define PATTERN_BEAR    -1                         // Идентификатор наличия медвежего..
                                                   // ..паттерна

#define FIRST_PART      "_1_"                      // Части имен объектов для..
#define SECOND_PART     "_2_"                      // ..установления различия объектов,..
#define THIRD_PART      "_3_"                      // ..относящихся к одному паттерну

#define DBHLC_DESCRIPTION "Bears DBHLC"            // Текстовое описание паттерна DBHLC
#define DBLHC_DESCRIPTION "Bulls DBLHC"            // Текстовое описание паттерна DBLHC

#define TBH_DESCRIPTION "Bears TBH"                // Текстовое описание паттерна TBH
#define TBL_DESCRIPTION "Bulls TBL"                // Текстовое описание паттерна TBL

#define RAILS_DESCRIPTION_BULLS "Bulls Rails"      // Текстовое описание паттерна Рельсы
#define RAILS_DESCRIPTION_BEARS "Bears Rails"      // Текстовое описание паттерна Рельсы

#define CPR_DESCRIPTION_BULLS "Bulls CPR"          // Текстовое описание паттерна CPR
#define CPR_DESCRIPTION_BEARS "Bears CPR"          // Текстовое описание паттерна CPR

#define IB_DESCRIPTION_BULLS "Bulls IB"            // Текстовое описание паттерна IB
#define IB_DESCRIPTION_BEARS "Bears IB"            // Текстовое описание паттерна IB

#define HR_DESCRIPTION_BULLS "Bulls HR"            // Текстовое описание паттерна HR
#define HR_DESCRIPTION_BEARS "Bears HR"            // Текстовое описание паттерна HR

#define BUOVB_DESCRIPTION "Bulls BUOVB"            // Текстовое описание паттерна BUOVB
#define BEOVB_DESCRIPTION "Bears BEOVB"            // Текстовое описание паттерна BEOVB

#define PPR_DESCRIPTION_BULLS "Bulls PPR"          // Текстовое описание паттерна PPR
#define PPR_DESCRIPTION_BEARS "Bears PPR"          // Текстовое описание паттерна PPR

#define PINBAR_DESCRIPTION_BULLS "Bulls Pin Bar"   // Текстовое описание паттерна Pin Bar
#define PINBAR_DESCRIPTION_BEARS "Bears Pin Bar"   // Текстовое описание паттерна Pin Bar

#define MCM_DESCRIPTION_BULLS "Bulls MCM"          // Текстовое описание паттерна MCM
#define MCM_DESCRIPTION_BEARS "Bears MCM"          // Текстовое описание паттерна MCM

#define IR_DESCRIPTION_BULLS "Bulls IR"            // Текстовое описание паттерна IR
#define IR_DESCRIPTION_BEARS "Bears IR"            // Текстовое описание паттерна IR

#define SUMMARY_TEXT_SIZE 10                       // Размер шрифта информационного табло
#define SUMMARY_TEXT_FONT "Courier New"            // Шрифт текста информационного табло
#define SUMMARY_OFFSET    2                        // Расстояние между строками..
                                                   // ..информационного табло в пикселях
#define TEXT_NO_PATTERN   "Новый паттерн не обнаружен"// Содержание информационного табло
                                                   // ..при отсутствии нового паттерна

//+-------------------------------------------------------------------------------------+
//| Custom indicator initialization function                                            |
//+-------------------------------------------------------------------------------------+
int init()
{
   return(0);
}
//+-------------------------------------------------------------------------------------+
//| Custom indicator deinitialization function                                          |
//+-------------------------------------------------------------------------------------+
int deinit()
{
   DeleteAllObjects();
   return(0);
}
//+-------------------------------------------------------------------------------------+
//| Удаление всех объектов, созданных индикатором                                       |
//+-------------------------------------------------------------------------------------+
void DeleteAllObjects()
{
   for (int i = ObjectsTotal()-1; i >= 0; i--)     
      if (StringSubstr(ObjectName(i), 0, StringLen(PREFIX)) == PREFIX)
         ObjectDelete(ObjectName(i));
}
//+-------------------------------------------------------------------------------------+
//| Определение индекса бара, с которого необходимо производить перерасчет              |
//+-------------------------------------------------------------------------------------+
int GetRecalcIndex(int& total)
{
   int counted_bars = IndicatorCounted();          // Сколько баров уже посчитано
   total = Bars - 1;                               // Определение первого бара истории
   if (indBarsCount > 0 && indBarsCount < total)   // Если не нужно рассчитывать всю..
      total = indBarsCount;                        // ..историю, то начнем с указанного..
                                                   // ..бара - indBarsCount
   if (counted_bars == 0)                          // Кол-во посчитанных баров - 0. 
   {
      DeleteAllObjects();                          // Не забудем удалить все созданные..
                                                   // ..объекты
      return(total);                               // Нужно пересчитать всю историю
   }
   return(Bars - counted_bars - 1);                // Начинаем с первого непосчитанного..
                                                   // ..бара
}
//+-------------------------------------------------------------------------------------+
//| Подача звукового сигнала об образовании паттерна                                    |
//+-------------------------------------------------------------------------------------+
void PatternAlert(bool doAlert, int index, datetime& lastAlert, string soundFileName)
{
   if (!doAlert)                                   // Звуковое оповещение не требуется
      return;
   if (index != 1)                                 // Оповещение только для крайнего..
      return;                                      // ..правого по графику паттерна
   if (lastAlert >= Time[0])                       // На текущем баре оповещение уже..
      return;                                      // ..производилось
      
   PlaySound(soundFileName);                       // Воспроизведение звука
   lastAlert = Time[0];                            // Запомним, что оповещение..
                                                   // ..произведено
}
//+-------------------------------------------------------------------------------------+
//| Отображение графического объекта - прямоугольника                                   |
//+-------------------------------------------------------------------------------------+
void ShowRectangle(string name, datetime time1, double price1, datetime time2, 
                   double price2, string description, color clr)
{
   if (ObjectFind(name) < 0)                       // Если объект не существует
   {
      ObjectCreate(name, OBJ_RECTANGLE,            // Создадим его
                   0, time1, price1, time2, price2); 
      ObjectSet(name, OBJPROP_COLOR, clr);         // Установим цвет,..
      ObjectSet(name, OBJPROP_BACK, true);         // ..положение относительно другой..
                                                   // ..графики..
      ObjectSetText(name, description, 0);         // ..и описание
      return;
   }
   
   ObjectMove(name, 0, time1, price1);             // Перемещение существующего объекта
   ObjectMove(name, 1, time2, price2);             // Перемещение существующего объекта
}
//+-------------------------------------------------------------------------------------+
//| Отображение графического объекта - текстовой надписи                                |
//+-------------------------------------------------------------------------------------+
void ShowText(string name, datetime time1, double price1, string description)
{
   if (ObjectFind(name) < 0)                       // Если объект не существует
   {
      ObjectCreate(name, OBJ_TEXT, 0, time1, price1);// Создадим его и..
      ObjectSetText(name, description, textSize,   // ..выведем надпись
                    fontName, textColor);
      return;                            
   }
   
   ObjectMove(name, 0, time1, price1);             // Перемещение существующего объекта
}
//+-------------------------------------------------------------------------------------+
//| Отображение паттерна, состоящего из прямоугольника и текстовой надписи              |
//+-------------------------------------------------------------------------------------+
void ShowTypicalPattern(int startIndex, int endIndex, color clr, int patternType, 
                        string description)
{
// - 1 - == Поиск верхней и нижней границ паттерна ======================================
   double lowPrice = Low[iLowest(NULL, 0, MODE_LOW,// Нижняя граница паттерна
                         startIndex - endIndex + 1, endIndex)];
   double highPrice = High[iHighest(NULL, 0,       // Верхняя граница паттерна
                           MODE_HIGH, startIndex - endIndex + 1, endIndex)];
// - 1 - == Окончание блока =============================================================

// - 2 - == Отображение прямоугольника ==================================================
   datetime leftTime = Time[startIndex];           // Начальное время паттерна
   datetime rightTime  = Time[endIndex];           // Конечное время паттерна
   string name = GetObjectName(endIndex, patternType, FIRST_PART);// Имя объекта паттерна
   ShowRectangle(name, leftTime, lowPrice,         // Отображение объекта
                 rightTime, highPrice, description, clr);
// - 2 - == Окончание блока =============================================================

// - 3 - == Подпись паттерна ============================================================
   if (!showPatternDescription)                    // Если текстовую надпись отображать..
      return;                                      // ..не следует, то уходим
   name = GetObjectName(endIndex, patternType, SECOND_PART);// Имя объекта паттерна
   ShowText(name, Time[(startIndex + endIndex)/2], // Отображение объекта
            lowPrice, description);
// - 3 - == Окончание блока =============================================================
}           
//+-------------------------------------------------------------------------------------+
//| Удаление объекта                                                                    |
//+-------------------------------------------------------------------------------------+
void DeleteObject(string name)
{
   if (ObjectFind(name) == 0)
      ObjectDelete(name);
}
//+-------------------------------------------------------------------------------------+
//| Генерация имени графического объекта                                                |
//+-------------------------------------------------------------------------------------+
string GetObjectName(int index, int patternType, string middlePart)
{
   return (PREFIX + typesOfPatterns[patternType] + middlePart + Time[index]);
}
//+-------------------------------------------------------------------------------------+
//| Определение типа паттерна, находящего на указанном баре                             |
//+-------------------------------------------------------------------------------------+
int GetPatternType(int index)
{
   int total = ArraySize(typesOfPatterns);         // Количество типов паттернов
   for (int i = 0; i < total; i++)                 // Проверка всех типов паттернов
   {
      string name = GetObjectName(index, i, FIRST_PART);// Достаточно найти первую..
                                                   // ..часть паттерна - прямоугольник
      if (ObjectFind(name) == 0)                   // Надпись (вторая часть), скорее..
         return(i);                                // ..всего, тоже существует
   }
   return(-1);                                     // Ни один из паттернов не найден
}
//+-------------------------------------------------------------------------------------+
//| Удаление любого паттерна, отображаемого индикатором, в указанном диапазоне          |
//+-------------------------------------------------------------------------------------+
void DeleteAnyPattern(int index, int patternStart)
{
   for (int i = index; i < patternStart; i++)
   {
      int type = GetPatternType(i);     
      if (type < 0)                                // Ни один паттерна не найден
         continue;
      DeleteObject(GetObjectName(i, type, FIRST_PART));// Удаление прямоугольника
      DeleteObject(GetObjectName(i, type, SECOND_PART));// Удаление подписи паттерна
      i--;                                         // Повторяем поиск паттернов на этом..
                                                   // ..баре - вдруг их больше одного
   }
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия элементарного паттерна Внутренний бар                           |
//+-------------------------------------------------------------------------------------+
bool IsSimpleIB(int index)
{
   if (Low[index] <= Low[index+1])                 // Минимум бара ниже минимума..
      return(false);                               // ..предыдущего бара - нет паттерна
      
   if (High[index] >= High[index+1])               // Максимум бара выше максимума..
      return(false);                               // ..предыдущего бара - нет паттерна

   double typeLast = Close[index] - Open[index];   // Тип бара index:
                                                   // ..>0 - бычий, <0 - медвежий
   double typePreLast = Close[index+1] - Open[index+1];// Тип предыдущего бара
   
   if ((typeLast >= 0 && typePreLast >= 0) ||      // Если бары одинакового типа, то..
       (typeLast <= 0 && typePreLast <= 0))        // ..паттерн не найден
      return(false);

   return(true);                                   // Паттерн найден
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна Внутренний бар                                         |
//+-------------------------------------------------------------------------------------+
bool IsIBPattern(int index, int total, int& patternStart)
{
   while(IsSimpleIB(patternStart) &&               // Поиск элементарных паттернов подряд
         patternStart < total)
      patternStart++;
      
   if (patternStart == index)                      // Ни один паттерн не найден
      return(false);   
      
   return(true);                                   // Паттерн найден
}
//+-------------------------------------------------------------------------------------+
//| Поиск и отображение паттернов Внутренний бар                                        |
//+-------------------------------------------------------------------------------------+
void FindAndShowIB(int index, int total)
{
   static datetime lastAlert = 0;
   int patternStart = index;

   if (!IsIBPattern(index, total, patternStart))   // Обнаружение и отображение паттерна
      return;

   DeleteAnyPattern(index, patternStart);          // Удаление перекрытых паттернов
   string description = IB_DESCRIPTION_BULLS;
   color clr = colorIBBulls;
   if (Close[index] < Open[index])
   {
      description = IB_DESCRIPTION_BEARS;
      clr = colorIBBears;
   }
   ShowTypicalPattern(patternStart, index,         // Отображение паттерна
                      clr, IB_INDEX, description);
   PatternAlert(alertIBpattern, index,             // Звуковое оповещение о нахождении..
                lastAlert, soundIBpattern);        // ..паттерна
}
//+-------------------------------------------------------------------------------------+
//| Подсчет количества баров с одинаковыми максимумами                                  |
//+-------------------------------------------------------------------------------------+
bool IsTwoEqualMax(int startIndex, int total, int equalPips, int& patternStart)
{
   for (int i = startIndex+1; i < total; i++)      //Поиск на разрешенном участке истории
      if (MathAbs(High[i] - High[i-1]) >           // Разность максимумов больше..
          equalPips*Point)                         // ..разрешенной величины - окончание
         break;                                    // ..цикла
   if (i - startIndex < 2)                         // Нет баров с одинаковыми максимумами
      return(false);      
   
   patternStart = i - 1;                           // Индекс первого бара паттерна
   return(true);                         
}
//+-------------------------------------------------------------------------------------+
//| Подсчет количества баров с одинаковыми минимумами                                   |
//+-------------------------------------------------------------------------------------+
bool IsTwoEqualMin(int startIndex, int total, int equalPips, int& patternStart)
{
   for (int i = startIndex+1; i < total; i++)      //Поиск на разрешенном участке истории
      if (MathAbs(Low[i] - Low[i-1]) >             // Разность минимумов больше..
          equalPips*Point)                         // ..разрешенной величины - окончание
         break;                                    // ..цикла
   if (i - startIndex < 2)                         // Нет баров с одинаковыми максимумами
      return(false);      
   
   patternStart = i - 1;                           // Индекс первого бара паттерна
   return(true);                         
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна DBHLC на указанном баре                                |
//+-------------------------------------------------------------------------------------+
bool IsDBHLCPattern(int index, int total, int& patternStart)
{
   if (Close[index] >= Low[index+1])               // Новый бар закрылся выше минимума..
      return(false);                               // ..предыдущего бара - нет паттерна

   if (!IsTwoEqualMax(index, total, equalPipsDB,   // Равны ли максимумы хотя бы у двух..
                      patternStart))               // ..баров подряд?
      return(false);                               // Если нет двух баров - нет паттерна

   return(true);
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна DBLHC на указанном баре                                |
//+-------------------------------------------------------------------------------------+
bool IsDBLHCPattern(int index, int total, int& patternStart)
{
   if (Close[index] <= High[index+1])              // Новый бар закрылся ниже максимума..
      return(false);                               // ..предыдущего бара - нет паттерна

   if (!IsTwoEqualMin(index, total, equalPipsDB,   // Равны ли минимумы хотя бы у двух..
                      patternStart))               // ..баров подряд?
      return(false);                               // Если нет двух баров - нет паттерна

   return(true);
}
//+-------------------------------------------------------------------------------------+
//| Поиск и отображение паттернов DBHLC и DBLHC                                         |
//+-------------------------------------------------------------------------------------+
void FindAndShowDB(int index, int total)
{
   static datetime lastAlert = 0;
   int patternStart = index;
// - 1 - == Паттерн DBHLC ===============================================================
   if (IsDBHLCPattern(index, total, patternStart)) // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, patternStart);       // Удаление перекрытых паттернов
      ShowTypicalPattern(patternStart, index,      // Отображение паттерна
                         colorDBHLC, 
                         DB_INDEX, DBHLC_DESCRIPTION);
      PatternAlert(alertDBpattern, index,          // Звуковое оповещение о нахождении..
                   lastAlert, soundDBpattern);     // ..паттерна
      return;
   }
// - 1 - == Окончание блока =============================================================

// - 2 - == Паттерн DBLHC ===============================================================
   if (IsDBLHCPattern(index, total, patternStart)) // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, patternStart);       // Удаление перекрытых паттернов
      ShowTypicalPattern(patternStart, index,      // Отображение паттерна
                         colorDBLHC, 
                         DB_INDEX, DBLHC_DESCRIPTION);
      PatternAlert(alertDBpattern, index,          // Звуковое оповещение о нахождении..
                   lastAlert, soundDBpattern);     // ..паттерна
   }
// - 2 - == Окончание блока =============================================================
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна TBH на указанном баре                                  |
//+-------------------------------------------------------------------------------------+
bool IsTBHPattern(int index, int total, int& patternStart)
{
   if (Low[index] < Open[index+1])                 // Новый бар не был поглощен..
       return(false);                              // ..предыдущим баром - нет паттерна
   
   if (Close[index+1] <= Open[index+1])            // Предыдущий бар не был бычьим
      return(false);                               // Нет паттерна

   if (!IsTwoEqualMax(index, total, equalPipsTB,   // Равны ли максимумы хотя бы у двух..
                      patternStart))               // ..баров подряд?
      return(false);                               // Если нет двух баров - нет паттерна
   
   return(true);                                   // Есть паттерн
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна TBL на указанном баре                                  |
//+-------------------------------------------------------------------------------------+
bool IsTBLPattern(int index, int total, int& patternStart)
{
   if (High[index] > Open[index+1])                // Новый бар не был поглощен..
       return(false);                              // ..предыдущим баром - нет паттерна
   
   if (Close[index+1] >= Open[index+1])            // Предыдущий бар не был медвежьим
      return(false);                               // Нет паттерна

   if (!IsTwoEqualMin(index, total, equalPipsTB,   // Равны ли минимумы хотя бы у двух..
                      patternStart))               // ..баров подряд?
      return(false);                               // Если нет двух баров - нет паттерна

   return(true);                                   // Есть паттерн
}
//+-------------------------------------------------------------------------------------+
//| Поиск и отображение паттернов TBH и TBL                                             |
//+-------------------------------------------------------------------------------------+
void FindAndShowTB(int index, int total)
{
   static datetime lastAlert = 0;
   int patternStart = index;
// - 1 - == Паттерн TBH =================================================================
   if (IsTBHPattern(index, total, patternStart))   // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, patternStart);       // Удаление перекрытых паттернов
      ShowTypicalPattern(patternStart, index,      // Отображение паттерна TBH
                         colorTBH,
                         TB_INDEX, TBH_DESCRIPTION);
      PatternAlert(alertTBpattern, index,          // Звуковое оповещение о нахождении..
                   lastAlert, soundTBpattern);     // ..паттерна
      return;
   }
// - 1 - == Окончание блока =============================================================

// - 2 - == Паттерн DBLHC ===============================================================
   if (IsTBLPattern(index, total, patternStart))   // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, patternStart);       // Удаление перекрытых паттернов
      ShowTypicalPattern(patternStart, index,      // Отображение паттерна TBL
                         colorTBL,
                         TB_INDEX, TBL_DESCRIPTION);
      PatternAlert(alertTBpattern, index,          // Звуковое оповещение о нахождении..
                   lastAlert, soundTBpattern);     // ..паттерна
   }
// - 2 - == Окончание блока =============================================================
}
//+-------------------------------------------------------------------------------------+
//| Определение долей тел свечей в их высоте и соотношения длин тел свечей              |
//+-------------------------------------------------------------------------------------+
bool IsRails(int index, double body1, double body2)
{
   if (body1 <= 0)                                 // Последний бар не бычий/медвежий - 
      return(false);                               // ..выход

   if (body2 <= 0)                                 // Предпоследний бар не медвежий/бычий
      return(false);                               // .. - выход

   double height1 = High[index] - Low[index];      // Общая высота последней свечи
   if (body1/height1 < bodyToHeightPercents/100)   // Тело свечи относительно ее высоты..
      return(false);                               // ..слишком мало - выход

   double height2 = High[index+1] - Low[index+1];  // Общая высота предпоследней свечи
   if (body2/height2 < bodyToHeightPercents/100)   // Тело свечи относительно ее высоты..
      return(false);                               // ..слишком мало - выход

   double ratio = 100*                             // Отношение длины тела одной свечи к
                  (1 - MathMin(body1, body2)/MathMax(body1, body2));// ..к другой в %
   if (ratio > bodyGreatPercents)                  // Отношение длин тел свечей больше..
       return(false);                              // ..заданного - выход

   return(true);                                   // Паттерн Рельсы присутствует
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия бычьего паттерна Рельсы на указанном баре                       |
//+-------------------------------------------------------------------------------------+
bool IsBullsRailsPattern(int index, int total)
{
   double body1 = Close[index] - Open[index];      // Тело последней свечи
   double body2 = Open[index+1] - Close[index+1];  // Тело предпоследней свечи
   
   return (IsRails(index, body1, body2));          // Присутствует ли паттерн Рельсы?
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия медвежьего паттерна Рельсы на указанном баре                    |
//+-------------------------------------------------------------------------------------+
bool IsBearsRailsPattern(int index, int total)
{
   double body1 = Open[index] - Close[index];      // Тело последней свечи
   double body2 = Close[index+1] - Open[index+1];  // Тело предпоследней свечи
   
   return (IsRails(index, body1, body2));          // Присутствует ли паттерн Рельсы?
}
//+-------------------------------------------------------------------------------------+
//| Поиск и отображение паттерна Рельсы                                                 |
//+-------------------------------------------------------------------------------------+
void FindAndShowRAILS(int index, int total)
{
   static datetime lastAlert = 0;
// - 1 - == Бычий паттерн Рельсы ========================================================
   if (IsBullsRailsPattern(index, total))          // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, index+1);            // Удаление перекрытых паттернов
      ShowTypicalPattern(index + 1, index,         // Отображение бычьего паттерна..
                         colorBullsRails,          // ..Рельсы
                         RAILS_INDEX, RAILS_DESCRIPTION_BULLS);
      PatternAlert(alertRAILSpattern, index,       // Звуковое оповещение о нахождении..
                   lastAlert, soundRAILSpattern);  // ..паттерна
      return;
   }
// - 1 - == Окончание блока =============================================================

// - 2 - == Медвежий паттерн Рельсы =====================================================
   if (IsBearsRailsPattern(index, total))          // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, index+1);            // Удаление перекрытых паттернов
      ShowTypicalPattern(index + 1, index,         // Отображение медвежьего паттерна..
                         colorBearsRails,          // ..Рельсы
                         RAILS_INDEX, RAILS_DESCRIPTION_BEARS);
      PatternAlert(alertRAILSpattern, index,       // Звуковое оповещение о нахождении..
                   lastAlert, soundRAILSpattern);  // ..паттерна
   }
// - 2 - == Окончание блока =============================================================
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна OVB на указанном баре                                  |
//+-------------------------------------------------------------------------------------+
bool IsOVBPattern(int index, int type)
{
   if (High[index] <= High[index+1])               // Максимум предпоследней свечи не..
      return(false);                               // ..поглощен последней свечей - выход

   if (Low[index] >= Low[index+1])                 // Минимум предпоследней свечи не..
      return(false);                               // ..поглощен последней свечей - выход

   double body1 = Close[index] - Open[index];      // Тело последней свечи
   double body2 = Close[index+1] - Open[index+1];  // Тело предпоследней свечи
   
   if ((body1 >= 0 && body2 >= 0) ||               // Последние две свечи принадлежат..
       (body1 <= 0 && body2 <= 0))                 // ..одиному и тому же типу баров.
      return(false);                               // Паттерн не обнаружен
      
   return ((body1 > 0 && type == BULL_BAR) ||      // Паттерн сформирован, если последний
           (body1 < 0 && type == BEAR_BAR));       // ..бар относится к указанному типу
   
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна BUOVB на указанном баре                                |
//+-------------------------------------------------------------------------------------+
bool IsBUOVBPattern(int index, int total)
{
   if (Close[index] <= High[index+1])              // Максимум предыдущей свечи не пробит
      return(false);                               // Паттерн не сформирован

   return (IsOVBPattern(index, BULL_BAR));         // Наличие паттерна OVB
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия паттерна BEOVB на указанном баре                                |
//+-------------------------------------------------------------------------------------+
bool IsBEOVBPattern(int index, int total)
{
   if (Close[index] >= Low[index+1])               // Минимум предыдущей свечи не пробит
      return(false);                               // Паттерн не сформирован

   return (IsOVBPattern(index, BEAR_BAR));         // Наличие паттерна OVB
}
//+-------------------------------------------------------------------------------------+
//| Поиск и отображение паттернов BUOVB и BEOVB                                         |
//+-------------------------------------------------------------------------------------+
void FindAndShowOVB(int index, int total)
{
   static datetime lastAlert = 0;
// - 1 - == Паттерн BUOVB ===============================================================
   if (IsBUOVBPattern(index, total))               // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, index+1);            // Удаление перекрытых паттернов
      ShowTypicalPattern(index + 1, index,         // Отображение паттерна BUOVB
                         colorBUOVB,               
                         OVB_INDEX, BUOVB_DESCRIPTION);
      PatternAlert(alertOVBpattern, index,         // Звуковое оповещение о нахождении..
                   lastAlert, soundOVBpattern);    // ..паттерна
      return;
   }
// - 1 - == Окончание блока =============================================================

// - 2 - == Паттерн BEOVB ===============================================================
   if (IsBEOVBPattern(index, total))               // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, index+1);            // Удаление перекрытых паттернов
      ShowTypicalPattern(index + 1, index,         // Отображение паттерна BEOVB
                         colorBEOVB,               
                         OVB_INDEX, BEOVB_DESCRIPTION);
      PatternAlert(alertOVBpattern, index,         // Звуковое оповещение о нахождении..
                   lastAlert, soundOVBpattern);    // ..паттерна
   }
// - 2 - == Окончание блока =============================================================
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия бычьего паттерна PPR на указанном баре                          |
//+-------------------------------------------------------------------------------------+
bool IsBullsPPRPattern(int index, int total)
{
   if (Close[index] <= High[index+1])              // Максимум предыдущей свечи не пробит
      return(false);                               // Паттерн не сформирован
      
   if (Low[index+1] >= Low[index+2] ||             // Минимум предыдущего бара не..
       Low[index+1] >= Low[index])                 // ..является минимумом паттерна
      return(false);                               // Паттерн не сформирован
      
   if (Close[index+2] >= Open[index+2])            // Стартовый бар паттерна не является
      return(false);                               // ..медвежьим - выход

   return (true);                                  // Паттерн сформирован
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия медвежьего паттерна PPR на указанном баре                       |
//+-------------------------------------------------------------------------------------+
bool IsBearsPPRPattern(int index, int total)
{
   if (Close[index] >= Low[index+1])               // Минимум предыдущей свечи не пробит
      return(false);                               // Паттерн не сформирован
      
   if (High[index+1] <= High[index+2] ||           // Максимум предыдущего бара не..
       High[index+1] <= High[index])               // ..является максимумом паттерна
      return(false);                               // Паттерн не сформирован

   if (Close[index+2] <= Open[index+2])            // Стартовый бар паттерна не является
      return(false);                               // ..бычьим - выход

   return (true);                                  // Паттерн сформирован
}
//+-------------------------------------------------------------------------------------+
//| Поиск и отображение паттерна PPR                                                    |
//+-------------------------------------------------------------------------------------+
void FindAndShowPPR(int index, int total)
{
   static datetime lastAlert = 0;
// - 1 - == Бычий паттерн PPR ===========================================================
   if (IsBullsPPRPattern(index, total))            // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, index+2);            // Удаление перекрытых паттернов
      ShowTypicalPattern(index + 2, index,         // Отображение бычьего паттерна PPR
                         colorBullsPPR,               
                         PPR_INDEX, PPR_DESCRIPTION_BULLS);
      PatternAlert(alertPPRpattern, index,         // Звуковое оповещение о нахождении..
                   lastAlert, soundPPRpattern);    // ..паттерна
      return;
   }
// - 1 - == Окончание блока =============================================================

// - 2 - == Медвежий паттерн PPR ========================================================
   if (IsBearsPPRPattern(index, total))            // Обнаружение и отображение паттерна
   {
      DeleteAnyPattern(index, index+2);            // Удаление перекрытых паттернов
      ShowTypicalPattern(index + 2, index,         // Отображение медвежьего паттерна PPR
                         colorBearsPPR,               
                         PPR_INDEX, PPR_DESCRIPTION_BEARS);
      PatternAlert(alertPPRpattern, index,         // Звуковое оповещение о нахождении..
                   lastAlert, soundPPRpattern);    // ..паттерна
   }
// - 2 - == Окончание блока =============================================================
}
//+-------------------------------------------------------------------------------------+
//| Приведение разности двух величин к целому значению (в пунктах)                      |
//+-------------------------------------------------------------------------------------+
int PD(double greater, double less)
{
   return(MathRound((greater - less)/Point));
}
//+-------------------------------------------------------------------------------------+
//| Относится ли свеча к определенному типу и малые ли тени у нее?                      |
//+-------------------------------------------------------------------------------------+
bool IsCandleTypeAndSmallShadows(int index, int openCloseToHL, double smaller, 
                                 double greater)
{
   if (greater <= smaller)                         // Свеча не заданного типа - выход
      return(false);
   
   if (PD(High[index], greater) > openCloseToHL)   // Большая цена тела свечи не около..
      return(false);                               // ..максимума - выход

   if (PD(smaller, Low[index]) > openCloseToHL)    // Меньшая цена тела свечи не около..
      return(false);                               // ..минимума - выход
      
   return(true);
}
//+-------------------------------------------------------------------------------------+
//| Поиск начала восходящего тренда                                                     |
//+-------------------------------------------------------------------------------------+
bool IsUpTrend(int index, int total, int& patternStart)
{
   while(High[patternStart+1] < High[patternStart] &&// Поиск начала восходящего тренда
         patternStart < total)
      patternStart++;
      
   if (patternStart < index+2)                     // Восходящий тренд состоит менее, чем
      return(false);                               // ..из двух баров - выход
      
   return(true);                                   // Есть восходящий тренд
}
//+-------------------------------------------------------------------------------------+
//| Поиск начала нисходящего тренда                                                     |
//+-------------------------------------------------------------------------------------+
bool IsDownTrend(int index, int total, int& patternStart)
{
   while(Low[patternStart+1] > Low[patternStart] &&// Поиск начала нисходящего тренда
         patternStart < total)
      patternStart++;
      
   if (patternStart < index+2)                     // Нисходящий тренд состоит менее, чем
      return(false);                               // ..из двух баров - выход
      
   return(true);                                   // Есть нисходящий тренд
}
//+-------------------------------------------------------------------------------------+
//| Определение наличия медвежьего паттерна HR на указанном баре                        |
//+-------------------------------------------------------------------------------------+
bool IsBearsHRPattern(int index, int total, int& patternStart)
{
   if (!IsCandleTypeAndSmallShadows(index,         // Является ли свеча
                                    openCloseToHighLowPointsHR,
                                    Close[index],  // ..медвежьей с малыми тенями?
                                    Open[index]))
      return(false);                               

   if (!IsSimpleIB(index))                         // Два последних бара должны являть..
      return(false);                               // ..собой простейший паттерн..
                                                   // ..Внутренний бар

   if (!I        

Recommend