3. MQL 4

MQL 4

  • E

    Hallo.

    Kennt sich Jemand mit MQL 4 aus? Ist ja eigentlich das Selbe wie C++.

    Ich zerbrech mir den Kopf darüber, wie man rausfinden kann, ob der RSI zuletzt über RSI_IL_2 ( obere Linie, 57.0 ) oder unter RSI_IL_1 ( untere Linie, 43.0 ) war. Das soll bestätigen, ob er eine Long- / Short-Order wirklich öffnet, wenn die anderen Bedingungen stimmen. Man müsste also - vermute ich jedenfalls - nacheinander den RSI von Kerze 2 an prüfen, bis die geprüfte Kerze über IL_2 / unter IL_1 ist. Habs mit ner while-Schleife versucht, aber da prüft er anscheinend immer nur bis Kerze 3. Das Problem ist wohl, glaube ich, dass die Bedingung für die Schleife irgendwie auch eine Vabriable enthält, die nach jedem Durchlauf geändert werden soll. Bin aber eher noch Einsteiger. Hab keine Ahnung, wie man das machen könnte.

    /*=============================================================================================================
// N O T I Z E N   U N D   I N F O S
//=============================================================================================================


Es sorgt für Bugs, Bar 1 mit Bar 0 zu vergleichen.

//-------------------------------------------------------------------------------------------------------------


//-------------------------------------------------------------------------------------------------------------

AutoLots werden falsch berechnet! Erst mal nicht benutzen!

//-------------------------------------------------------------------------------------------------------------

Bei SL 100 steigt er aus, obwohl im Trend noch Gewinne möglich sind.
SL 200 ist vielleicht immer noch zu wenig?
300 - 400 testen.

//-------------------------------------------------------------------------------------------------------------


RSI Periode:

1:RSI zeigt keine Werte.

2 ist zu schnell.

4 scheint gut zu sein. Ist aber ziemlich schnell.

5 wird getestet.


//-------------------------------------------------------------------------------------------------------------

STO Werte:

K-Period: 8 

D-Period: 6

Slowing:  5 wird getestet. Scheint ok zu sein.

//-------------------------------------------------------------------------------------------------------------

//=============================================================================================================
// P R O P E R T Y
//============================================================================================================*/
// #property strict
// #property strict sorgt anscheinend dafür, dass Kommentare im Konfig-Fenster im MT4 sichtbar sind.

#property copyright"RSI_STO_iTime_MT4_EA.mq4"
#property copyright"daniel-rudloff@web.de"
//=============================================================================================================
// B E S C H R E I B U N G
//=============================================================================================================
extern string TOY="true = on/yes";
extern string FON="false = off/no";
//=============================================================================================================
// E I N S T E L L U N G E N
//=============================================================================================================

extern string OOT="Open Order Types";

input bool open_Buy=true;
input bool open_Sell=true;

//-----------------------------------------------------------------------------------------------------------*/

extern string MN="Magic Numbers";

extern int Buy_MN=2;
extern int Sell_MN=4;

//-----------------------------------------------------------------------------------------------------------*/

extern string OOO1="Open Orders Only";
extern string OOO2="from/till?";
extern string OOO3="(Server Time)";

input bool Open_Only_From_Till=true; //

extern int Open_From_Hour=4; // Zum Testen ab 4 Uhr öffnen.
extern int Open_From_Min=0;
extern int Open_From_Sec=0;

extern int Open_Till_Hour=16;
extern int Open_Till_Min=52;
extern int Open_Till_Sec=0;

//-----------------------------------------------------------------------------------------------------------*/

extern string IOOFTF1="if";
extern string IOOFTF2="Open_Only_From_Till = false";
extern string IOOFTF3="Close_all_Orders_after";
extern string IOOFTF4="= false too";

extern string CAOTOC1="Close all Orders after";
extern string CAOTOC2="(Server Time)";

extern bool Close_all_Orders_after=true;

extern int Close_after_Hour=17;
extern int Close_after_Min=27;
extern int Close_after_Sec=0;

//-----------------------------------------------------------------------------------------------------------*/

extern double Lots=0.01;

extern string ALSZ="Auto Lotsize?"; // Wird falsch berechnet?

extern bool Percent_of_Balance=0; // Zum Testen aus
extern double Auto_Lotsize_Perc=0.25; // zum Testen 0,25%

