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));
|
|
}
|
|
//+------------------------------------------------------------------+
|