Indicadores: Nema MACD
Prezado autor,
Por favor, como posso verificar a lista completa de todos os MA suportados?
Obrigado!
Consulte a descrição - ela está explicada lá
Obrigado.
Ele diz:
- 1 -> EMA
- 2 -> DEMA
- 3 -> TEMA
- ....
- 10 -> DecEMA
- ....
- 50 -> a profundidade máxima calculada por esse indicador
Obrigado.
Ele diz:
- 1 -> EMA
- 2 -> DEMA
- 3 -> TEMA
- ....
- 10 -> DecEMA
- ....
- 50 -> a profundidade máxima calculada por esse indicador
A MA triangular não é um descendente da EMA - leia também a primeira frase
A MA triangular é um tipo de cálculo totalmente diferente
A MA triangular não é um descendente da EMA - leia também a primeira frase
A MA triangular é um tipo de cálculo totalmente diferente
Ok :)
Quais são os descendentes da EMA da profundidade 4 a 50, por favor???? (excluindo a profundidade 10)
Não entendo por que o autor ignora a pergunta. Talvez seja necessário escrever uma descrição mais clara?
DEMA é Double EMA, TEMA é Triple EMA, o nome é baseado na nomeação de tuplas, portanto, a 4ª EMA será Quadruple EMA, a 5ª é Penta EMA, a 6ª é Hexa EMA e assim por diante.
Na opção "Preço", adicione a opção para fazer referência ao preço de fechamento do "intervalo mais alto e mais baixo". No entanto, o aviso a seguir é exibido. Não hesite em pedir orientação, obrigado!
//------------------------------------------------------------------
#propriedade copyright "© mladen, 2016, MetaQuotes Software Corp."
#property link "www.forex-tsd.com, www.mql5.com"
//------------------------------------------------------------------
#property indicator_separate_window
//#property indicator_buffers 6
#property indicator_buffers 9
#property indicator_plots 3
#property indicator_label1 "OSMA filling"
#property indicator_type1 DRAW_FILLING
#property indicator_colour1 clrLightBlue,clrPeachPuff
#property indicator_label2 "MACD"
#property indicator_type2 DRAW_COLOR_LINE
#property indicator_colour2 clrSilver,clrDodgerBlue,clrSandyBrown
#property indicator_style2 STYLE_SOLID
#property indicator_width2 3
#property indicator_label3 "Sinal MACD"
#property indicator_type3 DRAW_LINE
#property indicator_colour3 clrSalmon
#property indicator_style3 STYLE_DOT
//
//
clrSalmon #property indicator_colour3 // //
//
//enum enPrices
enum enPrices
{
pr_close, // Fechar
pr_open, // Abrir
pr_high, // Alto
pr_low, // Baixo
pr_median, // Mediano
pr_typical, // Típico
pr_weighted, // Ponderado
pr_average, // Média (alto+baixo+aberto+fechado)/4
pr_medianb, // Corpo mediano médio (abrir+fechar)/2
pr_tbiased, // Tendência de preço tendenciosa
pr_tbiased2, // Tendência tendenciosa (extrema) do preço
pr_haclose, // Fechamento Heiken ashi
pr_haopen , // Heiken ashi aberto
pr_hahigh, // Alta do Heiken ashi
pr_halow, // Heiken ashi low
pr_hamedian, // Heiken ashi median
pr_hatypical, // Heiken ashi typical
pr_haweighted, // Heiken ashi ponderado
pr_haaverage, // Média do Heiken ashi
pr_hamedianb, // Corpo mediano do Heiken ashi
pr_hatbiased, // Tendência de preço tendenciosa do Heiken ashi
pr_hatbiased2, // Tendência de Heiken ashi com viés de preço (extremo)
pr_zoneclose, // Referência ao preço de fechamento dos pontos alto e baixo do intervalo ((pr_close-pr_lowest)/(pr_highest-pr_lowest)*100)
pr_zonehigh, // Ponto mais alto do intervalo (iHighest(NULL,0,MODE_HIGH,9,0))
pr_zonelow, // Ponto mais baixo do intervalo (iLowest(NULL,0,MODE_LOW,9,0))
};
input ENUM_TIMEFRAMES TimeFrame = PERIOD_CURRENT; // Período de tempo
input int MacdFast = 12; // Período rápido Período rápido
input int MacdSlow = 26; // Período lento Período lento
input int MacdSignal = 9; // Período do sinal // Período do sinal
input enPrices NemaPrice = pr_close; // Preço
input int NemaDepth = 1; & // Profundidade da NEMA nbsp;// Profundidade da NEMA
input bool AlertsOn = false; // Ativar alertas?
input bool AlertsOnCurrent = true; // Alerta na barra atual?
input bool AlertsMessage = true; // Exibe mensagens em alertas?
input bool AlertsSound = false; // Reproduzir som nos alertas input bool AlertsSound = false; // Reproduzir som nos alertas?
input bool AlertsEmail = false; // Enviar e-mail em alertas? input bool AlertsEmail = false; // Enviar e-mail em alertas?
input bool AlertsNotify = false; // Enviar notificação por push em alertas? Reproduzir som nos alertas?
input bool Interpolate = true; // Interpolar dados mtf ?
// input bool AlertsNotify = false; // Enviar notificação push sobre alertas.
// input bool Interpolate = true; // Interpolar dados mtf ?
// // Os dados do mtf serão usados como a fonte de dados para os dados do mtf.
// //
// // // // // // // // // // // // // // // // // //
double macd[],macdc[],signal[],fillu[],filld[],count[];
int _mtfHandle = INVALID_HANDLE; ENUM_TIMEFRAMES timeFrame.
#define _mtfCall iCustom(_Symbol,timeFrame,getIndicatorName(),PERIOD_CURRENT,MacdFast,MacdSlow,MacdSignal,NemaPrice,NemaDepth. AlertsOn,AlertsOnCurrent,AlertsMessage,AlertsSound,AlertsEmail,AlertsNotify)
double zonelow[],zonehigh[],zoneclose[];
int zonelow_handle; //--- Manipulador personalizado de "intervalo de preço baixo
int zonehigh_handle; //--- Manipulador de "intervalo alto" personalizado
int zoneclose_handle; //--- Manipulador personalizado de "preço de fechamento do intervalo
//------------------------------------------------------------------
// //--- Manipulador personalizado de "Intervalo de preço de fechamento" //
//------------------------------------------------------------------
//
//
//
//
//
int OnInit()
{
SetIndexBuffer(0,fillu ,INDICATOR_DATA);
SetIndexBuffer(1,filld ,INDICATOR_DATA);
SetIndexBuffer(1,filld ,INDICATOR_DATA); SetIndexBuffer(2,macd ,INDICATOR_DATA).
SetIndexBuffer(2,macdc ,INDICATOR_DATA); SetIndexBuffer(3,macdc ,INDICATOR_COLOR_INDEX);
SetIndexBuffer(3,macdc ,INDICATOR_COLOR_INDEX); SetIndexBuffer(4,signal ,INDICATOR_DATA);
SetIndexBuffer(4,signal ,INDICATOR_DATA); SetIndexBuffer(5,count ,INDICATOR_CALCULATIONS).
SetIndexBuffer(5,count ,INDICATOR_CALCULATIONS); SetIndexBuffer(6,zonelow ,INDICATOR_DATA);
SetIndexBuffer(6,zonelow ,INDICATOR_DATA); SetIndexBuffer(7,zonehigh ,INDICATOR_DATA);
SetIndexBuffer(7,zonehigh,INDICATOR_DATA); SetIndexBuffer(8,zoneclose,INDICATOR_DATA); timeFrame = MathMax
timeFrame = MathMax(_Period,TimeFrame);
IndicatorSetString(INDICATOR_SHORTNAME,timeFrameToString(timeFrame)+" nema macd ("+(string)MacdFast+ ", "+(string)MacdSlow+ ", "+(string)MacdSignal+", "+(string)NemaDepth+")");");
zonelow_handle = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,9,0));
zonehigh_handle = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0)); zoneclose_handle = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0))
zoneclose_handle = ((pr_close-zonelow_handle)/(zonehigh_handle-zonelow_handle))*100;
return(0);
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
int OnCalculate(const int rates_total,
const int prev_calculated,
const datetime& time[],
const double& open[],
const double& high[],
const double& low[],
const double& close[], const long& tick_volume[], const
const long& tick_volume[],
const long& volume[],
const int& spread[])
{
//---Copiar o valor de "intervalo" personalizado do indicador para o buffer do indicador
int COPY_RATES_LOW=CopyBuffer(zonelow_handle,0,0,rates_total,zonelow); int COPY_RATES_LOW=CopyBuffer(zonelow_handle,0,0,rates_total,zonelow)
int COPY_RATES_HIGH=CopyBuffer(zonehigh_handle,0,0,rates_total,zonehigh); int COPY_RATES_HIGH=CopyBuffer(zonehigh_handle,0,0,rates_total,zonehigh);
int COPY_RATES_CLOSE=CopyBuffer(zoneclose_handle,0,0,rates_total,zoneclose);
if (Bars(_Symbol,_Period)<rates_total) return(-1);
//
//
//
//
//
Se (timeFrame!=_Period)
{
double result[]; datetime currTime[],nextTime[];
se (!timeFrameCheck(timeFrame,time)) return(0);
se (_mtfHandle==INVALID_HANDLE) _mtfHandle = _mtfCall;
se (_mtfHandle==INVALID_HANDLE) return(0);
se (CopyBuffer(_mtfHandle,5,0,1,result)==-1) return(0);
//
//
//
return(0); // //
//
#definir _mtfRatio PeriodSeconds(timeFrame)/PeriodSeconds(_Period)
int i,k,n,limit = MathMin(MathMax(prev_calculated-1,0),MathMax(rates_total-(int) result[0]*_mtfRatio-1,0));
for (i=limit; i<rates_total && ! _StopFlag; i++ )
{
#define _mtfCopy(_buff,_buffNo) if (CopyBuffer(_mtfHandle,_buffNo,time[i],1, result)==-1) break; _buff[i] = result[0]
_mtfCopy(fillu ,0); filld[i] = 0;
_mtfCopy(macd ,2).
_mtfCopy(macdc ,3).
_mtfCopy(signal ,4).
_mtfCopy(signal ,4); _mtfCopy(zonelow ,5).
_mtfCopy(zonehigh,6).
_mtfCopy(zoneclose,7).
//
//
_mtfCopy(zoneclose,7); // //
//
//
if (!Interpolate) continue; CopyTime(_Symbol, timeFrame,time[i ],1,currTime).
se (i<(rates_total-1)) { CopyTime(_ Symbol,timeFrame,time[i+1],1,nextTime); se (currTime[0]==nextTime[0]) continue; }
for(n=1; (i-n)> 0 && time[i-n] > ;= currTime[0]; n++) continue;
for(k=1; (i-k)>=0 && k<n; k++)
{
#define _mtfInterpolate(_buff ) _buff[i-k] = _buff[i]+(_buff[i-n]-_buff[i])*k/n
_mtfInterpolate(fillu ).
_mtfInterpolate(macd ).
_mtfInterpolate(signal).
_mtfInterpolate(signal); _mtfInterpolate(zoneclose).
_mtfInterpolate(zonehigh); _mtfInterpolate(signal); _mtfInterpolate(zoneclose); _mtfInterpolate(zonehigh)
_mtfInterpolate(zoneclose); _mtfInterpolate(zonehigh); _mtfInterpolate(zoneelow);
} & nbsp;
}
return(i);
}
//
//
//
//
//
int i=(int)MathMax(prev_calculated-1,0); for (; i<rates_total && ! _StopFlag; i++)
{
double price = getPrice(NemaPrice,open,close,high,low,i,rates_total);
macd[i] = iNema(price,MacdFast,NemaDepth,i,rates_total,0)-iNema(price,MacdSlow ,NemaDepth,i,rates_total,1);
signal[i] = iNema(macd[i],MacdSignal ,NemaDepth,i,rates_total,2);
macdc[i] = (macd[i]>signal[i]) ? 1 : (macd[i]<signal[i]) ? 2 : (i>0) ? macdc[i-1] : 0;
fillu[i] = macd[i]-signal[i];
filld[i] = 0;
}
count[rates_total-1] = MathMax(rates_total-prev_calculated+1,1);
manageAlerts(time,macdc,rates_total); return(rates_total); }
return(rates_total);
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
#define _nemaInstances 3
#define _nemaInstancesSize 51
#define _nemcInstancesSize 51
#definir _nema 50
double _workNema[][_nemaInstances*_nemaInstancesSize].
double _workNemc[][ _nemcInstancesSize].
double iNema(double value, double period, int depth, int i, int bars, int instanceNo=0)
{
depth = MathMax(MathMin(depth,_nemcInstancesSize-1),1);
int cInstance = instanceNo; instanceNo *= _nemaInstancesSize;
se (ArrayRange(_workNema,0) ! = barras) ArrayResize(_workNema,barras); if (ArrayRange(_workNema,0) !
se (ArrayRange(_workNemc,0) < cInstance+1) { ArrayResize(_workNemc,cInstance+1); _workNemc[cInstance][0 ]=-1; }
if (_workNemc[cInstance][0] ! = depth)
{_workNemc[cInstance][0] = depth; for(int k=1; k<=depth; k++) _workNemc[cInstance][k] = fatorial(profundidade)/(fatorial(profundidade-k)*fatorial(k)); }
//
//
//
//
//
_workNema[i][instanceNo+_nema] = valor;
se (período>1)
{
double alpha = 2,0/(1,0+período), sign=1; _workNema[i][instanceNo+_nema] = 0;
for (int k=0; k<depth; k++, sign *= -1)
{
_workNema[i][instanceNo+k ] = (i>0) ? _workNema[i-1][instanceNo+k]+alpha*(value-_workNema[i-1][instanceNo+k]) : value; value = _workNema[i][instanceNo+k];
_workNema[i][instanceNo+_nema] += value*sign*_workNemc[cInstance][k+1];
}
}
return(_workNema[i][instanceNo+_nema]);
}
double factorial(int n) { double a=1; for(int i=1; i<=n; i++) a*=i; return(a); }
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//
#definir priceInstances 1
double zoneLow = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,9,0)); double zoneHigh = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0)); double zoneHigh = iHigh(NULL,0,MODE_HIGH,9,0))
double zoneHigh = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0)); & nbsp;
double zoneClose = ((pr_close-zoneLow)/(zoneHigh-zoneLow))*100;
double workHa[][priceInstances*4]; double getPrice(int t_close-zoneLow)/(zoneHigh-zoneLow)*100;
double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i,int _bars , int instanceNo=0)
{
se (tprice>=pr_haclose)
{
se (ArrayRange(workHa,0)! = _bars) ArrayResize(workHa,_bars); instanceNo*=4;
//
//
//
//
//
double haOpen; if (i>0)
se (i>0)
haOpen = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;
senão haOpen = (open[i]+close[i])/2;
double haClose = (open[i] + high[i] + low[i] + close[i]) / 4,0;
double haHigh = MathMax(high[i], MathMax(haOpen,haClose));
double haLow = MathMin(low[i] , MathMin(haOpen,haClose)); double haLow = MathMin(low[i] , MathMin(haOpen,haClose))
if(haOpen < haClose) { workHa[i][instanceNo+0] = haLow; workHa[i][instanceNo+1] = haHigh; }& nbsp; else { workHa[i][instanceNo+1] = haHigh; }
else { workHa[i][instanceNo+0] = haHigh; workHa[i][ instanceNo+1] = haLow; }
workHa[i][instanceNo+2] = haOpen;
workHa[i][instanceNo+3] = haClose;
//
//
//
// //
//
switch (tprice)
{
case pr_haclose: return(haClose);
case pr_haclose: return(haClose); case pr_haopen: return(haOpen); case pr_hahigh: return(haHigh); case pr_haclose: return(haHigh); return(haHigh)
case pr_hahigh: return(haHigh); case pr_halow: return(haLow); return(haLow); return(haHigh)
case pr_halow: return(haLow); case pr_hamedian: return(haHigh); case pr_halow: return(haLow)
case pr_hamedian: return((haHigh+haLow)/2.0);
case pr_hamedianb: return((haOpen+haClose)/2,0);
case pr_hatypical: return((haHigh+haLow+haClose)/3,0);
case pr_haweighted: return((haHigh+haLow+haClose+haClose)/4,0);
case pr_haaverage: return((haHigh+haLow+haClose+haOpen)/4,0);
case pr_hatbiased.
se (haClose>haOpen)
return((haHigh+haClose)/2.0); case pr_hatbiased: if (haClose>haOpen)
else return((haLow+haClose)/2.0);
case pr_hatbiased2.
se (haClose>haOpen) return(haHigh); case_hatbiased2.
se (haClose<haOpen) return(haLow); return(haClose)
return(haLow); return(haClose).
case pr_zoneclose: return(zoneClose); case pr_zonehigh: return(zoneClose); if (haClose<haOpen) return(haLow); return(haClose)
case pr_zonehigh: return(zoneHigh); case pr_zonelow: return(zoneHigh); return(zoneHigh); return(zoneHigh)
case pr_zonelow: return(zoneLow); case pr_zonelow: return(zoneLow)
}
}
//
//
//
//
//
switch (tprice)
case pr_close: return(close[i]); }
case pr_close: return(close[i]); case pr_open: return(open[i]); } }
case pr_open: return(open[i]); case pr_high: return(high[i]); // switch (tprice) { case pr_close: return(close[i]); return(open[i])
case pr_high: return(high[i]); case pr_low: return(low[i]); case pr[i])
case pr_low: return(low[i]); case pr_median: return(low[i])
case pr_median: return((high[i]+low[i])/2.0); case pr_medianb: return(high[i]+low[i])/2.0)
case pr_medianb: return((open[i]+close[i])/2.0);
case pr_typical: return((high[i]+low[i]+close[i])/3,0);
case pr_weighted: return((high[i]+low[i]+close[i]+close[i])/4.0);
case pr_average: return((high[i]+low[i]+close[i]+open[i])/4.0);
case pr_tbiased.
se (close[i]>open[i])
return((high[i]+close[i])/2.0); case pr_tbiased.
else return((low[i]+close[i])/2.0); case pr_tbiased2: if (low[i]+close[i])/2.0)
case pr_tbiased2.
if (close[i]>open[i]) return(high[i]); case pr_tbiased2.
if (close[i]<open[i]) return(low[i]);
return(low[i]); return(close[i]) return(close[i]); return(close[i]); return(close[i])
case pr_zoneclose: return(zoneclose[i]); return(low[i]); return(close[i]); return(close[i]); return(close[i])
case pr_zonehigh: return(zonehigh[i]); case pr_zonelow: return(zonehigh[i]); return(zonehigh[i])
case pr_zonelow: return(zonelow[i]); return(zonehigh[i]);
}
return(0); }
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
void manageAlerts(const datetime& atime[], double& atrend[], int bars)
{
if (!AlertsOn) return; return; int whichBar = bars-1; if (!AlertsOnCurrent)
int whichBar = bars-1; if (!AlertsOnCurrent) whichBar = bars-2; datetime time1 = atime[whichBar].
se (atrend[whichBar] ! = atrend[whichBar-1])
{
se (atrend[whichBar] == 1) doAlert(time1, "up"); se (atrend[whichBar] == 1)
se (atrend[whichBar] == 2) doAlert(time1, "down");
}
}
//
//
//
//
//
void doAlert(datetime forTime, string doWhat)
{
static string previousAlert="nothing"; static datetime previousTime; static datetime forTime, string doWhat {
static datetime previousTime; static string previousAlert="nothing"; static datetime previousTime
static string previousAlert="nothing"; static datetime previousTime; string message.
Se (previousAlert ! = doWhat || previousTime ! = forTime)
previousAlert = doWhat; message; if (previousAlert !
previousAlert = doWhat; previousTime = forTime; forTime
previousTime = forTime.
//
//
//
previousAlert = doWhat; previousTime = forTime; // //
//
message = timeFrameToString(_Period)+" "+_Symbol+" at "+TimeToString(TimeLocal(),TIME_SECONDS)+" nema macd state changed para "+doWhat;
Se (AlertsMessage) Alert(message);
se (AlertsEmail) SendMail(_Symbol+" nema macd",message); se (AlertsNotify)
se (AlertsNotify) SendNotification(message); se (AlertsSound)
se (AlertsSound) PlaySound("alert2.wav");
}
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//
string getIndicatorName()
{
string path = MQL5InfoString(MQL5_PROGRAM_PATH); string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\\\Indicator
string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\\Indicators\\";
string name = StringSubstr(path,StringLen(data));
return(name);
}
//
//
//
//
//
int _tfsPer[]={PERIOD_M1,PERIOD_M2,PERIOD_M3,PERIOD_M4,PERIOD_M5,PERIOD_M6,PERIOD_M10,PERIOD_M12,PERIOD_M15,PERIOD_M20, PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1,PERIOD_W1,PERIOD_MN1}; string _tfsStr[]_tfsStr[]_tfsStr[]_tfsStr[]_tfsString
string _tfsStr[]={"1 minuto", "2 minutos", "3 minutos", "4 minutos", "5 minutos", "6 minutos", "10 minutos", "12 minutos", "15 minutos", "20 minutos", "30 minutos", "1 hora", "2 horas", "3 horas", "4 horas", "6 horas", "8 horas", "12 horas", "diariamente", "semanalmente", "mensalmente"}; }
string timeFrameToString(int period)
{
if (period==PERIOD_CURRENT)
period = _Period.
int i; for(i=0;i<ArraySize(_tfsPer);i++) if (period==_tfsPer[i]) break;
return(_tfsStr[i]);
}
//
//
//
//
//
bool timeFrameCheck(ENUM_TIMEFRAMES _timeFrame,const datetime& time[])
{
static bool warned=false;
if (time[0]<SeriesInfoInteger(_Symbol,_timeFrame,SERIES_FIRSTDATE))
{
datetime startTime,testTime[];
if (SeriesInfoInteger(_Symbol,PERIOD_M1,SERIES_TERMINAL_FIRSTDATE,startTime))
if (startTime>0) { CopyTime( _Symbol,_timeFrame,time[0],1,testTime); SeriesInfoInteger(_Symbol,_timeFrame,SERIES_FIRSTDATE,startTime); }
if (startTime<=0 || startTime>time[0]) { Comment(MQL5InfoString(MQL5_PROGRAM_NAME)+"\nDados ausentes for "+timeFrameToString(_timeFrame)+" time frame\nRe-trying on next tick"); warned=true; return(false); }
}
if (warned) { Comment(""); warned=false; }
return(true); }
}
================================================================================================================================== ====================================
Descrição.
Possível perda de dados devido à conversão de tipo de 'double' para 'int' Nema_MACD.mq5 109 21
0 erros, 2 avisos, 212 msec decorridos 1 3
==================================================================================
95 int OnInit()
96 {
109 zonelow_handle = iLow(NULL,0,iLowest(NULL,0,MODE_LOW,9,0));
110 zonehigh_handle = iHigh(NULL,0,iHighest(NULL,0,MODE_HIGH,9,0));
111 zoneclose_handle = ((pr_close-zonelow_handle)/(zonehigh_handle-zonelow_handle))*100;
Price_zoneClose
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso
Nema MACD:
MACD calculada usando a NEMA.
Autor: Mladen Rakic