//-----------------------------------------------------------------------------------------------------------*/

extern int Slippage=99999999;

//-----------------------------------------------------------------------------------------------------------*/

extern string MSE="Max Spread";
input bool Only_MS_Allowed=true;
extern int Max_Spread=50; //

//-----------------------------------------------------------------------------------------------------------*/

extern int Stop_Loss=300; // 300 testen

//-----------------------------------------------------------------------------------------------------------*/

extern string TS="Trailing Stop"; // Bei ActivTrades müssen SL/TP anscheinend mindestens 5 sein

input bool Trailing_Stop=false; // Zum Testen aus
extern int Trailing_Stop_Step=30; // Bei TSS 6 wurden gar keine Orders geöffnet.

//-----------------------------------------------------------------------------------------------------------*/

extern int Take_Profit=2000; // Zum Testen 2000

//-------------------------------------------------------------------------------------------------------------

input ENUM_TIMEFRAMES Timeframe=60; // M60 scheint intraday am Besten zu sein...
input ENUM_TIMEFRAMES NewBar_Timeframe=5; // 5 Min müssten mehr als genug sein...

//-------------------------------------------------------------------------------------------------------------

// RSI Einstellungen

extern string esRSI="Relative Strength Index";

extern double RSI_Min = 0.0;   // unten
extern double RSI_Max = 100.0; // oben

extern double RSI_IL_1 = 43.0; // unten
extern double RSI_IL_2 = 57.0; // oben

extern int RSI_Period = 3; // Zum Testen 3

input ENUM_APPLIED_PRICE RSI_Price = PRICE_CLOSE;

//-------------------------------------------------------------------------------------------------------------

// STO Einstellungen

extern string esSO1="Stochastic Oszillator";
extern string esSO2="(without int averaging method)";
extern string esSO3="(without int price_field)";

extern double Sto_Min = 0.0;   // unten
extern double Sto_Max = 100.0; // oben

extern double Sto_IL_1 = 20.0; // unten
extern double Sto_IL_2 = 80.0; // oben

extern int K_Period = 8;
extern int D_Period = 6;
extern int Slowing  = 5; // Bei 0 hat STO keine Werte.

//-------------------------------------------------------------------------------------------------------------

//=============================================================================================================
// D E K L A R A T I O N E N
//=============================================================================================================

bool RT,SPR_AL,BuyInv,SelInv,OM,OC;

double Buy_SL,Sel_SL,Buy_TP,Sel_TP;

int i,Ti;

//=============================================================================================================
// I N I T / D E I N I T
//=============================================================================================================
int OnInit(){
  ChartSetSymbolPeriod(0,Symbol(),Timeframe);
  return(0);}
void OnDeinit(const int reason){
  return;}
