Zum Inhalt springen
View in the app

A better way to browse. Learn more.

#T/N/X/T

A full-screen app on your home screen with push notifications, badges and more.

To install this app on iOS and iPadOS
  1. Tap the Share icon in Safari
  2. Scroll the menu and tap Add to Home Screen.
  3. Tap Add in the top-right corner.
To install this app on Android
  1. Tap the 3-dot menu (⋮) in the top-right corner of the browser.
  2. Tap Add to Home screen or Install app.
  3. Confirm by tapping Install.

Verbindung von Indikatoren

Geschrieben

Hallo Leute,
ich hoffe ihr könnt mir weiterhelfen http://www.expert-advisor.com/forum/images/smilies/smile.gif

 

1) Ich versuche - nun schon seit Tagen - auf einen gleitenden Durchschnitt den Aroon Oszillator anzuwenden.

Einen programmierten Aroon Oszillator zu finden war nicht schwer, allerdings bezieht sich er natürlich auf den aktuellen Kurs.

 

Der Code des Aroon Oszillator ist:

//+------------------------------------------------------------------+
//| Custom Aroon Oscillator_v1.mq4 |
//| rafcamara | 
//| Has corrected - Ramdass |
//+------------------------------------------------------------------+
#property copyright "rafcamara"
#property link "rafcamara@yahoo.com"
//---- indicator settings
#property indicator_separate_window
#property indicator_buffers 4
#property indicator_color1 DodgerBlue
#property indicator_color2 Red
#property indicator_color3 Snow
#property indicator_color4 Green
//---- indicator parameters
extern int AroonPeriod = 10;
extern int Filter = 50;
extern int CountBars = 300;
//---- indicator buffers
double ind_buffer1[];
double ind_buffer2[];
double ind_buffer3[];
double HighBarBuffer[];
double LowBarBuffer[];
double ArOscBuffer[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
//---- additional buffers are used for counting.
IndicatorBuffers(6);
SetIndexBuffer(4, HighBarBuffer);
SetIndexBuffer(5, LowBarBuffer);
SetIndexBuffer(3, ArOscBuffer);
SetIndexBuffer(0, ind_buffer1);
SetIndexBuffer(1, ind_buffer2);
SetIndexBuffer(2, ind_buffer3);
//---- drawing settings
SetIndexStyle(0, DRAW_HISTOGRAM, STYLE_SOLID, 1);
SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 1);
SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, 1);
SetIndexStyle(3, DRAW_LINE, STYLE_SOLID, 1);
//----
IndicatorDigits(0);
//-- indicator buffers mapping
if(!SetIndexBuffer(0, ind_buffer1) && !SetIndexBuffer(1, ind_buffer2)
&& !SetIndexBuffer(2, ind_buffer3))
Print("cannot set indicator buffers!");
//---- name for DataWindow and indicator subwindow label
IndicatorShortName("AroonOsc_v1 (" + AroonPeriod + ", " + Filter + ")");
//---- initialization done
return(0);
}
//+------------------------------------------------------------------+
//| Aroon Oscilator |
//+------------------------------------------------------------------+
int start()
{
if(CountBars >= Bars) 
CountBars=Bars;
SetIndexDrawBegin(0, Bars - CountBars + AroonPeriod + 1);
SetIndexDrawBegin(1, Bars - CountBars + AroonPeriod + 1);
SetIndexDrawBegin(2, Bars - CountBars + AroonPeriod + 1);
SetIndexDrawBegin(3, Bars - CountBars + AroonPeriod + 1);
double ArOsc, HighBar = 0, LowBar = 0;
int ArPer; 
int limit, i;
// bool up,dn;
int counted_bars = IndicatorCounted();
//----
ArPer = AroonPeriod;
//---- check for possible errors
if(counted_bars < 0) 
return(-1);
//---- initial zero
if(counted_bars < 1)
{
for(i = 1; i <= ArPer; i++) 
HighBarBuffer[CountBars-i] = 0.0;
for(i = 1; i <= ArPer; i++) 
LowBarBuffer[CountBars-i] = 0.0;
for(i = 1; i <= ArPer; i++) 
ArOscBuffer[CountBars-i] = 0.0;
for(i = 1; i <= ArPer; i++) 
ind_buffer1[CountBars-i] = 0.0;
for(i = 1; i <= ArPer; i++) 
ind_buffer2[CountBars-i] = 0.0;
for(i = 1; i <= ArPer; i++) 
ind_buffer3[CountBars-i] = 0.0;
} 
//---- last counted bar will be recounted
//if(counted_bars>0) counted_bars--;
limit = CountBars - AroonPeriod;
//----Calculation---------------------------
for(i = 0; i < limit; i++)
{
HighBarBuffer[i] = Highest(NULL, 0, MODE_HIGH, ArPer, i); //Periods from HH 
LowBarBuffer[i] = Lowest(NULL, 0, MODE_LOW, ArPer, i);	 //Periods from LL
ArOscBuffer[i] = 100*(LowBarBuffer[i] - HighBarBuffer[i]) / ArPer;	 //Short formulation
}
//---- dispatch values between 2 buffers
for(i = limit - 1; i >= 0; i--)
{
ArOsc=ArOscBuffer[i];
if(ArOsc > Filter)
{
ind_buffer1[i] = ArOsc;
ind_buffer2[i] = 0.0;
ind_buffer3[i] = 0.0; 
} 
if(ArOsc < -Filter)
{
ind_buffer1[i] = 0.0;
ind_buffer2[i] = ArOsc;
ind_buffer3[i] = 0.0;
}
if(ArOsc <= Filter && ArOsc >= -Filter)
{
ind_buffer1[i] = 0.0;
ind_buffer2[i] = 0.0;
ind_buffer3[i] = ArOsc;
} 
}
//---- done
return(0);
}
//+------------------------------------------------------------------+

 

Nun finde ich - da ich außer euren kleinen Thread zu MQL4 keine wirkliche Erfahrung habe - keine Variable wo auf Kursdaten zugegriffen wird - die man entsprechend auf den Gleitenden Durchschnitt ändern muss.

 

Oder sind

IndicatorBuffers(6);
SetIndexBuffer(4, HighBarBuffer);
SetIndexBuffer(5, LowBarBuffer);
SetIndexBuffer(3, ArOscBuffer);
SetIndexBuffer(0, ind_buffer1);
SetIndexBuffer(1, ind_buffer2);
SetIndexBuffer(2, ind_buffer3);

die Variablen? Dieser Buffer verwirrt mich :D

Müssen die beiden Indikatoren (MA3gr und Aroon Oszillator) dann auch in einer Code-Datei liegen oder kann ein Code auf die Ergebnisse eines anderen Codes zugreifen?

 

2) Zusätzlich will ich danach die Inverse Fisher Transformation auf den Aroon Oszillator anwenden.

 

Alle Dateien findet Ihr im Anhang.


Kann mir da jemand weiterhelfen? http://www.expert-advisor.com/forum/images/smilies/smile.gif

Über Hilfe würde ich mich wirklich sehr sehr freuen! http://www.expert-advisor.com/forum/images/smilies/smile.gif

Indikatoren.zip

Featured Replies

Geschrieben

