Ist es Möglich zurück an den Anfang der Kurs-Daten zu springen innerhalb einer initialisierung?

Einloggen oder registrieren, um einen Kommentar zu schreiben
Bayne
745
Bayne  

Hey,

ich würde gerne alle KursDaten die ich brauche in ein File schreiben.   Logischerweise muss der EA dafür erstmal die gesamten Daten durchlaufen.   Anfang bis Ende.

danach soll mein Neuronales Netzwerk auf diese Daten Trainiert werden.


Um eine Neuinitialisierung zu vermeiden frage ich:

Ist es Möglich Am ende wieder an den Anfang zu springen        (etwa nach dem Pseudocode:)


input bool training = true                    // Training or Livetrading
static bool filewritten;                      // is file already written in first trail, so that now we can train on it?


OnTick()
{
if(training = true && filewritten=false)
      {
      WriteFile();                    //write file

      if(iTime(...) == FinalDay)      // if all data written, stop writing...
            {
            filewritten = true;
            JumpBackToBeginnDate(); <========== THIS is what I am looking for !!!
            }
      
      }

else if (training = true && filewritten = true)
      {
      TrainOnFile();                  // ... and start training
      }


else if (traininf = false)
  {TradingAlgorithm();}               //normal boring trade executions
}
amando
1735
amando  
Bayne:

Hey,

ich würde gerne alle KursDaten die ich brauche in ein File schreiben.   Logischerweise muss der EA dafür erstmal die gesamten Daten durchlaufen.   Anfang bis Ende.

danach soll mein Neuronales Netzwerk auf diese Daten Trainiert werden.


Um eine Neuinitialisierung zu vermeiden frage ich:

Ist es Möglich Am ende wieder an den Anfang zu springen        (etwa nach dem Pseudocode:)


Also ich miss gestehen, ich hab keine ahnung was du meinst. Und dieser code kann nicht funktionieren 

Bayne
745
Bayne  
amando:

Also ich miss gestehen, ich hab keine ahnung was du meinst. Und dieser code kann nicht funktionieren 

Ich habe ein Neuronales Netz das ich trainieren will. Mein Bester Einfall ist leider nur dieses anhand einer CSV mit den Input Daten zu trainieren.

Die CSV muss ich jedoch erst noch erstellen. Wenn ich die Erstellung und das Training in einem Zug  erledigen kann wäre das Top.

Um die Daten in eine CSV zu schreiben fällt mir momentan nur ein bei jeder Neuen Bar die Indikatoren, Kurse usw zu generieren und als eine neue Zeile zu schreiben.

Ich will aber den EA nicht zweimal durchlaufen lassen ( einmal mit bool "collectdata" und einmal mit bool "trainingondata" auf true) (oder gar 2 verschiedene EAs).

Deshalb war mein gedanke der, in der OnTick() eine funktion zu generieren die die daten sammelt und wenn diese über den kompletten History Verlauf gelaufen ist und alles in eine CSV geschrieben hat letztenendes die zeit zurückzusetzen und dann die Trainingsfunktion TrainOnFile() durchlaufen zu lassen. Von Anfang bis Ende der Daten. (wobei mir gerade einfällt, das der zweite teil auch geschehen kann ohne nochmal über alle Kursabfolgen zu iterieren, sondern diese funktion einfach an die letzte Data des gesamten kursverlaufes zu setzen und dort auszuführen...)


Wie auch immer... Ist es möglich innerhalb einer StrategieTester Session zurück an den Anfang zu springen?

nach dem schema (Start : 11.01.2017 ; End 11.01.2018; ) und wenn ein bestimmtes ereignis aufkommt (z.B. das letzte Datum 11.01.2018) dass die funktion wie in einem loop zurück zum 11.01.2017 spring und von dort aus nocheinmal neu testet (mit dem unterschied dass nun ein bool aktiviert wurde der den EA etwas ganz anderes berechnen lässt)