//=============================================================================================================
// E A   F U N K T I O N E N   S T A R T
//=============================================================================================================
int start(){
//=============================================================================================================
// O P E N   T I M E
//=============================================================================================================

RT=false; // RT = Right Time

if(Open_Only_From_Till==false){
  RT=true;
  Close_all_Orders_after=false;}

if(Open_Only_From_Till==true&&Hour()>=Open_From_Hour&&Minute()>=Open_From_Min&&Seconds()>=Open_From_Sec&&Hour()<=Open_Till_Hour&&Minute()<=Open_Till_Min&&Seconds()<=Open_Till_Sec)RT=true;

//-------------------------------------------------------------------------------------------------------------

datetime NewBarTF = iTime(Symbol(),NewBar_Timeframe,0);
datetime TradingTF = iTime(Symbol(),Timeframe,0);

//=============================================================================================================
// L O T S
//=============================================================================================================


double Min_L=MarketInfo(Symbol(),MODE_MINLOT);
double Max_L=MarketInfo(Symbol(),MODE_MAXLOT);


if(Percent_of_Balance==true){
    
  
  double M_REQ=MarketInfo(Symbol(),MODE_MARGINREQUIRED); // nötige Margin für 1 Lot (100.000 Units)


//////////////////////////////////////////////////////////////////////////////////////////////////////////////


  double OpZ_A = 1.0 / Ask; // OpZ = One Point Zero ( 1.0 )


//////////////////////////////////////////////////////////////////////////////////////////////////////////////


//"1 Lot" geteilt durch Mindest-Lot, um später raus zu finden, wie viel Margin für Mindest-Lot gebraucht wird.
//z.B.: 1 Lot / 0.01 L = 100
  double OneL_MinL = 1.0 / Min_L; // ?


//Margin_für_1_Lot geteilt durch Ergebnis, um raus zu finden, wie viel Margin für Mindest_Lot benötigt wird.
//z.B.:  €1000,00 / 100 = €10,00
  double MREQ_MinL = OpZ_A / OneL_MinL; // ?


//////////////////////////////////////////////////////////////////////////////////////////////////////////////


//1% von Kontostand ausrechnen
//z.B.: €1000,00 / 100% = €10,00
  double OPAB = AccountBalance() / 100.0;


//1% des Kontostands * Prozent, für die Lots gekauft werden sollen
//z.B.: €10,00 * 2,5% = €25,00
  double OPAB_ALP = OPAB * Auto_Lotsize_Perc; // ?


//////////////////////////////////////////////////////////////////////////////////////////////////////////////


//Betrag, für den Lots gekauft werden sollen / Margin für Mindest-Lot
//z.B.: €25,00 / €10,00 = 2,5
  double OPABALP_MREQMinL = OPAB_ALP / MREQ_MinL;


//Ergebnis * Mindest-Lot
//z.B.: 2,5 * 0.01L = 0.025L (aufgerundet 0.03L)
  Lots = OPABALP_MREQMinL * Min_L; //  ?

}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////

if(Lots<Min_L)Lots=Min_L;
if(Lots>Max_L)Lots=Max_L;

//=============================================================================================================
// M A X   S P R E A D
//=============================================================================================================

//aktueller Spread
double SPR=Ask-Bid;

//-------------------------------------------------------------------------------------------------------------

//Max Spread Bedingungen
SPR_AL=false;
if((Only_MS_Allowed==false)||(Only_MS_Allowed==true&&NormalizeDouble(SPR<=Max_Spread*_Point,_Digits)))SPR_AL=true;

//=============================================================================================================
// S T O P   L O S S
//=============================================================================================================

//SL auf 0 stellen, wenn oben <1,
//um irgendwelche Missverständnisse zu vermeiden.
if(Stop_Loss<1){
  Buy_SL=0.0;
  Sel_SL=0.0;}

  else{
    Buy_SL=NormalizeDouble(Ask-Stop_Loss*_Point,_Digits);
    Sel_SL=NormalizeDouble(Bid+Stop_Loss*_Point,_Digits);}

//SL genauso groß wie Minstoplevels machen, wenn er kleiner ist:
double MSL=MarketInfo(Symbol(),MODE_STOPLEVEL);
if(Buy_SL<MSL)Buy_SL=MSL;
if(Sel_SL<MSL)Sel_SL=MSL;

//=============================================================================================================
// T A K E   P R O F I T
//=============================================================================================================

//TP auf 0 stellen, wenn oben <1,
//um irgendwelche Missverständnisse zu vermeiden.
if(Take_Profit<1){
  Buy_TP=0.0;
  Sel_TP=0.0;}

  else{
    Buy_TP=NormalizeDouble(Ask+Take_Profit*_Point,_Digits);
    Sel_TP=NormalizeDouble(Bid-Take_Profit*_Point,_Digits);}

//=============================================================================================================
// R S I   D E K L A R A T I O N
//=============================================================================================================

double RSI=iRSI(Symbol(),Timeframe,RSI_Period,RSI_Price,1);

//=============================================================================================================
// S T O C H A S T I C   D E K L A R A T I O N
//=============================================================================================================

double Sto_Ma=iStochastic(Symbol(),Timeframe,K_Period,D_Period,Slowing,NULL,NULL,MODE_MAIN,1);
double Sto_Si=iStochastic(Symbol(),Timeframe,K_Period,D_Period,Slowing,NULL,NULL,MODE_SIGNAL,1);

//=============================================================================================================
// P R U E F E N   O B   O R D E R S   G E O E F F N E T   S I N D
//=============================================================================================================

BuyInv=false;
SelInv=false;

for(i=OrdersTotal()-1;i>=0;i--){
  if(OrderSelect(i,SELECT_BY_POS)){
    if(OrderType()==OP_BUY&&OrderMagicNumber()==Buy_MN&&OrderSymbol()==Symbol())BuyInv=true;
    if(OrderType()==OP_SELL&&OrderMagicNumber()==Sell_MN&&OrderSymbol()==Symbol())SelInv=true;}}

//=============================================================================================================
// O P E N   O R D E R S
//=============================================================================================================

if( NewBarTF==TradingTF && RT==true && SPR_AL==true && BuyInv==false && SelInv==false ){


  if(open_Buy==true){

//         unten
    if(RSI>RSI_IL_1&&Sto_Ma>Sto_Si ){

      if(IsTradeAllowed()==true)Ti=OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage,Buy_SL,Buy_TP,NULL,Buy_MN,0,Beige);

      Print( "send Buy:" , "-RSI=",RSI , "-RSI_IL_1=",RSI_IL_1 , "-Sto_Ma=",Sto_Ma , "-Sto_Si=",Sto_Si , "-Bid=",Bid , "-Ask=",Ask , "-Spr=",SPR );

      if(Percent_of_Balance==true)Print( "AutoLot:" , "-MarginReq1L=",M_REQ , "-MinLot=",Min_L , "-OneL/MinL=",OneL_MinL , "-MREQ/MinL=",MREQ_MinL , "-AccBal=",AccountBalance() , "-1PercAccBal=",OPAB , "-ALP=",Auto_Lotsize_Perc , "-1PercAccBal*ALP=",OPAB_ALP , "-OPABALP/MREQMinL=",OPABALP_MREQMinL , "-OPABALP_MREQMinL*Min_L=",OPABALP_MREQMinL , "-Lots=OPABALP_MREQMinL*Min_L=",Lots );

      return(Ti);}}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////


  if(open_Sell==true){

//         oben
    if(RSI<RSI_IL_1&&Sto_Ma<Sto_Si ){

      if(IsTradeAllowed()==true)Ti=OrderSend(Symbol(),OP_SELL,Lots,Bid,Slippage,Sel_SL,Sel_TP,NULL,Sell_MN,0,Blue);

      Print( "send Sell:" , "-RSI=",RSI , "-RSI_IL_1=",RSI_IL_1 , "-Sto_Ma=",Sto_Ma , "-Sto_Si=",Sto_Si , "-Bid=",Bid , "-Ask=",Ask , "-Spr=",SPR );

      if(Percent_of_Balance==true)Print( "AutoLot:" , "-MarginReq1L=",M_REQ , "-MinLot=",Min_L , "-OneL/MinL=",OneL_MinL , "-MREQ/MinL=",MREQ_MinL , "-AccBal=",AccountBalance() , "-1PercAccBal=",OPAB , "-ALP=",Auto_Lotsize_Perc , "-1PercAccBal*ALP=",OPAB_ALP , "-OPABALP/MREQMinL=",OPABALP_MREQMinL , "-OPABALP_MREQMinL*Min_L=",OPABALP_MREQMinL , "-Lots=OPABALP_MREQMinL*Min_L=",Lots );

      return(Ti);}}

}


