//+------------------------------------------------------------------+
//|                                             Indicators_class.mqh |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

#include <..\General_class_.mqh>

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
class CIndicators_class
  {

   //+------------------------------------------------------------------------------------------------+
   //|   Объявляем функции, их возращаемый тип, параметры и типы параметров принимаемых функциями                                                                   |
   //+------------------------------------------------------------------------------------------------+

public:

                     CIndicators_class();
                    ~CIndicators_class();

   void              RSI_buffers(double &RSIBuffer[]);
   void              RSI_handle(string Simbol,ENUM_TIMEFRAMES Period_, int RSi_ma_period, ENUM_APPLIED_PRICE   RSI_applied_price, bool ChartIndAdd);

   void              Stohastic_buffers(double &Stohastic_main[],double &Stohastic_signal[]);
   void              Stochastic_handle(string Simbol,ENUM_TIMEFRAMES Period_, int InpPeriodK1, int InpPeriodD1, int InpSlowing1,
                                       ENUM_MA_METHOD Stohastic_MA_Mode, ENUM_STO_PRICE Stohastic_STO_PRICE);

   void              MA_(string symbol, ENUM_TIMEFRAMES timeframe, int ma_period,
                         int ma_shift, ENUM_MA_METHOD ma_method, ENUM_APPLIED_PRICE appliedPrice,
                         int ma_Handle,double& ma_values[], bool ChartIndAdd);

   void              Bollinger_bands(string Simbol,ENUM_TIMEFRAMES Period_, int BBPeriod, int _ma_shift, double BBDev,
                                     ENUM_APPLIED_PRICE Applied_price,int BBHandle,double &up[],
                                     double &dn[],double &bs[], bool ChartIndAdd);

   void              Alligator_buffers(double &Alligator_jaw[], double &Alligator_teeth[],double &Alligator_lips[]);
   void              Aligator_handle(string Simbol,ENUM_TIMEFRAMES Period_, int Alligator_jaw_period,int Alligator_jaw_shift,int Alligator_teeth_period,
                                     int Alligator_teeth_shift,int Alligator_lips_period,int Alligator_lips_shift,ENUM_MA_METHOD Aligator_MA_Mode,ENUM_APPLIED_PRICE Aligator_Applied_price);
   void              AO_buffers(double &iAOBuffer[]);
   void              AO_handle(string Simbol,ENUM_TIMEFRAMES Period_);
   
   void              AC_(string Simbol,ENUM_TIMEFRAMES Period_,int handle_AC, double &iACBuffer[], bool ChartIndAdd);

   void              MACD(string Simbol,ENUM_TIMEFRAMES Period_, int Fast_ema_period, int Slow_ema_period, int Signal_period,
                          ENUM_APPLIED_PRICE Applied_price_MACD, int handle_MACD,double &MACD[],double &SignalMACD[], bool ChartIndAdd);


   void              Envelopes_buffers(double &Envelopes_Up[],double &Envelopes_Dn[]);
   void              Envelopes_handle(string Simbol,ENUM_TIMEFRAMES Period_,int Envelopes_ma_period,int Envelopes_ma_shift,ENUM_MA_METHOD Envelopes_ma_method,
                                      ENUM_APPLIED_PRICE Envelopes_applied_price,double Envelopes_deviation, bool ChartIndAdd);

   void              ATR_buffers(double &iATRBuffer[]);
   void              ATR_handle(string Simbol,ENUM_TIMEFRAMES Period_,int ma_period_first, bool ChartIndAdd);

   void              Standard_Deviation_buffers(double &iStdDevBuffer[]);
   void              Standard_Deviation_handle(string Simbol,ENUM_TIMEFRAMES Period_,int StdDev_ma_period,int StdDev_ma_shift,
         ENUM_MA_METHOD StdDev_ma_method,ENUM_APPLIED_PRICE StdDev_applied_price,bool ChartIndAdd);

  };
