Lässt Metatrader4 sich in einem EA so programmieren, das der Ausstieg nicht auf Pip Basis sondern von anderen Faktoren abhängig gemacht wird ?

 

Ich meine z.B.

 

• Schließe die offene Position wenn vom letzten höchsten Hoch eine Gegenbewegung von sagen wir mal 8% erfolgt ist.
  oder
  
• Schlie0e die Position wenn der Schlußkurs unter dem vorletztem Hoch ist.
  oder
  
• Schlie0e die Position wenn es ein Gap von beispielsweise minimum 4 Pips gegeben hat
  

usw....

Lässt Metatrader4 sich in einem EA so programmieren, das der Ausstieg nicht auf Pip Basis sondern von anderen Faktoren abhängig gemacht wird ?

...

Ja

Ich meine z.B.

 

• Schließe die offene Position wenn vom letzten höchsten Hoch eine Gegenbewegung von sagen wir mal 8% erfolgt ist.
  oder
  
• Schlie0e die Position wenn der Schlußkurs unter dem vorletztem Hoch ist.
  oder
  
• Schlie0e die Position wenn es ein Gap von beispielsweise minimum 4 Pips gegeben hat
  

usw....

 

• Ja natürlich,
  
• ja wobei die Frage ob vorletzte höchste Hoch oder wirklich High[2],
  
• ja wobei wieder die Frage "was ist ein Gap?". Also zwischen zwei ticks? Das ist von Broker zu Broker verschieden wie du die Ticks kriegst...
  

Aber an sich: Ja alles kein Problem. Als eigener EA oder willst es in einen anderen integrieren?

Aber an sich: Ja alles kein Problem. Als eigener EA oder willst es in einen anderen integrieren?

Gut zu wissen.

Sollte es jemals dazu kommen, dann als eigener EA.

Aber so weit ist es nocht nicht.

 

Das was ich mir vorstelle gibt es in dieser Form so noch nicht.

Oder besser ausgedrückt, wird es ganz sicher geben, aber eben nicht käuflich.

 

War erst mal eine Informationsfrage, ob MT da irgendwelche Grenzen der Programmierung hat.

Kann ich denn weiterdenkend davon ausgehen, das alles was in MT umsetzbar ist, in den anderen populären Programmiersprachen

erst recht machbar ist ?

Kann ich denn weiterdenkend davon ausgehen, das alles was in MT umsetzbar ist, in den anderen populären Programmiersprachen

erst recht machbar ist ?

Ich weiß nicht genau welche Sprachen "populär" sind, aber in ernstzunehmenden Sprachen gehts auf jeden Fall ;)

Ob man "erst recht" sagen kann ist eine andere Frage. Manche Dinge sind in MT möglicherweise sogar einfacher zu implementieren. Aber du hast natürlich recht die Funktionalität und Möglichkeiten sind eigentlich überall gleich.

Auch bei NinjaTrader sind das Basis-Funktionen, die relative einfach umzusetzen sind.

Ich gehe stark davon aus, das alle APIs bzw. Trading-Programme mit manueller Programmierung solche

Abfragen und Prüfungen zulassen.

Das was ich mir vorstelle gibt es in dieser Form so noch nicht.

Oder besser ausgedrückt, wird es ganz sicher geben, aber eben nicht käuflich.

 

Dann hab ich mal die Vermutung das der Teil wo du eher Fragen solltest obs programmierbar ist, nicht bei diesen "einfachen" Stops liegt ;)

Dann hab ich mal die Vermutung das der Teil wo du eher Fragen solltest obs programmierbar ist, nicht bei diesen "einfachen" Stops liegt ;)

Doch doch, der Einstieg ist sehr einfach gehalten gehalten, dreht sich alles um Pivots.

Da diese ja nun sicher keine Hürde des programmierens darstellen, ging es mir um das machbare bei den Ausstiegen.

 

Mit diesen blöden Einstiegen habe ich noch nie Geld verdienen können, immer erst beim Ausstieg...

Dank euch auf jeden Fall erst mal, weitere Fragen werden dann vielleicht noch folgen.

in den anderen populären Programmiersprachen erst recht machbar ist ?

 