//=============================================================================================================
// M O D I F Y   O R D E R S
//=============================================================================================================


if(Trailing_Stop==true){

  for(i=OrdersTotal()-1;i>=0;i--){
    if(OrderSelect(i,SELECT_BY_POS)){
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

      //Neuer BUY-"SL" (B_TS) Funktionen/Berechnungen
      if(OrderType()==OP_BUY&&OrderMagicNumber()==Buy_MN&&OrderSymbol()==Symbol()){

        //BUY-Öffnungskurs - gesendeten BUY-SL, um Wert zu ermitteln, der vom Ask abgezogen wurde:
        double BOOP_BOSL = OrderOpenPrice() - OrderStopLoss();
        
        //ASK - BUY_SL double-Wert = neuer BUY-"SL", der bei OrderModify gesendet werden soll:
        double Buy_TS = Ask - BOOP_BOSL;

        //neuer BUY_"SL" - Trailing_Stop_Step.
        //Damit soll geprüft werden, ob BUY_"SL" (B_TS) nach gezogen werden muss.
        double BuyTS_TSS = NormalizeDouble( Buy_TS - Trailing_Stop_Step *_Point,_Digits);
        
        //Wenn aktueller/zuletzt gesendeter BUY_SL kleiner als
        //neuer BUY_SL - TSS ist, soll neuer BUY_"SL" (BUY_TS) gesendet werden:
        if( OrderStopLoss() < BuyTS_TSS ){
          
          if(IsTradeAllowed()==true)OM=OrderModify(OrderTicket(),OrderOpenPrice(),Buy_TS,OrderTakeProfit(),0,CLR_NONE);
          
          Print( "OM Buy:" , Symbol() , "-Bid=",Bid , "-Ask=",Ask , "-Spr=",SPR );}}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////


      //Neuer SELL-"SL" (S_TS) Funktionen/Berechnungen
      if(OrderType()==OP_SELL&&OrderMagicNumber()==Sell_MN&&OrderSymbol()==Symbol()){

        //gesendeter SELL_SL - Öffnungskurs, um double-Wert ermitteln, der zum BID dazu gerechnet wurde:
        double SOSL_SOOP = OrderStopLoss() - OrderOpenPrice();

        //BID + SELL-SL double-Wert = neuer SELL-"SL", der bei OrderModify gesendet werden soll
        double Sel_TS = Bid + SOSL_SOOP;

        double SelTS_TSS=NormalizeDouble(Sel_TS + Trailing_Stop_Step *_Point,_Digits);
        
        if( OrderStopLoss() > SelTS_TSS ){
          
          if(IsTradeAllowed()==true)OM=OrderModify(OrderTicket(),OrderOpenPrice(),Sel_TS,OrderTakeProfit(),0,CLR_NONE);
          
          Print( "OM Sell:" , Symbol() , "-Bid=",Bid , "-Ask=",Ask , "-Spr=",SPR );}}

}}}


