FxTesterDE - Informationen für Trader

beim stöbern bin ich über den SwingLine Indikator gestolpert: http://vtadwiki.vtad.de/index.php/Swingline-Indikator

Je nach Einstellung zeigt der SwingLine Indikator extreme Hochs und Tiefs oder kann auch als Stopsignal verwendet werden, Beispiele sind auf obiger Webseite zu sehen.

Da ich dann aber keinen fertigen SwingLine Indikator für den Metatrader 4 gefunden habe, habe ich ihn mir selber schnell erstellt, und hier dann ein paar kleine Erweiterungen eingebaut.

//+------------------------------------------------------------------+
//|                                                    SwingLine.mq4 |
//|                                Copyright © -2011, by Forexdigger |
//|                                        http://www.Forexdigger.de |
//+------------------------------------------------------------------+

#property copyright "Copyright © 2011, by Forexdigger "
#property link      "http://www.Forexdigger.de"

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Aqua
#property indicator_color2 Red

//---- input parameters
extern int       before = 0;
extern int       after = 5;
extern int       shift = 1;
extern bool     strict = false;
extern bool    strict2 = false;
extern double distance = 0.0001;
extern int  minPercent = 50;
extern bool fastDrawBack = true;
//---- buffers
double SwingHigh[];
double SwingLow[];
//+------------------------------------------------------------------+

int    span=0;



//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_LINE, STYLE_DOT);
   SetIndexStyle(1,DRAW_LINE, STYLE_DOT);
   SetIndexDrawBegin(0,before+3);
   SetIndexDrawBegin(1,before+3);
   SetIndexBuffer(0,SwingHigh);
   SetIndexBuffer(1,SwingLow);
   
   IndicatorDigits(Digits);
   span = before + after +1;
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
     
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    limit;
int    counted_bars = IndicatorCounted();
int x ;
//---- last counted bar will be recounted
if (counted_bars>0)
counted_bars--;
else
counted_bars = 1;
limit = Bars - counted_bars;
for (int i=limit; i>=0; i--)
{
    int position = shift + i;
    int selBar = after + position;
    double difference;
    double difference2;
     
      if ( iHighest(NULL,0,MODE_HIGH, span ,position) == selBar)
      {
         bool isNewHigh = true;
         
         if (strict)
         {
            if (after>0)
            {
               for ( x = position; x < selBar; x++)
               {
                  if (High[x] > High[x+1]) isNewHigh = false;
               }
           
            }
            if (before>0)
            {
               for ( x = selBar; x < selBar + before; x++)
               {
                  if (High[x] < High[x+1]) isNewHigh = false;
               }
           
            }
         }
         
         if (strict2)
         {
            if (after>0)
            {
               for ( x = position; x < selBar; x++)
               {
                  if (Low[x] > Low[x+1]) isNewHigh = false;
               }
           
            }
            if (before>0)
            {
               for ( x = selBar; x < selBar + before; x++)
               {
                  if (Low[x] < Low[x+1]) isNewHigh = false;
               }
           
            }
         }
       
       
       
       double lowestHigh = High[iLowest(NULL,0,MODE_HIGH, after ,position)];
       difference = High[selBar] - High[position];
       difference2 = High[selBar] - lowestHigh;
       
       if ( minPercent > 0 && (difference2 * 0.01 * minPercent) > difference) isNewHigh = false;
         
       if (isNewHigh) SwingHigh[i] = High[selBar]+ distance; else SwingHigh[i] = SwingHigh[i+1];
      }
      else
      {
         
         if ( fastDrawBack && High[position] > SwingHigh[i+1] - distance)
         {
            SwingHigh[i] = High[position] + distance;
         }
         else
         {
            SwingHigh[i] = SwingHigh[i+1];
         }
      }
     
     
      // SwingLineLow
     
      if ( iLowest(NULL,0,MODE_LOW, span ,position) == selBar)
      {
         bool isNewLow = true;
         
         if (strict)
         {
            if (after>0)
            {
               for ( x = position; x < selBar; x++)
               {
                  if (Low[x] < Low[x+1]) isNewLow = false;
               }
           
            }
            if (before>0)
            {
               for ( x = selBar; x < selBar + before; x++)
               {
                  if (Low[x] > Low[x+1]) isNewLow = false;
               }
           
            }
         }
         
         if (strict2)
         {
            if (after>0)
            {
               for ( x = position; x < selBar; x++)
               {
                  if (High[x] < High[x+1]) isNewLow = false;
               }
           
            }
            if (before>0)
            {
               for ( x = selBar; x < selBar + before; x++)
               {
                  if (High[x] > High[x+1]) isNewLow = false;
               }
           
            }
         }
       
       
       
       double highestLow = Low[iHighest(NULL,0,MODE_LOW, after ,position)];
       difference = Low[position] - Low[selBar] ;
       difference2 = highestLow - Low[selBar] ;
       
       if ( minPercent > 0 && (difference2 * 0.01 * minPercent) > difference) isNewLow = false;
         
       if (isNewLow) SwingLow[i] = Low[selBar] - distance; else SwingLow[i] = SwingLow[i+1];
      }
      else
      {
         
         if ( fastDrawBack && Low[position] < SwingLow[i+1] + distance)
         {
            SwingLow[i] = Low[position] - distance;
         }
         else
         {
            SwingLow[i] = SwingLow[i+1];
         }
      }
     
     
   }
   return(0);
  }