So ganz sicher bin ich mir da eher nicht : Wo kann ich noch einen Trade gegen einen anderen laufen lassen . Und gleichzeitig auch noch jeden Trade individuell ansprechen, indem ich jedem Trade einen

eigenen Namen geben kann ? Also, es hat einiges gedauert, bis ich halbwegs MT4-Laufen gelernt habe, aber jetzt wächst meine Symapthie von Tag zu Tag . Aber ich kann nur mit wenigen anderen Sprachen

vergleichen . Wäre wirklich interessant zu wissen, ob es komfortablere Programmiersprachen mit aber gleicher Funktionalität gibt ? KB

So ganz sicher bin ich mir da eher nicht : Wo kann ich noch einen Trade gegen einen anderen laufen lassen . Und gleichzeitig auch noch jeden Trade individuell ansprechen, indem ich jedem Trade einen

eigenen Namen geben kann ? Also, es hat einiges gedauert, bis ich halbwegs MT4-Laufen gelernt habe, aber jetzt wächst meine Symapthie von Tag zu Tag . Aber ich kann nur mit wenigen anderen Sprachen

vergleichen . Wäre wirklich interessant zu wissen, ob es komfortablere Programmiersprachen mit aber gleicher Funktionalität gibt ? KB

 

Sagen wir so: sobald du dich in die Richtung der "echten" Programmiersprachen bewegst is alles möglich, nur die Frage ob du das als "komfortabel" bezeichnen würdest. Das Problem mit komfortablen Programmiersprachen ist halt immer, das es immer einen Punkt gibt wo dir das "komfortabel" die Möglichkeiten einschränkt. Und umgekehrt das Mehr an Möglichkeiten und Funktionalität die Komfortabilität reduziert.

 

Es stimmt schon MT hat was die Orderverwaltung angeht ein paar Vorteile, aber es ging ja nicht um die Frage "Ist es einfach machbar" sondern um das "Ist es machbar" ;).

Neue Frage zum gleichen Thema

 

Für den automatischen Handel auf meinem privaten nicht weiter abgesicherten Server nutze ich ausschließlich Order mit SL (oder Hedge) und oft TP . Denn wenn mein Server sich mal ungewollt verabschiedet, dann ist es schön einen SL sein eigen nennen zu dürfen, könnte sonst teuer werden .

 

Problem ist nun, dass dieses Vorgehen mich oft zwingt, zu überprüfen ob der Trade noch im Markt ist oder aber eben nicht mehr ...SL oder TP könnten ihn in der Zwischenzeit geschlossen haben .

 

Bislang löse ich dies über die Abfrage der "Orderhistory > 0" ...muss aber dann eben jedesmal Schleife (For) , OderSelect , IF ... usw usw .abfragen . Dazu kommt, dass ich alleine im aktuellen Projekt (das ich gerade erstelle) bis zu 10 Trades gleichzeitig und unabhängig voneinander im Markt haben kann . Also muss ich Ticket oder Magicnummer berücksichtigen und das macht es noch komplizierter .

Das alles ist also relativ aufwendig und ich habe noch keine Standardlösung dafür , die ich dann auch in späteren EA´s einsetzen kann .

 

Wie geht Ihr vor ? So wie ich hier beschreibe ... oder gibt es etwas Einfaches um zu prüfen, ob eine bestimmte bzw individuelle Order noch im Markt ist oder aber von einem Tick zum nächsten aus dem Markt (SL/TP) genommen wurde ?

 

KB

Wie geht Ihr vor ? So wie ich hier beschreibe ... oder gibt es etwas Einfaches um zu prüfen, ob eine bestimmte bzw individuelle Order noch im Markt ist oder aber von einem Tick zum nächsten aus dem Markt (SL/TP) genommen wurde ?

Das mit dem Durchlaufen der Orders und Kombination mit Magicnumber oder Ticket sieht zwar im Quelltext immer gewaltig aus, ist aber die "richtige" Methode. So kannst Du immer direkt feststellen, ob sich ein Trade bereits in der Orderhistorie befindet oder nicht. 10 Trades sind da ja geradezu langweilig, da mache Dir mal keine Sorgen .