//=============================================================================================================
// C L O S E   O R D E R S
//=============================================================================================================


for(i=OrdersTotal()-1;i>=0;i--){
  if(OrderSelect(i,SELECT_BY_POS)){


    if(OrderType()==OP_BUY&&OrderMagicNumber()==Buy_MN&&OrderSymbol()==Symbol()){
      
      if((Sto_Ma<Sto_Si ) ||(Close_all_Orders_after==true&&Hour()>=Close_after_Hour&&Minute()>=Close_after_Min&&Seconds()>=Close_after_Sec) ){

        if(IsTradeAllowed()==true)OC=OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,DarkGoldenrod);
        
        Print( "close Buy:" , Symbol() , "-Sto_Ma=",Sto_Ma , "-Sto_Si=",Sto_Si , "-Bid=",Bid , "-Ask=",Ask , "-Spr=",SPR );}}


    if(OrderType()==OP_SELL&&OrderMagicNumber()==Sell_MN&&OrderSymbol()==Symbol()){
      
      if((Sto_Ma>Sto_Si ) ||(Close_all_Orders_after==true&&Hour()>=Close_after_Hour&&Minute()>=Close_after_Min&&Seconds()>=Close_after_Sec) ){

        if(IsTradeAllowed()==true)OC=OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,DarkGreen);
        
        Print( "close Sell:" , Symbol() , "-Sto_Ma=",Sto_Ma , "-Sto_Si=",Sto_Si , "-Bid=",Bid , "-Ask=",Ask , "-Spr=",SPR );}}
        
}}


//=============================================================================================================
// E A   F U N K T I O N E N   B E E N D E N
//=============================================================================================================
return(0);}

    Edit:Kann man hier eigentlich keine Dateien hochladen?

    0
    ?
     1 Antwort
  • ?

    @EmQEl sagte in MQL 4:

    Kennt sich Jemand mit MQL 4 aus? Ist ja eigentlich das Selbe wie C++.

    ich leider nicht, sorry.
    aber eine c++-variante speziell für börsen-zocker finde ich interessant.
    wo gibt es mehr informationen zu der sprache?

    0
  • E

    MQL 4 ist schon alt. Inzwischen gibts schon lange MQL 5, von dem ich aber keine Ahnung habe. In den nächsten Jahren, vermute ich, erscheint MQL 6, bzw. der Metatrader 6. MQL 4 für den Metatrader 4 lernen lohnt sich eigentlich nicht mehr. Dazu gibts aber einige Bücher und etliche Webseiten und Videos. Einfach mal suchen.

    Wie gesagt ist MQL 4 eigentlich das Gleiche wie C++. Wie könnte man in Letzterem die oben gestellte Aufgabe lösen?

    0 1 Antwort

  • @EmQEl sagte in MQL 4:

    Wie gesagt ist MQL 4 eigentlich das Gleiche wie C++. Wie könnte man in Letzterem die oben gestellte Aufgabe lösen?

    Sorry, aber Programmieren für den Metatrader hat mit Vanilla C++ genau garnix zu tun.

    @EmQEl sagte in MQL 4:

    ob der RSI zuletzt über RSI_IL_2 ( obere Linie, 57.0 ) oder unter RSI_IL_1 ( untere Linie, 43.0 ) war.

    Werte Merken und vergleichen?

    0
  • E

    @EmQEl sagte in MQL 4:

    ob der RSI zuletzt über RSI_IL_2 ( obere Linie, 57.0 ) oder unter RSI_IL_1 ( untere Linie, 43.0 ) war.

    Werte Merken und vergleichen?

    Daran dachte ich auch schon. Aber dann müsste man Stunden lang Daten sammeln...

    Kennt sich Jemand hier aus mit Metatrader / MQL und FOREX Trading?

    Wahrscheinlich gehts nur mit mehreren (verschachtelten?) Schleifen oder ganz ohne Schleife. Ne While-Schleife kann wahrscheinlich nicht ne Bedingung prüfen und gleichzeitig Selbige bei Jedem Durchlauf verändern. So wird das wohl nix...

    https://filehorst.de/d/dfBbwxsz

    double RSI=iRSI(Symbol(),Timeframe,RSI_Period,RSI_Price,1);