//+------------------------------------------------------------------+
//| Объявляем конструктор класса                                     |
//+------------------------------------------------------------------+
CIndicators_class::CIndicators_class()
  {

  }
//+------------------------------------------------------------------+
//| Объявляем деструктор класса                                      |
//+------------------------------------------------------------------+
CIndicators_class::~CIndicators_class()
  {

  }
//+------------------------------------------------------------------+
//| RSI                                                      |
//+------------------------------------------------------------------+
//--- input parameters
//input int                  RSi_ma_period=14;                 // период усреднения
//input ENUM_APPLIED_PRICE   RSI_applied_price=PRICE_CLOSE;    // тип цены
////--- индикаторный буфер
//double         RSIBuffer[];
//--- переменная для хранения хэндла индикатора iRSI
int    handle_RSI;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class:: RSI_handle(string Simbol,ENUM_TIMEFRAMES Period_, int RSi_ma_period, ENUM_APPLIED_PRICE
                                    RSI_applied_price, bool ChartIndAdd)
  {
   handle_RSI = iRSI(Simbol,Period_, RSi_ma_period,RSI_applied_price);

   if(handle_RSI < 0)
     {
      Print("Ошибка при создании RSI - № ошибки: ", _LastError, "!!");
      return;
     }
   if(ChartIndAdd == true)
      ChartIndicatorAdd(ChartID(), 1, handle_RSI);
  }
