1717 lines
70 KiB
MQL5
1717 lines
70 KiB
MQL5
 | //+------------------------------------------------------------------+
| ||
//| Trend.mqh |
| |||
//| Copyright 2000-2025, MetaQuotes Ltd. |
| |||
//| https://www.mql5.com |
| |||
//+------------------------------------------------------------------+
| |||
#include "Indicator.mqh"
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiADX. |
| |||
//| Purpose: Class of the "Average Directional Index" indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiADX : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
| |||
public:
| |||
CiADX(void);
| |||
~CiADX(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
double Plus(const int index) const;
| |||
double Minus(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_ADX); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiADX::CiADX(void) : m_ma_period(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiADX::~CiADX(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create the "Average Directional Index" indicator |
| |||
//+------------------------------------------------------------------+
| |||
bool CiADX::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iADX(symbol,period,ma_period);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiADX::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiADX::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
| |||
{
| |||
if(CreateBuffers(symbol,period,3))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="ADX";
| |||
m_status="("+symbol+","+PeriodDescription()+","+IntegerToString(ma_period)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(1)).Name("PLUS_LINE");
| |||
((CIndicatorBuffer*)At(2)).Name("MINUS_LINE");
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Main buffer of "Average Directional Index" |
| |||
//+------------------------------------------------------------------+
| |||
double CiADX::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Plus buffer of "Average Directional Index" |
| |||
//+------------------------------------------------------------------+
| |||
double CiADX::Plus(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(1);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Minus buffer of "Average Directional Index" |
| |||
//+------------------------------------------------------------------+
| |||
double CiADX::Minus(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(2);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiADXWilder. |
| |||
//| Purpose: Class of the "Average Directional Index |
| |||
//| by Welles Wilder" indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiADXWilder : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
| |||
public:
| |||
CiADXWilder(void);
| |||
~CiADXWilder(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
double Plus(const int index) const;
| |||
double Minus(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_ADXW); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiADXWilder::CiADXWilder(void) : m_ma_period(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiADXWilder::~CiADXWilder(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Average Directional Index by Welles Wilder" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiADXWilder::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iADXWilder(symbol,period,ma_period);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiADXWilder::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiADXWilder::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
| |||
{
| |||
if(CreateBuffers(symbol,period,3))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="ADXWilder";
| |||
m_status="("+symbol+","+PeriodDescription()+","+IntegerToString(ma_period)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(1)).Name("PLUS_LINE");
| |||
((CIndicatorBuffer*)At(2)).Name("MINUS_LINE");
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Main buffer of "Average Directional Index |
| |||
//| by Welles Wilder" |
| |||
//+------------------------------------------------------------------+
| |||
double CiADXWilder::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Plus buffer of "Average Directional Index |
| |||
//| by Welles Wilder" |
| |||
//+------------------------------------------------------------------+
| |||
double CiADXWilder::Plus(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(1);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Minus buffer of "Average Directional Index |
| |||
//| by Welles Wilder" |
| |||
//+------------------------------------------------------------------+
| |||
double CiADXWilder::Minus(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(2);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiBands. |
| |||
//| Purpose: Class of the "Bollinger Bands" indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiBands : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ma_shift;
| |||
double m_deviation;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiBands(void);
| |||
~CiBands(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int MaShift(void) const { return(m_ma_shift); }
| |||
double Deviation(void) const { return(m_deviation); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const double deviation,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Base(const int index) const;
| |||
double Upper(const int index) const;
| |||
double Lower(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_BANDS); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const double deviation,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiBands::CiBands(void) : m_ma_period(-1),
| |||
m_ma_shift(-1),
| |||
m_deviation(EMPTY_VALUE),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiBands::~CiBands(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Bollinger Bands" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiBands::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const double deviation,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iBands(symbol,period,ma_period,ma_shift,deviation,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ma_shift,deviation,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiBands::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,
| |||
params[2].double_value,(int)params[3].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiBands::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const double deviation,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,3))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="Bands";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+
| |||
DoubleToString(deviation)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_ma_shift =ma_shift;
| |||
m_deviation=deviation;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("BASE_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ma_shift);
| |||
((CIndicatorBuffer*)At(1)).Name("UPPER_BAND");
| |||
((CIndicatorBuffer*)At(1)).Offset(ma_shift);
| |||
((CIndicatorBuffer*)At(2)).Name("LOWER_BAND");
| |||
((CIndicatorBuffer*)At(2)).Offset(ma_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Base buffer of "Bollinger Bands" |
| |||
//+------------------------------------------------------------------+
| |||
double CiBands::Base(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Upper buffer of "Bollinger Bands" |
| |||
//+------------------------------------------------------------------+
| |||
double CiBands::Upper(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(1);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Lower buffer of "Bollinger Bands" |
| |||
//+------------------------------------------------------------------+
| |||
double CiBands::Lower(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(2);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiEnvelopes. |
| |||
//| Purpose: Class of the "Envelopes" indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiEnvelopes : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ma_shift;
| |||
ENUM_MA_METHOD m_ma_method;
| |||
int m_applied;
| |||
double m_deviation;
| |||
| |||
public:
| |||
CiEnvelopes(void);
| |||
~CiEnvelopes(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int MaShift(void) const { return(m_ma_shift); }
| |||
ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); }
| |||
int Applied(void) const { return(m_applied); }
| |||
double Deviation(void) const { return(m_deviation); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method,
| |||
const int applied,const double deviation);
| |||
//--- methods of access to indicator data
| |||
double Upper(const int index) const;
| |||
double Lower(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_ENVELOPES); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method,
| |||
const int applied,const double deviation);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiEnvelopes::CiEnvelopes(void) : m_ma_period(-1),
| |||
m_ma_shift(-1),
| |||
m_ma_method(WRONG_VALUE),
| |||
m_applied(-1),
| |||
m_deviation(EMPTY_VALUE)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiEnvelopes::~CiEnvelopes(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Envelopes" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiEnvelopes::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method,
| |||
const int applied,const double deviation)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iEnvelopes(symbol,period,ma_period,ma_shift,ma_method,applied,deviation);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ma_shift,ma_method,applied,deviation))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiEnvelopes::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,
| |||
(ENUM_MA_METHOD)params[2].integer_value,(int)params[3].integer_value,
| |||
(int)params[4].double_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiEnvelopes::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,const ENUM_MA_METHOD ma_method,
| |||
const int applied,const double deviation)
| |||
{
| |||
if(CreateBuffers(symbol,period,2))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name="Envelopes";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+
| |||
MethodDescription(ma_method)+","+PriceDescription(applied)+","+
| |||
DoubleToString(deviation)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_ma_shift =ma_shift;
| |||
m_ma_method=ma_method;
| |||
m_applied =applied;
| |||
m_deviation=deviation;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("UPPER_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ma_shift);
| |||
((CIndicatorBuffer*)At(1)).Name("LOWER_LINE");
| |||
((CIndicatorBuffer*)At(1)).Offset(ma_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Upper buffer of "Envelopes" |
| |||
//+------------------------------------------------------------------+
| |||
double CiEnvelopes::Upper(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to Lower buffer of "Envelopes" |
| |||
//+------------------------------------------------------------------+
| |||
double CiEnvelopes::Lower(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(1);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiIchimoku. |
| |||
//| Purpose: Class of the "Ichimoku Kinko Hyo" indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiIchimoku : public CIndicator
| |||
{
| |||
protected:
| |||
int m_tenkan_sen;
| |||
int m_kijun_sen;
| |||
int m_senkou_span_b;
| |||
| |||
public:
| |||
CiIchimoku(void);
| |||
~CiIchimoku(void);
| |||
//--- methods of access to protected data
| |||
int TenkanSenPeriod(void) const { return(m_tenkan_sen); }
| |||
int KijunSenPeriod(void) const { return(m_kijun_sen); }
| |||
int SenkouSpanBPeriod(void) const { return(m_senkou_span_b); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int tenkan_sen,const int kijun_sen,const int senkou_span_b);
| |||
//--- methods of access to indicator data
| |||
double TenkanSen(const int index) const;
| |||
double KijunSen(const int index) const;
| |||
double SenkouSpanA(const int index) const;
| |||
double SenkouSpanB(const int index) const;
| |||
double ChinkouSpan(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_ICHIMOKU); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int tenkan_sen,const int kijun_sen,const int senkou_span_b);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiIchimoku::CiIchimoku(void) : m_tenkan_sen(-1),
| |||
m_kijun_sen(-1),
| |||
m_senkou_span_b(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiIchimoku::~CiIchimoku(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Ichimoku Kinko Hyo" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiIchimoku::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int tenkan_sen,const int kijun_sen,const int senkou_span_b)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iIchimoku(symbol,period,tenkan_sen,kijun_sen,senkou_span_b);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,tenkan_sen,kijun_sen,senkou_span_b))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiIchimoku::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiIchimoku::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int tenkan_sen,const int kijun_sen,const int senkou_span_b)
| |||
{
| |||
if(CreateBuffers(symbol,period,5))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="Ichimoku";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(tenkan_sen)+","+IntegerToString(kijun_sen)+","+
| |||
IntegerToString(senkou_span_b)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_tenkan_sen =tenkan_sen;
| |||
m_kijun_sen =kijun_sen;
| |||
m_senkou_span_b=senkou_span_b;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("TENKANSEN_LINE");
| |||
((CIndicatorBuffer*)At(1)).Name("KIJUNSEN_LINE");
| |||
((CIndicatorBuffer*)At(2)).Name("SENKOUSPANA_LINE");
| |||
((CIndicatorBuffer*)At(2)).Offset(kijun_sen);
| |||
((CIndicatorBuffer*)At(3)).Name("SENKOUSPANB_LINE");
| |||
((CIndicatorBuffer*)At(3)).Offset(kijun_sen);
| |||
((CIndicatorBuffer*)At(4)).Name("CHIKOUSPAN_LINE");
| |||
((CIndicatorBuffer*)At(4)).Offset(-kijun_sen);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to TenkanSen buffer of "Ichimoku Kinko Hyo" |
| |||
//+------------------------------------------------------------------+
| |||
double CiIchimoku::TenkanSen(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to KijunSen buffer of "Ichimoku Kinko Hyo" |
| |||
//+------------------------------------------------------------------+
| |||
double CiIchimoku::KijunSen(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(1);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to SenkouSpanA buffer of "Ichimoku Kinko Hyo" |
| |||
//+------------------------------------------------------------------+
| |||
double CiIchimoku::SenkouSpanA(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(2);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to SenkouSpanB buffer of "Ichimoku Kinko Hyo" |
| |||
//+------------------------------------------------------------------+
| |||
double CiIchimoku::SenkouSpanB(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(3);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to ChikouSpan buffer of "Ichimoku Kinko Hyo" |
| |||
//+------------------------------------------------------------------+
| |||
double CiIchimoku::ChinkouSpan(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(4);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiMA. |
| |||
//| Purpose: Class of the "Moving Average" indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiMA : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ma_shift;
| |||
ENUM_MA_METHOD m_ma_method;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiMA(void);
| |||
~CiMA(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int MaShift(void) const { return(m_ma_shift); }
| |||
ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_MA); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiMA::CiMA(void) : m_ma_period(-1),
| |||
m_ma_shift(-1),
| |||
m_ma_method(WRONG_VALUE),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiMA::~CiMA(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiMA::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iMA(symbol,period,ma_period,ma_shift,ma_method,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ma_shift,ma_method,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,
| |||
(ENUM_MA_METHOD)params[2].integer_value,(int)params[3].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="MA";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+
| |||
MethodDescription(ma_method)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_ma_shift =ma_shift;
| |||
m_ma_method=ma_method;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ma_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
double CiMA::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiSAR. |
| |||
//| Purpose: Class of the "Parabolic Stop And Reverse System" |
| |||
//| indicator. |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiSAR : public CIndicator
| |||
{
| |||
protected:
| |||
double m_step;
| |||
double m_maximum;
| |||
| |||
public:
| |||
CiSAR(void);
| |||
~CiSAR(void);
| |||
//--- methods of access to protected data
| |||
double SarStep(void) const { return(m_step); }
| |||
double Maximum(void) const { return(m_maximum); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_SAR); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiSAR::CiSAR(void) : m_step(EMPTY_VALUE),
| |||
m_maximum(EMPTY_VALUE)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiSAR::~CiSAR(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Parabolic Stop And Reverse System" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiSAR::Create(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iSAR(symbol,period,step,maximum);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,step,maximum))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiSAR::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,params[0].double_value,params[1].double_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiSAR::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const double step,const double maximum)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="SAR";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
DoubleToString(step,4)+","+DoubleToString(maximum,4)+","+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_step =step;
| |||
m_maximum=maximum;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Parabolic Stop And Reverse System" |
| |||
//+------------------------------------------------------------------+
| |||
double CiSAR::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiStdDev. |
| |||
//| Purpose: Class indicator "Standard Deviation". |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiStdDev : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ma_shift;
| |||
ENUM_MA_METHOD m_ma_method;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiStdDev(void);
| |||
~CiStdDev(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int MaShift(void) const { return(m_ma_shift); }
| |||
ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_STDDEV); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiStdDev::CiStdDev(void) : m_ma_period(-1),
| |||
m_ma_shift(-1),
| |||
m_ma_method(WRONG_VALUE),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiStdDev::~CiStdDev(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Standard Deviation" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiStdDev::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iStdDev(symbol,period,ma_period,ma_shift,ma_method,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ma_shift,ma_method,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiStdDev::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,
| |||
(ENUM_MA_METHOD)params[2].integer_value,(int)params[3].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiStdDev::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,
| |||
const ENUM_MA_METHOD ma_method,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="StdDev";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ma_shift)+","+
| |||
MethodDescription(ma_method)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_ma_shift =ma_shift;
| |||
m_ma_method=ma_method;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ma_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Standard Deviation" |
| |||
//+------------------------------------------------------------------+
| |||
double CiStdDev::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiDEMA. |
| |||
//| Purpose: Class indicator "Double Exponential Moving Average". |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiDEMA : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ind_shift;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiDEMA(void);
| |||
~CiDEMA(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int IndShift(void) const { return(m_ind_shift); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_DEMA); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiDEMA::CiDEMA(void) : m_ma_period(-1),
| |||
m_ind_shift(-1),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiDEMA::~CiDEMA(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Double Exponential Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiDEMA::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iDEMA(symbol,period,ma_period,ind_shift,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ind_shift,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiDEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiDEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="DEMA";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ind_shift)+","+
| |||
PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_ind_shift=ind_shift;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ind_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Double Exponential Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
double CiDEMA::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiTEMA. |
| |||
//| Purpose: Class indicator "Triple Exponential Moving Average". |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiTEMA : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ind_shift;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiTEMA(void);
| |||
~CiTEMA(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int IndShift(void) const { return(m_ind_shift); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_TEMA); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ma_shift,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiTEMA::CiTEMA(void) : m_ma_period(-1),
| |||
m_ind_shift(-1),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiTEMA::~CiTEMA(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Triple Exponential Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiTEMA::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iTEMA(symbol,period,ma_period,ind_shift,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ind_shift,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiTEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiTEMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="TEMA";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ind_shift)+","+
| |||
PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_ind_shift=ind_shift;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ind_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Triple Exponential Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
double CiTEMA::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiFrAMA. |
| |||
//| Purpose: Class indicator "Fractal Adaptive Moving Average". |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiFrAMA : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_ind_shift;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiFrAMA(void);
| |||
~CiFrAMA(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int IndShift(void) const { return(m_ind_shift); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_FRAMA); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiFrAMA::CiFrAMA(void) : m_ma_period(-1),
| |||
m_ind_shift(-1),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiFrAMA::~CiFrAMA(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Fractal Adaptive Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiFrAMA::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iFrAMA(symbol,period,ma_period,ind_shift,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,ind_shift,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiFrAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,(int)params[2].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiFrAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int ind_shift,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="FrAMA";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(ind_shift)+","+
| |||
PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period=ma_period;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ind_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Fractal Adaptive Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
double CiFrAMA::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiAMA. |
| |||
//| Purpose: Class indicator "Adaptive Moving Average". |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiAMA : public CIndicator
| |||
{
| |||
protected:
| |||
int m_ma_period;
| |||
int m_fast_ema_period;
| |||
int m_slow_ema_period;
| |||
int m_ind_shift;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiAMA(void);
| |||
~CiAMA(void);
| |||
//--- methods of access to protected data
| |||
int MaPeriod(void) const { return(m_ma_period); }
| |||
int FastEmaPeriod(void) const { return(m_fast_ema_period); }
| |||
int SlowEmaPeriod(void) const { return(m_slow_ema_period); }
| |||
int IndShift(void) const { return(m_ind_shift); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int fast_ema_period,const int slow_ema_period,
| |||
const int ind_shift,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_AMA); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int fast_ema_period,const int slow_ema_period,
| |||
const int ind_shift,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiAMA::CiAMA(void) : m_ma_period(-1),
| |||
m_fast_ema_period(-1),
| |||
m_slow_ema_period(-1),
| |||
m_ind_shift(-1),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiAMA::~CiAMA(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Adaptive Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiAMA::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int fast_ema_period,const int slow_ema_period,
| |||
const int ind_shift,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iAMA(symbol,period,ma_period,fast_ema_period,slow_ema_period,ind_shift,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,ma_period,fast_ema_period,slow_ema_period,ind_shift,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,
| |||
(int)params[2].integer_value,(int)params[3].integer_value,
| |||
(int)params[4].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiAMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int ma_period,const int fast_ema_period,const int slow_ema_period,
| |||
const int ind_shift,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="AMA";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(ma_period)+","+IntegerToString(fast_ema_period)+","+IntegerToString(slow_ema_period)+","+
| |||
IntegerToString(ind_shift)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_ma_period =ma_period;
| |||
m_fast_ema_period=fast_ema_period;
| |||
m_slow_ema_period=slow_ema_period;
| |||
m_ind_shift =ind_shift;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ind_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Adaptive Moving Average" |
| |||
//+------------------------------------------------------------------+
| |||
double CiAMA::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Class CiVIDyA. |
| |||
//| Purpose: Class indicator "Variable Index DYnamic Average". |
| |||
//| Derives from class CIndicator. |
| |||
//+------------------------------------------------------------------+
| |||
class CiVIDyA : public CIndicator
| |||
{
| |||
protected:
| |||
int m_cmo_period;
| |||
int m_ema_period;
| |||
int m_ind_shift;
| |||
int m_applied;
| |||
| |||
public:
| |||
CiVIDyA(void);
| |||
~CiVIDyA(void);
| |||
//--- methods of access to protected data
| |||
int CmoPeriod(void) const { return(m_cmo_period); }
| |||
int EmaPeriod(void) const { return(m_ema_period); }
| |||
int IndShift(void) const { return(m_ind_shift); }
| |||
int Applied(void) const { return(m_applied); }
| |||
//--- method of creation
| |||
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int cmo_period,const int ema_period,
| |||
const int ind_shift,const int applied);
| |||
//--- methods of access to indicator data
| |||
double Main(const int index) const;
| |||
//--- method of identifying
| |||
virtual int Type(void) const { return(IND_VIDYA); }
| |||
| |||
protected:
| |||
//--- methods of tuning
| |||
virtual bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[]);
| |||
bool Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int cmo_period,const int ema_period,
| |||
const int ind_shift,const int applied);
| |||
};
| |||
//+------------------------------------------------------------------+
| |||
//| Constructor |
| |||
//+------------------------------------------------------------------+
| |||
CiVIDyA::CiVIDyA(void) : m_cmo_period(-1),
| |||
m_ema_period(-1),
| |||
m_ind_shift(-1),
| |||
m_applied(-1)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Destructor |
| |||
//+------------------------------------------------------------------+
| |||
CiVIDyA::~CiVIDyA(void)
| |||
{
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Create indicator "Variable Index DYnamic Average" |
| |||
//+------------------------------------------------------------------+
| |||
bool CiVIDyA::Create(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int cmo_period,const int ema_period,
| |||
const int ind_shift,const int applied)
| |||
{
| |||
//--- check history
| |||
if(!SetSymbolPeriod(symbol,period))
| |||
return(false);
| |||
//--- create
| |||
m_handle=iVIDyA(symbol,period,cmo_period,ema_period,ind_shift,applied);
| |||
//--- check result
| |||
if(m_handle==INVALID_HANDLE)
| |||
return(false);
| |||
//--- indicator successfully created
| |||
if(!Initialize(symbol,period,cmo_period,ema_period,ind_shift,applied))
| |||
{
| |||
//--- initialization failed
| |||
IndicatorRelease(m_handle);
| |||
m_handle=INVALID_HANDLE;
| |||
return(false);
| |||
}
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize the indicator with universal parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiVIDyA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
| |||
{
| |||
//---
| |||
return(Initialize(symbol,period,(int)params[0].integer_value,(int)params[1].integer_value,
| |||
(int)params[2].integer_value,(int)params[3].integer_value));
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Initialize indicator with the special parameters |
| |||
//+------------------------------------------------------------------+
| |||
bool CiVIDyA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
| |||
const int cmo_period,const int ema_period,
| |||
const int ind_shift,const int applied)
| |||
{
| |||
if(CreateBuffers(symbol,period,1))
| |||
{
| |||
//--- string of status of drawing
| |||
m_name ="VIDyA";
| |||
m_status="("+symbol+","+PeriodDescription()+","+
| |||
IntegerToString(cmo_period)+","+IntegerToString(ema_period)+","+IntegerToString(ind_shift)+","+
| |||
PriceDescription(applied)+") H="+IntegerToString(m_handle);
| |||
//--- save settings
| |||
m_cmo_period=cmo_period;
| |||
m_ema_period=ema_period;
| |||
m_ind_shift =ind_shift;
| |||
m_applied =applied;
| |||
//--- create buffers
| |||
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
| |||
((CIndicatorBuffer*)At(0)).Offset(ind_shift);
| |||
//--- ok
| |||
return(true);
| |||
}
| |||
//--- error
| |||
return(false);
| |||
}
| |||
//+------------------------------------------------------------------+
| |||
//| Access to buffer of "Variable Index DYnamic Average" |
| |||
//+------------------------------------------------------------------+
| |||
double CiVIDyA::Main(const int index) const
| |||
{
| |||
CIndicatorBuffer *buffer=At(0);
| |||
//--- check
| |||
if(buffer==NULL)
| |||
return(EMPTY_VALUE);
| |||
//---
| |||
return(buffer.At(index));
| |||
}
| |||
//+------------------------------------------------------------------+
|