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

Sehe ich das so richtig?

 

Ein kleines Beispiel:

 

1) Ich will die Kurse auf Stundenbasis in ein Array bekommen.

Mein Limit ist 4.

 

Kurse:

19.00 Uhr: 1.9000 (aktuellster)

18.00 Uhr: 1.8000

17.00 Uhr: 1.7000

16.00 Uhr: 1.6000 (ältester)

 

Adressierung der Bars:

0 -> 1.9000

1 -> 1.8000

2 -> 1.7000

3 -> 1.6000

 

Genau so möchte ich es ja im Array auch stehen haben, damit die Logik des Charts eingehalten wird.

 

Array:

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

Array Pos. 0 = Bar 0 = 1.9000

Array Pos. 1 = Bar 1 = 1.8000

Array Pos. 2 = Bar 2 = 1.7000

Array Pos. 3 = Bar 3 = 1.6000

 

-> Damit müsste eigentlich alles stimmen. Das Array wäre (mMn) mit (1.9000, 1.8000, 1.7000, 1.6000) befüllt.

 

2) Was passiert als nächstes?

Es gibt einen neuen Kurs für 20.00 Uhr

 

Kurse:

20.00 Uhr: 2.0000 (aktuellster)

19.00 Uhr: 1.9000

18.00 Uhr: 1.8000

17.00 Uhr: 1.7000

16.00 Uhr: 1.6000 (ältester)

 

Adressierung der Bars:

0 -> 2.0000

1 -> 1.9000

2 -> 1.8000

3 -> 1.7000

4 -> 1.6000

 

Array:

Da das Array unter int start() gefüllt wird, wird es (mMn) komplett von vorne wieder befüllt

 

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

Array Pos. 0 = Bar 0 = 2.0000

Array Pos. 1 = Bar 1 = 1.9000

Array Pos. 2 = Bar 2 = 1.8000

Array Pos. 3 = Bar 3 = 1.7000

Stop, da das Limit 4 ist

 

3) Wo ist nun wieder mein Fehler, oder für was brauche ich das ...

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

...?

 

4) Wenn ich mit Beispielcodes (die nicht auf Kurse etc zugreifen) etwas testen will, wie geht das mit dem MetaEditor?

Geht das irgendwie sehr einfach ohne dass man es im MetaTrader starten muss?

Ich habe einen C-Editor, dort kann man den Code compilen und (in einem DOS Fenster) testen.

 

Vielen vielen Dank Leute!

Grüß euch.

 

ich befürchte ihr stellt euch das viel zu kompliziert vor.

Arvidsson: Du hast fast Recht mit der Aussage "Es ist genau das Gleiche".

Solang die Berechnung innerhalb der Schleife nicht auf Werte zurückgreift die sich während der Ausführung ändern, ist es genau das gleiche.

 

Zur Verdeutlichung, bei der folgenden Berechnung MUSS die schleife die Werte in dieser Richtung durchlaufen weil im jeweils nächsten Durchlauf ein Resultat des vorigen Durchlaufs verwendet wird.

int values[6];
values[0]= 1;
for(int i= 0;i < 5;i++) {
values[i+1]= values[i]+i;
}

Sind die Berechnungen der einzelnen Durchläufe aber unabhängig dann ist es komplett egal in welcher Reihenfolge man durchläuft. In unserem Fall füllt man die Werte eines Arrays aufgrund von Werten die alle bereits vor Beginn der Schleife feststehen und nicht geändert werden -> Somit komplett unabhängige Berechnungen.

 

Was jedoch nicht gleich ist, ist die anzahl der Durchläufe:

Bleiben wir beim Beispiel limit = 5

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

i startet bei 5 und läuft bis 0 also für die Werte 5,4,3,2,1,0 wird die Schleife ausgeführt

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

hier startet i bei 0, wenn i = 5 ist ist die Bedingung i

Das ist in dem Fall der einzige Unterschied.

 

Bzgl Werte von hinten nach vorne schreiben oder umgekehrt:

Es ist in dem Fall wie gesagt egal ob ich zuerst den 0ten Wert an die Stelle 0 schreibe und dann den 5ten an die Stelle 5, oder zuerst den 5ten an die Stelle 5 und dann den 0ten an die Stelle 0. Am Ende steht Wert 0 an der Stelle 0 und Wert 5 an der Stelle 5.

 

HTH

Eine gute Nachricht

 

Dann befülle ich den Array mit i--, da im restlichen Skript auch damit gearbeitet wird.

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