Chris70
122
Chris70  

Ach ja... irgendwie doch schwer mit anzusehen;-)

Wozu die Trainingsdaten überhaupt speichern? Sie sind nach dem Training uninteressant. Zudem: der Metatrader häuft doch bereits Berge an Tickdaten auf der Festplatte an und liefert alle nötigen Instrumente, darauf zuzugreifen. Wozu also diese unter anderem Format ein zweites Mal speichern?

Wenn Du nicht speicherst erübrigt sich auch das "Zurücksetzen" für einen zweiten Durchlauf (=den vorgeschlagenen eigentlichen Trainingsdurchlauf). Du kannst bereits beim ersten und einzigen Durchlauf trainieren. Dann entweder Training bis das Testintervall beendet ist oder nach x Iterationen oder wenn das NN konvergiert (also wenn die cost function minimiert ist, sich z.B. also pro x Iterationen nicht mehr um mehr als 0.x Promille verbessert) --> danach TesterStop().

Du kannst Training und Trading über zwei verschiedene EA's handhaben, oder (einfacher) setze z.B. eine Input-Variable "input bool training_mode; //true=training, false=trading" und teile Dein Hauptprogramm entsprechend in zwei Pfade.

Zu der anderen Frage (nochmal: warum Dutzende Threads für ein Topic = Umsetzung neuronaler Netze in MQL5?) mit dem Y_Label: welche Frage soll das NN beantworten???? Dann ergibt sich das mit dem Label von selbst. Ein neuronales Netz ist ja kein magischer heiliger Gral, sondern nur ein schlaues Verfahren, um eine nicht-lineare Gleichung mit beliebig vielen Variablen per automatisierter empirischer Näherung zu lösen. Das ist sicherlich irgendwie ein geniales Konzept - was die Gleichung überhaupt lösen soll, wäre aber eine wichtige Frage.

Otto Pauser
1537
Otto Pauser  
Bayne:


if(training = true && filewritten=false)

Was willst du mit einem NN, wenn du nicht mal die primitivsten Grundlagen beherrschst.

if(training = true && filewritten=false)

Ist eine Zuweisung , kein logischer Vergleich. Muss heißen:

if(training == true && filewritten == false)

// besser:

if(training && !filewritten)
Chris70
122
Chris70  

Otto hat Recht. Man bemerkt an Deinem Code immer wieder, dass Du noch nicht sehr erfahren bist. Das ist ja absolut okay und auch neuronale Netze können ja eine Übung sein, mit der man programmieren lernen kann. Die Frage ist nur, ob die Reihenfolge zielführend ist, wenn man damit auch Geld verdienen möchte. Programmiere besser zuerst die Komponenten, die Teil JEDES Expert Advisors sein sollten, nämlich Module für

  • Position-Sizing
  • Drawdown-Management
  • Order-Handling
  • Regeln für Übernacht- und Wochenend-Positionen,Silvester, Weihnachten
  • Gebühren-Tracking
  • Swap-Berechung (und Verrechnung mit Balance)
  • Berechnung von Komissionen
  • korrekte GMT-Zeit im Backtesting
  • Umgang mit irregulären Symbolen (Gold/Silber, ECN-Accounts..)
  • Error-Handling
  • Erstellung erweiterter Backtest-Ergebnisberichte
  • ...
  • ...   [wem fällt noch was ein, was in der Liste noch fehlt? was ist alles für euch ein MUSS? --> wäre ein anderer Thread, aber sicherlich interessant]

Liege ich richtig in der Annahme, dass Du das meiste davon nicht fertig stehen hast? Ja, oder? Ich habe gerade mal bei mir nachgesehen: der allgemeine Code als jungfräuliche Ausgangsbasis, noch bevor irgendeine Handelslogik (geschweige künstliche Intelligenz) implementiert ist, macht bei mir alleine schon 1895 Zeilen aus und ist ein MUSS für annähernd realistische Tests und Sicherheit im live-Trading. Deshalb wäre es sicherlich zielführender, wenn Du zuerst solche Komponenten programmieren würdest. Ich befürchte aber, Du wirst das nicht hören wollen.