..............oder nicht. 10 Trades sind da ja geradezu langweilig, da mache Dir mal keine Sorgen .

 

 

ok ok ... also Orderhistory() ... dann mach ich das mal so, dass ich bei jedem Durchlauf, pauschal alle Trades in eine Matrix lade,speichere und dann mit dem Durchlauf vorher vergleiche . Dazu nutze ich ArrayCopy und kann dann http://book.mql4.com/build/events als Grundlage für den eigenen Code nehmen .

 

Danke auch :-)

 

Schöne Osterfeiertage

 

KB

ok ok ... also Orderhistory() ... dann mach ich das mal so, dass ich bei jedem Durchlauf, pauschal alle Trades in eine Matrix lade,speichere und dann mit dem Durchlauf vorher vergleiche . Dazu nutze ich ArrayCopy und kann dann http://book.mql4.com/build/events als Grundlage für den eigenen Code nehmen .

 

Äh wie? Wozu in eine Matrix speichern? Um was geht es dir? Zu sehen wenn eine geschlossen is, oder die offenen durchzugehen?

Wenn du nur die offenen bearbeiten willst, brauchst du nix speichern sondern gehst einfach immer alle offenen orders durch.

Um was geht es dir?

 

ein handelnder Trade tradet mit dem Trend und wird durch einen passiven Trade gehedgt : der passive Trade kann je nach Zustand des handelnden Trades entweder a.) Pending sein, er kann aber auch b.) mit TSL & TP selber die Korrektur des Marktes abdippen (wenn der Verlust des handelnden Trades in Grenzen ist) oder aber er kann c.) "verriegelt werden"... TSL und TP des passiven Trades werden mit OrderModify() entfernt und durch einen SL ersetzt .

 

Nur wenn Fall c.) eintritt , dann werden

 

- c.1.) entweder beide Trades bei Erreichen eines Umkehrsignales zusammen geschlossen . Das macht der EA .

- c.2.) oder der Kurs kehrt zu ursprünglichen Werten zurück und der passive Trade wird durch den SL geschlossen . Das macht der Server .

 

 

Der EA steuert das Zusammenspiel , im besonderen aber den Wechsel von Fall b.) nach Fall c.) . Danach muss kontinuierlich der Fall c.1. und c.2. geprüft werden .

On Top nun kommt, dass im Falle von c.) ein nächste Pärchen, wieder bestehend aus einem handelnden und einem absichernden (hedge) passiven Pärchen zum Handel freigegeben wird . Auch diese werden wie oben beschrieben , gesteuert .

Insgesamt erlaubt mir mein RM/MM 5 Pärchen . Es darf aber immer nur ein Pärchen aktiv sein . Die anderen warten in der "Bank" oder sind verriegelt, weil der FloatingLoss des handelnden Trades zu groß wurde .

 

Den EA nenne ich "Ernten" ... er soll abarbeiten, nachdem ich als Trader meine Arbeit geleistet habe : Das Erkennen attraktiver Chartformationen "BWILC unter Berücksichtigung des übergeordneten Trend" .

 

Um was geht es dir?

 

in diesem Zusammenspiel würde ich gerne vermeiden, dass ich bei jedem Durchlauf X Trades analysieren muss um Veränderungen durch den Server festzustellen . Dahinter steckt der Geiz mit CPU-Kapa die vermutlich überhaupt kein Problem ist , wie mir Conglom-O aufzeigte . Aber ich bin halt "so erzogen" . ;) . Es scheint, dass ich umdenken sollte .

 

 

KB

 

PS.: Die langatmige Erklärung bitte ich zu entschuldigen . Aber es gehört sich wohl so, wenn ich um Hilfe bitte und der Hilfsbereite um den Hintergrund bittet , finde ich .

PPS.: "Event Tracking Function" , http://book.mql4.com/build/events , scheint genau diesen Job zu erledigen .

 

oben habe ich geschrieben :

 

über die Abfrage der "Orderhistory > 0" ...muss aber

 

ich meinte doch "OrderCloseTime() > 0 " aber geschrieben habe ich "..history" .

 

