Jump to content






Photo
- - - - -

Vorstab gefolgt von Innenstäben

Posted by Lobo.Trader , 29. October 2011 · 2,081 views

void ArrayFuellen()                              //                                               |
  {                                              //0                                              |
double low1, high1, opn2, cls2, low3, high3     ;// locale Variable                               |
//------------------------------------------------------------------------------------------------+
                                                 //                                               |
for(int i = 1 ; i <= Min1[0][0] ; i++)          {//1                                              |
                                                 //                                               |
Min1[i][0] = iTime(Markt,1,i)                   ;// Eintragen des jeweiligen Bar                  |
Min1[i][1] = iOpen(Markt,1,i)                   ;//                                               |
Min1[i][2] = iLow(Markt,1,i)                    ;//                                               |
Min1[i][3] = iHigh(Markt,1,i)                   ;//                                               |
Min1[i][4] = iClose(Markt,1,i)                  ;//                                               |
Min1[i][5] = iVolume(Markt,1,i)                 ;//                                               |
Min1[i][6] = iBars(Markt,1)-1                  ;}//1                                              |
                                                 //                                               |
for (     i= Min1[0][0]; i>1 ; i--)             {//1Innenstäbe suchen                             |
   low1 = Min1[i][2] ; high1 = Min1[i][3]       ;// Low & High des möglichen Vorstab              |
                                                 //                                               |
   for ( int j= i-1; j>0 ; j--)                 {//2die folgenden Stäbe vergleichen               |
      opn2 = Min1[j][1];cls2 = Min1[j][4]       ;// Open und Close des möglichen Innenstabes      |
      if ((( low1 < opn2) && (low1 < cls2)) &&   // wenn Open und Close des untersuchten Stabes   |
          (( high1 > opn2) && (high1 > cls2)))  {//3zwischen Hgh und Low des Referenzstabes, dann |
                                                 // ist es ein Innenstab zu (i)                   |
          Min1[i][7] = 1;Min1[j][8] = 1         ;// Flag für Vorstab und Innenstab eintragen      |
                                                }//3                                              |
      if (!((( low1 < opn2) && (low1 < cls2)) && // wenn Open und Close des untersuchten Stabes   |
          (( high1 > opn2) && (high1 > cls2)))) {//3zwischen Hgh und Low des Referenzstabes, dann |
          i = j+1                               ;// Zeiger nachziehen                             |
          break                                ;}//3                                              |
                                                }//2"for j" es handelt sich um einen NormalBar    |
                                                }//1"for i"                                       |
                                                 //                                               |
//------------------------------------------------------------------------------------------------+   
   return                                       ;//                                               |
  }                                              //0                                              |
//------------------------------------------------------------------------------------------------+

In Min1[0][0] ist die Adresse der letzten Zeile enthalten .

Es wird ein Array gefüllt und anschliessend nach Innenstäben durchsucht . Der erste Stab, dem dann
die Innenstäber folgen, wird in der Spalte [7] markiert, die Innenstäbe dann in der Spalte [8] .

Lobo

  • 4



Photo
Lobo.Trader
09. November 2011
der Code sieht dann im Chart so aus

Posted Image
    • 0
  • Report
Photo
Lobo.Trader
16. November 2011
der Code wurde ergänzt um eine Trenderkennung nach Kahler .

Posted Image

Der Kennung dazu :

//+-----------------------------------------------------------------------------------------------+
//|                            ___________TrendDefinition.mqh  V 4.2.                             |
//|                           The code should be used for   EA   only                             |
//+-----------------------------------------------------------------------------------------------+
//+-----------------------------------------------------------------------------------------------+
//|   Function  : Trenderkennung nach Kahler                                                      |
//|                                                                                               |
//+-----------------------------------------------------------------------------------------------+
                                                 //                                               |