Du wirst übrigens von neuronalen Netzen enttäuscht sein, weil Du falsche Erwartungen hast. Ich habe ja schon rausgehört, dass Deine Inputdaten einfach nur auf den vergangenen Preisdaten beruhen. Und rate ich richtig? Du willst damit zukünftige Preise prognostizieren (das konkrete Y-Label willst Du ja immer noch nicht verraten)? Das wird nicht funktionieren. Ein normales MLP ist nicht für Zeitreihen geeignet. Da brauchst Du mindestens irgendeine Art rekurrentes Netz. LSTM's sind dafür der Klassiker. Und trotzdem wird es nicht brauchbar funktionieren, so dass nach Spread und Gebühren noch ein "Edge" übrigbleibt. Du bist nicht der Erste, der das ausprobiert.

Neuronale Netze habe trotzdem ihre Berechtigung, doch das sind meist abgefahrenere Anwendungen als der Versuch, Preise vorherzusagen (Beispiel: Sentiment-Analyse anhand von Tweets).

Und WENN Du Dich dann wirklich an künstlicher Intelligenz versuchst, gibt es sinnvollere Bereiche als neuronale Netze. Genetische Algorithmen sind z.B. eine super hilfreiche Sache [edit: habe gerade im englischen Teil des Forums ein Topic dazu angefangen]. Aber lass die neuronalen Netze momentan sein!

Christian
2826
Christian  

Chris hat die Kernpunkte schon dargestellt.

Ich ergänze ein wenig aus meiner Erfahrung heraus.