Es ändert nichts am Problem , das ja nun auch eigentlich gelöst ist . Aber es tut mir leid, dass ich da eventuell in die Irre geführt habe .

 

KB

Mit OrderSelect() wäre die sicherste und richtige Variante,

theoretisch könntest du auch die ausgeführte Positionen als statische Variablen speichern,

aber um sicher zu gehen, muss du auf jedem Fall die History durchchecken.

Das einzig sinnvolle was du machen kannst um die CPU-Ressourcen zu sparen ist, wenn du Anzahl von Trades in der AccountHistory auf den letzten Tag oder die letzten 3 Tage einstellst,

dann brauchst du nicht die ganze History durchgehen

Ok, also so wie ich es jetzt verstanden habe, würd es dir reichen wenn du die offenen Trades checkst oder? Weil wenn er nicht mehr da ist, wurde er durch den Server geschlossen.

 

Außer meiner Sicht spielt hier nicht die CPU eine Rolle sondern das "wie is es gscheit?". Bei jedem Tick die gesamte History durchzulaufen ist sicher nicht gut für CPU, nur die offenen Trades zu checken ist normal aber kein Problem.

Da du aber mehrere Päarchen offen haben kannst und ich mir noch nicht ganz sicher bin ob du jetzt nur aufgrund der offenen Positionen eindeutig sagen kannst was Sache ist, könnte es in deinem Fall auch Sinn machen ein kleines Array mit den Ordertickets zu speichern. In dem Fall nur eine Warnung: Ich hab gehört das manche Broker Ordertickets teils ändern, man sollte das speichern dieser also immer ein bissl mit Vorsicht genießen.

Zur Variante mit nur den offenen Pos checken: Wie wäre es wenn du den Päarchen jeweils eindeutige Magics gibst? zB automatische die letzte Stelle weiterzählst (modulo 10), dann kannst du auch bei den offenen Pos genau sagen welche Order von welchem Päarchen noch da ist etc. und musst nichts "annehmen" (was du tust sobald du Tickets speicherst und nicht immer den aktuellen Stand vom Broker checkst).

Zum Performanceunterschied zwischen offene Pos checken und Tickets speichern: Genaugenommen musst du bei den Tickets auch jedesmal checken ob die noch so sind wie du denkst (also Pos offen/geschlossen etc), also läufst du sowieso mindestens alle offenen von dir durch. Sofern auf dem MT nit viele andere EAs laufen, also performancetechnisch kein Unterschied.

 

Die Geizigkeit bei CPU-Belastung kenn ich, geht mir gleich. Aber teils gehts leider nicht anders. Heutzutage darf man teils auch einen kleinen TradeOff zugunsten der Codelesbarkeit in Kauf nehmen ;)

 

hth

Danke Euch, dann mache ich das mal wieder so wie schon an anderer Stelle hier : Ich nutze Euren Input und poste dann anschließend den Code . Da ich ja ohnehin modular arbeite,macht es mir garnichts aus und andere kleine Broker haben auch etwas von Eurer freundlichen Unterstützung .

 

Also ...zum Konzept =>

 

nutze dann Oderselect() um inhaltliche Veränderungen zu verfolgen und ich konzentriere mich auf die Magicnummer zur Identifizierung des Trades . Da ich diese bereits im EA einsetze, ist das besonders easy für mich . Anbei : das mit dem eventuellen Verändern der Ticketnummer kannte ich nicht, guter Hinweis .

 

- durch den Vgl der Orderhistory vorher/nachher sehe ich ob ein Trade geschlossen wurde : OrdersHistoryTotal( ) . Wenn das der Fall ist, dann muss ich eben herausfinden, welcher Trade und welches Pärchen das war . Dies ist für c.1. wichtig, denn dann muss der handelnde Trade wieder durch einen normalen passiven Trade (beginnend mit "pending")geschützt werden . Ausserdem muss dann ein möglicherweise inzwischen aktiviertes Pärchen wieder sinnvoll deaktiviert werden .

 

