Hi,

 

ich habe von Mt4 gar keine Ahnung und brauch mal eure Hilfe. Im Netz bin ich über einen Indikator gestolpert, den ich gerne auch in Python oder TradingView verwenden würde. Das ist ein Kaufman`s Adaptive Moving Average, allerdings mit drei Zuständen.

 

Jetzt die Frage, was sind die Bedingungen für den neutralen Zustand? Da bin ich mir nicht so sicher. Würde mal behaupten, das entscheidet sich hier:

 

ddK = ( AMA - AMA0 );
if ( ( MathAbs(ddK) ) > ( dK * Point ) && ( ddK > 0 ) ) 
	kAMAupsig[pos]  = AMA;

if ( ( MathAbs(ddK) ) > ( dK * Point ) && ( ddK < 0 )) 
	kAMAdownsig[pos] = AMA;

Kann es sein, wenn sich keine Änderung vom AMA-Wert davor ergibt, die Differenz dazwischen ist Null, dann wird weder kAMAupsig noch kAMAdownsig gesetzt, bzw. geplotted ?

Den Term "( MathAbs(ddK) ) > ( dK * Point ) && ( ddK > 0 )" finde ich eigenartig. MathAbs zieht man bestimt den absoluten Betrag von ddK. ddK ist als Fließkommazahl definiert. Dann vergleicht man die Fließkommazahl mit einem booleschen Ausdruck "( dK * Point ) && ( ddK > 0 )" ? Häää?

 

Vollständigen Code findet Ihr ganz unten, originalen Code habe ich angehängt. Hier zwei Quellen vom Indikator:

 

#5 Range-bound trading (Following WellxAMA)
https://forex-strategies-revealed.com/range-bound-trading/following-wellxama

Simple Scalp Machine
https://www.forexfactory.com/thread/292842-simple-scalp-machine

 

 

 

//+------------------------------------------------------------------+
//|                                                      Kaufman.mq4 |
//|                             Copyright © -2005, by konKop & wellx |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2004, by konKop,wellx"
#property link      "http://www.metaquotes.net"

#property indicator_chart_window
#property indicator_buffers 3
#property indicator_color1 Sienna
#property indicator_color2 DeepSkyBlue
#property indicator_color3 Gold

//---- input parameters
extern int       periodAMA=9;
extern int       nfast=2;
extern int       nslow=30;
extern double    G=2.0;
extern double    dK=2.0; 

//---- buffers
double kAMAbuffer[];
double kAMAupsig[];
double kAMAdownsig[];

//+------------------------------------------------------------------+

int    cbars=0, prevbars=0, prevtime=0;
double slowSC,fastSC;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE);
   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,159);
   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexBuffer(0,kAMAbuffer);
   SetIndexBuffer(1,kAMAupsig);
   SetIndexBuffer(2,kAMAdownsig);
   
   
   IndicatorDigits(4);
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start(){
	int    i, pos=0;
	double noise = 0.000000001 , AMA , AMA0, signal , ER;
	double dSC , ERSC , SSC, ddK;

	if (prevbars==Bars) 
		return(0);
    
	//---- TODO: add your code here
	slowSC = (2.0 /(nslow+1));
	fastSC = (2.0 /(nfast+1));
	cbars  = IndicatorCounted();
	
	if ( Bars <= ( periodAMA + 2)) 
		return(0);
	
	//---- check for possible errors
	if ( cbars < 0) 
		return(-1);
	
	//---- last counted bar will be recounted
	if ( cbars > 0) 
		cbars--;
	
	
	pos  = Bars - periodAMA - 2;
	AMA0 = Close[pos+1];
	
	while (pos>=0){
		if( pos == Bars - periodAMA - 2) 
			AMA0 = Close[pos+1];
		
		signal = MathAbs( Close[pos] - Close[pos+periodAMA]);
		noise=0.000000001;
		
		for(i=0;i<periodAMA;i++){
			noise=noise+MathAbs(Close[pos+i]-Close[pos+i+1]);
		};
		
		ER              = signal / noise;
		dSC             = (fastSC-slowSC);
		ERSC            = ER * dSC;
		SSC             = ERSC + slowSC;
		AMA             = AMA0 + ( MathPow(SSC,G)*(Close[pos]-AMA0));
		kAMAbuffer[pos] = AMA;

		ddK = ( AMA - AMA0 );
		if ( ( MathAbs(ddK) ) > ( dK * Point ) && ( ddK > 0 ) ) 
			kAMAupsig[pos]  = AMA;
		
		if ( ( MathAbs(ddK) ) > ( dK * Point ) && ( ddK < 0 )) 
			kAMAdownsig[pos] = AMA;

		AMA0 = AMA;
		pos--;
     };
//----
   prevbars=Bars;
   return(0);
  }

 

wellxAMA.mq4

 

if ( ( MathAbs(ddK) ) > ( dK * Point ) && ( ddK > 0 ) ) 
	kAMAupsig[pos]  = AMA;

if ( ( MathAbs(ddK) ) > ( dK * Point ) && ( ddK < 0 )) 
	kAMAdownsig[pos] = AMA;

dK = ( AMA - AMA0 );

Kann es sein, wenn sich keine Änderung vom AMA-Wert davor ergibt, die Differenz dazwischen ist Null, dann wird weder kAMAupsig noch kAMAdownsig gesetzt, bzw. geplotted ?

Den Term "( MathAbs(ddK) ) > ( dK * Point ) && ( ddK > 0 )" finde ich eigenartig. MathAbs zieht man bestimt den absoluten Betrag von ddK. ddK ist als Fließkommazahl definiert. Dann vergleicht man die Fließkommazahl mit einem booleschen Ausdruck "( dK * Point ) && ( ddK > 0 )" ? Häää?

 

Wo vergleichst Du denn da einen boolschen Ausdruck?

Es wird in beiden Fällen als Erstes überprüft, ob der Betrag von ddK größer ist als dK (=Mindestbewegung für eine Veränderung). Für das up muss dann ddK noch>0 sein, für das down gilt ddK

Ich gehe mal davon aus, dass die Priorität der Operatoren sich an C anlehnt:

https://de.wikibooks.org/wiki/C-Programmierung:_Liste_der_Operatoren_nach_Priorit%C3%A4t

Dann kommt ">" vor dem logischen UND "&&" und es macht Sinn: Zuerst wird ( MathAbs(ddK) mit ( dK * Point ) verglichen. Das wird dann mit dem logischen UND und ( ddK > 0 ) verbunden... Dachte zuerst, ( dK * Point ) && ( ddK > 0 ) wird zuerst ausgewertet.

Ja, MQL4 ist eher wie C. Und falls man sich mal unsicher ist, kann man ja noch immer Klammern setzen, so dass es einem gefällt. Bspw dann so:

if ((MathAbs(ddK)>dK*Point) && ddK>0) 
	kAMAupsig[pos]  = AMA;

if ((MathAbs(ddK)>dK*Point) && ddK<0) 
	kAMAdownsig[pos] = AMA;

Lieber eine Klammer zu viel als zu wenig.... :) Habe ich mir auch angewöhnt.... :)