void DefTrend(int TF,int Br,double hgh3,double hgh2,double hgh1,double low3   ,//                 |
              double low2,double low1)           //0                                              |
{                                                //                                               |
bool SwingHigh , SwingLow , OutsideBar          ;//                                               |
//+-----------------------------------------------------------------------------------------------+
                                                 // "Oben" == Swing to Short                      |
    if ( hgh1 < hgh2 && hgh2 > hgh3 )            // wenn vorletzte High ein Maximum gewesen ist   |
      SwingHigh = true                          ;// dann zuweisen                                 |
     else                                        //                                               |
      SwingHigh = false                         ;// eindeutig verneinen                           |
//+-----------------------------------------------------------------------------------------------+
                                                 // "Unten" == Swing to Long                      |
    if ( low3 > low2 && low2 < low1 )            // wenn vorletzte Low ein Minimum gewesen ist    |
      SwingLow = true                           ;// dann zuweisen                                 |
     else                                        //                                               |
      SwingLow = false                          ;// eindeutig verneinen                           |
//+-----------------------------------------------------------------------------------------------+
                                                 // " Oben & unten " == Aussenstab                |
    if ((hgh2 > hgh3) && (low2 < low3))          // wenn ein Max und ein Min erkannt wurde,       |
       OutsideBar = true                        ;// dann zuweisen                                 |
     else                                        //                                               |
       OutsideBar = false                       ;// eindeutig verneinen                           |
//+-----------------------------------------------------------------------------------------------+
switch(TF)                                      {//1                                              |
  case 240:                                      //                                               |
    if (SwingHigh && (Min240[Br-1][8]==0))      {//2 Ein Max gefunden und es ist kein Innenstab   |
      Min240[Br-1][9]= -1                      ;}//2 der Shorttrend beginnt nun                   |
    if (SwingLow && (Min240[Br-1][8]==0))       {//2 Ein Min gefunden und es ist kein Innenstab   |
      Min240[Br-1][9]=  1                      ;}//2 der Longtrend beginnt nun                    |
    if (OutsideBar && (Min240[Br-1][4]>Min240[Br-1][1])) // grüner OutsideBar                     |
                    Min240[Br-1][10]= 1         ;//  positiver Flag für grünen OB                 |
    if (OutsideBar && (Min240[Br-1][4]<Min240[Br-1][1])) // roter OutsideBar                      |
                    Min240[Br-1][10]= - 1       ;//  negativer Flag für roten OB                  |
   break                                        ;//                                               |
  default:break                                ;}//1                                              |
//+-----------------------------------------------------------------------------------------------+
 return                                         ;//                                               |
}                                                //0Exit the user-defined function                |
//------------------------------------------------------------------------------------------------|

Der Code ist in einer Include, denn er soll als Modul in einen anderen EA integriert werden .

Mit dem Ergebniss bin ich nicht zufrieden . Ich werde einen weiteren Algorythmus definieren müssen, der mir mehr Stetigkeit in den ansonsten recht trendtreuen Markt des AUDUSD bringt .

Vermutlich sind die wunderschönen Beispielbilder in Kahler´s Buch in einem anderen Markt mit weniger Kanälen (Innenstäbe) entstanden .

Lobo
    • 0
  • Report

December 2018

M T W T F S S
     12
3456789
10 11 1213141516
17181920212223
24252627282930
31      

Recent Comments

Recent Entries

0 user(s) viewing

0 members, 0 guests, 0 anonymous users

My Gallery Albums

Random Album Image

Trenderkennung ergänzt

Categories

Tags

    Twitter

    Latest Visitors

    • 28. Aug 2017 - 16:00 Uhr
    • 18. Jun 2016 - 20:19 Uhr
    • Photo
      Zahnstocher
      27. Feb 2014 - 21:50 Uhr
    • Photo
      endrusin
      14. Oct 2013 - 11:51 Uhr
    • Photo
      stefan
      09. Mar 2013 - 18:03 Uhr

    Digg