Indicadores: Nema MACD
Estimado autor,
¿Cómo puedo comprobar la lista completa de cada MA apoyado por favor?
Gracias.
Ver la descripción - se explica allí
Gracias.
Dice:
- 1 -> EMA
- 2 -> DEMA
- 3 -> TEMA
- ....
- 10 -> DecEMA
- ....
- 50 -> la profundidad máxima calculada por este indicador
Gracias.
Eso dice:
- 1 -> EMA
- 2 -> DEMA
- 3 -> TEMA
- ....
- 10 -> DecEMA
- ....
- 50 -> la profundidad máxima calculada por este indicador
Triangular MA no es un descendiente de EMA - por favor, lea la primera frase también
Triangular MA es un tipo completamente diferente de cálculo
La MA triangular no es descendiente de la EMA - lea también la primera frase
La MA triangular es un tipo de cálculo totalmente diferente
Ok :)
¿Cuáles son los descendientes de la EMA desde la profundidad 4 hasta la 50, por favor? (excluyendo la profundidad 10)
No entiendo por qué el autor ignora la pregunta. ¿Quizás haya que escribir una descripción más clara?
DEMA es Doble EMA, TEMA es Triple EMA, el nombre se basa en la nomenclatura de tuplas, así que la 4ª EMA será Cuádruple EMA, la 5ª es Penta EMA, la 6ª es Hexa EMA, y así sucesivamente.
En la opción "Precio", añada la opción de hacer referencia al precio de cierre del "rango más alto y más bajo",Sin embargo, aparece la siguiente advertencia, por favor haga Sin embargo, aparece la siguiente advertencia, por favor no dude en pedir consejo, ¡gracias!
//------------------------------------------------------------------
#property copyright "© mladen, 2016, MetaQuotes Software Corp."
#property link "www.forex-tsd.com, www.mql5.com"
//------------------------------------------------------------------
#property indicador_separar_ventana
//#property indicator_buffers 6
#propiedad indicator_buffers 9
#property indicator_plots 3
#property indicator_label1 "Relleno OSMA"
#propiedad indicator_type1 DRAW_FILLING
#propiedad indicator_colour1 clrLightBlue,clrPeachPuff
#property indicator_label2 "MACD"
#property indicator_type2 DRAW_COLOR_LINE
#propiedad indicator_colour2 clrSilver,clrDodgerBlue,clrSandyBrown
#propiedad indicator_style2 STYLE_SOLID
#propiedad indicator_width2 3
#property indicator_label3 "Señal MACD"
#property indicator_type3 DRAW_LINE
#property indicator_colour3 clrSalmon
#property indicator_style3 STYLE_DOT
//
//
clrSalmon #propiedad indicator_colour3 // //
//
//enum enPrecios
enum enPrecios
{
pr_close, // Cerrar
pr_open, // Abierto
pr_high, // Alto
pr_low, // Bajo
pr_median, // Mediana
pr_typical, // Típico
pr_weighted, // Ponderado
pr_average, // Media (alto+bajo+abierto+cerrado)/4
pr_medianb, // Promedio mediana cuerpo (abierto+cerrado)/2
pr_tbiased, // Precio tendencialmente sesgado
pr_tbiased2, // Precio (extremo) sesgado por la tendencia
pr_haclose, // Cierre Heiken ashi
pr_haopen , // Apertura Heiken ashi
pr_hahigh, // Máximo Heiken ashi
pr_halow, // Heiken ashi low
pr_hamedian, // Heiken ashi mediana
pr_hatypical, // Heiken ashi típico
pr_haweighted, // Heiken ashi ponderado
pr_haaverage, // Media Heiken ashi
pr_hamedianb, // Heiken ashi mediana del cuerpo
pr_hatbiased, // Precio sesgado por la tendencia Heiken ashi
pr_hatbiased2, // Precio tendencial (extremo) de Heiken ashi
pr_zoneclose, // Referencia al precio de cierre de los puntos máximo y mínimo del rango ((pr_close-pr_lowest)/(pr_highest-pr_lowest)*100)
pr_zonehigh, // Punto más alto del intervalo (iHighest(NULL,0,MODE_HIGH,9,0))
pr_zonelow, // Punto más bajo del intervalo (iLowest(NULL,0,MODE_LOW,9,0))
};
input ENUM_TIMEFRAMES TimeFrame = PERIOD_CURRENT; // Periodo de tiempo
input int MacdFast = 12; // Periodo rápido Periodo rápido
input int MacdSlow = 26; // Periodo lento Periodo lento
input int MacdSignal = 9; // Periodo señal // Periodo señal
input enPrecios NemaPrice = pr_close; // Precio
input int NemaDepth = 1; & // Profundidad NEMA nbsp;// Profundidad NEMA
input bool AlertsOn = false; // ¿Activar alertas?
input bool AlertsOnCurrent = true; // ¿Alertar en la barra actual?
input bool AlertsMessage = true; // ¿Mostrar mensajes como en las alertas?
input bool AlertsSound = false; // ¿Reproducir sonido en las alertas? input bool AlertsSound = false; // ¿Reproducir sonido en las alertas?
input bool AlertsEmail = false; // ¿Enviar un email en las alertas? input bool AlertsEmail = false; // ¿Enviar email en las alertas?
input bool AlertsNotify = false; // ¿Enviar notificaciones push en las alertas? ¿Reproducir sonido en las alertas?
input bool Interpolate = true; // Interpolar datos mtf ?
// input bool AlertsNotify = false; // Enviar notificación push en alertas.
// input bool Interpolate = true; // Interpolar datos mtf ?
// // Los datos mtf se utilizarán como fuente de datos para los datos 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; //--- Gestor personalizado "intervalo precio bajo
int zonehigh_handle; //--- Gestor personalizado de "intervalo alto
int zoneclose_handle; //--- Gestor personalizado de "precio de cierre de intervalo
//------------------------------------------------------------------
// //--- Manipulador "Intervalo Precio Cierre" personalizado //
//------------------------------------------------------------------
//
//
//
//
//
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+ ", "+(cadena)MacdSignal+", "+(cadena)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_calculado,
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& volumen[],
const int& spread[])
{
//---Copia el valor de "rango" personalizado del indicador al buffer del 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);
//
//
//
//
//
if (timeFrame!=_Period)
{
double resultado[]; datetime currTime[],nextTime[];
if (!timeFrameCheck(timeFrame,time)) return(0);
if (_mtfHandle==INVALID_HANDLE) _mtfHandle = _mtfCall;
if (_mtfHandle==INVALID_HANDLE) return(0);
if (CopyBuffer(_mtfHandle,5,0,1,result)==-1) return(0);
//
//
//
return(0); // //
//
#define _mtfRatio PeriodSeconds(timeFrame)/PeriodSeconds(_Period)
int i,k,n,limit = MathMin(MathMax(prev_calculado-1,0),MathMax(rates_total-(int) result[0]*_mtfRatio-1,0));
¡for (i=limit; i<total_tarifas && ! _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(zonaalta,6).
_mtfCopy(zonacierre,7).
//
//
_mtfCopy(zoneclose,7); // //
//
//
if (!Interpolate) continue; CopyTime(_Symbol, timeFrame,time[i ],1,currTime).
if (i<(rates_total-1)) { CopyTime(_ Symbol,timeFrame,time[i+1],1,nextTime); if (currTime[0]==nextTime[0]) continue; }
for(n=1; (i-n)> 0 && time[i-n] > ;= currTime[0]; n++) continuar;
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_calculado-1,0); for (; i<total_tasas && ! _StopFlag; i++)
{
double price = getPrice(NemaPrice,open,close,high,low,i,rates_total);
macd[i] = iNema(precio,MacdFast,NemaDepth,i,tasas_total,0)-iNema(precio,MacdSlow NemaDepth,i,rates_total,1);
signal[i] = iNema(macd[i],MacdSignal ,NemaDepth,i,rates_total,2);
macdc[i] = (macd[i]>señal[i]) ? 1 : (macd[i]<señal[i]) ? 2 : (i>0) ? macdc[i-1] : 0;
fillu[i] = macd[i]-señal[i];
filld[i] = 0;
}
count[rates_total-1] = MathMax(rates_total-prev_calculated+1,1);
manageAlerts(time,macdc,rates_total); return(rates_total); }
return(tasas_total);
}
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
#define _nemaInstances 3
#define _nemaInstancesSize 51
#define _nemcTamañoInstancias 51
#define _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;
¡si (ArrayRange(_trabajoNema,0) ! ¡= bars) ArrayResize(_workNema,bars); if (ArrayRange(_workNema,0) !
si (ArrayRange(_obraNema,0) < cInstancia+1) { ArrayResize(_obraNema,cInstancia+1); _obraNema[cInstancia][0 ]=-1; }
¡if (_workNemc[cInstance][0] ! = profundidad)
{_workNemc[cInstance][0] = profundidad; for(int k=1; k<=profundidad; k++) _workNemc[cInstance][k] = factorial(profundidad)/(factorial(profundidad-k)*factorial(k)); }
//
//
//
//
//
_workNema[i][instanceNo+_nema] = valor;
if (period>1)
{
double alpha = 2.0/(1.0+period), sign=1; _workNema[i][instanceNo+_nema] = 0;
for (int k=0; k<profundidad; k++, signo *= -1)
{
plantilla[i][instanciaNo+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] += valor*signo*_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); }
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//
#define precioInstancias 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)
{
if (tprice>=pr_haclose)
{
if (¡ArrayRange(workHa,0)! = _bars) ArrayResize(workHa,_bars); instanceNo*=4;
//
//
//
//
//
double haOpen; if (i>0)
si (i>0)
haOpen = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;
else 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][ instanciaNo+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((haAlto+haBajo)/2,0);
case pr_hamedianb: return((haOpen+haClose)/2.0);
case pr_hatypical: return((haAlto+haBajo+haCierre)/3,0);
case pr_haweighted: return((haAlto+haBajo+haCierre+haCierre)/4,0);
case pr_haaverage: return((haAlto+haBajo+haCierre+haCierre)/4,0);
caso pr_hatbiased.
si (haCierre>haApertura)
return((haAlto+haCierre)/2,0); case pr_hatbiased: if (haCierre>haAbrir)
else return((haLow+haClose)/2.0);
caso pr_hatbiased2.
if (haClose>haOpen) return(haHigh); case_hatbiased2.
if (haClose<haOpen) return(haLow); return(haClose)
return(haBajo); return(haCierre).
caso pr_zoneeclose: return(zoneClose); caso 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((alto[i]+bajo[i])/2.0); case pr_medianb: return(alto[i]+bajo[i])/2.0)
case pr_medianb: return((open[i]+close[i])/2.0);
case pr_typical: return((alto[i]+bajo[i]+cerrado[i])/3,0);
case pr_weighted: return((alta[i]+baja[i]+cierre[i]+cierre[i])/4,0);
case pr_average: return((alto[i]+bajo[i]+cerrado[i]+abierto[i])/4,0);
case pr_tbiased.
si (cierre[i]>apertura[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(bajo[i]); return(cierre[i]) return(cierre[i]); return(cierre[i]); return(cierre[i])
case pr_zoneclose: return(zoneclose[i]); return(low[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(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].
¡if (atrend[whichBar] ! = atrend[whichBar-1])
{
if (atrend[whichBar] == 1) doAlert(time1, "up"); if (atrend[whichBar] == 1)
if (atrend[whichBar] == 2) doAlert(time1, "down");
}
}
//
//
//
//
//
void doAlert(datetime forTime, string doWhat)
{
static string previousAlert="nada"; static datetime previousTime; static datetime forTime, string doWhat {
static datetime previousTime; static string previousAlert="nada"; static datetime previousTime
static string previousAlert="nada"; static datetime previousTime; string message.
¡if (previousAlert ! ¡= doWhat || previousTime ! = forTime)
¡previousAlert = doWhat; message; if (previousAlert !
AlertaAnterior = doWhat; horaAnterior = forTime; forTime
horaanterior = horaf.
//
//
//
previousAlert = doWhat; previousTime = forTime; // //
//
message = timeFrameToString(_Period)+" "+_Symbol+" at "+TimeToString(TimeLocal(),TIME_SECONDS)+" nema macd state changed a "+doWhat;
if (AlertsMessage) Alerta(mensaje);
if (AlertsEmail) SendMail(_Symbol+" nema macd",mensaje); if (AlertsNotify)
if (AlertsNotify) SendNotification(mensaje); if (AlertsSound)
if (AlertsSound) PlaySound("alert2.wav");
}
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//
cadena getIndicatorName()
{
string path = MQL5InfoString(MQL5_PROGRAM_PATH); string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Indicator
string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\MQL5\\Indicators\\";
string nombre = StringSubstr(ruta,StringLen(datos));
return(nombre);
}
//
//
//
//
//
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
cadena _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", "diario", "semanal", "mensual"}; }
cadena timeFrameToString(int periodo)
{
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)+"\nDatos que faltan for "+timeFrameToString(_timeFrame)+" time frame\nRe-trying on next tick"); warned=true; return(false); }
}
if (warned) { Comment(""); warned=false; }
return(true); }
}
================================================================================================================================== ====================================
Descripción.
posible pérdida de datos debido a la conversión de tipo de 'double' a 'int' Nema_MACD.mq5 109 21
0 errores, 2 advertencias, 212 mseg transcurridos 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;
Precio_zonaCerrar
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso
Nema MACD:
MACD, calculado con NEMA.
Autor: Mladen Rakic