Erklärung der externen Veriabeln:

before = 0;
Anzahl der Bars die vor dem Extrem berücksichtigt werden, für SwingLine-High müsswen diese alle niedriger sein

after = 5;
Anzahl der Bars nach dem Extrem, müssen für die SwingLine-High auch alle niegriger sein

wenn before und after beide auf 0 stehen wird nichts gezeichnet

shift = 1;
bei 1 wird wird der Wert eine Bar verzögert angezeigt und dann auch nicht mehr geändert, so sind Durchbrüche immer klar erkennbar.

strict = false;
bei true muss die Bars für die SwingLine-High vorher immer höhere Hochs als die vorhergehende und die danach immer tiefere Hochs als die vorhergehende.

strict2 = false;
ähnlich wie bei strict, nur das hier dann die Tiefs einer Bar immer höher bzw tiefer sein müssen als bei der verhergehenden Bar


distance = 0.0001;
zusätzliche Distanz der Linie, wird bei der SwingLIne-High draufgeschlagen und bei der SwingLine-Low abgezogen, so haben die Linien etwas zusätzliche Distanz, so können z.B. false breakout bei denen das alte Hoch nur um 1-2 Pips übertroffen werden ausgefiltert werden.

minPercent = 50;
es wird im after Bereich für die SwingLine-High das tiefste Hoch und der Abstand zur Referenzbar ermittelt, und nur wenn der Abstand zwischen Referenzbar und letzter Bar mindestens diesen Prozentwert entspricht wird die SwingLine auch nachgezogen. So wird z.B. etwas Spielraum gelassen wenn ein Trend eine kurze Pause einlegt und kurzzeitig in Gegenrichtung geht.

fastDrawBack = true;
mit der Einstellun true werdem bei Durchbrüchen der Linien diese direkt nachgezogen, anstatt auf die Bestätigung eines neuen Extrems zu warten. Gerade bei Verwendung als Stopsignal ist diese Einstellung wichtig.

Ich habe jetzt meist die Funktion für die SwingLine-High beschrieben, für die SwingLine-Low ist es genauso nur eben andersrum...

hier mal ein paar mögliche Einstellungen:

als Stopsignal für einen Trendfolger mit 2 Pips zusätzlichem Sicherheitsabstand:
extern int       before = 0;
extern int       after = 5;
extern int       shift = 1;
extern bool     strict = false;
extern bool    strict2 = false;
extern double distance = 0.0002;
extern int  minPercent = 50;
extern bool fastDrawBack = true;

Fractalchannel:
extern int       before = 2;
extern int       after = 2;
extern int       shift = 0;
extern bool     strict = false;
extern bool    strict2 = false;
extern double distance = 0.0000;
extern int  minPercent = 0;
extern bool fastDrawBack = true;

Eure Meinung dazu? Natürlich könnt ihr auch gerne eure Konfigurationen als weitere Beispiele posten.

ich werde den Indikator wohl bei einem Trendfolger als Stopindikator einsetzen, also zur Ermittlung des initialen SL und zum nachziehen des SL...   kannst ihn dir ja mal auf nen chart legen und ein wenig mit den Einstellungen rumspielen....  dann sieht man schnell was er kann....