Hallo und willkommen bei Tom-Next,

 

ich versuche es mal der Reihe nach:

1. Was bedeutet dieser code:

 

IndicatorBuffers(6);

SetIndexBuffer(4, HighBarBuffer);

SetIndexBuffer(5, LowBarBuffer);

SetIndexBuffer(3, ArOscBuffer);

SetIndexBuffer(0, ind_buffer1);

SetIndexBuffer(1, ind_buffer2);

SetIndexBuffer(2, ind_buffer3);

Ein Indikator besteht aus mehreren "Buffern" in die Werte geschrieben werden können. Ein Buffer ist hier nichts anderes als eine Liste von Werten wobei jedem Bar im Chart genau 1 Wert zugeordnet ist. Diese werden dann verwendet um den Indikator zu zeichnen. Wie genau sie verwendet werden wird extra definiert.

 

Im Code hier wird zuerstmal festgelegt das dieser Indikator 6 Buffer verwendet. D.h. für jeden Bar im Chart gibt der Indikator 6 Werte an.

 

Damit man jetzt für jeden Bar einen Wert zuweisen kann, muss man die entsprechende Datenstruktur haben. In MQL4 läuft das über Arrays. Weiter oben im Code werden die 6 Arrays für die Buffer deklariert:

 

 

//---- indicator buffers

double ind_buffer1[];

double ind_buffer2[];

double ind_buffer3[];

double HighBarBuffer[];

double LowBarBuffer[];

double ArOscBuffer[];

 

Man beachte das hier keine Größenangabe vorkommt. Durch das verknüpfen des Arrays mit dem Buffer:

 

SetIndexBuffer(4, HighBarBuffer);

SetIndexBuffer(5, LowBarBuffer);

SetIndexBuffer(3, ArOscBuffer);

SetIndexBuffer(0, ind_buffer1);

SetIndexBuffer(1, ind_buffer2);

SetIndexBuffer(2, ind_buffer3);

Kümmert sich MQL4 selbst darum das die Arrays die richtige Größe haben und bei neuen Bars die Werte entsprechend umpositioniert werden. In der start() funktion des Indikators ist garantiert das wir zB mit

 

ind_buffer1[barOffset]

immer Zugriff auf denBufferwert beim Bar mit Offset "BarOffset" haben.

 

2. Wo wird im Aroon auf den aktuellen Kurs zugegriffen:

 

Genau genommen nur in 2 Zeilen:

 

 

HighBarBuffer[i] = Highest(NULL, 0, MODE_HIGH, ArPer, i); //Periods from HH

LowBarBuffer[i] = Lowest(NULL, 0, MODE_LOW, ArPer, i); //Periods from LL

 

Hier wird der entsprechende Buffer auf das HighestHigh bzw. LowestLow der letzen ArPer-Bars gesetzt. Im weiteren Verlauf werden diese 2 Bufferwerte dann weiterverwendet, aber hier ist der einzige Zugriff auf den aktuellen Kurs.

 

Um hier nicht das Höchste Hoch des Kurses sondern eines eigenen Arrays zu erhalten verwendet man am Besten

http://docs.mql4.com/array/ArrayMaximum bzw. für das LowestLow http://docs.mql4.com/array/ArrayMinimum

 

3. Fisher:

 

Hier ist der Zugriff auf den Kurs in dieser Zeile:

 

 

for (int i = limit; i >= 0; i--) wma0[i] = iMA(NULL, 0, 2, 0, MODE_LWMA, PRICE_CLOSE, i);

indem der LWMA auf den Price Close angewendet wird.

Hier müsste man stattdessen mittels http://docs.mql4.com/indicators/imaonarray den WMA des gewünschten Arrays verwenden.

 

hth

 

Geschrieben
  • Autor

Vielen Dank für die Ausführliche Antwort!

 

Teste ich heute Abend gleich :-)

Müssen die drei Codes in eine Datei gepackt werden, oder können sie auch so auf die jeweiligen Daten zugreifen?

Geschrieben

Hi,

 

mMn die beste Variante ist es jeweils einen indikator zu machen der ggf. auf den anderen über iCustom zugreift. Also einen eigenen Aroon machen der auf den MA zugreift (hier benötigst du kein iCustom) und dann einen eigenen Fisher der über iCustom auf den eigenen Aroon zugreift.

Geschrieben
  • Autor

Warum braucht man für den Zugriff auf den MA kein iCustom? Es ist doch auch ein eigener / selbst Erstellter Indikator?

 

Danke weiterhin :-)

Geschrieben
  • Autor

Aroon Oscillator:

 

Hätte ich einfach so umgesetzt:

for(i = 0; i < limit; i++)
      {
  	     HighBarBuffer[i] = int ArrayMaximum(double array[MA3G], int count=WHOLE_ARRAY, int start=0);  //Periods from HH	   
  	     LowBarBuffer[i] = int ArrayMinimum(double array[MA3G], int count=WHOLE_ARRAY, int start=0);		//Periods from LL
  	     ArOscBuffer[i] = 100*(LowBarBuffer[i] - HighBarBuffer[i]) / ArPer;		//Short formulation
      }

Allerdings wird im alten Code ...

HighBarBuffer[i] = Highest(NULL, 0, MODE_HIGH, ArPer, i)

... noch "ArPer" berücksichtigt, was wohl laut dem Code...

extern int AroonPeriod = 10;

ArPer = AroonPeriod;

... die Zeitspanne ist auf die sich der Aroon Oscillator beziehen soll.

 

Muss ich die nicht auch noch einbauen, und anstatt dem "WHOLE_ARRAY" die "ArPer" Variable einfügen?

Ist die Bezeichnung des MA im Array mit "MA3G" richtig?

 

Fischer

 

Hätte ich so umgesetzt:

wma0 = double iMAOnArray( double array[ArOsc], int 0, int 2, int 0, int MODE_LWMA, int i);

 

Inwiefern binde ich da iCustom noch mit ein? Einfach davor setzen?

Stimmt die Variable "ArOsc"?

 

 

Danke Danke Danke für die weitere Hilfe! :)

Geschrieben

Grüß Dich, @ Arvidsson und herzlich Willkommen bei uns .

 

Unser Mythos sitzt vermutlich gerade vor dem TV und schüttelt verwundert den Kopf ( aktuell 0 : 1 , armer Mythos friends.gif ... aber da kommt ja noch eine 2.Hälfte kb-smile.gif )

 

Auch ich sitze vor dem TV , aber eben entspannter (NOCH) , und kann daher zwischendurch neue Post´s scannen & ggfs antworten .

 

Hier in diesem Fall geht das , ich habe eine Antwort :

 

iCustom dient dazu, einen Indi, der in derselben MT4-Installation aber als ein seperater Indikator in einer eigener Datei abgelegt wurde, zu nutzen .

Also ruft ein Indi einen anderen Indi auf (iCustom) , "befragt" diesen und nimmt dann dessen Antwort entgegen um nun selber mit dieser Antwort weiter zu arbeiten .

 

Der MA, ist ein Indikator der unter einem einzelnen Befehlt verborgen ist und daher als Befehl in Deinen Code direkt eingebettet ist . "iMA"

http://docs.mql4.com/indicators/iMA

 