//+------------------------------------------------------------------+
void CIndicators_class:: RSI_buffers(double &RSIBuffer[])
  {
   ArraySetAsSeries(RSIBuffer, true);
   ArrayResize(RSIBuffer,5);

   int RSI_main = CopyBuffer(handle_RSI, 0, 0, 5, RSIBuffer);

   if(RSI_main < 0)
     {
      Print("Данные RSI_buffers не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора RSI_buffers ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }
//+------------------------------------------------------------------+
//| Stohastic                                                      |
//+------------------------------------------------------------------+
//--- input parameters
//input int                 InpPeriodK1    =  5;                   // First Stochastic %K period
//input int                 InpPeriodD1    =  3;                   // First Stochastic %D period
//input int                 InpSlowing1    =  3;                   // First Stochastic slowing
//input ENUM_MA_METHOD Stohastic_MA_Mode = MODE_CLOSE;
//input ENUM_STO_PRICE Stohastic_STO_PRICE = STO_LOWHIGH;
//double Stohastic_main[];
//double Stohastic_signal[];
//input int     low_lim=20;
//input int     up_lim=80;
int handle_Stohastic = 0;
//0 - MAIN_LINE, 1 - SIGNAL_LINE.
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class:: Stochastic_handle(string Simbol,ENUM_TIMEFRAMES Period_, int InpPeriodK1, int InpPeriodD1, int InpSlowing1,
      ENUM_MA_METHOD Stohastic_MA_Mode, ENUM_STO_PRICE Stohastic_STO_PRICE)
  {
   handle_Stohastic = iStochastic(Simbol,Period_, InpPeriodK1, InpPeriodD1, InpSlowing1, Stohastic_MA_Mode, Stohastic_STO_PRICE);
   if(handle_Stohastic < 0)
     {
      Print("Ошибка при создании Stochastic - № ошибки: ", _LastError, "!!");
      return;
     }
   ChartIndicatorAdd(ChartID(), 1, handle_Stohastic);
  }
//+------------------------------------------------------------------+
void CIndicators_class:: Stohastic_buffers(double &Stohastic_main[],double &Stohastic_signal[])
  {
   ArraySetAsSeries(Stohastic_main, true);
   ArraySetAsSeries(Stohastic_signal, true);
   ArrayResize(Stohastic_main, 5);
   ArrayResize(Stohastic_signal,5);

   int St_main = CopyBuffer(handle_Stohastic, 0, 0, 5, Stohastic_main);
   int St_signal = CopyBuffer(handle_Stohastic, 1, 0, 5, Stohastic_signal);

   if(St_main < 0 || St_signal < 0)
     {
      Print("Данные Stohastic_buffers не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора Stohastic_buffers ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }

//+------------------------------------------------------------------+
//| Moving average                                                     |
//+------------------------------------------------------------------+
//input int ma_period = 19;
//input int ma_shift    = 0;
//int handle_MA;
//double MA[];
//input ENUM_APPLIED_PRICE Applied_price_MA = PRICE_OPEN;
//input ENUM_MA_METHOD MA_Mode = MODE_SMA;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::MA_(string symbol, ENUM_TIMEFRAMES timeframe, int ma_period,
                            int ma_shift, ENUM_MA_METHOD ma_method, ENUM_APPLIED_PRICE appliedPrice,
                            int ma_Handle,double &ma_values[], bool ChartIndAdd)
  {
   bool firstrunMA = true;
   if(firstrunMA)
     {
      ma_Handle = iMA(symbol,timeframe,ma_period,ma_shift,ma_method,appliedPrice);
      if(ma_Handle < 0)
        {
         Print("Создан неккоретный хэндл: ", _LastError);
         return;
        }
      if(ChartIndAdd == true)
         ChartIndicatorAdd(ChartID(),0, ma_Handle);
      firstrunMA = false;
     }

   ArraySetAsSeries(ma_values, true);
   ArrayResize(ma_values, 5);
   int copied_values = CopyBuffer(ma_Handle, 0, 0, 5, ma_values);
   if(copied_values < 0)
     {
      Print("Ошибка при копировании данных MA: ", _LastError);
      return;
     }

  }

//+------------------------------------------------------------------+
//|   Bollinger_bands                                                |
//+------------------------------------------------------------------+
//input int    BBPeriod   = 30;             // Bands Period1
//input double BBDev      = 1;              // Bands Deviation1
//input double Razmah     = 20;             // Bands Deviation1 in Points
//input ENUM_APPLIED_PRICE Bollinger_Applied_price = PRICE_CLOSE;
//int _bars = 0;
//double up[], dn[], bs[];
//int BBHandle = 0;
bool firstrunBollinger_bands= true;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::Bollinger_bands(string Simbol,ENUM_TIMEFRAMES Period_, int BBPeriod, int _ma_shift, double BBDev,
                                        ENUM_APPLIED_PRICE Applied_price,int BBHandle,
                                        double &up[],double &dn[],double &bs[], bool ChartIndAdd)
  {
   if(firstrunBollinger_bands)
     {
      BBHandle = iBands(Simbol, Period_, BBPeriod, _ma_shift,  BBDev, Applied_price);
      if(BBHandle < 0)
        {
         Print("Ошибка при создании BBHandle - № ошибки: ", _LastError, "!!");
         return;
        }
      if(ChartIndAdd == true)
         ChartIndicatorAdd(ChartID(), 0, BBHandle);
      firstrunBollinger_bands = false;
     }
   ArraySetAsSeries(up, true);
   ArraySetAsSeries(dn, true);
   ArraySetAsSeries(bs, true);
   ArrayResize(up, 5);
   ArrayResize(dn, 5);
   ArrayResize(bs, 5);

   int bbands_bs = CopyBuffer(BBHandle, 0, 0, 5, bs);
   int bbands_up = CopyBuffer(BBHandle, 1, 0, 5, up);
   int bbands_dn = CopyBuffer(BBHandle, 2, 0, 5, dn);

   if(bbands_bs < 0 || bbands_up < 0 || bbands_dn < 0)
     {
      Print("Данные Bollinger bands  не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора Bollinger bands  ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }


  }
//+------------------------------------------------------------------+
//|  Aligator                                            |
//+------------------------------------------------------------------+
//int      Alligator_jaw_period   = 13;    // Alligator: period for the calculation of jaws
//int      Alligator_jaw_shift    = 8;     // Alligator: horizontal shift of jaws
//int      Alligator_teeth_period = 8;     // Alligator: period for the calculation of teeth
//int      Alligator_teeth_shift  = 5;     // Alligator: horizontal shift of teeth
//int      Alligator_lips_period  = 5;     // Alligator: period for the calculation of lips
//int      Alligator_lips_shift   = 3;     // Alligator: horizontal shift of lips
// ENUM_MA_METHOD Aligator_MA_Mode = MODE_SMA;
// ENUM_APPLIED_PRICE Aligator_Applied_price = PRICE_CLOSE;
//double Alligator_jaw[];
//double Alligator_teeth[];
//double Alligator_lips[];

int handle_iAlligator = 0;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::Aligator_handle(string Simbol,ENUM_TIMEFRAMES Period_, int Alligator_jaw_period,int Alligator_jaw_shift,int Alligator_teeth_period,
                                        int Alligator_teeth_shift,int Alligator_lips_period,int Alligator_lips_shift,ENUM_MA_METHOD Aligator_MA_Mode,ENUM_APPLIED_PRICE Aligator_Applied_price)
  {
   handle_iAlligator = iAlligator(Simbol, Period_, Alligator_jaw_period, Alligator_jaw_shift, Alligator_teeth_period,
                                  Alligator_teeth_shift, Alligator_lips_period, Alligator_lips_shift, Aligator_MA_Mode, Aligator_Applied_price);
   if(handle_iAlligator == INVALID_HANDLE)
     {
      Print("Ошибка при создании Alligator - номер ошибки: ", _LastError, "!!");
      return;
     }
   ChartIndicatorAdd(ChartID(), 0, handle_iAlligator);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class:: Alligator_buffers(double &Alligator_jaw[], double &Alligator_teeth[],double &Alligator_lips[])
  {
   ArraySetAsSeries(Alligator_jaw, true);
   ArraySetAsSeries(Alligator_teeth, true);
   ArraySetAsSeries(Alligator_lips, true);
   ArrayResize(Alligator_jaw, 5);
   ArrayResize(Alligator_teeth, 5);
   ArrayResize(Alligator_lips, 5);

   int Alligator_jaw_data = CopyBuffer(handle_iAlligator, 0, 0, 5, Alligator_jaw);
   int Alligator_teeth_data = CopyBuffer(handle_iAlligator, 1, 0, 5, Alligator_teeth);
   int Alligator_lips_data = CopyBuffer(handle_iAlligator, 2, 0, 5, Alligator_lips);

   if(Alligator_jaw_data < 0 || Alligator_teeth_data < 0 || Alligator_lips_data < 0)
     {
      Print("Данные Alligator не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора Alligator ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }
//+------------------------------------------------------------------+
//|  Индикатор AС                                            |
//+------------------------------------------------------------------+
bool firstrunAC = true;
//double iACBuffer[];
//int handle_AC = 0;
void CIndicators_class::AC_(string Simbol,ENUM_TIMEFRAMES Period_,int handle_AC, double &iACBuffer[], bool ChartIndAdd)
  {
   if(firstrunAC)
     {
      handle_AC = iAC(Simbol, Period_);
      if(handle_AC == INVALID_HANDLE)
        {
         Print("Ошибка при создании AC - номер ошибки: ", _LastError, "!!");
         return;
        }
      if(ChartIndAdd == true)
         ChartIndicatorAdd(ChartID(), 1, handle_AC);
      firstrunAC = false;
     }
   ArraySetAsSeries(iACBuffer, true);
   ArrayResize(iACBuffer, 10);

   int AC_data = CopyBuffer(handle_AC, 0, 0, 10, iACBuffer);
   if(AC_data < 0)
     {
      Print("Данные AC не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора AC ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }


//+------------------------------------------------------------------+
//|  Индикатор AO                                            |
//+------------------------------------------------------------------+
//double iAOBuffer[];
int handle_AO = 0;
void CIndicators_class::AO_handle(string Simbol,ENUM_TIMEFRAMES Period_)
  {
   handle_AO = iAO(Simbol, Period_);
   if(handle_AO == INVALID_HANDLE)
     {
      Print("Ошибка при создании AO - номер ошибки: ", _LastError, "!!");
      return;
     }
   ChartIndicatorAdd(ChartID(), 1, handle_AO);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class:: AO_buffers(double &iAOBuffer[])
  {
   ArraySetAsSeries(iAOBuffer, true);
   ArrayResize(iAOBuffer, 10);

   int AO_data = CopyBuffer(handle_AO, 0, 0, 10, iAOBuffer);
   if(AO_data < 0)
     {
      Print("Данные AO не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора AO ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }
//+------------------------------------------------------------------+
//|  Индикатор MACD                                           |
//+------------------------------------------------------------------+
//double MACD[], SignalMACD[];
//int        Fast_ema_period = 12,  // период быстрой средней
//           Slow_ema_period = 26,  // период медленной средней
//           Signal_period = 9   ;// период усреднения разности
//ENUM_APPLIED_PRICE Applied_price_MACD = PRICE_CLOSE;
//int handle_MACD;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
//bool firstrunMACD = true;
void CIndicators_class::MACD(string Simbol,ENUM_TIMEFRAMES Period_, int Fast_ema_period, int Slow_ema_period,
                             int Signal_period, ENUM_APPLIED_PRICE Applied_price_MACD, int handle_MACD,double &MACD[],double &SignalMACD[], bool ChartIndAdd)
  {
//if(firstrunMACD)
//  {
   handle_MACD = iMACD(Simbol, Period_, Fast_ema_period, Slow_ema_period, Signal_period, Applied_price_MACD);
   if(handle_MACD == INVALID_HANDLE)
     {
      Print("Ошибка при создании MA - № ошибки: ", _LastError, "!!");
      return;
     }
   if(ChartIndAdd == true)
      ChartIndicatorAdd(ChartID(), 1, handle_MACD);
//firstrunMACD = false;
//}
   ArraySetAsSeries(MACD, true);
   ArraySetAsSeries(SignalMACD, true);
   ArrayResize(MACD, 5);
   ArrayResize(SignalMACD, 5);

   int macd_data = CopyBuffer(handle_MACD, 0, 0, 5, MACD);
   int signal_macd_data = CopyBuffer(handle_MACD, 1, 0, 5, SignalMACD);
   if(signal_macd_data < 0 || macd_data < 0)
     {
      Print("Данные MACD не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора MACD ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }

//+------------------------------------------------------------------+
//|  Индикатор Envelopes                                           |
//+------------------------------------------------------------------+
//input int                  Envelopes_ma_period=14;              // период скользящей
//input int                  Envelopes_ma_shift=0;                // смещение
//input ENUM_MA_METHOD       Envelopes_ma_method=MODE_SMA;        // тип сглаживания
//input ENUM_APPLIED_PRICE   Envelopes_applied_price=PRICE_CLOSE; // тип цены
//input double               Envelopes_deviation=0.1;             // отклонение границ от скользящей
////--- индикаторный буфер
//double         Envelopes_Up[];
//double         Envelopes_Dn[];
//--- переменная для хранения хэндла индикатора iEnvelopes
int handle_Envelopes;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::Envelopes_handle(string Simbol,ENUM_TIMEFRAMES Period_,int Envelopes_ma_period,int Envelopes_ma_shift,ENUM_MA_METHOD Envelopes_ma_method,
      ENUM_APPLIED_PRICE Envelopes_applied_price,double Envelopes_deviation, bool ChartIndAdd)
  {
   handle_Envelopes = iEnvelopes(Simbol, Period_, Envelopes_ma_period, Envelopes_ma_shift,  Envelopes_ma_method,
                                 Envelopes_applied_price, Envelopes_deviation);
   if(handle_Envelopes == INVALID_HANDLE)
     {
      Print("Ошибка при создании Envelopes - № ошибки: ", _LastError, "!!");
      return;
     }
   if(ChartIndAdd == true)
      ChartIndicatorAdd(ChartID(), 1, handle_Envelopes);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::Envelopes_buffers(double &Envelopes_Up[],double &Envelopes_Dn[])
  {
   ArraySetAsSeries(Envelopes_Up, true);
   ArraySetAsSeries(Envelopes_Dn, true);
   ArrayResize(Envelopes_Up, 5);
   ArrayResize(Envelopes_Dn, 5);

   int Envelopes_data_UP = CopyBuffer(handle_Envelopes, 0, 0, 5, Envelopes_Up);
   int Envelopes_data_DN = CopyBuffer(handle_Envelopes, 1, 0, 5, Envelopes_Dn);
   if(Envelopes_data_UP < 0 || Envelopes_data_DN < 0)
     {
      Print("Данные Envelopes не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора Envelopes ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }
//+------------------------------------------------------------------+
//|  Average True Range(ATR)                                         |
//+------------------------------------------------------------------+
//int               ma_period_first   = 12;          // averaging period first ATR
//input double               coefficient_ATR1  = 1.5;  // coefficient_ATR1
//double iATRBuffer[];
int    handle_iATR;              // variable for storing the handle of the iATR indicator
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::ATR_handle(string Simbol,ENUM_TIMEFRAMES Period_,int ma_period_first, bool ChartIndAdd)
  {
   handle_iATR = iATR(Simbol, Period_, ma_period_first);
   if(handle_iATR == INVALID_HANDLE)
     {
      Print("Ошибка при создании handle_ATR - № ошибки: ", _LastError, "!!");
      return;
     }
   if(ChartIndAdd == true)
      ChartIndicatorAdd(ChartID(), 1, handle_iATR);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::ATR_buffers(double &iATRBuffer[])
  {
   ArraySetAsSeries(iATRBuffer, true);
   ArrayResize(iATRBuffer, 5);

   int iATRBuffer_data = CopyBuffer(handle_iATR, 0, 0, 5, iATRBuffer);
   if(iATRBuffer_data < 0)
     {
      Print("Данные ATR не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора ATR ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }

//+------------------------------------------------------------------+
//|  Индикатор Standard_Deviation                                    |
//+------------------------------------------------------------------+
//--- входные параметры
input int                  StdDev_ma_period=20;              // период усреднения
input int                  StdDev_ma_shift=0;                // смещение
input ENUM_MA_METHOD       StdDev_ma_method=MODE_SMA;        // тип сглаживания
input ENUM_APPLIED_PRICE   StdDev_applied_price=PRICE_CLOSE; // тип цены
//--- индикаторный буфер
double         iStdDevBuffer[];
//--- переменная для хранения хэндла индикатора iStdDev
int    StdDev_handle;

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class::Standard_Deviation_handle(string Simbol,ENUM_TIMEFRAMES Period_,int StdDev_ma_period,int StdDev_ma_shift,
      ENUM_MA_METHOD StdDev_ma_method,ENUM_APPLIED_PRICE StdDev_applied_price,bool ChartIndAdd)
  {
   StdDev_handle = iStdDev(Simbol, Period_,StdDev_ma_period,StdDev_ma_shift,StdDev_ma_method,StdDev_applied_price);
   if(StdDev_handle == INVALID_HANDLE)
     {
      Print("Ошибка при создании Standard Deviation - номер ошибки: ", _LastError, "!!");
      return;
     }
   if(ChartIndAdd == true)
      ChartIndicatorAdd(ChartID(), 1, StdDev_handle);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CIndicators_class:: Standard_Deviation_buffers(double &iStdDevBuffer[])
  {
   ArraySetAsSeries(iStdDevBuffer, true);
   ArrayResize(iStdDevBuffer, 10);

   int StdDev_data = CopyBuffer(StdDev_handle, 0, 0, 10, iStdDevBuffer);
   if(StdDev_data < 0)
     {
      Print("Данные Standard Deviation не загрузились", _LastError);
      SendMail(_Symbol + "Ошибка загрузки данных индикатора Standard Deviation ", _Symbol + " Ошибка загрузки данных индикаторов");
      return;
     }
  }
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+

//+------------------------------------------------------------------+