- während ich 1.) den floating loss des EA und 2.) SL und TP bei jedem Tick verfolgen will, so muss alles andere seltener durchgeführt werden . Im Hauptprogramm des EA ist bereits ein solcher Filter vorhanden, der nach neuen Perioden filtert . Also kann ich CPU zusätzlich schonen, wenn ich das berücksichtige .

 

Der entsprechende Auszug aus dem Hauptprogramm sieht wie folgt aus :

 

                                                 //                                               |
//+-----------------------------------------------------------------------------------------------+
//|                                *****   HAUPTPROGRAMM  *****                                   |
//+-----------------------------------------------------------------------------------------------+
                                                //                                               |
int start()                                      //                                               |
{                                                //                                               |
    Terminal()                                 ;// Status aller Trades holen , Foating P&L check |
    Event1()                                   ;// auf geschlossene Trades überprüfen            |
    Flags()                                    ;// Schwellwerte des RM/MM prüfen und ggfs Flags  |
                                                //                                               |
    if (prevTime == Time[0]) return(0)         ;// EA nur am Anfang der Periode                  |
    prevTime = Time[0]                         ;//                                               |
                                               ;//                                               |
    Visual()                                   ;// Informationsleiste updaten                    |
    Event2()                                   ;// Tradeveränderungen vollständig prüfen         |
                                                //                                               |
//   überprüfen ob der Markt dreht (Swing-Flag aus Terminal() ) und ggfs den  Hedge sperren & das |
//   nächste Pair zum handel freigeben                                                            |
    RMMM()                                     ;// Check for Swinging Market and lock in case    |
    Swing()                                    ;// trending back ? => all flat                   |
                                                //                                               |
//                   Tradingpreise ermitteln bzw gemäß aktuellem  Kurs aktualisieren              |
                                                //                                               |

 

Ich bedanke mich nun artig bei MQL4.com und nenne schön ordentlich die #Include Terminal() aus http://book.mql4.com/build/orders

und die #Include Events() aus http://book.mql4.com/build/events als Quelle aus der ich meine eigenen #Includes Event1() und

Event2() ableiten werde . Das kommt dann im nächsten Post von mir .

 

KB

Danke Euch, dann mache ich das mal wieder so wie schon an anderer Stelle hier : Ich nutze Euren Input und poste dann anschließend den Code . Da ich ja ohnehin modular arbeite,macht es mir garnichts aus und andere kleine Broker haben auch etwas von Eurer freundlichen Unterstützung .

 

- durch den Vgl der Orderhistory vorher/nachher sehe ich ob ein Trade geschlossen wurde : OrdersHistoryTotal( ) .

 

muss ich dich wieder warnen: Darauf würde ich mich nicht verlassen. Ich würde nicht ausschließen das der Broker alte Orders (zB nach einem Monat/Jahr) nicht mehr in der History führt. Wie immer hab ich schon von solchen Fällen gehört, mir selber noch nicht passiert, aber ich hab auch noch nicht viele Broker durch.

Diese ganzen Warnungen klingen vielleicht komisch, und bei den meisten Brokern sollten sie auch nicht nötig sein, aber ich finde wenn man mögliche Fehlerquellen ausschließen kann, sollte man das auch tun.

zB hier wäre es doch einfacher statt OrdersHistoryTotal einfach OrdersTotal zu nehmen. Also die Anzahl der offenen Trades (wenn einer geschlossen wird ändert sich ja beides).

In beiden Fällen solltest du vielleicht mitbedenken das du den EA dann nur exklusiv betreiben darfst. Weil sobald ein anderer EA mit anderer Magic, oder du händisch oder was weiß ich, Orders erstellt/schließt bauts dich auf. OrdersTotal unterscheided nicht nach Magicnumber. Wenn du die offenen einfach schnell durchläufst, bist du gegen solche Probleme gefeit.

 

Wenn ich eines beim EA-Programmieren gelernt hab, dann das "Safety first". Es geht in den Backtests gut, es geht im Livetest gut und dann kommst du im Realbetrieb nach 3 Monaten auf die Idee einen zweiten EA dazuzuschalten weils so gut läuft (und dein EA eh mit Magics arbeitet)... und Bumm Chaos und keiner weiß warum.

 

hth

 

Diese ganzen Warnungen klingen vielleicht komisch, und bei den meisten Brokern sollten sie auch nicht nötig sein, aber ich finde wenn man mögliche Fehlerquellen ausschließen kann, sollte man das auch tun.

zB hier wäre es doch einfacher statt ........

 

Mythos, diese Warnungen klingen für mich nicht im geringsten komisch ... meinen Avatar habe ich damals nach persönlichen Erfahrungen ausgesucht. Saftey First .

 

In beiden Fällen solltest du vielleicht mitbedenken das du den EA dann nur exklusiv betreiben darfst.

 

Dies wiederum will ich nun vermeiden, Magicnumber habe ich schon im Code , also zähle ich einfach meine Magicnummern-Trades durch , ist nur ein bischen mehr Arbeit für meine CPU und ich kann ansonsten auf meinem Konto herumtoben wie ich lustig bin, ohne dass ich "Ernten" bei seiner Arbeit störe :-)

 