Die Berechnung bleibt auch so

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

Damit dürfte ich nun (theoretisch) fertig sein

Ich teste das ganze morgen mal und berichte ob es funktioniert

 

Eine Frage zur Verfeinerung hätte ich noch:

Ich gebe beim iCustom und iMAonArray immer die Variablen an mit denen der Ausgangswert berechnet wurde.

Wenn ich diese ändern wollen würde, müsste ich jedes mal den Code ändern und neu im MT starten.

 

Hier mal eine Übersicht zur Verdeutlichung:

3rdGenMA:

Variablen zur Berechnung: 89, 21, 3, 5

-> Ist über "extern" definiert, damit könnte ich es jederzeit im MT ändern

 

Aroon Oscillator:

Variablen zur Berechnung: 10, 50, 300

-> Ist über "extern" definiert, damit könnte ich es jederzeit im MT ändern

Und er greift über ...

MABuffer[i] = iCustom(NULL, 0, "3rdGenMA",89,21,3,5, 0, i);

... auf die Variablen des 3rdGenMA zu. Änder ich die Variablen des 3rdGenMA im MT, wird der 3rdGenMA zwar anders berechnet, aber der Aroon Oscillator greift immernoch auf Daten mit den falschen Variablen zu. Der Code wird sich ja nicht automatisch mitändern?

 

Fischer:

Variablen zur Berechnung: 4, 4

Beim Fischer des gleiche. Die 4, 4 könnte ich im MT (wegen extern) jederzeit ändern, aber er greift natürlich auf die Daten aus dem Oscillator über ...

AroonBuffer[i] = iCustom(NULL, 0, "Aroon Oscillator_v1",10,50,300, 0, i);

... mit fixen Variablenwerten zu.

 

Müsste ich da einfach noch ein paar "extern Variablen" definieren die ich dann anstatt den "fixen Werten" einfüge - oder gibt es eine viel einfachere Lösung?

Ich hoffe man kann meiner Schilderung folgen

Bearbeitet 8. September 201312 Jr. von Arvidsson

Genau,

 

du musst die Inputparameter die du als Parameter haben willst einfach per extern auch als Inputparameter definieren... (schöner Satz oder? ;)

Und dann im Code statt den "hardcodierten" Werten die Variablen verwenden.

Langsam wird es ja mit mir ;-)

 

Bin schon gespannt ob die beiden Skripte morgen funktionieren.

 

Tausend Dank an alle Helfer...besonderen Dank natürlich an Mythos :-)

Ok es funktioniert leider nichts

 

Beim AroonOscillator kommen für einige Sekunden lauter rote vertikale Linien - danach ist alles Weg.

Der Fischer arbeitet daher auch nicht.

 

Jemand eine Idee woran es liegen könnte?

Bearbeitet 9. September 201312 Jr. von Arvidsson

Was ich vergessen habe:

Im MT wird beim Indikator (AroonOscillator) links oben angezeigt: AroonOsc_v1 (10,50) 0 0 -0 -0

In der Ausgangslage war es: AroonOsc_v1 (10,50) 60 0 0 60

 

Komisch ...

Jetzt werde ich leider zum Spamer, aber Editieren ging nicht mehr :D

 

Alt:

for(i = 0; i < limit; i++)
{
MABuffer[i] = iCustom(NULL, 0, "ThrdGenMA",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
}

 

Neu:

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

Habe also des MABuffer vor dem ArrayMax/Min entfernt. Jetzt wird der AroonOscillator gezeichnet - hoffe es stimmt :)

Aktuell habe ich noch zwei komisches Probleme.

 

1) Der Fischer wird erst ab dem Startzeitpunkt berechnet - für die abgelaufenen Bars wird nichts gezeichnet.

Ist das normal? Der AroonOsc & die MA werden ja auch sofort für die Vergangenheitswerte berechnet.

 

2) Wenn ich die Indikatoren im Chart aktiviere kommt beim Fischer in M5 erstmal nur eine gerade Linie, obwohl bei M15 etc. schön etwas gezeichnet wird.

Siehe: http://charts.mql5.com/2/470/eurusdt-m5-varengold-wertpapierhandelsbank-ag-2.png

 

Beende ich den Veragolt MT, öffne ihn sofort wieder, kommt auch in M5 der Indikator.

Siehe: http://charts.mql5.com/2/470/eurusdt-m5-varengold-wertpapierhandelsbank-ag-3.png

 

Wie kann so etwas komisches passieren?