Er findet sich in der Liste der technischen Indikatoren des MQL4 Handbuches : http://docs.mql4.com/indicators

 

Oder in anderen Worten : Sehr bekannte Indis wurden vorgecodet und können mit Befehlen aufgerufen werden . Ist es aber eine Eigenentwicklung, etwas ganz spezifisches, dann codet man diesen Indi seperat und nutzt dann iCustom um den Eigenbau-Indi aufzurufen .

Persönlich nutze ich iCustom dann, wenn ich mehrere Indi´s verkoppele und diese dann ein einzelnes Signal abgeben (Flag) .

 

Hoffe hilft

KB

Geschrieben
  • Autor

Danke für die Antwort :)

Allerdings ist mein MA kein "gewöhnlicher" MA sondern ein abgeänderter - womit ich nach deiner Erklärung auch hier den iCustomer benutzen muss.

 

Nur wie genau weiß ich noch nicht kb-smile.gif

Geschrieben

Jein, ich war vorm Fernseher, aber hab nicht fußball gschaut. 0:1 klingt jetzt eh no nit so schlimm :D

 

@Arvidsson: Du vermischt hier die Deklaration einer Funktion und ihren aufruf.

int ArrayMaximum(double array[], int count=WHOLE_ARRAY, int start=0)
ist die Deklaration, sie gibt an das diese Funktion einen int-Wert zurückgibt, und als Parameter ein double-array (wegen den [] nicht wegen dem Wort "array"), einen int und noch einen int will. Zusätzlich haben Parameter 2 und 3 jeweils einen Defaultwert der verwendet wird wenn er im Code weggelassen wird.

 

Beim Funktionsaufruf schreibst du die Datentypen (int,double,...) nicht mehr dazu und auch die Defaultwerte gehören hier nicht mehr hin.

Details dazu gibt es hier: http://book.mql4.com/basics/functions

 

Um den MA in deinen Aroon zu bringen würde ich folgende Vorgehensweise vorschlagen:

Der Indikator erhält einen weiteren Buffer der die MA-Werte enthält. Sprich bei jedem start() musst du für die geänderten Bars den MA-Wert (per iMA) in das entsprechende Buffer-array schreiben

Von diesem Buffer-array kannst du dann mittels bufferArray[ArrayMaximum(bufferArray,ArPer,barOffset)] das Maximum bzw. entsprechend das Minimum für den Bereich ausrechnen mit dem er Aroon dann arbeiten kann.

 

bzgl. Fisher:

gleiches Thema, schau dir am besten nochmal die Kapitel über Arrays und Funktionen durch, dann erklärt sich vieles von allein.

 

hth

 

Edit: ja wenn du einen selbstgeschriebenen Indikator statt dem "StandardMA" verwenden willst, musst du ihn via iCustom einbinden. Details zu iCustom: http://docs.mql4.com/indicators/icustom

Geschrieben
  • Autor

So, habe mir jetzt die Seiten zu Function und Arrays durchgelesen. Mag am Englisch liegen, aber oft habe ich nur Bahnhof verstanden kb-smile.gif white_flag.gif

 

Trotzdem habe ich versucht, das umzusetzen was du mir gesagt hast.

Der komplette Code lautet nun:

bullet_go.png

 
//+------------------------------------------------------------------+
//|                                  Custom Aroon Oscillator_v1.mq4  |
//|                                                       rafcamara  | 
//|                                         Has corrected - Ramdass  |
//+------------------------------------------------------------------+
#property  copyright "rafcamara"
#property  link      "rafcamara@yahoo.com"
//---- indicator settings
#property  indicator_separate_window
#property  indicator_buffers 4
#property  indicator_color1  DodgerBlue
#property  indicator_color2  Red
#property  indicator_color3  Snow
#property  indicator_color4  Green
//---- indicator parameters
extern int AroonPeriod = 10;
extern int Filter = 50;
extern int CountBars = 300;
//---- indicator buffers
double     ind_buffer1[];
double     ind_buffer2[];
double     ind_buffer3[];
double     HighBarBuffer[];
double     LowBarBuffer[];
double     ArOscBuffer[];
double     MABuffer[];
 
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
    //---- additional buffers are used for counting.
    IndicatorBuffers(6);
    SetIndexBuffer(4, HighBarBuffer);
    SetIndexBuffer(5, LowBarBuffer);
    SetIndexBuffer(3, ArOscBuffer);
    SetIndexBuffer(0, ind_buffer1);
    SetIndexBuffer(1, ind_buffer2);
    SetIndexBuffer(2, ind_buffer3);
    //---- drawing settings
    SetIndexStyle(0, DRAW_HISTOGRAM, STYLE_SOLID, 1);
    SetIndexStyle(1, DRAW_HISTOGRAM, STYLE_SOLID, 1);
    SetIndexStyle(2, DRAW_HISTOGRAM, STYLE_SOLID, 1);
    SetIndexStyle(3, DRAW_LINE, STYLE_SOLID, 1);
//----
    IndicatorDigits(0);
    //-- indicator buffers mapping
    if(!SetIndexBuffer(0, ind_buffer1) && !SetIndexBuffer(1, ind_buffer2)
    && !SetIndexBuffer(2, ind_buffer3))
        Print("cannot set indicator buffers!");
    //---- name for DataWindow and indicator subwindow label
    IndicatorShortName("AroonOsc_v1 (" + AroonPeriod + ", " + Filter + ")");
    //---- initialization done
    return(0);
  }