//-------------------------------------------------------------------------------------------------------------


// RSI past

int RSI_Past_Bar = 2;
double RSI_Past = iRSI(Symbol(),Timeframe,RSI_Period,RSI_Price,RSI_Past_Bar);

int RSI_P_under=0;

          while( RSI_Past < RSI ){

      RSI_P_under++;
    
      RSI_Past_Bar++;

      return(RSI_P_under);}
    0 2 Antworten

  • Dieser Beitrag wurde gelöscht!
    0

  • @EmQEl
    Warum solltest du stundenlang Daten sammeln wollen? Warum in die Zukunft schauen?

    Ich nutze AgenaTrader. Und dieser liefert mir Kursdaten in verschiedenen Zeiteinheiten. Für jede Zeiteinheit bekomme ich eine wählbare Menge von Kerzen. So nutze ich privat für die Bestimmung der Großwetterlage bis zu 500 Wochenkerzen eines Kurses.

    Beschreibe doch mal bitte genau was du berechnen willst. Wie berechnet man den RSI, den RSI_IL_1 und RSI_IL_2? Auch gerne mal wie man diese von Hand berechnet. (PS: Willkommen in der Informatik)

    Prüfe auch mal ob du irgentwelche Plugins (Conditions, Indikatoren) in dieser Richtung findest.

    Und lass für den Anfang die Finger von Short-Order!!! Keinen Hebel und immer einen Stop setzen!!!

    0
  • E

    https://filehorst.de/d/dkdGqvEG

    IL 1 / 2 werden nicht berechnet. Bekommen nur ihren Wert in den Globalen Variablen.

    https://de.wikipedia.org/wiki/Relative_Strength_Index

    *Relative Strength Index
    Zur Navigation springen
    Zur Suche springen

    Der Relative Strength Index oder Relative-Stärke-Index (kurz: RSI) ist ein oszillierender Indikator, der 1978 von Welles Wilder entwickelt wurde. Er gehört zu den am häufigsten verwendeten Indikatoren in der technischen Analyse. Technisch gehört der RSI zu den Range-Compression-Oszillatoren; er kann Werte im Bereich von 0 bis 100 Prozent annehmen.

    Der RSI ist zu unterscheiden vom RSL-Indikator, dem Indikator der Relativen Stärke nach Robert A. Levy.
    Inhaltsverzeichnis

    1 Berechnung