So nochmal ich

Die noch offenen Fragen sind nicht so wichtig - ist ja nur noch ne Kleinigkeit

 

ABER:

Wo anders komme ich nicht weiter.

 

Code_alt:

for(int i=0; i<limit; i++)
    {  MaxH = High[Highest(NULL,0,MODE_HIGH,period,i)];
       MinL = Low[Lowest(NULL,0,MODE_LOW,period,i)];
      price = (High[i]+Low[i])/2;
      Value = 0.33*2*((price-MinL)/(MaxH-MinL)-0.5) + 0.67*Value1;

Sehe ich das richtig:

- Er sammelt die Höchststände (MODE_HIGH)

- Davon sammelt er die Hochpunkte (Highest)

- Und davon werden nochmal die Hochpunkte gesammelt (High)

[Erklärung zu High: Series array that contains the highest prices of each bar of the current chart.]

 

Bisher hatte ich immer nur Highest und weiß daher nicht wie ich mit dem High umgehen muss.

 

Mein Vorschlag:

for(int i=0; i<limit; i++)
    {  AroonBuffer[i] = iCustom(NULL, 0, "Aroon Oscillator_finish",AroonPeriod,Filter,CountBars, 0, i);
       MaxH = High[ArrayMaximum(AroonBuffer,period,i)];
       MinL = Low[ArrayMinimum(AroonBuffer,period,i)];
      price = (High[i]+Low[i])/2; 

Aber das funktioniert leider nicht :-(

Muss ich das High ersetzen damit es mit Arrays arbeiten kann? Habe leider durch google`n nichts gefunden und bin einmal mehr auf euch angewiesen.

 

Danke schon einmal im Voraus!

Kurze Rűckmeldung, dass ich mitlese aber erst heut (feier)abend Zeit habe , um zu beantworten, soweit mir das mőglich ist.

Gruss

KB

 

android & tapatalk

 

 

Ok , da bin ich wieder :

 

... und wieder bin ich nicht in die übergeordneten Zusammenhänge Deines Codes eingestiegen aber ich habe vielmehr versucht mir die von Dir zitierten Codeschnipsel zu Gemüte zu führen .

Und da habe ich Anmerkungen die ich Dir vorstellen darf ....

 

I.)

 

for(int i=0; i<limit; i++)
    {  MaxH = High[Highest(NULL,0,MODE_HIGH,period,i)];
       MinL = Low[Lowest(NULL,0,MODE_LOW,period,i)];
      price = (High[i]+Low[i])/2;
      Value = 0.33*2*((price-MinL)/(MaxH-MinL)-0.5) + 0.67*Value1;

I.1.) Dazu sehe bitte mal http://codebase.mql4.com/7730 . Ich hatte mal ähnlichen Code wie Du und habe dann auch die Nutzung von iHighest und iLowest umgestellt und einige Probleme damit lösen können (dabei weiss ich, dass oft so gecodet wird, wie Du es geschrieben hast) . Aber wenn Du die nützliche F1-Taste nutzt und dann KEINEN Hilfetip bekommst, dann ist meist etwas faul im ...

Und bei Highest und Lowest gibts nix , bei iHighest und iLowest aber schon

I.2.) MaxH und MinL , Deine Varibalen , notieren Dir Preise und keine BarAdressen . Willst Du das ? Denn hier steht

 

Leseanleitung: Aroon Indikator

Der Aroon-Indikator besteht aus zwei Linien: Der Aroon-Up misst die Tage, die seit dem letzten Hoch des Kurses vergangen sind, der Aroon-Down hingegen die Tage seit dem letzten Tief. Das Indikatorenpaar, bestehend aus AroonUp und AroonDown, wird überlagert dargestellt.

Aroon misst & vergleicht Zeiten .

 

 

II.) Schliesslich zu dieser Sequenz :

for(int i=0; i<limit; i++)
    {  AroonBuffer[i] = iCustom(NULL, 0, "Aroon Oscillator_finish",AroonPeriod,Filter,CountBars, 0, i);
       MaxH = High[ArrayMaximum(AroonBuffer,period,i)];
       MinL = Low[ArrayMinimum(AroonBuffer,period,i)];
      price = (High[i]+Low[i])/2; 

II.1.) iCustom :

Das ist spannend (für mich immer wieder , jedenfalls ) : Und zwar liegt der Teufel in dem Detail der Parameterübergabe , da mußt Du genau synchron sein .

So wie Du den Indikator "Aroon Oscillator_finish" aufrufst, hat dieser genau zwei externe Variablen die genau denselben Typ (Double/INT oder String) haben , wie Dein

aufrufender Indkator . Und dort frägst Du dann genau einen DOUBLEWert ab, nämlich in Deinem Fall den ersten (null´ten) Indikatorbuffer der dort mit dem SetIndexBuffer(0,DeinName[]) definiert wurde . Und aus dem, also dem dortigen Array "DeinName" rufst Du den Wert "i" ab . Das solltest Du mal gucken , ich hatte da immer meine Problemchen, wie gesagt.

 

II.2.) Mit dem ArraxMaximum und ArrayMinimum suchst Du bei jedem Durchgang durch Deine Schleife nach dem Max und dem Min . GLEICHZEITIG aber befüllst Du erst den Array . D.h. im ersten zweiten dritten.... Durchlauf hat der Array den Du überprüftst einen , zwei , drei Werte ..... , das ist so gewollt ?

 

Wenn Du jetzt wieder mal meinen Tip aufnehmen möchtest und mit Print und i arbeitest und guckst was mit dem Array "AroonBuffer" (Inhalt und Umfang des Array) passiert, während Du durch diese Schleife läufst, dann kann das interessant werden . Tip: Verbinde den Print mit BAR im Chart, dann kannst Du nachher mit der Maus auch die Kurse überprüfen . Dazu nutze ich immer die Time-Conversion, hier ein typischer Ausschnitt wie ich das bei mir mache :

//+----------------------------------------------------------------------------------------------------+
// Information                                                                                         |
//+----------------------------------------------------------------------------------------------------+
   if (Bar1_1 != iBars(Markt,1))                {//1 alle Min ausführen um CPU zu sparen               |
      Bar1_1 = iBars(Markt,1)                   ;//                                                    |
      jetzt = TimeToStr(TimeCurrent(),TIME_DATE|TIME_MINUTES);//                                       |
      GetCurMoneyData()                         ;//                                                    |
      Basic()                                   ;//                                                    |
      MoneyStat()                               ;//                                                    |
   }                                             //1                                                   |
//                                                                                                     |
   if (Bar5_1 != iBars(Markt,5)                ){//11alle 5 Min ausführen um CPU zu sparen             |
   Bar5_1 = iBars(Markt,5)                      ;//                                                    |
   if (!IsTesting() )                           {//2                                                   |
   if (CurrentTrend >0 ) Print("********** ",jetzt,"  START ZYKLUS ",Bars," im Markt : ",Markt ,//     |
                        " , aktueller TradeTrend ist    LONG         **********")              ;//     |
   if (CurrentTrend <0 ) Print("********** ",jetzt,"  START ZYKLUS ",Bars," im Markt : ",Markt ,//     |
                        " , aktueller TradeTrend ist    SHORT        **********")              ;//     |
   if (CurrentTrend==0 ) Print("********** ",jetzt,"  START ZYKLUS ",Bars," im Markt : ",Markt ,//     |
                        " , aktueller TradeTrend ist    RANGE        **********")              ;//     |
                                                }//2                                                   |
//+----------------------------------------------------------------------------------------------------+

 

Wie immer hoffe ich, dass ich helfen konnte und wünsche einen schönen Abend .

 

KB

Sehe ich das richtig:

- Er sammelt die Höchststände (MODE_HIGH)

- Davon sammelt er die Hochpunkte (Highest)

- Und davon werden nochmal die Hochpunkte gesammelt (High)

[Erklärung zu High: Series array that contains the highest prices of each bar of the current chart.]

Nicht ganz:

iHighest gibt dir den offset des Bars mit dem höchsten Wert.

Im Array "High" sind die Höchststände der einzelnen Bars gespeichert. Somit bekommst du mit dem code einfach nur das höchste Hoch innerhalb der Periode.

MaxH = High[ArrayMaximum(AroonBuffer,period,i)];

Zerleg diese Zeile mal in die Einzelteile (mithilfe der Doku), dann wirds du schnell merken warum das nicht funktioniert. Also Schritt für Schritt: Was macht ArrayMaximum und was liefert dir High[...] ?

Wieder mal vielen Dank für die ausführlichen Antworten

 

Werde mir das ganze in den nächsten Tagen nochmal genau anschauen :-)

bin schon ganz gespannt , was denn der Arvidson zu berichten hat ....

 

Ihm ein schönes Coder-WE und allen anderen auch ein erholsames WE

 

KB