Indikatoren: Nema MACD
Lieber Autor,
Wie kann ich bitte die vollständige Liste aller unterstützten MA überprüfen?
Danke!
Siehe die Beschreibung - dort wird es erklärt
Danke.
Hier steht:
- 1 -> EMA
- 2 -> DEMA
- 3 -> TEMA
- ....
- 10 -> DecEMA
- ....
- 50 -> die von diesem Indikator berechnete maximale Tiefe
Danke.
Es sagt:
- 1 -> EMA
- 2 -> DEMA
- 3 -> TEMA
- ....
- 10 -> DecEMA
- ....
- 50 -> die von diesem Indikator berechnete maximale Tiefe
Triangular MA ist kein Ableger des EMA - lesen Sie bitte auch den ersten Satz
Triangular MA ist eine völlig andere Art der Berechnung
Triangular MA ist kein Abkömmling von EMA - bitte lesen Sie auch den ersten Satz
Triangular MA ist eine völlig andere Art der Berechnung
Ok :)
Was sind die Ableger des EMA von Tiefe 4 bis 50 bitte??? (außer Tiefe 10)
Ich verstehe nicht, warum der Autor die Frage ignoriert. Vielleicht muss eine klarere Beschreibung geschrieben werden?
DEMA ist Double EMA, TEMA ist Triple EMA, der Name basiert auf Tupel Benennung, so dass die 4. EMA wird Quadruple EMA, 5. ist Penta EMA, 6. ist Hexa EMA, und so weiter.
Fügen Sie in der Option "Preis" die Option hinzu, den Schlusskurs des "Bereichs Höchst- und Tiefstkurs" zu referenzieren. Es erscheint jedoch die folgende Warnung, bitte zögern Sie nicht, um Rat zu fragen, vielen Dank!
//------------------------------------------------------------------
#property copyright "© mladen, 2016, MetaQuotes Software Corp."
#property link "www.forex-tsd.com, www.mql5.com"
//------------------------------------------------------------------
#property indicator_separate_window
//#property indicator_buffers 6
#Eigenschaft indicator_buffers 9
#eigenschaft indicator_plots 3
#property indicator_label1 "OSMA-Füllung"
#property indicator_type1 DRAW_FILLING
#property indicator_colour1 clrHellblau,clrPfirsichPuff
#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 "MACD-Signal"
#property indicator_type3 DRAW_LINE
#property indicator_colour3 clrSalmon
#property indicator_style3 STYLE_DOT
//
//
clrSalmon #property indicator_colour3 // //
//
//enum enPreise
enum enPreise
{
pr_close, // Schließen
pr_open, // Öffnen
pr_high, // Hoch
pr_low, // Tief
pr_median, // Mittelwert
pr_typisch, // Typisch
pr_weighted, // Gewichtet
pr_average, // Durchschnitt (hoch+niedrig+öffnen+schließen)/4
pr_medianb, // Durchschnittlicher Medianwert (offen+geschlossen)/2
pr_tbiased, // Trendverzerrter Preis
pr_tbiased2, // Trendverzerrter (extremer) Preis
pr_haclose, // Heiken-Ashi-Schlusskurs
pr_haopen , // Heiken-Ashi-Eröffnung
pr_hahigh, // Heiken ashi hoch
pr_halow, // Heiken ashi niedrig
pr_hamedian, // Heiken ashi Median
pr_hatypisch, // Heiken ashi typisch
pr_haweighted, // Heiken ashi gewichtet
pr_haaverage, // Heiken ashi Durchschnitt
pr_hamedianb, // Heiken ashi medianer Körper
pr_hatbiased, // Heiken ashi trendverzerrter Preis
pr_hatbiased2, // Heiken ashi trendverzerrter (extremer) Preis
pr_zoneclose, // Referenz auf den Schlusskurs des höchsten und niedrigsten Punkts der Spanne ((pr_close-pr_lowest)/(pr_highest-pr_lowest)*100)
pr_zonehigh, // Höchster Punkt des Intervalls (iHighest(NULL,0,MODE_HIGH,9,0))
pr_zonelow, // Niedrigster Punkt des Bereichs (iLowest(NULL,0,MODE_LOW,9,0))
};
input ENUM_TIMEFRAMES TimeFrame = PERIOD_CURRENT; // Zeitrahmen
input int MacdFast = 12; // Schneller Zeitraum Schneller Zeitraum
input int MacdSlow = 26; // Langsamer Zeitraum Langsamer Zeitraum
input int MacdSignal = 9; // Signalperiode // Signal-Periode
input enPreise NemaPreis = pr_close; // Preis
Eingabe int NemaDepth = 1; & // NEMA-Tiefe nbsp;// NEMA-Tiefe
input bool AlertsOn = false; // Alarme einschalten?
input bool AlertsOnCurrent = true; // Warnung bei aktuellem Balken?
input bool AlertsMessage = true; // Meldung bei Alarmen anzeigen? bei Alarmen?
input bool AlertsSound = false; // Ton bei Alarmen abspielen input bool AlertsSound = false; // Ton bei Alarmen abspielen?
input bool AlertsEmail = false; // E-Mail bei Alarmen versenden? input bool AlertsEmail = false; // E-Mail bei Alarmen versenden?
input bool AlertsNotify = false; // Push-Benachrichtigung senden bei Ton bei Alarmen abspielen?
input bool Interpolate = true; // Interpolieren mtf-Daten ?
// Eingabe bool AlertsNotify = false; // Push-Benachrichtigung bei Alarmen senden.
// Eingabe bool Interpolate = true; // Interpoliere mtf-Daten ?
// // Die mtf-Daten werden als Datenquelle für die mtf-Daten verwendet.
// //
// // // // // // // // // // // // // // // // // //
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; //--- Benutzerdefinierter "Intervall-Tiefstpreis"-Handler
int zonehigh_handle; //--- Angepasster "Intervall hoch"-Handler
int zoneclose_handle; //--- Angepasster "Intervall-Schlusskurs"-Handler
//------------------------------------------------------------------
//--- Benutzerdefinierter Handler "Intervall Schlusskurs" //--- Benutzerdefinierter Handler "Intervall Schlusskurs
//------------------------------------------------------------------
//
//
//
//
//
int OnInit()
{
SetIndexPuffer(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);
SetIndexPuffer(4,signal ,INDICATOR_DATA); SetIndexPuffer(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[])
{
//---Kopieren des benutzerdefinierten "Range"-Werts des Indikators in den Indikatorpuffer
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 result[]; 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_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).
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++) 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(preis,MacdFast,NemaDepth,i,rates_total,0)-iNema(preis,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 _nemcInstanzenGröße 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;
if (ArrayRange(_workNema,0) ! = bars) ArrayResize(_workNema,bars); if (ArrayRange(_workNema,0) !
if (ArrayRange(_workNemc,0) < cInstance+1) { ArrayResize(_workNemc,cInstance+1); _workNemc[cInstance][0 ]=-1; }
if (_workNemc[cInstance][0] ! = Tiefe)
{_workNemc[cInstance][0] = Tiefe; for(int k=1; k<=Tiefe; k++) _workNemc[cInstance][k] = faktoriell(Tiefe)/(faktoriell(Tiefe-k)*faktoriell(k)); }
//
//
//
//
//
_workNema[i][instanceNo+_nema] = Wert;
if (Zeitraum>1)
{
double alpha = 2.0/(1.0+Periode), sign=1; _workNema[i][instanceNo+_nema] = 0;
for (int k=0; k<Tiefe; 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); }
//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//
#define 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)
{
if (tprice>=pr_haclose)
{
if (ArrayRange(workHa,0)! = _bars) ArrayResize(workHa,_bars); instanceNo*=4;
//
//
//
//
//
double haOpen; if (i>0)
if (i>0)
haOpen = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;
sonst 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; sonst { workHa[i][instanceNo+1] = haHigh; }
sonst { 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);
Fall pr_hatbiased.
if (haClose>haOpen)
return((haHigh+haClose)/2.0); case pr_hatbiased: if (haClose>haOpen)
sonst return((haLow+haClose)/2.0);
Fall pr_hatbiased2.
if (haClose>haOpen) return(haHigh); case_hatbiased2.
if (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(niedrig[i]); case pr_median: return(niedrig[i])
case pr_median: return((hoch[i]+niedrig[i])/2.0); case pr_medianb: return(hoch[i]+niedrig[i])/2.0)
case pr_medianb: return((open[i]+close[i])/2.0);
case pr_typisch: return((hoch[i]+niedrig[i]+schluss[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);
Fall pr_tbiased.
if (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)
Fall pr_tbiased2.
if (close[i]>open[i]) return(high[i]); case pr_tbiased2.
if (close[i]<open[i]) return(low[i]);
return(niedrig[i]); return(schließen[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(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="nothing"; static datetime previousTime; static datetime forTime, string doWhat {
static datetime previousTime; static string previousAlert="nichts"; static datetime previousTime
static string previousAlert="nothing"; static datetime previousTime; string message.
if (previousAlert ! = doWhat || previousTime ! = forTime)
previousAlert = doWhat; message; if (previousAlert !
previousAlert = doWhat; previousTime = forTime; forTime
vorigeZeit = forZeit.
//
//
//
previousAlert = doWhat; previousTime = forTime; // //
//
message = timeFrameToString(_Period)+" "+_Symbol+" at "+TimeToString(TimeLocal(),TIME_SECONDS)+" nema macd state changed auf "+DoWhat;
if (AlertsMessage) Alert(message);
if (AlertsEmail) SendMail(_Symbol+" nema macd",message); if (AlertsNotify)
if (AlertsNotify) SendNotification(Nachricht); if (AlertsSound)
if (AlertsSound) PlaySound("alert2.wav");
}
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//
string getIndicatorName()
{
string path = MQL5InfoString(MQL5_PROGRAM_PATH); string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\\\MQL5\\Indikator
string data = TerminalInfoString(TERMINAL_DATA_PATH)+"\\\\MQL5\\\\Indikatoren\";
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[]_tfsString
string _tfsStr[]={"1 Minute", "2 Minuten", "3 Minuten", "4 Minuten", "5 Minuten", "6 Minuten", "10 Minuten", "12 Minuten", "15 Minuten", "20 Minuten", "30 Minuten", "1 Stunde", "2 Stunden", "3 Stunden", "4 Stunden", "6 Stunden", "8 Stunden", "12 Stunden", "täglich", "wöchentlich", "monatlich"}; }
string timeFrameToString(int period)
{
if (Zeitraum==PERIOD_CURRENT)
Zeitraum = _Zeitraum.
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)+"\nFehlende Daten for "+timeFrameToString(_timeFrame)+" time frame\nRe-trying on next tick"); warned=true; return(false); }
}
if (warned) { Comment(""); warned=false; }
return(true); }
}
================================================================================================================================== ====================================
Beschreibung.
möglicher Datenverlust durch Typkonvertierung von 'double' nach 'int' Nema_MACD.mq5 109 21
0 Fehler, 2 Warnungen, 212 msec verstrichen 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;
Preis_ZoneSchließen
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Nema MACD:
MACD berechnet auf Basis des NEMA.
Autor: Mladen Rakic