Also dein Ergeiz ist schon mal EINE wichtige Vorraussetzung .Dann fehlen aber leider ALLE Grundlagen.Das du dann auch noch  die jahrelang   gereiften FrameWorks(TensorFlow,Keras,PyTorch....... https://de.wikipedia.org/wiki/Deep_Learning)

einfach ignorierst ,zeugt von fehlender Vorstellungskraft um so eine Technik anzuwenden.


Du stolperst von einem Hinderniss zum nächsten ,ohne überhaupt dem Ziel die Anwendung eines Netzes näher zu kommen.

Um so etwas umzusetzen kommen sehr viele Zeilen Code zusammen.Chris hat es schon angedeutet. Bei mir sind alleine im PreProcess 1000 Zeilen drin.Das ist nur der Part der die Daten vorbereitet um dann dein so gesuchtes Y-Label zu erstellen.

In dem Tempo wie du lernst ist das einfache OrderSend() noch sehr viele Jahre entfernt.


Spiel mit Python....

Dafür wurde es gemacht. Entwicklungszeit verkürzen.

Daten bleiben Daten . Ob die nun durch MQL5  oder Python verarbeitet werden ist am Ende Egal.


Ich stand vor dem gleichen Problem wie du .Glücklicherweise war mir sofort bewusst das das Proof of Concept nicht in MQL5 entsteht.Habe mich dann für MatLab entschieden.

Bau dir einen Trading-Simulator in Python und probiere dich da aus.Im einfachsten Falle ist das eine große Schleife für die Tickdaten.

So kannst du alles frei gestallten und nach dem du überzeugt bist suchst du dir eine passende Kombination aus :


KI-FrameWork

Schnittstelle

TradingSoftware


Dein aktueller Weg wird dir kein Geld bringen.

Deep Learning – Wikipedia
Deep Learning – Wikipedia
  • de.wikipedia.org
Deep Learning (frei übersetzt: ‚tiefgehendes Lernen‘) bezeichnet eine Klasse von Optimierungsmethoden künstlicher neuronaler Netze, die zahlreiche Zwischenlagen ( ) zwischen Eingabeschicht und Ausgabeschicht haben und dadurch eine umfangreiche innere Struktur aufweisen. In Erweiterungen der Lernalgorithmen für Netzstrukturen mit sehr wenigen...
Bayne
745
Bayne  
Christian:

Bau dir einen Trading-Simulator in Python und probiere dich da aus.Im einfachsten Falle ist das eine große Schleife für die Tickdaten.


Das hatte mein interesse damals geweckt, nur fiel mir schwer ein weg ein den Strategie Tester aus MQL brauchbar nachzuahmen ohne den gleichen Zeitaufwand wie die MQL implementierung eines NNs zu haben ... 

Christian
2826
Christian  
Bayne:

Das hatte mein interesse damals geweckt, nur fiel mir schwer ein weg ein den Strategie Tester aus MQL brauchbar nachzuahmen ohne den gleichen Zeitaufwand wie die MQL implementierung eines NNs zu haben ... 

Ich kann dir hier als Hilfe mal mein TradingSimulator in Matlab zeigen.

Als input bekommt er eine Datenbank mit Kauf und Verkaufssymbolen auf Minutenbasis . Immer zum CLOSE

Die Datenbank wird vorhher erstellt mit dem Netz . Warum getrennt?

Spätere Nachvollziebarkeit. Und durch Multithreading kann ich 4-5 Tests gleichzeitig machen.

Es kommt auch nicht auf die Slippage an oder Spread wenn du ein Proof of Conecept machtst.

DBtable =  Datenbank  MinutenBars.

dbSignals = Tradingsignale Zeiteinheit Minuten

opts = Parameter für den Test.


MatLab Code !

function [SimulatorResult] = NT_TradingSimulator(DBtable,dbSignals,opts)

save DBtable_Sim.mat DBtable;

%% Check some Envorements

opts.sim.bParallel = false ; %is_in_parallel();


%% Define Variables



Acc = Account;
Acc.StartBalance = 100000;
Acc.Balance = Acc.StartBalance;
Par = Param;

Par.StoppLoss  = 100;
Par.TakeProfit = 100;
Par.SimulatorLength = 10000;
Par.SimulatorMaxLength = 100;
Par.SimulatorMaxLength = opts.sim.simEnd;
Par.SimulatorLength = opts.sim.simEnd-opts.sim.simStart-300;

opts.trade.newTradeAfterTicks = 0;

simTicks = opts.sim.simEnd-opts.sim.simStart;    % Calc Real Simulator Ticks 
opts.sim.simTicks = simTicks;                    % Export Simulated Ticks for Plot
% assignin('base', 'opts', opts);

BalanceLow = 0;
BalanceHigh = 0;









%% Broker Setting
Point = 5;



% Create Result Array    Ask Bid OpenClosePrice TradeIn PnL_Ticks  PnL_� FREE Balance Signal TradeSignal BalanceLow BalanceHigh
%                         1   2       3            4        5        6    7     8       9       10           11           12

AR = zeros(opts.sim.simEnd,12); 

Ask                = DBtable.CLOSE;
% Bid                = DBtable.Bid(1);
DT                 = DBtable.TIME;
% DTmsc              = DBtable.DTmsc(1);
OpenClosePrice     = 0;
TradeIn            = 0;
PnL_Ticks          = 0;
PnL_Eur            = 0;
FREE               = 0;
Signal             = 0;
TradeSignal        = 0;
BalanceLow         = 0;
BalanceHigh        = 0;

% dbTrain           = table(Ask,Bid,DT,DTmsc);
% dbTrainSmall      = table(Ask,Bid);
% dbLoopT           = table(Ask,Bid,OpenClosePrice,TradeIn,PnL_Ticks,PnL_Eur,FREE,Signal,TradeSignal);



% clearvars Ask Bid DT DTmsc OpenClosePrice TradeIn PnL_Ticks PnL_Eur FREE Signal TradeSignal  ;






% Create Trade Array    
% TradeNum  TickNum   Dir   EntryTick   ExitTick  Status  PnL/Ticks  PnL  Commission   Lots
%   1        2        3        4          5         6        7        8      9          10
Trades = zeros(10,10);

Number         = 0;
TickNumber     = 0;
Dir            = 0;
EntryTick      = 0;
ExitTick       = 0;
Status         = 0;
PnL_Ticks      = 0;
PnL_Eur        = 0;
Commission     = 0;


% TradesT = table(Number,TickNumber,Dir,EntryTick,ExitTick,Status,PnL_Ticks,PnL_Eur,Commission);

% clearvars Number TickNumber Dir EntryTick ExitTick Status PnL_ticks PnL_eur Commission; 

% Create Trade Array for Plot    
TradesLong  = zeros(1,1);
TradesShort = zeros(1,1);





%% Simulation
if ~opts.sim.bParallel
    disp('*******************************************************')
    fprintf('Simulator started....\n')
    disp('*******************************************************')



  

    fprintf('\n')
    fprintf('Start at Time: %s  Tick: %d \n',DBtable.TIME(opts.sim.simStart),opts.sim.simStart)
    fprintf('End   at Time: %s  Tick: %d \n',DBtable.TIME(opts.sim.simEnd),opts.sim.simEnd)

    
end

Commission = 4; % 4� pro Lot

 FirstTick = true;
 Pos = false;
 PnL = 0;
 Balance = Acc.StartBalance;
 Equity = Balance;
 Balance_last = 0;
 Lots = 10;
 OpenPrice = 0;
 ClosePrice = 0;
 CloseTick = 0;
 TradeTick_open = 0;
 TradeTick_close = 0;
 TradeTypLong = false;
 TradeTypShort = false;
 FirstSignal = false;
 Trade_allowed = false;  % Trading is allowed or vorbidden
 Short_first = false;    % Detector first Signal Short
 Long_first = false;     % Detector first Signal Long
 
 Trades_long  = 0;
 Trades_short = 0;
 Trades_all   = 0;


% Vars for loop 


bool.ProcessNewTick   = false;

bool.TradingAllowed   = opts.sim.bTradingAllowed;


% Init Process Display

LoopStart = 1;
LoopEnd   = opts.sim.simEnd;

 round(LoopEnd/100);
Perc = 0;

% if ~opts.sim.bParallel
%   dispstat('10','init'); %one time only init 
%   dispstat('Begining the process loop...','keepthis','timespamp'); 
% end




% %% Create SubDirectory for Re-Test one Sim Result
%  if ~opts.sim.bTrainNewModel
%      cd(opts.core.AbsPath);
%      addpath(pwd);
%      NT_createReTestDir();
%  end

 %%  Create Output Graphics and Draw new Data
if ~opts.sim.bParallel && opts.Plot.ShowSimulatorProgressGui
     figure;
     ax1 = subplot(2,1,1);
     h_SimulatorOutputAX1 = plot(1,DBtable.Ask(1));
     ax2 = subplot(2,1,2);
     h_SimulatorOutputAX2 = plot(1,AR(1,8));
end

%% Simulator Loop
%
% % if ~opts.sim.bParallel
%   hbar_s = parfor_progressbar_v1(100,'Computing Trade Signals...');  %create the progress bar
% % end

for x = LoopStart : 1 : LoopEnd

    AR(x,1) = DBtable.CLOSE(x);                      % Save Ask
     
    if opts.core.simSTOP == true                    % Detect Stop Signal and exit
        break;
    end
    
    if ~opts.sim.bParallel
        if (mod(x,= 0)
         Perc = Perc +1;
%          hbar_s.iterate(1);   % update progress by one iteration
         %%  Works not in Virtual Mode dispstat(sprintf('Processing %d%%   Trades: %d',Perc,Trades_all),'timestamp'); 
%          dispstat(sprintf('Processing %d%%   Trades: %d  Balance: %d low: %d high: %d',Perc,Trades_all,round(AR(x-1,8)),round(AR(x-1,11)),round(AR(x-1,12))),'timestamp');
         %sprintf('Processing %d%%   Trades: %d',Perc,Trades_all);
         
         %% Create Output Graphics and Draw new Data
         if opts.Plot.ShowSimulatorProgressGui
           set(h_SimulatorOutputAX1,'XData',(1:x))
           set(h_SimulatorOutputAX1,'YData',DBtable.CLOSE(1:x))
           set(h_SimulatorOutputAX2,'XData',(1:x))
           set(h_SimulatorOutputAX2,'YData',AR(1:x,8))
          % refreshdata
           drawnow
         end
        end
    end
    

    
  
 

    
    
     


    
% ****************************************************************************************************************
% Trade Core  ****************************************************************************************************
% ****************************************************************************************************************
  if bool.TradingAllowed 
      
    
    
    
    PosOpened = false;
    PosClosed = false;
    TradeOpenLong = false;
    TradeOpenShort = false;
    TradeClose = false;
 
if ~FirstTick
    
    
    AR(x,9) = dbSignals(x);                          % Save actual Signal
    
    if opts.trade.InvertTrigger == false              % Original Trigger Logic
        if dbSignals(x) > opts.sim.SignalTriggerBuy   
         TradeOpenLong = true;
         Long_first = true;    
          if TradeTypShort
              TradeClose = true;
          end
         AR(x,10) = 1;
        end

        if dbSignals(x) < opts.sim.SignalTriggerSell
          TradeOpenShort = true;
          Short_first = true;
          if TradeTypLong
              TradeClose = true;
          end
          AR(x,10) = -1;
        end
    end
    if opts.trade.InvertTrigger == true                  % Switch Trigger Logic
        if dbSignals(x) < opts.sim.SignalTriggerSell   
         TradeOpenLong = true;
         Long_first = true;    
          if TradeTypShort
              TradeClose = true;
          end
         AR(x,10) = 1;
        end

        if dbSignals(x) > opts.sim.SignalTriggerBuy
          TradeOpenShort = true;
          Short_first = true;
          if TradeTypLong
              TradeClose = true;
          end
          AR(x,10) = -1;
        end
    end
 
    
end  

%% Detect First Switch of Signal
if Short_first && Long_first
    Trade_allowed = true;
end


%% Process TradeSignals

    if TradeClose                                          %% Close
   
      % TradeTyp = '';
       ClosePrice = DBtable.CLOSE(x);
%        CloseTick = x;
       Pos = false;
       PosClosed = true;
       TradeTypLong = false;
       TradeTypShort = false;
       OpenPrice = 0;
       
       
       % Fill Trade Array
       % TradeNum  TickNum   Dir   EntryTick   ExitTick  Status  PnL/Ticks  PnL  Commission Lots
       %   1        2        3        4          5         6        7        8       9       10
       Trades(Trades_all,5)     = DBtable.CLOSE(x);                     % Exit Price 
       Trades(Trades_all,6)     = 2;                                  % Status (0=Free 1=Open 2=Closed)
       Trades(Trades_all,7)     = round(PnL_ticks);                   % Profit and Loss Ticks
       Trades(Trades_all,8)     = round(PnL_ticks*Lots,2);            % Profit and Loss 
       Trades(Trades_all,9)     = Lots*Commission;                    % Commision for one Turn
       Trades(Trades_all,10)    = Lots;                               % Lots for Trade
   end



   if TradeOpenLong...      %% Buy 
      && ~Pos...
      && Trade_allowed
       %&& x > CloseTick + opts.trade.newTradeAfterTicks 
       
       TradeTypLong = true;
       OpenPrice = DBtable.CLOSE(x);
%        OpenTick = x;   
       Pos = true;
       %PosOpened = true;
       Trades_long = Trades_long + 1;
       Trades_all = Trades_all + 1;
       
       % Fill Trade Array
       % TradeNum  TickNum   Dir   EntryTick   ExitTick  Status  PnL/Ticks PnL   Commission  Lots
       %   1        2        3        4          5         6        7       8        9       10
       TradesLong(Trades_long,1) = x;              % Save Tick for Plot
       
       Trades(Trades_all,1)      = Trades_all;     % Trade Number
       Trades(Trades_all,2)      = x;              % Tick Number
       Trades(Trades_all,3)      = 1;              % Direction (Buy = 1  Sell = -1)
       Trades(Trades_all,4)      = DBtable.CLOSE(x); % Entry Price 
       Trades(Trades_all,6)      = 1;              % Status (0=Free 1=Open 2=Closed)
       
   end
   
  if TradeOpenShort...        %% Sell
     && ~Pos...
     && Trade_allowed
     %&& x > CloseTick + opts.trade.newTradeAfterTicks 
       
       TradeTypShort = true;
       OpenPrice = DBtable.CLOSE(x);
%        OpenTick = x;   
       Pos = true;
%        PosOpened = true;
       Trades_short = Trades_short + 1 ;
       Trades_all = Trades_all + 1;
       
       % Fill Trade Array
       % TradeNum  TickNum   Dir   EntryTick   ExitTick  Status  PnL/Ticks  PnL Commission Lots
       %   1        2        3        4          5         6        7        8      9       10
       TradesShort(Trades_short,1) = x;        % Save Tick for Plot
       
       
       Trades(Trades_all,1)    = Trades_all;     % Trade Number
       Trades(Trades_all,2)    = x;              % Tick Number
       Trades(Trades_all,3)    = -1;             % Direction (Buy = 1  Sell = -1)
       Trades(Trades_all,4)    = DBtable.CLOSE(x); % Entry Price 
       Trades(Trades_all,6)    = 1;              % Status (0=Free 1=Open 2=Closed)
   end

   
   
    
  
   
   
%% Calc Profit and Loss of open Position  
   
    if PosClosed
     
      AR(x,8) = AR(x-1,7);  
      %AR(x,7) = 0; %AR(x,8);
      AR(x,7) = AR(x,8); 
      
      
    end
   
   
    % Calc Positition if its open 
    if Pos && TradeTypLong  
        AR(x,3) = OpenPrice;
        AR(x,4) = 1;
        PnL_ticks = round(DBtable.CLOSE(x)-OpenPrice,6)/0.00001;
        AR(x,5) = PnL_ticks;
        
        AR(x,6) = (PnL_ticks*Lots)-Lots*Commission;
        Balance = Balance_last + AR(x,6);
        
        if ~PosClosed
          AR(x,8) = AR(x-1,8);
          AR(x,7) = AR(x,8) + AR(x,6); 
        end
    end
    
    if Pos && TradeTypShort
        AR(x,3) = OpenPrice;
        AR(x,4) = 1;
        PnL_ticks = round(OpenPrice-DBtable.CLOSE(x),6)/0.00001;
        AR(x,5) = PnL_ticks;
        AR(x,6) = (PnL_ticks*Lots)-Lots*Commission;
        Balance = Balance_last + AR(x,6);
        
        if ~PosClosed
         AR(x,8) = AR(x-1,8);
         AR(x,7) = AR(x,8) + AR(x,6); 
        end
    end
    
    
    
    
    
    
    
    % Calc Equity
    if ~FirstTick 
        
        
      if ~Pos && ~PosClosed 
       AR(x,3) = ClosePrice;  
       AR(x,8) = AR(x-1,8)+AR(x,6); 
       AR(x,7) = AR(x,8)+AR(x,6);    
      end          
    
    
% Calc Balance Low/High
       BalanceLow  = AR(x-1,11);
       BalanceHigh = AR(x-1,12);
        
       if AR(x,8) < BalanceLow            % save lowest Balance
          AR(x,11) = AR(x,8); 
       else 
          AR(x,11) = AR(x-1,11);
       end
      
       if AR(x,8) > BalanceHigh          %save highest Balance
           AR(x,12) = AR(x,8);
       else
           AR(x,12) = AR(x-1,12);
       end 
    end
    
    
    
    % Fill Result Array    Ask Bid OpenClosePrice TradeIn PnL_Ticks  PnL_� FREE Balance Signal TradeSignal BalanceLow BalanceHigh
    %                       1   2       3            4        5        6    7     8        9       10          11         12
   
    
   
   
    
    FirstTick = false;  
  end
% ****************************************************************************************************************
% ****************************************************************************************************************
% ****************************************************************************************************************
  
    
    
 
end
%  close(hbar_s);   %close progress bar
%  if ~opts.sim.bParallel
%   dispstat('Finished.','keepprev');
%  end
%% Postprocessing Simulator Loop
%clear x
  if ~opts.sim.bParallel
    disp('*******************************************************')
    disp('Simulator End!');
    disp('*******************************************************')
  end
    %% TradesT = table(Number,TickNumber,Dir,EntryTick,ExitTick,Status,PnL_Ticks,PnL_Eur,Commission);
    for i = 1 : 1 : Trades_all
        
    % TradesT(i) = table(Trades(i,1),Trades(i,2),Trades(i,3),Trades(i,4),Trades(i,5),Trades(i,6),Trades(i,7),Trades(i,8),Trades(i,9));       

    end
%     Simulator.DB_Signals = DB_Signals;
%     Simulator.Par = Par;
    Simulator.AR  = AR;
%     Simulator.Acc = Acc;
    Simulator.Result.Trades       = Trades;
    Simulator.Result.Trades_all   = Trades_all;
    Simulator.Result.Trades_long  = Trades_long;
    Simulator.Result.Trades_short = Trades_short;
    
    Simulator.Trades       = Trades;
    Simulator.Trades_all   = Trades_all;
    Simulator.Trades_long  = Trades_long;
    Simulator.Trades_short = Trades_short;
    Simulator.Com          = Trades_all*Lots*Commission;

    Simulator.Result.endBalance    = AR(x,8);
    Simulator.Result.BalanceLow    = AR(x,11);
    Simulator.Result.BalanceHigh   = AR(x,12);
    Simulator.Result.Profit        = AR(x,8)-AR(1,8);
    Simulator.Result.ProfitForward = AR(x,8)-AR(opts.sim.simStart,8);

    
    Simulator.Sim_ticks = simTicks;

    Simulator.TicksTrL = TradesLong;
    Simulator.TicksTrS = TradesShort;


    Simulator.Ticks = LoopEnd-LoopStart;

   
    Result = Simulator.Result.Profit;
    Balance = Simulator.Result.endBalance;
    if ~opts.sim.bParallel
        
        fprintf('Results:\n')
        fprintf('End Balance        : %d \n',round(Simulator.Result.endBalance))
        fprintf('Balance High       : %d \n',round(Simulator.Result.BalanceHigh))
        fprintf('Balance Low        : %d \n',round(Simulator.Result.BalanceLow))
        fprintf('Profit             : %d \n',round(Simulator.Result.Profit))
        fprintf('Profit Forward     : %d \n',round(Simulator.Result.ProfitForward))
        fprintf('Comission          : %d \n',Trades_all*Lots*Commission)
        fprintf('Trades             : %d \n',Simulator.Result.Trades_all)
        fprintf('Trades Long        : %d \n',Simulator.Result.Trades_long)
        fprintf('Trades Short       : %d \n',Simulator.Result.Trades_short)

%         fprintf('SignalTrigger Buy  : %d \n',round(opts.sim.SignalTriggerBuy,2))
%         fprintf('SignalTrigger Sell : %d \n',round(opts.sim.SignalTriggerSell,2))

    
    end
Einloggen oder registrieren, um einen Kommentar zu schreiben