//+------------------------------------------------------------------+
//| Aroon Oscilator                                                  |
//+------------------------------------------------------------------+
int start()
  {
    if(CountBars >= Bars) 
        CountBars=Bars;
    SetIndexDrawBegin(0, Bars - CountBars + AroonPeriod + 1);
    SetIndexDrawBegin(1, Bars - CountBars + AroonPeriod + 1);
    SetIndexDrawBegin(2, Bars - CountBars + AroonPeriod + 1);
    SetIndexDrawBegin(3, Bars - CountBars + AroonPeriod + 1);
    double   ArOsc, HighBar = 0, LowBar = 0;
    int      ArPer; 
    int      limit, i;
    // bool     up,dn;
    int counted_bars = IndicatorCounted();
    //----
    ArPer = AroonPeriod;
    //---- check for possible errors
    if(counted_bars < 0) 
        return(-1);
    //---- initial zero
    if(counted_bars < 1)
      {
        for(i = 1; i <= ArPer; i++) 
            HighBarBuffer[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            LowBarBuffer[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ArOscBuffer[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ind_buffer1[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ind_buffer2[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ind_buffer3[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            MABuffer[CountBars-i] = 0.0;
      } 
    //---- last counted bar will be recounted
    //if(counted_bars>0) counted_bars--;
    limit = CountBars - AroonPeriod;
    //----Calculation---------------------------
    for(i = 0; i < limit; i++)
      {
        MABuffer[i] = iCustom(NULL, 0, "3rdGenMA",89,21,3,5, 0, 0);
      HighBarBuffer[i] = MABuffer[ArrayMaximum(MABuffer,ArPer,barOffset)]; //Periods from HH     
      LowBarBuffer[i] = MABuffer[ArrayMinimum(MABuffer,ArPer,barOffset)]; //Periods from LL
      ArOscBuffer[i] = 100*(LowBarBuffer[i] - HighBarBuffer[i]) / ArPer; //Short formulation
      }
    //---- dispatch values between 2 buffers
    for(i = limit - 1; i >= 0; i--)
      {
        ArOsc=ArOscBuffer[i];
        if(ArOsc > Filter)
          {
            ind_buffer1[i] = ArOsc;
            ind_buffer2[i] = 0.0;
            ind_buffer3[i] = 0.0;      
          }       
        if(ArOsc < -Filter)
          {
            ind_buffer1[i] = 0.0;
            ind_buffer2[i] = ArOsc;
            ind_buffer3[i] = 0.0;
          }
        if(ArOsc <= Filter && ArOsc >= -Filter)
          {
            ind_buffer1[i] = 0.0;
            ind_buffer2[i] = 0.0;
            ind_buffer3[i] = ArOsc;
          }  
      }
    //---- done
    return(0);
  }
//+------------------------------------------------------------------+

Was ich geändert habe:

1) Es wird ein weiterer Buffer namens "MABuffer" definiert

double     MABuffer[];
2) Nach int start() wird der Buffer - wie alle anderen auch - auf 0 gesetzt. Allerdings bleibt wohl der letzte Wert erhalten. Ich denke der MABuffer muss für die neuen Werte auch auf 0 gesetzt werden?
 
for(i = 1; i <= ArPer; i++) 
            MABuffer[CountBars-i] = 0.0;
3) Der MABuffer bekommt seine Werte mithilfe des iCustom aus dem 3rdGenMA-Script.
 
for(i = 0; i < limit; i++)
      {
        MABuffer[i] = iCustom(NULL, 0, "3rdGenMA",89,21,3,5, 0, 0);
4) Die High/LowBarBuffer berechnen sich nun aus den Maximum/Minimum des erstellen MABuffers. Ich habe das "bufferArray" jeweils durch den Namen des Buffers "MABuffer" ersetzt. Ich hoffe das war richtig?
 
for(i = 0; i < limit; i++)
      {
        MABuffer[i] = iCustom(NULL, 0, "3rdGenMA",89,21,3,5, 0, 0);
      HighBarBuffer[i] = MABuffer[ArrayMaximum(MABuffer,ArPer,barOffset)]; //Periods from HH     
      LowBarBuffer[i] = MABuffer[ArrayMinimum(MABuffer,ArPer,barOffset)]; //Periods from LL
      ArOscBuffer[i] = 100*(LowBarBuffer[i] - HighBarBuffer[i]) / ArPer; //Short formulation
      }

Ich hoffe wenigstens dass ich nicht alles falsch gemacht habe. blush.png

Sorry dass ich mich so anstelle deng.gif scare3.gif

Bearbeitet von Mythos
quote tags in code tags geändert

Geschrieben

Es sieht auf jeden Fall schon viel richtiger aus ;)

Ein paar Punkte hast du noch übersehen:

  • der MABuffer muss auch noch als Indexbuffer gesetzt werden damit sich MQL um die Größe und Reihung kümmert. Also IndicatorBuffers(7) und mittels SetIndexBuffer setzen.
  • beim aufruf von iCustom hast du den Offset vergessen (Ist glaub ich der letzte Parameter). Der Indikator wird immer "am aktuellen Bar" aufgerufen, und berechnet die Werte für alle Bars der Vergangenheit die sich geändert haben. IN der aktuellen Form würdest du für die gesamte History den MAWert des aktuellen Bars verwenden
  • Bei ArrayMax und ArrayMin verwendest du barOffset was nicht definiert ist, ich vermute du meinst hier "i"

Sorry dass ich mich so anstelle

Kein Problem, jeder hat einmal angefangen ;)

 

hth

Geschrieben
  • Autor

Next try grin.gif

 

1. MABuffer wird definiert

double     ind_buffer1[];
double     ind_buffer2[];
double     ind_buffer3[];
double     HighBarBuffer[];
double     LowBarBuffer[];
double     ArOscBuffer[];
double     MABuffer[];

2. MABuffer wird als IndexBuffer gesetzt

 //---- additional buffers are used for counting.
    IndicatorBuffers(7);
    SetIndexBuffer(4, HighBarBuffer);
    SetIndexBuffer(5, LowBarBuffer);
    SetIndexBuffer(3, ArOscBuffer);
    SetIndexBuffer(0, ind_buffer1);
    SetIndexBuffer(1, ind_buffer2);
    SetIndexBuffer(2, ind_buffer3);
    SetIndexBuffer(6, MABuffer);

3. Buffer werden auf 0 gesetzt

 if(counted_bars < 1)
      {
        for(i = 1; i <= ArPer; i++) 
            HighBarBuffer[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            LowBarBuffer[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ArOscBuffer[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ind_buffer1[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ind_buffer2[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            ind_buffer3[CountBars-i] = 0.0;
        for(i = 1; i <= ArPer; i++) 
            MABuffer[CountBars-i] = 0.0;
      } 

4. MABuffer wird aus 3rdGenMA befüllt und daraus wird Max/Min bestimmt

//----Calculation---------------------------
    for(i = 0; i < limit; i++)
      {
        MABuffer[i] = iCustom(NULL, 0, "3rdGenMA",89,21,3,5, 0, i);
  	     HighBarBuffer[i] = MABuffer[ArrayMaximum(MABuffer,ArPer,i)]; 	//Periods from HH  	   
  	     LowBarBuffer[i] = MABuffer[ArrayMinimum(MABuffer,ArPer,i)];		//Periods from LL
  	     ArOscBuffer[i] = 100*(LowBarBuffer[i] - HighBarBuffer[i]) / ArPer;		//Short formulation
      }

-> Das barOffset habe ich von dir übernommen gehabt (bufferArray[ArrayMaximum(bufferArray,ArPer,barOffset)]). Wusste nicht was das bedeutet noidea.gif Habe nun für iCustom am Ende auch "i" genommen.

In der Erklärung (F1) steht, dass die letzte Variable shift (Index of the value taken from the indicator buffer (shift relative to the current bar the given amount of periods ago)) ist. Also müsste es ja mit "i" passen, dass er immer nur den aktuellen nimmt - oder? blush.png

Geschrieben
  • Autor

Habe nur den Compiler drüberlaufen lassen - der hat jedenfalls keinen Fehler gemeldet.

Testen kann ich es leider erst am Montag, da ich bis dahin unterwegs bin.

 

Dann mal zum Fischer

bullet_go.png


//+------------------------------------------------------------------+
//|                        Smoothed RSI Inverse Fisher Transform.mq4 |
//|                                     © 2011 MaryJane@ForexFactory |
//|   Indicator formula © 2010 Sylvain Vervoort, http://stocata.org/ |
//+------------------------------------------------------------------+

#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Blue
#property indicator_width1 3
#property indicator_level1 12
#property indicator_level2 88
#property indicator_levelcolor DarkGray
//--- input parameters
extern int       RsiPeriod=4;
extern int       EmaPeriod=4;
//--- buffers
double wma0[], wma1[], wma2[], wma3[], wma4[], wma5[], wma6[], wma7[], wma8[], wma9[];
double ema0[], ema1[], rainbow[], rsi[], srsi[], fish[];
int OldTime, OldBars;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
   {
//---- indicators
   IndicatorBuffers(6); 
   SetIndexStyle(0, DRAW_LINE);
   SetIndexBuffer(0, fish);
   SetIndexBuffer(1, rainbow);
   SetIndexBuffer(2, rsi);
   SetIndexBuffer(3, ema0);
   SetIndexBuffer(4, ema1);
   SetIndexBuffer(5, srsi);
//---- reset counters   
   OldTime = 0; OldBars = 0;
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
   {
//----
   
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
   {
   int counted_bars = IndicatorCounted();
   if (counted_bars < 0) return (-1);
   if (counted_bars > 0) counted_bars--;
   int limit = Bars - 1 - counted_bars;
//---- resize/shift extra buffers on first and every next bar
   if (Time[0] != OldTime) SyncExtraBuffers();
//---- prepare partial averages
   for (int i = limit; i >= 0; i--) wma0[i] = iMA(NULL, 0, 2, 0, MODE_LWMA, PRICE_CLOSE, i);
   for (i = limit; i >= 0; i--) wma1[i] = iMAOnArray(wma0, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma2[i] = iMAOnArray(wma1, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma3[i] = iMAOnArray(wma2, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma4[i] = iMAOnArray(wma3, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma5[i] = iMAOnArray(wma4, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma6[i] = iMAOnArray(wma5, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma7[i] = iMAOnArray(wma6, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma8[i] = iMAOnArray(wma7, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma9[i] = iMAOnArray(wma8, 0, 2, 0, MODE_LWMA, i);
//---- weigh the averages
   for (i = limit; i >= 0; i--)
      {
      double rb_val =  5 * wma0[i] + 4 * wma1[i] + 3 * wma2[i] + 2 * wma3[i] + wma4[i] + wma5[i] + wma6[i] + wma7[i] + wma8[i] + wma9[i];
      rb_val /= 20;
      rainbow[i] = rb_val;
      }
//---- calculate rsi from rainbow smoothed price curve 
   for (i = limit; i >= 0; i--) rsi[i] = 0.1 * (iRSIOnArray(rainbow, 0, RsiPeriod, i) - 50);
//---- smooth the rsi with Vervoort zero lag MA
   for (i = limit; i >= 0; i--) ema0[i] = iMAOnArray(rsi, 0, EmaPeriod, 0, MODE_EMA, i);
   for (i = limit; i >= 0; i--) ema1[i] = iMAOnArray(ema0, 0, EmaPeriod, 0, MODE_EMA, i);
   for (i = limit; i >= 0; i--) srsi[i] = ema0[i] + (ema0[i] - ema1[i]);
//---- do the fish
   for (i = limit; i >= 0; i--) fish[i] = ((MathExp(2 * srsi[i]) - 1) / (MathExp(2 * srsi[i]) + 1) + 1) * 50;
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Shift array elements without having to do it one-by-one          |
//+------------------------------------------------------------------+
void SyncExtraBuffers()
   {
   if (OldBars == Bars)
//---- if Bars = MaxBarsOnChart, arrays wouldn't resize & shift below
//---- we have to shrink them a bit, one bar does.
      {
      ArrayResize(wma0, Bars - 1);
      ArrayResize(wma1, Bars - 1);
      ArrayResize(wma2, Bars - 1);
      ArrayResize(wma3, Bars - 1);
      ArrayResize(wma4, Bars - 1);
      ArrayResize(wma5, Bars - 1);
      ArrayResize(wma6, Bars - 1);
      ArrayResize(wma7, Bars - 1);
      ArrayResize(wma8, Bars - 1);
      ArrayResize(wma9, Bars - 1);
      }
//---- on first Start(), when Time[0] != 0, this will give an init size to arrays and
//---- set them as Series (because of iMAOnArray and iRSIOnArray). Hence nothing
//---- in init() as this place will be visited first in any case.
//---- The flip trick below is necessary on further resizing/shifting since ArrayResize()
//---- adds/removes elements on the LEFT SIDE if set as Series so arrays wouldn't shift
//---- and it would be necessary to do a for (n=Bars-1; n>=0; n--){wmaX[n+1]=wmaX[n];}
//---- ten times on every new bar. this is much quicker.
   ArraySetAsSeries(wma0, false); ArrayResize(wma0, Bars); ArraySetAsSeries(wma0, true);
   ArraySetAsSeries(wma1, false); ArrayResize(wma1, Bars); ArraySetAsSeries(wma1, true);
   ArraySetAsSeries(wma2, false); ArrayResize(wma2, Bars); ArraySetAsSeries(wma2, true);
   ArraySetAsSeries(wma3, false); ArrayResize(wma3, Bars); ArraySetAsSeries(wma3, true);
   ArraySetAsSeries(wma4, false); ArrayResize(wma4, Bars); ArraySetAsSeries(wma4, true);
   ArraySetAsSeries(wma5, false); ArrayResize(wma5, Bars); ArraySetAsSeries(wma5, true);
   ArraySetAsSeries(wma6, false); ArrayResize(wma6, Bars); ArraySetAsSeries(wma6, true);
   ArraySetAsSeries(wma7, false); ArrayResize(wma7, Bars); ArraySetAsSeries(wma7, true);
   ArraySetAsSeries(wma6, false); ArrayResize(wma6, Bars); ArraySetAsSeries(wma6, true);
   ArraySetAsSeries(wma8, false); ArrayResize(wma8, Bars); ArraySetAsSeries(wma8, true);
   ArraySetAsSeries(wma9, false); ArrayResize(wma9, Bars); ArraySetAsSeries(wma9, true);
//---- reset counters   
   OldTime = Time[0]; OldBars = Bars;
   }
//+------------------------------------------------------------------+

Da würde ich es eigentlich genauso machen.

 

1) Einen neuen Buffer definieren:


//--- buffers
double wma0[], wma1[], wma2[], wma3[], wma4[], wma5[], wma6[], wma7[], wma8[], wma9[];
double ema0[], ema1[], rainbow[], rsi[], srsi[], fish[]; AroonBuffer[];
2) Auch ihn als Indexbuffer setzen

//---- indicators
   IndicatorBuffers(7); 
   SetIndexStyle(0, DRAW_LINE);
   SetIndexBuffer(0, fish);
   SetIndexBuffer(1, rainbow);
   SetIndexBuffer(2, rsi);
   SetIndexBuffer(3, ema0);
   SetIndexBuffer(4, ema1);
   SetIndexBuffer(5, srsi);
   SetIndexBuffer(6, AroonBuffer);
3) Und nun soll der wma0 aus den Daten des AroonOszilators errechnet werden.

//---- prepare partial averages
   for (int i = limit; i >= 0; i--) wma0[i] = iMA(NULL, 0, 2, 0, MODE_LWMA, iCustom(NULL, 0, "Aroon Oscillator_v1",10,50,300, 0, i), i);
   for (i = limit; i >= 0; i--) wma1[i] = iMAOnArray(wma0, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma2[i] = iMAOnArray(wma1, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma3[i] = iMAOnArray(wma2, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma4[i] = iMAOnArray(wma3, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma5[i] = iMAOnArray(wma4, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma6[i] = iMAOnArray(wma5, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma7[i] = iMAOnArray(wma6, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma8[i] = iMAOnArray(wma7, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma9[i] = iMAOnArray(wma8, 0, 2, 0, MODE_LWMA, i);
-> Geht das so einfach? Oder kann ich das iCustom nicht in die Formel packen?

 

Danke Mythos! biggrin.png

Geschrieben
  • Autor

Nachdem ich ihn extra definiert habe ...

double wma0[], wma1[], wma2[], wma3[], wma4[], wma5[], wma6[], wma7[], wma8[], wma9[];
double ema0[], ema1[], rainbow[], rsi[], srsi[], fish[];
double AroonBuffer[];

... gibt der Compiler keine Fehlermeldungen.

 

Aber jetzt fällt mir was auf ... ich arbeite später gar nicht mit dem AroonBuffer grin.gif

Also entweder brauche ich gar keinen extra Buffer, oder ich muss die Werte erst in den AroonBuffer laden.

Ala:

int start()
   {
   int counted_bars = IndicatorCounted();
   if (counted_bars < 0) return (-1);
   if (counted_bars > 0) counted_bars--;
   int limit = Bars - 1 - counted_bars;
//---- resize/shift extra buffers on first and every next bar
   if (Time[0] != OldTime) SyncExtraBuffers();
//---- prepare AroonBuffer   
   for(int i = 0; i < limit; i++)
      {
       AroonBuffer[i] = iCustom(NULL, 0, "Aroon Oscillator_v1",10,50,300, 0, i);
        }
   
//---- prepare partial averages
   for (i = limit; i >= 0; i--) wma0[i] = iMA(NULL, 0, 2, 0, MODE_LWMA, AroonBuffer, i);
   for (i = limit; i >= 0; i--) wma1[i] = iMAOnArray(wma0, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma2[i] = iMAOnArray(wma1, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma3[i] = iMAOnArray(wma2, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma4[i] = iMAOnArray(wma3, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma5[i] = iMAOnArray(wma4, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma6[i] = iMAOnArray(wma5, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma7[i] = iMAOnArray(wma6, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma8[i] = iMAOnArray(wma7, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma9[i] = iMAOnArray(wma8, 0, 2, 0, MODE_LWMA, i);

Dann gibt es auch keine Fehlermeldung com Compiler.

 

Ist wenigstens eins richtig? idea.gif

Geschrieben
  • Autor

bullet_go.png

//+------------------------------------------------------------------+
//|                        Smoothed RSI Inverse Fisher Transform.mq4 |
//|                                     © 2011 MaryJane@ForexFactory |
//|   Indicator formula © 2010 Sylvain Vervoort, http://stocata.org/ |
//+------------------------------------------------------------------+

#property indicator_separate_window
#property indicator_buffers 1
#property indicator_color1 Blue
#property indicator_width1 3
#property indicator_level1 12
#property indicator_level2 88
#property indicator_levelcolor DarkGray
//--- input parameters
extern int       RsiPeriod=4;
extern int       EmaPeriod=4;
//--- buffers
double wma0[], wma1[], wma2[], wma3[], wma4[], wma5[], wma6[], wma7[], wma8[], wma9[];
double ema0[], ema1[], rainbow[], rsi[], srsi[], fish[];
double AroonBuffer[];
int OldTime, OldBars;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
   {
//---- indicators
   IndicatorBuffers(7); 
   SetIndexStyle(0, DRAW_LINE);
   SetIndexBuffer(0, fish);
   SetIndexBuffer(1, rainbow);
   SetIndexBuffer(2, rsi);
   SetIndexBuffer(3, ema0);
   SetIndexBuffer(4, ema1);
   SetIndexBuffer(5, srsi);
   SetIndexBuffer(6, AroonBuffer);
//---- reset counters   
   OldTime = 0; OldBars = 0;
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
   {
//----
   
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
   {
   int counted_bars = IndicatorCounted();
   if (counted_bars < 0) return (-1);
   if (counted_bars > 0) counted_bars--;
   int limit = Bars - 1 - counted_bars;
//---- resize/shift extra buffers on first and every next bar
   if (Time[0] != OldTime) SyncExtraBuffers();
//---- prepare AroonBuffer   
   for(int i = limit; i >= 0; i--)
      {
       AroonBuffer[i] = iCustom(NULL, 0, "Aroon Oscillator_v1",10,50,300, 0, i);
        }
   
//---- prepare partial averages
   for (i = limit; i >= 0; i--) wma0[i] = iMAOnArray(AroonBuffer, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma1[i] = iMAOnArray(wma0, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma2[i] = iMAOnArray(wma1, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma3[i] = iMAOnArray(wma2, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma4[i] = iMAOnArray(wma3, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma5[i] = iMAOnArray(wma4, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma6[i] = iMAOnArray(wma5, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma7[i] = iMAOnArray(wma6, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma8[i] = iMAOnArray(wma7, 0, 2, 0, MODE_LWMA, i);
   for (i = limit; i >= 0; i--) wma9[i] = iMAOnArray(wma8, 0, 2, 0, MODE_LWMA, i);
//---- weigh the averages
   for (i = limit; i >= 0; i--)
      {
      double rb_val =  5 * wma0[i] + 4 * wma1[i] + 3 * wma2[i] + 2 * wma3[i] + wma4[i] + wma5[i] + wma6[i] + wma7[i] + wma8[i] + wma9[i];
      rb_val /= 20;
      rainbow[i] = rb_val;
      }
//---- calculate rsi from rainbow smoothed price curve 
   for (i = limit; i >= 0; i--) rsi[i] = 0.1 * (iRSIOnArray(rainbow, 0, RsiPeriod, i) - 50);
//---- smooth the rsi with Vervoort zero lag MA
   for (i = limit; i >= 0; i--) ema0[i] = iMAOnArray(rsi, 0, EmaPeriod, 0, MODE_EMA, i);
   for (i = limit; i >= 0; i--) ema1[i] = iMAOnArray(ema0, 0, EmaPeriod, 0, MODE_EMA, i);
   for (i = limit; i >= 0; i--) srsi[i] = ema0[i] + (ema0[i] - ema1[i]);
//---- do the fish
   for (i = limit; i >= 0; i--) fish[i] = ((MathExp(2 * srsi[i]) - 1) / (MathExp(2 * srsi[i]) + 1) + 1) * 50;
//----
   return(0);
   }
//+------------------------------------------------------------------+
//| Shift array elements without having to do it one-by-one          |
//+------------------------------------------------------------------+
void SyncExtraBuffers()
   {
   if (OldBars == Bars)
//---- if Bars = MaxBarsOnChart, arrays wouldn't resize & shift below
//---- we have to shrink them a bit, one bar does.
      {
      ArrayResize(wma0, Bars - 1);
      ArrayResize(wma1, Bars - 1);
      ArrayResize(wma2, Bars - 1);
      ArrayResize(wma3, Bars - 1);
      ArrayResize(wma4, Bars - 1);
      ArrayResize(wma5, Bars - 1);
      ArrayResize(wma6, Bars - 1);
      ArrayResize(wma7, Bars - 1);
      ArrayResize(wma8, Bars - 1);
      ArrayResize(wma9, Bars - 1);
      }
//---- on first Start(), when Time[0] != 0, this will give an init size to arrays and
//---- set them as Series (because of iMAOnArray and iRSIOnArray). Hence nothing
//---- in init() as this place will be visited first in any case.
//---- The flip trick below is necessary on further resizing/shifting since ArrayResize()
//---- adds/removes elements on the LEFT SIDE if set as Series so arrays wouldn't shift
//---- and it would be necessary to do a for (n=Bars-1; n>=0; n--){wmaX[n+1]=wmaX[n];}
//---- ten times on every new bar. this is much quicker.
   ArraySetAsSeries(wma0, false); ArrayResize(wma0, Bars); ArraySetAsSeries(wma0, true);
   ArraySetAsSeries(wma1, false); ArrayResize(wma1, Bars); ArraySetAsSeries(wma1, true);
   ArraySetAsSeries(wma2, false); ArrayResize(wma2, Bars); ArraySetAsSeries(wma2, true);
   ArraySetAsSeries(wma3, false); ArrayResize(wma3, Bars); ArraySetAsSeries(wma3, true);
   ArraySetAsSeries(wma4, false); ArrayResize(wma4, Bars); ArraySetAsSeries(wma4, true);
   ArraySetAsSeries(wma5, false); ArrayResize(wma5, Bars); ArraySetAsSeries(wma5, true);
   ArraySetAsSeries(wma6, false); ArrayResize(wma6, Bars); ArraySetAsSeries(wma6, true);
   ArraySetAsSeries(wma7, false); ArrayResize(wma7, Bars); ArraySetAsSeries(wma7, true);
   ArraySetAsSeries(wma6, false); ArrayResize(wma6, Bars); ArraySetAsSeries(wma6, true);
   ArraySetAsSeries(wma8, false); ArrayResize(wma8, Bars); ArraySetAsSeries(wma8, true);
   ArraySetAsSeries(wma9, false); ArrayResize(wma9, Bars); ArraySetAsSeries(wma9, true);
//---- reset counters   
   OldTime = Time[0]; OldBars = Bars;
   }
//+------------------------------------------------------------------+

Das muss stimmen good2.gif

Noch eine Frage zum laden der Daten des AroonBuffer.
Im "AroonOscillator" Code habe ich die Daten mit

for(int i = 0; i < limit; i++)
geladen.
In dem "Fischer" Coder werden alle anderen Buffer mit

for (i = limit; i >= 0; i--)
geladen.

Ist es richtig wenn ich das zweite nehme - was sonst auch in der Datei verwendet wird?

Bearbeitet von Mythos

Geschrieben

Hi,

 

eine kleine Bitte:

Wenn du jedesmal den gesamten Code einbindest, schließ ihn in detail-tags ein damit der Thread nicht unnötig aufgeblasen wird.

 

bzgl. der Forschleife: das ist eigentlich eine super Gelegenheit um es selber zu lernen. Versuch mal rauszufinden was der Unterschied zwischen den Varianten ist. Dazu benötigt man nur minimales Programmierwissen ;)

Geschrieben
  • Autor

Sorry, habe ich mir schon letztes mal gedacht als du es überarbeitet hast. Habe nur keinen Button dazu gefunden, aber anscheinend reicht der detail-code. gossip.gif

Beachte ich ab jetzt grin.gif

 

Wie die for-Schleife funktioniert weiß ich glaube ich.

for(int i = 0; i < limit; i++)

-> Es startet bei i=0, und es läuft solange bis i das "limit" erreicht (eine Variable die vorher wohl definiert wird). Und der Counter zählt jeweils um eins vorwärts.

 

Was mich nur überrascht hat, ist dass die Schleife beim Fischer-Code rückwärts läuft.

for (i = limit; i >= 0; i--)

-> Es startet bei limit und läuft bis 0 mit jeweils einem Schritt rückwärts.

 

Er wendet also den iMAOnArray rückwärts an?

Wenn das so gewollt ist, dann muss man die Daten aus dem AroonOscillator aber doch vorwärts in den Buffer füllen.

Sonst habe ich rückwärts-gefüllte-Daten die rückwärts ausgelesen werden -> also eigentlich wieder vorwärts kb-smile.gif

 

Ich hoffe man versteht was ich meine blush.png

Geschrieben
  • Autor

Gestärkt durch ein Abendessen müsste ich das schaffen grin.gif

 

Also wenn ich habe:


for(int i = limit; i >= 0; i--)
      {
       AroonBuffer[i] = iCustom(NULL, 0, "Aroon Oscillator_v1",10,50,300, 0, i);
        }

Es startet bei Limit (int limit = Bars - 1 - counted_bars) - sagen wir es ist 5, und endet bei 0.

Im AroonBuffer steht damit:

i=5 -> Da bei iCustom das i auch berücksichtigt wird läd er den (ich denke mal) 5. letzten Wert aus dem Aroon Oscillator

i=4 -> 4. letzter Wert aus dem Aroon Oscillator

i=3 -> 3. letzter Wert aus dem Aroon Oscillator

i=2 -> 2. letzter Wert aus dem Aroon Oscillator

i=1 -> Letzter Wert aus dem Aroon Oscillator

i=0 -> Aktueller Wert aus dem Aroon Oscillator

 

Bei:

for(int i = 0; i < limit; i++)

Es startet bei 0 und endet bei limit (int limit = Bars - 1 - counted_bars) - sagen wir es ist 5.

Im AroonBuffer steht damit:

i=0 -> Da bei iCustom das i auch berücksichtigt wird läd er den aktuellen Wert aus dem Aroon Oscillator

i=1 -> Letzten Wert aus dem Aroon Oscillator

i=2 -> 2. letzter Wert aus dem Aroon Oscillator

i=3 -> 3. letzter Wert aus dem Aroon Oscillator

i=4 -> 4. letzter Wert aus dem Aroon Oscillator

i=5 -> 5. letzter Wert aus dem Aroon Oscillator

 

Demnach wäre es total egal wie man es macht shocked.gif

 

Jetzt schau ich mir den iMAOnArray an.

for (i = limit; i >= 0; i--) wma0[i] = iMAOnArray(AroonBuffer, 0, 2, 0, MODE_LWMA, i);

Es startet bei i=5, da die Zeiteinheit auf 2 eingestellt ist - wird glaube ich noch nichts berechnet

Bei i=4 müsste dann der LWMA aus i=5 und i=4 errechnet werden (i=4 mehr gewichtet).

Bei i=3 müsste dann der LWMA aus i=4 und i=3 errechnet werden (i=3 mehr gewichtet).

Bei i=2 müsste dann der LWMA aus i=3 und i=2 errechnet werden (i=2 mehr gewichtet).

Bei i=1 müsste dann der LWMA aus i=2 und i=1 errechnet werden (i=1 mehr gewichtet).

Bei i=0 müsste dann der LWMA aus i=1 und i=0 errechnet werden (i=0 mehr gewichtet).

 

Er berechnet damit die "alten" LWMA zuerst - aber das sollte eigentlich kein Problem sein?

 

 

Nachdem ich mir vorher doch recht sicher war, habe ich nun gar keine Ahnung ob ich auch nur annähern richtig liege.noidea.gif

Gut das du nochmal genau nachgefragt hast Mythos! flowers.gif

Bearbeitet von Arvidsson

Geschrieben

Muss erstmal ein lautes Lob an Euch beide loswerden . Mythos, Deine Hilfsbereitschaft ......

 

Arvidsson .... finde es schön, dass Du Dich so verbeißt und nicht aufgibst , aber es steht ja auch in Deinem Avatar und den Satz kann ich nur mehrfach dick unterstreichen WORK HARD , wenn Du an der Börse bleiben willst .

 

zum Post #22 : Bitte gucke Dir nochmals genau an, wie die einzelnen BAR´s im Chart nummeriert (adressiert) sind und vergleiche das dann mit der Indizierung Deiner Array und Deiner FOR-Schleifen . Eine iMaOnArray , die ja den Durchschnitt mehrerer vorheriger == älterer Kurse durchrechnet ( BAR-Adressen ? ) ..... und dann den nächsten Schritt heraufzählt würde ..... ? Na ? blush.gif

 

Limit ist irgendein Variablenname , aber in diesem Kontext sehr wahrscheinlich die Zahl der BAR´s die es zu verarbeiten gilt ( BARs in Chart)

 

KB

 

Links zum Thema

Am wichtigsten der hier :

http://book.mql4.com/variables/arrays

 

Dann noch, wie es wohl zu Limit gekommen ist .... BARS - IndicatorCounted()

http://forum.mql4.com/39632

 

Mehr zu iMaOnArray, u.a. Thread in MQL-4

http://forum.mql4.com/9228

Geschrieben
  • Autor

Guten Morgen an alle,

 

ich komme nicht weiter ... aber der Reihe nach.

 

1)

zum Post #22 : Bitte gucke Dir nochmals genau an, wie die einzelnen BAR´s im Chart nummeriert (adressiert) sind ...

-> Eine genaue Erklärung zu den Bars konnte ich nicht finden, nur dass der aktuelle Bar wohl mit i=0 adressiert ist, und der erste (älterste) mit -1.

http://docs.mql4.com/predefined/variables/close

The current bar which is the last in the array is indexed as 0. The oldest bar, the first in the chart, is indexed as Bars-1.

Ich dachte eigentlich es läuft von 0=aktuell bis 5(z.B.) älterster

 

2)

...und vergleiche das dann mit der Indizierung Deiner Array und Deiner FOR-Schleifen .

Ich tüftel nun schon seit fast 2 Stunden herum, aber ich weiß nicht auf was du hinaus willst.

Wird mein AroonBuffer nicht absteigend befüllt wie ich oben beschrieben habe?

Bin grad etwas am verzweifeln mellow.png

 

3)

Eine iMaOnArray , die ja den Durchschnitt mehrerer vorheriger == älterer Kurse durchrechnet ( BAR-Adressen ? ) ..... und dann den nächsten Schritt heraufzählt würde ..... ? Na ? blush.gif

Ok. Im 3rdGenMA Script wird der MA auch absteigend (mit i--) berechnet. Klingt auch logisch^^

Geschrieben

Moin

 

der KernPunkt ist der folgende :

 

Jeder Bar hat eine Adresse und der jüngste Bar beginnt mit Null, der nächst ältere heißt "1" und nicht "-1".

Wenn Dein Chart 100 Tage im D1 darstellten (sollte) , dann hast Du 100 Adressen, die Höchste lautet 99 .

 

Wenn Du nun die FOR-Schleife mit 0 beginnend nach oben zu LIMIT zählst ( "++") , dann berechnest Du vom jüngsten

zum ältesten BAR hin .

 

Umgekehrt, wenn Du von LIMIT herunter zählst ("--") ,dann beginnst Du eben mit dem ältesten Wert .

 

Nun kommt der (auch für mich immer wieder ) schwierige Teil : Du mußt darauf achten, dass die Indizierung (die Adressierung) Deiner

Array´s die NICHTS mit dem Chart zu tun haben, der Logik des Charts folgen .

Im Chart ist der jüngste Bar der mit der Adresse "0" . Im Array ist es "im Standard" umgekehrt . Dein erster Wert bekommt die "0", der ersten

Platz im Array . Das nächste Datum bekommt den nächsten freien Platz, die Nummer "1" . Nun ist "1" jünger als "0" . Usw .

Im Chart passiert das nicht ..... was eben noch "0" war wird automatisch auf "1" geschoben, "0" wird dann neu beschrieben und somit ist der

neueste Wert nun auf der "0" und nicht so wie im Array auf der "1" .

 

So, und damit man da nicht laufend hin-und-her-denken muss , dafür gibt es den Befehl

 

bool ArraySetAsSeries( double&array[], bool set) 

 

Damit kannst Du Deinen Array umschalten und seine Indizierung umkehren .

 

Und genau das würde ich Dir immer dann empfehlen, wenn Du eine Datenreihe bearbeitest, die parallel zum Chart läuft (wie zum Beispiel alle Indikatoren)

 

Diese Thema mußt Du richtig gut vertiefen ! Sonst rennst Du Dir im DEBUGGing "einen Wolf"

 

Experimentiere mit Beispielcode , nutze die Befehle Alert und Print um Dir Variablen ausdrucken zu lassen . Beschreibe die Variablen mit den

Werten, die Du vermutest und prüfe, ob das dann auch so ist .

 

For i ....
      {
      For j .....
            {
            Print ("i=",i," , j=",j," ,  BarOpen(i)=", Open[i]," ,  BarClose(j)=", Close[j]," , meinArray[i][j]=",meinArray[i][j]);// EDIT Syntax korrigiert :-)
            }
       }

Gehören immer wieder zu meinen Tools um meine Denkknoten zu entwirren .

 

Hoffentlich hilft es Dir

KB

 

PS.: Schreibe Dir das alles, ohne mich in Deinen Code eingelesen zu haben sondern ich konzentriere mich darauf, Dir Denkanregungen & Arbeitstechniken aufzuzeigen, die ich mir damals (auch mit viel Hilfe von Mythos & Kollegen hier) erarbeitet habe . Daher kann ich nicht auf Details in Deinem Code (Arroon) eingehen . Da steckt aber auch schon Mythos drinnen .

Geschrieben
  • Autor

Danke für die ausführliche Erklärung!

Genau die Zusammenhänge haben mir gefehlt.yess.gif

Ist echt eine super Community hier! good2.gif

Bearbeitet von Arvidsson

Dein Kommentar

Du kannst jetzt schreiben und Dich später registrieren. Wenn Du ein Konto hast, melde Dich jetzt an, um unter Deinem Benutzernamen zu schreiben.

Gast
Auf dieses Thema antworten...

Account

Navigation

Suche

Suche

Configure browser push notifications

Chrome (Android)
  1. Tap the lock icon next to the address bar.
  2. Tap Permissions → Notifications.
  3. Adjust your preference.
Chrome (Desktop)
  1. Click the padlock icon in the address bar.
  2. Select Site settings.
  3. Find Notifications and adjust your preference.