2 Signal
3 Literatur
4 Weblinks

    Berechnung

    Der Indikator setzt die Auf- und Abwärtsbewegungen eines Basiswerts über die Zeit in Relation. Dazu wird ein gleitender Mittelwert der Auf- und Abwärtsbewegungen berechnet und ins Verhältnis gesetzt. Welles Wilder wählte hier 14 Tage (entsprechend α=1/14 oder N=27 in der EMA-Terminologie). Daneben sind heute auch 7, 9 oder 25 Tage üblich. Je kürzer der betrachtete Zeitraum ist, desto volatiler ist der Indikator, allerdings werden mit längeren Zeiträumen auch weniger Signale ausgelöst.

    Es wird zuerst die Summe aller positiven und negativen Kursänderungen errechnet:

    sum up ( t ) := ∑ i = 1 n max { P ( t − i + 1 ) − P ( t − i ) ; 0 } sum down ( t ) := − ∑ i = 1 n min { P ( t − i + 1 ) − P ( t − i ) ; 0 } {\displaystyle {\begin{aligned}{\text{sum}}_{\text{up}}(t)&:=\sum _{i=1}^{n}\max\{P(t-i+1)-P(t-i);0\}\\{\text{sum}}_{\text{down}}(t)&:=-\sum _{i=1}^{n}\min\{P(t-i+1)-P(t-i);0\}\end{aligned}}} {\displaystyle {\begin{aligned}{\text{sum}}_{\text{up}}(t)&:=\sum _{i=1}^{n}\max\{P(t-i+1)-P(t-i);0\}\\{\text{sum}}_{\text{down}}(t)&:=-\sum _{i=1}^{n}\min\{P(t-i+1)-P(t-i);0\}\end{aligned}}}

    Anschließend wird der Mittelwert der Summen genommen:

    avg up := sum up n avg down := sum down n {\displaystyle {\begin{aligned}{\text{avg}}_{\text{up}}&:={\frac {{\text{sum}}_{\text{up}}}{n}}\\{\text{avg}}_{\text{down}}&:={\frac {{\text{sum}}_{\text{down}}}{n}}\end{aligned}}} {\displaystyle {\begin{aligned}{\text{avg}}_{\text{up}}&:={\frac {{\text{sum}}_{\text{up}}}{n}}\\{\text{avg}}_{\text{down}}&:={\frac {{\text{sum}}_{\text{down}}}{n}}\end{aligned}}}

    Der RSI ergibt sich dann mit

    RSI := avg up avg up + avg down {\displaystyle {\text{RSI}}:={\frac {{\text{avg}}_{\text{up}}}{{\text{avg}}_{\text{up}}+{\text{avg}}_{\text{down}}}}} {\displaystyle {\text{RSI}}:={\frac {{\text{avg}}_{\text{up}}}{{\text{avg}}_{\text{up}}+{\text{avg}}_{\text{down}}}}}

    Alternativ zum arithmetischen Mittel kann auch exponentielle Glättung verwendet werden.
    Signal

    Aktien mit einem RSI von über 70 Prozent werden als „überkauft“ betrachtet, Werte mit einem RSI unter 30 Prozent als „überverkauft“. Manche Analysten passen diese Werte je nach Börsenumfeld an:

    in einem Bullenmarkt (Aufwärtstrend): Referenzlinie bei 40 % (überverkauft) und 80 % (überkauft)
in einem Bärenmarkt (Abwärtstrend): Referenzlinie bei 20 % (überverkauft) und 60 % (überkauft)

    Allgemein wertet man das Erreichen oder Überschreiten der Schwellenwerte Richtung Mittelbereich als eines mehrerer möglicher Kauf- bzw. Verkaufssignale.*

    0 1 Antwort

  • @EmQEl
    Ok nachdem ich nochmal dein Eingangsposting gelesen habe, glaube ich langsam zu wissen was du möchtest.

    Du hast ja in deinen Beispielen immer wieder die iRSI Funktion benutzt. Ein Blick in die Doku der RSI Funktion liefert mir da einen Verdacht.

    RSI Doku

    Probiere doch mal bitte folgendes. Setze timeframe auf PERIOD_D1, period auf 3, applied_price auf PRICE_CLOSE und offset auf 0. Und nun schnapp dir einen Tageskurs und lass den RSI berechnen. Nun berechne diesen Wert von Hand aus den drei aktuellsten Kerzen. Sie müssten übereinstimmen.

    Und nun setze offset auf 1 und berechne wiederum den RSI. Wenn meine Vermutung stimmt, kannst du auch diesen von Hand ausrechnen, in dem du die vier aktuellsten Kerzen nimmst und die aktuellste Kerze verwirfst.

    Daher vermute ich dass du einfach über den Offset iterieren musst. Du bestimmt den RSI für Offset=0 und vergleichst den Wert mit RSI_IL_1 und RSI_IL_2. Ist die Bedingung nicht erfüllt erhöhst du Offset um 1, bestimmst den RSI neu und vergleichst wiederrum. Ist danach die Bedingung nicht erfüllt, wiederholst du das Ganze für Offset 2, 3, 4, 5, 6,...

    0
  • E

    Weiss gerade nicht, was mit Offset gemeint ist.

    Damit wird jedenfalls sozusagen der RSI aufgerufen, dessen Include im MQL-include Ordner ist:

    double RSI=iRSI(Symbol(),Timeframe,RSI_Period,RSI_Price,1);

    Wobei die 1 am Ende für die Kerze steht, auf die er berechnet werden soll. Im Grunde müsste man diese einfach nur immer wieder mit ++ erhöhen, bis man weiß, aus welcher Richtung der RSI kommt.

    RSI Indikator:
    https://filehorst.de/d/dmnEnFeH

    (MT 4) EA:
    https://filehorst.de/d/dvhdFlhc

    Erst mal die Anfangswerte deklarieren:

    int RSI_Past_Bar = 2;