Und hier ist der Code Event1() :

 

//+------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------------------------------------+
void Event1()                                    //                                                |
{                                                //                                                |
//+------------------------------------------------------------------------------------------------+
  TradeCountNew = 0                            ;// zerroize Counter                               |
  int Qnt=0                                    ;// Zeroize orders counter                         |
  for(int i=0; i<OrdersTotal(); i++)            // nur market und pending orders                  |
    {                                           //                                                |
     if((OrderSelect(i,SELECT_BY_POS)==true)    // den nächsten Trade aus der OrderListe auswählen|
     && (OrderSymbol()==Symbol()))              // Vorselektion, sonst brauche ich Magic garnicht |
       {                                        // .... erst überprüfen                           |
//+------------------------------------------------------------------------------------------------+
       Qnt++                                   ;// Amount of orders                               |
       if (OrderMagicNumber()>99700 &&          // Wenn es sich um                                |
           OrderMagicNumber()<99800)            // einen Ernten-Trade  handelt,                   |
           {                                    //                                                |
             TradeCountNew++                   ;// Ernten - Magicnumber gefunden , Count um 1 rauf|
           }                                    // die Klammer ist unnötig aber nur im Moment, wer|
       }                                        // weiß denn jetzt, was noch kommt ? KB nicht :-) |
    }                                           //                                                |
       if(TradeCountOld==TradeCountNew) return ;// alles beim alten                               |
//+------------------------------------------------------------------------------------------------+
  TradeCountOld = TradeCountNew                ;// etwas hat sich geändert . Counter rücksetzen   |
  ChangeModus = true                           ;// Flag setzen, dass sich etwas geändert hat .    |
// dieses Flag signalisiert anderen Programmteilen, dass weitere Prüfungen erfolgen müssen .       |
// diese müssen dann das Flag wieder zurücksetzen . ChangeModus ist also eine globale Bool -       |
// Variable . TradeCountNew /-Old sind globale INT                                                 |
 return                                        ;//                                                |
}                                                //                                                |
//+------------------------------------------------------------------------------------------------+
//+------------------------------------------------------------------------------------------------+ 

 

(Edit :)

Die Magicnumber habe ich vor definiert mit Nummern, die offensichtlich größer als 99770 aber

kleiner als 99800 sind .(Ende Edit)

 

Der Code ist im Compiler OK aber noch durch keinen Test gelaufen , ggfs muss später nachgebessert werden .

 

KB

 

Edit : Der Thread entfernt sich inhaltlich vom Titel des Thread . ... ?

Da bin ich wieder "... und ich hab da ma´ ne Frage ...."

 

//+------------------------------------------------------------------------------------------------+
         case ER_MAGIC_B21:                     //                                                |
           {                                    //                                                |
           LN = 1                              ;// erste Pair , Long                              |
           Eintrag(LN)                         ;// Daten eintragen                                |
           Beurteilen(LN)                      ;// den Trade klassifizieren                       |
           if(Ernten_New[LN][9]<MaxFloatLoss1 && Ernten_New[LN][0]>20)//                          |
             {Ernten_New[LN][10]=2.0;Ernten_New[LN+1][10]=1.0;       }// HIER IST EIN FEHLER      |
           }                                    //                                                |
           break;                               //                                                |
