1722 lines
70 KiB
MQL5
1722 lines
70 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| Oscilators.mqh |
|
|
//| Copyright 2000-2025, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#include "Indicator.mqh"
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiATR. |
|
|
//| Purpose: Class of the "Average True Range" idnicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiATR : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
|
|
public:
|
|
CiATR(void);
|
|
~CiATR(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;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_ATR); }
|
|
|
|
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 |
|
|
//+------------------------------------------------------------------+
|
|
CiATR::CiATR(void) : m_ma_period(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiATR::~CiATR(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Average True Range" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiATR::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iATR(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 CiATR::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiATR::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="ATR";
|
|
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");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Average True Range" |
|
|
//+------------------------------------------------------------------+
|
|
double CiATR::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiBearsPower. |
|
|
//| Purpose: Class indicator "Bears Power". |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiBearsPower : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
|
|
public:
|
|
CiBearsPower(void);
|
|
~CiBearsPower(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
//--- method create
|
|
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;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_BEARS); }
|
|
|
|
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 |
|
|
//+------------------------------------------------------------------+
|
|
CiBearsPower::CiBearsPower(void) : m_ma_period(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiBearsPower::~CiBearsPower(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Bears Power" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiBearsPower::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iBearsPower(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 CiBearsPower::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiBearsPower::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="BearsPower";
|
|
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");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Bears Power" |
|
|
//+------------------------------------------------------------------+
|
|
double CiBearsPower::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiBullsPower. |
|
|
//| Purpose: Class of the "Bulls Power" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiBullsPower : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
|
|
public:
|
|
CiBullsPower(void);
|
|
~CiBullsPower(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
//--- method create
|
|
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;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_BULLS); }
|
|
|
|
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 |
|
|
//+------------------------------------------------------------------+
|
|
CiBullsPower::CiBullsPower(void) : m_ma_period(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiBullsPower::~CiBullsPower(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create indicator "Bulls Power" |
|
|
//+------------------------------------------------------------------+
|
|
bool CiBullsPower::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iBullsPower(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 CiBullsPower::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiBullsPower::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="BullsPower";
|
|
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");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Bulls Power" |
|
|
//+------------------------------------------------------------------+
|
|
double CiBullsPower::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiCCI. |
|
|
//| Purpose: Class of the "Commodity Channel Index" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiCCI : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
int m_applied;
|
|
|
|
public:
|
|
CiCCI(void);
|
|
~CiCCI(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
int Applied(void) const { return(m_applied); }
|
|
//--- method create
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,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_CCI); }
|
|
|
|
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 applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiCCI::CiCCI(void) : m_ma_period(-1),
|
|
m_applied(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiCCI::~CiCCI(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Commodity Channel Index" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiCCI::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iCCI(symbol,period,ma_period,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,ma_period,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiCCI::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));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Commodity Channel Index" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiCCI::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="CCI";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(ma_period)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_ma_period=ma_period;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Commodity Channel Index" |
|
|
//+------------------------------------------------------------------+
|
|
double CiCCI::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiChaikin. |
|
|
//| Purpose: Class of the "Chaikin Oscillator" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiChaikin : public CIndicator
|
|
{
|
|
protected:
|
|
int m_fast_ma_period;
|
|
int m_slow_ma_period;
|
|
ENUM_MA_METHOD m_ma_method;
|
|
ENUM_APPLIED_VOLUME m_applied;
|
|
|
|
public:
|
|
CiChaikin(void);
|
|
~CiChaikin(void);
|
|
//--- methods of access to protected data
|
|
int FastMaPeriod(void) const { return(m_fast_ma_period); }
|
|
int SlowMaPeriod(void) const { return(m_slow_ma_period); }
|
|
ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); }
|
|
ENUM_APPLIED_VOLUME Applied(void) const { return(m_applied); }
|
|
//--- method of creation
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ma_period,const int slow_ma_period,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_CHAIKIN); }
|
|
|
|
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 fast_ma_period,const int slow_ma_period,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiChaikin::CiChaikin(void) : m_fast_ma_period(-1),
|
|
m_slow_ma_period(-1),
|
|
m_ma_method(WRONG_VALUE),
|
|
m_applied(WRONG_VALUE)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiChaikin::~CiChaikin(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create indicator "Chaikin Oscillator" |
|
|
//+------------------------------------------------------------------+
|
|
bool CiChaikin::Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ma_period,const int slow_ma_period,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iChaikin(symbol,period,fast_ma_period,slow_ma_period,ma_method,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,fast_ma_period,slow_ma_period,ma_method,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiChaikin::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,(ENUM_APPLIED_VOLUME)params[3].integer_value));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiChaikin::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ma_period,const int slow_ma_period,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="Chaikin";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(fast_ma_period)+","+IntegerToString(slow_ma_period)+","+
|
|
MethodDescription(ma_method)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_fast_ma_period=fast_ma_period;
|
|
m_slow_ma_period=slow_ma_period;
|
|
m_ma_method =ma_method;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Chaikin Oscillator" |
|
|
//+------------------------------------------------------------------+
|
|
double CiChaikin::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiDeMarker. |
|
|
//| Purpose: Class of the "DeMarker" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiDeMarker : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
|
|
public:
|
|
CiDeMarker(void);
|
|
~CiDeMarker(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;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_DEMARKER); }
|
|
|
|
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 |
|
|
//+------------------------------------------------------------------+
|
|
CiDeMarker::CiDeMarker(void) : m_ma_period(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiDeMarker::~CiDeMarker(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create indicator "DeMarker" |
|
|
//+------------------------------------------------------------------+
|
|
bool CiDeMarker::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iDeMarker(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 CiDeMarker::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiDeMarker::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="DeMarker";
|
|
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");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "DeMarker" |
|
|
//+------------------------------------------------------------------+
|
|
double CiDeMarker::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiForce. |
|
|
//| Purpose: Class of the "Force Index" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiForce : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
ENUM_MA_METHOD m_ma_method;
|
|
ENUM_APPLIED_VOLUME m_applied;
|
|
|
|
public:
|
|
CiForce(void);
|
|
~CiForce(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); }
|
|
ENUM_APPLIED_VOLUME Applied(void) const { return(m_applied); }
|
|
//--- method of creation
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int ma_period,const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_FORCE); }
|
|
|
|
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 ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiForce::CiForce(void) : m_ma_period(-1),
|
|
m_ma_method(WRONG_VALUE),
|
|
m_applied(WRONG_VALUE)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiForce::~CiForce(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create indicator "Force Index" |
|
|
//+------------------------------------------------------------------+
|
|
bool CiForce::Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int ma_period,const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iForce(symbol,period,ma_period,ma_method,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,ma_period,ma_method,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiForce::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int num_params,const MqlParam ¶ms[])
|
|
{
|
|
return(Initialize(symbol,period,(int)params[0].integer_value,(ENUM_MA_METHOD)params[1].integer_value,
|
|
(ENUM_APPLIED_VOLUME)params[2].integer_value));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiForce::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int ma_period,const ENUM_MA_METHOD ma_method,const ENUM_APPLIED_VOLUME applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="Force";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(ma_period)+","+MethodDescription(ma_method)+","+
|
|
VolumeDescription(applied)+","+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_ma_period=ma_period;
|
|
m_ma_method=ma_method;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Force Index" |
|
|
//+------------------------------------------------------------------+
|
|
double CiForce::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiMACD. |
|
|
//| Purpose: Class of the "Moving Averages |
|
|
//| Convergence-Divergence" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiMACD : public CIndicator
|
|
{
|
|
protected:
|
|
int m_fast_ema_period;
|
|
int m_slow_ema_period;
|
|
int m_signal_period;
|
|
int m_applied;
|
|
|
|
public:
|
|
CiMACD(void);
|
|
~CiMACD(void);
|
|
//--- methods of access to protected data
|
|
int FastEmaPeriod(void) const { return(m_fast_ema_period); }
|
|
int SlowEmaPeriod(void) const { return(m_slow_ema_period); }
|
|
int SignalPeriod(void) const { return(m_signal_period); }
|
|
int Applied(void) const { return(m_applied); }
|
|
//--- method of creation
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
double Signal(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_MACD); }
|
|
|
|
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 fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiMACD::CiMACD(void) : m_fast_ema_period(-1),
|
|
m_slow_ema_period(-1),
|
|
m_signal_period(-1),
|
|
m_applied(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiMACD::~CiMACD(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Moving Averages Convergence-Divergence" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiMACD::Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iMACD(symbol,period,fast_ema_period,slow_ema_period,signal_period,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,fast_ema_period,slow_ema_period,signal_period,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiMACD::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiMACD::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,2))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="MACD";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(fast_ema_period)+","+IntegerToString(slow_ema_period)+","+
|
|
IntegerToString(signal_period)+","+PriceDescription(applied)+","+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_fast_ema_period=fast_ema_period;
|
|
m_slow_ema_period=slow_ema_period;
|
|
m_signal_period =signal_period;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
((CIndicatorBuffer*)At(1)).Name("SIGNAL_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to Main buffer of "Moving Averages |
|
|
//| Convergence-Divergence" |
|
|
//+------------------------------------------------------------------+
|
|
double CiMACD::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to Signal buffer of "Moving Averages |
|
|
//| Convergence-Divergence" |
|
|
//+------------------------------------------------------------------+
|
|
double CiMACD::Signal(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(1);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiMomentum. |
|
|
//| Purpose: Class of the "Momentum" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiMomentum : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
int m_applied;
|
|
|
|
public:
|
|
CiMomentum(void);
|
|
~CiMomentum(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
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 applied);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_MOMENTUM); }
|
|
|
|
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 applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiMomentum::CiMomentum(void) : m_ma_period(-1),
|
|
m_applied(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiMomentum::~CiMomentum(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Momentum" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiMomentum::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iMomentum(symbol,period,ma_period,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,ma_period,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiMomentum::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));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiMomentum::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name="Momentum";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(ma_period)+","+PriceDescription(applied)+","+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_ma_period=ma_period;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Momentum" |
|
|
//+------------------------------------------------------------------+
|
|
double CiMomentum::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiOsMA. |
|
|
//| Purpose: Class of the "Moving Average of Oscillator |
|
|
//| (MACD histogram)" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiOsMA : public CIndicator
|
|
{
|
|
protected:
|
|
int m_fast_ema_period;
|
|
int m_slow_ema_period;
|
|
int m_signal_period;
|
|
int m_applied;
|
|
|
|
public:
|
|
CiOsMA(void);
|
|
~CiOsMA(void);
|
|
//--- methods of access to protected data
|
|
int FastEmaPeriod(void) const { return(m_fast_ema_period); }
|
|
int SlowEmaPeriod(void) const { return(m_slow_ema_period); }
|
|
int SignalPeriod(void) const { return(m_signal_period); }
|
|
int Applied(void) const { return(m_applied); }
|
|
//--- method of creation
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,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_OSMA); }
|
|
|
|
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 fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiOsMA::CiOsMA(void) : m_fast_ema_period(-1),
|
|
m_slow_ema_period(-1),
|
|
m_signal_period(-1),
|
|
m_applied(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiOsMA::~CiOsMA(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create indicator "Moving Average of Oscillator |
|
|
//| (MACD histogram)" |
|
|
//+------------------------------------------------------------------+
|
|
bool CiOsMA::Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iOsMA(symbol,period,fast_ema_period,slow_ema_period,signal_period,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,fast_ema_period,slow_ema_period,signal_period,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiOsMA::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiOsMA::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int fast_ema_period,const int slow_ema_period,
|
|
const int signal_period,const int applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="OsMA";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(fast_ema_period)+","+IntegerToString(slow_ema_period)+","+
|
|
IntegerToString(signal_period)+","+PriceDescription(applied)+","+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_fast_ema_period=fast_ema_period;
|
|
m_slow_ema_period=slow_ema_period;
|
|
m_signal_period =signal_period;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Moving Average of Oscillator |
|
|
//| (MACD histogram)" |
|
|
//+------------------------------------------------------------------+
|
|
double CiOsMA::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiRSI. |
|
|
//| Purpose: Class of the "Relative Strength Index" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiRSI : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
int m_applied;
|
|
|
|
public:
|
|
CiRSI(void);
|
|
~CiRSI(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
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 applied);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_RSI); }
|
|
|
|
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 applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiRSI::CiRSI(void) : m_ma_period(-1),
|
|
m_applied(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiRSI::~CiRSI(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create indicator "Relative Strength Index" |
|
|
//+------------------------------------------------------------------+
|
|
bool CiRSI::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iRSI(symbol,period,ma_period,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,ma_period,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiRSI::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));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiRSI::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="RSI";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(ma_period)+","+PriceDescription(applied)+","+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_ma_period=ma_period;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Relative Strength Index" |
|
|
//+------------------------------------------------------------------+
|
|
double CiRSI::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiRVI. |
|
|
//| Purpose: Class of the "Relative Vigor Index" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiRVI : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
|
|
public:
|
|
CiRVI(void);
|
|
~CiRVI(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 Signal(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_RVI); }
|
|
|
|
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 |
|
|
//+------------------------------------------------------------------+
|
|
CiRVI::CiRVI(void) : m_ma_period(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiRVI::~CiRVI(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Relative Vigor Index" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiRVI::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iRVI(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 CiRVI::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 the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiRVI::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period)
|
|
{
|
|
if(CreateBuffers(symbol,period,2))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="RVI";
|
|
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("SIGNAL_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to Main buffer of "Relative Vigor Index" |
|
|
//+------------------------------------------------------------------+
|
|
double CiRVI::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to Signal buffer of "Relative Vigor Index" |
|
|
//+------------------------------------------------------------------+
|
|
double CiRVI::Signal(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(1);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiStochastic. |
|
|
//| Purpose: Class of the "Stochastic Oscillator" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiStochastic : public CIndicator
|
|
{
|
|
protected:
|
|
int m_Kperiod;
|
|
int m_Dperiod;
|
|
int m_slowing;
|
|
ENUM_MA_METHOD m_ma_method;
|
|
ENUM_STO_PRICE m_price_field;
|
|
|
|
public:
|
|
CiStochastic(void);
|
|
~CiStochastic(void);
|
|
//--- methods of access to protected data
|
|
int Kperiod(void) const { return(m_Kperiod); }
|
|
int Dperiod(void) const { return(m_Dperiod); }
|
|
int Slowing(void) const { return(m_slowing); }
|
|
ENUM_MA_METHOD MaMethod(void) const { return(m_ma_method); }
|
|
ENUM_STO_PRICE PriceField(void) const { return(m_price_field); }
|
|
//--- method create
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int Kperiod,const int Dperiod,const int slowing,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_STO_PRICE price_field);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
double Signal(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_STOCHASTIC); }
|
|
|
|
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 Kperiod,const int Dperiod,const int slowing,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_STO_PRICE price_field);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiStochastic::CiStochastic(void) : m_Kperiod(-1),
|
|
m_Dperiod(-1),
|
|
m_slowing(-1),
|
|
m_ma_method(WRONG_VALUE),
|
|
m_price_field(WRONG_VALUE)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiStochastic::~CiStochastic(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Stochastic Oscillator" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiStochastic::Create(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int Kperiod,const int Dperiod,const int slowing,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_STO_PRICE price_field)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iStochastic(symbol,period,Kperiod,Dperiod,slowing,ma_method,price_field);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,Kperiod,Dperiod,slowing,ma_method,price_field))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiStochastic::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,(ENUM_MA_METHOD)params[3].integer_value,
|
|
(ENUM_STO_PRICE)params[4].integer_value));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with special parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiStochastic::Initialize(const string symbol,const ENUM_TIMEFRAMES period,
|
|
const int Kperiod,const int Dperiod,const int slowing,
|
|
const ENUM_MA_METHOD ma_method,const ENUM_STO_PRICE price_field)
|
|
{
|
|
if(CreateBuffers(symbol,period,2))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="Stochastic";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(Kperiod)+","+IntegerToString(Dperiod)+","+IntegerToString(slowing)+","+
|
|
MethodDescription(ma_method)+","+IntegerToString(price_field)+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_Kperiod =Kperiod;
|
|
m_Dperiod =Dperiod;
|
|
m_slowing =slowing;
|
|
m_ma_method =ma_method;
|
|
m_price_field=price_field;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
((CIndicatorBuffer*)At(1)).Name("SIGNAL_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to Main buffer of "Stochastic Oscillator" |
|
|
//+------------------------------------------------------------------+
|
|
double CiStochastic::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to Signal buffer of "Stochastic Oscillator" |
|
|
//+------------------------------------------------------------------+
|
|
double CiStochastic::Signal(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(1);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiWPR. |
|
|
//| Purpose: Class of the "Williams' Percent Range" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiWPR : public CIndicator
|
|
{
|
|
protected:
|
|
int m_calc_period;
|
|
|
|
public:
|
|
CiWPR(void);
|
|
~CiWPR(void);
|
|
//--- methods of access to protected data
|
|
int CalcPeriod(void) const { return(m_calc_period); }
|
|
//--- method of creation
|
|
bool Create(const string symbol,const ENUM_TIMEFRAMES period,const int calc_period);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_WPR); }
|
|
|
|
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 calc_period);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiWPR::CiWPR(void) : m_calc_period(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiWPR::~CiWPR(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Williams' Percent Range" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiWPR::Create(const string symbol,const ENUM_TIMEFRAMES period,const int calc_period)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period))
|
|
return(false);
|
|
//--- create
|
|
m_handle=iWPR(symbol,period,calc_period);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,calc_period))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiWPR::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 cpecial parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiWPR::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int calc_period)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="WPR";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(calc_period)+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_calc_period=calc_period;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Williams' Percent Range" |
|
|
//+------------------------------------------------------------------+
|
|
double CiWPR::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Class CiTriX. |
|
|
//| Purpose: Class of the "Triple Exponential Moving Averages |
|
|
//| Oscillator" indicator. |
|
|
//| Derives from class CIndicator. |
|
|
//+------------------------------------------------------------------+
|
|
class CiTriX : public CIndicator
|
|
{
|
|
protected:
|
|
int m_ma_period;
|
|
int m_applied;
|
|
|
|
public:
|
|
CiTriX(void);
|
|
~CiTriX(void);
|
|
//--- methods of access to protected data
|
|
int MaPeriod(void) const { return(m_ma_period); }
|
|
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 applied);
|
|
//--- methods of access to indicator data
|
|
double Main(const int index) const;
|
|
//--- method of identifying
|
|
virtual int Type(void) const { return(IND_TRIX); }
|
|
|
|
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 applied);
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CiTriX::CiTriX(void) : m_ma_period(-1),
|
|
m_applied(-1)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
CiTriX::~CiTriX(void)
|
|
{
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Triple Exponential Moving Averages |
|
|
//| Oscillator" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiTriX::Create(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
//--- check history
|
|
if(!SetSymbolPeriod(symbol,period)) return(false);
|
|
//--- create
|
|
m_handle=iTriX(symbol,period,ma_period,applied);
|
|
//--- check result
|
|
if(m_handle==INVALID_HANDLE)
|
|
return(false);
|
|
//--- indicator successfully created
|
|
if(!Initialize(symbol,period,ma_period,applied))
|
|
{
|
|
//--- initialization failed
|
|
IndicatorRelease(m_handle);
|
|
m_handle=INVALID_HANDLE;
|
|
return(false);
|
|
}
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize the indicator with universal parameters |
|
|
//+------------------------------------------------------------------+
|
|
bool CiTriX::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));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Create the "Triple Exponential Moving Averages |
|
|
//| Oscillator" indicator |
|
|
//+------------------------------------------------------------------+
|
|
bool CiTriX::Initialize(const string symbol,const ENUM_TIMEFRAMES period,const int ma_period,const int applied)
|
|
{
|
|
if(CreateBuffers(symbol,period,1))
|
|
{
|
|
//--- string of status of drawing
|
|
m_name ="TriX";
|
|
m_status="("+symbol+","+PeriodDescription()+","+
|
|
IntegerToString(ma_period)+","+PriceDescription(applied)+") H="+IntegerToString(m_handle);
|
|
//--- save settings
|
|
m_ma_period=ma_period;
|
|
m_applied =applied;
|
|
//--- create buffers
|
|
((CIndicatorBuffer*)At(0)).Name("MAIN_LINE");
|
|
//--- ok
|
|
return(true);
|
|
}
|
|
//--- error
|
|
return(false);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Access to buffer of "Triple Exponential Moving Averages |
|
|
//| Oscillator" |
|
|
//+------------------------------------------------------------------+
|
|
double CiTriX::Main(const int index) const
|
|
{
|
|
CIndicatorBuffer *buffer=At(0);
|
|
//--- check
|
|
if(buffer==NULL)
|
|
return(EMPTY_VALUE);
|
|
//---
|
|
return(buffer.At(index));
|
|
}
|
|
//+------------------------------------------------------------------+
|