double RSI_Past = iRSI(Symbol(),Timeframe,RSI_Period,RSI_Price,RSI_Past_Bar);

int RSI_P_under=0;
int RSI_P_over=0;

    Dann Kerze für Kerze prüfen:

        if(RSI>RSI_IL_1&&Sto_Ma>Sto_Si ){
      
          
     while( RSI_Past < RSI ){
      
      RSI_P_under++;
          
      RSI_Past_Bar++;
      
      Print( "-RSI_Past_Bar=",RSI_Past_Bar , "-RSI_Past=",RSI_Past , "-RSI_P_under=",RSI_P_under );
          
      return(RSI_P_under);}

        if(RSI<RSI_IL_2&&Sto_Ma<Sto_Si ){
    
    
      while( RSI_Past > RSI ){
        
        RSI_P_over++;
        
        RSI_Past_Bar++;
        
        Print( "-RSI_Past_Bar=",RSI_Past_Bar , "-RSI_Past=",RSI_Past , "-RSI_P_over=",RSI_P_over );
        
        return(RSI_P_over);}

    Wenn am Ende der RSI_Past öfter über oder unter RSI Bar 1 war, soll das jeweils ne Bestätigung für Buy / Sell sein.

    Edit: Aber so wird das wahrscheinlich nix...

    0 1 Antwort

  • @EmQEl

    Weiss gerade nicht, was mit Offset gemeint ist.

    Sorry, ich meinte damit den shift Parameter. Schau einfach in die RSI Doku, dort siehst du den shift Parameter.

    Im Grunde müsste man diese einfach nur immer wieder mit ++ erhöhen, bis man weiß, aus welcher Richtung der RSI kommt.

    Genau das ist auch meine Vermutung. Ich würde aber wie zuvor besprochen die iRSI Funktion und deren Parameter überprüfen.

    0
  • E

    Oben war ich komplett auf dem Holzweg, befürchte ich...

    Es sollen allgemein in beide Richtungen Orders geöffnet werden:

    Buy (also drauf setzen, dass der Kurs nach oben geht), wenn die RSI-Kurve über IL 1 (untere Linie) ist und die Stochastic-Indikator anzeigt, dass es nach oben geht.

    if( RSI>RSI_IL_1 && Sto_Ma>Sto_Si  ){ ... Send Buy

    Sell (also drauf setzen, dass der Kurs nach unten geht), wenn die RSI-Kurve unter IL 2 (obere Linie) ist und der Stochastic-Indikator anzeigt, dass es nach unten geht.

    if( RSI<RSI_IL_2 && Sto_Ma<Sto_Si  ){... Send Sell

    Wie findet man also raus, ob die RSI-Kurve vorher bei nem Buy vorher unter IL 1 (untere Linie) und bei nem Sell vorher über IL 2 (obere Linie) war? Um Fehlsignale zu vermeiden.

    double RSI_Past = iRSI(Symbol(),Timeframe,RSI_Period,RSI_Price,RSI_Past_Bar);
int RSI_Past_Bar = 2;

    Eigentlich kann man ja nur mit ner Schleife ein RSI-Shift (RSI_Past_Bar) nach dem anderen abfragen, indem man diesen mit ++ nach jeder Prüfung erhöht. Eigentlich einfach, aber ich hab keine Ahnung wie schreiben und formulieren usw...

    EA:
    filehorst.de/d/deBEAHBG

    RSI Oszillator:
    filehorst.de/d/dFJGgJqd

    0
Anmelden zum Antworten