//+------------------------------------------------------------------------------------------------+

 

In diesem Code funktioniert die Zuweisung der absoluten Werte "2.0" und "1.0" in den mit Double definierten Array Ernten_New abgesichert nicht, denn ich hatte eine Comment-Anweisung in der "IF"-Abfrage platziert, die mir "o" für beide Zellen ausgegeben hat . Alternativ wird auch der Wert "2" und "1" nicht übernommen . Nach MQL-Handbuch scheine ich aber sauber gecodet zu haben, ich habe gleiche Syntax dort vorgefunden . http://book.mql4.com/variables/arrays

Die Zeile , in der zugewiesen soll habe ich markiert mit "HIER IST EIN FEHLER" .

 

Vielen Dank im voraus

 

Euer KB

Offensichtlicher Fehler ist da keiner.

Wie hast du denn das Array deklariert und wie stellst du fest, dass die Zuweisungen nicht funktionieren?

Offensichtlicher Fehler ist da keiner.

Wie hast du denn das Array deklariert und wie stellst du fest, dass die Zuweisungen nicht funktionieren?

 

double     Mas_Ord_New[31][9],                   // Current order array ..                        |
          Mas_Ord_Old[31][9],                   // .. old order array                            |
          Ernten_New[10][10],                   // All new Orders of EA Ernten ..                |
          Ernten_Old[10][10],                   // All old Orders of EA Ernten ..                |

 

Dies ist die zugehörige Deklarierung .

 

In den Code oben hatte ich eine Comment-Anweisung plaziert, die die Werte der beiden Zellen Ernten_New[LN][10] und Ernten_New[LN+1][10] auszudrucken hatte . Hier bekam ich als Ergebnis "0" obwohl IF "True" war und somit auch die Zuweisungen hätten stattfinden müssen .

KB

Habe die Comment Anweisung eingefügt und als Alternative den Werten 2 und 1 die Variablen A und B zugeordnet . Zusätzlich Neustart des Compiler und des Terminal . Ergebnis unverändert . Nicht zu fassen :

 

 

Der Code :

 

void Einsortieren(int Magicnr)                   //                                                |
{                                                //                                                |
//+------------------------------------------------------------------------------------------------+
//|   function  : sortiert die selektierte Order in d. Array Ernten ein und klassifiziert den Trade|
//|               nach jeweiligem Zustand Trader/Hedge , L/S , pending/aktiv , verriegelt N/J      |
//+------------------------------------------------------------------------------------------------+
       int LN = 0                              ;// LN = Line = Zeile                              |
       double A = 2 , B = 1                    ;//                                                |
       switch( Magicnr )                        //                                                |
       {                                        //                                                |
//+------------------------------------------------------------------------------------------------+
         case ER_MAGIC_B21:                     //                                                |
           {                                    //                                                |
           LN = 1                              ;// erste Pair , Long                              |
           Eintrag(LN)                         ;// Daten eintragen                                |
           Beurteilen(LN)                      ;// den Trade klassifizieren                       |
           if(Ernten_New[LN][9]<MaxFloatLoss1 && Ernten_New[LN][0]>20)//                          |
             {
             Ernten_New[LN][10]=A;
             Ernten_New[LN+1][10]=B;
    Comment (" Noch ein Test ",Ernten_New[LN][10],"|",Ernten_New[LN+1][10],"|",A,"|",B);
             }//                          |
           }                                    //                                                |
           break;                               //                                                |
//+------------------------------------------------------------------------------------------------+

Ich zitiere deinen Link:

 

For example, for the array

Mas[10][15]

the element with the smallest indexes value is the element

Mas[0,0]

, the one with maximal indexes values is the element

Mas[9,14]

.

 

Demnach ist

Ernten_New[10][10],                   // All new Orders of EA Ernten ..                
Ernten_Old[10][10],                   // All old Orders of EA Ernten ..                

falsch, um auf Index[10] zuzugreifen. Stattdessen musst du mit [11] deklarieren, damit du eine Indexierung von 0 bis 10 hast (11 Elemente). Dann sollte auch das Zuweisen und Zugreifen funktionieren.