Jump to content
Tom Next - Daytrading Community
  • entry
    1
  • comments
    2
  • views
    10,120

Vorstab gefolgt von Innenstäben


Lobo.Trader

3,865 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

2 Comments


Recommended Comments

der Code wurde ergänzt um eine Trenderkennung nach Kahler .

 

gallery_3578_76_4403.gif

 

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

  • Upvote 2
Link to comment
×
×
  • Create New...