EIN EA BASIEREND AUF B BANDS UND B WIDTH, BRAUCHE DRINGEND HILFE!!

Alain Verleyen 2013.04.10 16:03 #11

surubabs:

Sorry einige Rechtschreibfehler,

Ich möchte die Breite des Bandes für diese es brauchen einige Berechnung wie

Breite=(oberes-Band-unteres-Band)/Basisband

Ist es möglich, diese Berechnung innerhalb der Ea zu machen?

Wie kann man das definieren? Als ich es versuchte, bekam ich einen Fehler,

Width[]=(Upperband[ ]-Lowerband[ ])/Baseband[ ],

Bitte um Ratschläge

Zeigen Sie bitte echten Code von dem, was Sie versuchen.

surubabs Suresh Kakkattil 2013.04.10 17:57 #12

angevoyageur:
Zeigen Sie echten Code von dem, was Sie versuchen, bitte.

Ich bin immer noch daran arbeiten, Sir, wenn u Replay zu meinem Beitrag, ich poste, was ich auf sie arbeiten,

//+------------------------------------------------------------------+
//|                                            Bolinger_Width_EA.mq5 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"

//--- input parameters
input int bands_period= 20;        // Bollinger Bands period
input int bands_shift = 0;         // Bollinger Bands shift
input double deviation= 2;         // Standard deviation
input double   Lot=1;            // Lots to trade
input ENUM_APPLIED_PRICE  applied_price=PRICE_CLOSE; //type of price or handle
//--- global variables
int BolBandsHandle;                // Bolinger Bands handle
double iBBUp[],iBBLow[],iBBMidle[];   // dynamic arrays for numerical values of Bollinger Bands
double width;
double            inputs[];        // array for storing inputs
double            weight[20];        // array for storing weights
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
  
//--- Do we have sufficient bars to work
   if(Bars(_Symbol,_Period)<60) // total number of bars is less than 60?
     {
      Alert("We have less than 60 bars on the chart, an Expert Advisor terminated!!");
      return(-1);
     }
//--- get handle of the Bollinger Bands and Width indicators
   BolBandsHandle=iBands(NULL,PERIOD_M1,bands_period,bands_shift,deviation,PRICE_CLOSE);
//--- Check for Invalid Handle
   if(BolBandsHandle<0)
     {
      Alert("Error in creation of indicators - error: ",GetLastError(),"!!");
      return(-1);
     }

   return(0);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- release indicator handles
   IndicatorRelease(BolBandsHandle);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- we will use the static Old_Time variable to serve the bar time.
//--- at each OnTick execution we will check the current bar time with the saved one.
//--- if the bar time isn't equal to the saved time, it indicates that we have a new tick.

   static datetime Old_Time;
   datetime New_Time[1];
   bool IsNewBar=false;

//--- copying the last bar time to the element New_Time[0]
   int copied=CopyTime(_Symbol,_Period,0,1,New_Time);
   if(copied>0) // ok, the data has been copied successfully
     {
      if(Old_Time!=New_Time[0]) // if old time isn't equal to new bar time
        {
         IsNewBar=true;   // if it isn't a first call, the new bar has appeared
         if(MQL5InfoInteger(MQL5_DEBUGGING)) Print("We have new bar here ",New_Time[0]," old time was ",Old_Time);
         Old_Time=New_Time[0];            // saving bar time
        }
     }
   else
     {
      Alert("Error in copying historical times data, error =",GetLastError());
      ResetLastError();
      return;
     }

//--- EA should only check for new trade if we have a new bar
   if(IsNewBar==false)
     {
      return;
     }

//--- do we have enough bars to work with
   int Mybars=Bars(_Symbol,_Period);
   if(Mybars<60) // if total bars is less than 60 bars
     {
      Alert("We have less than 60 bars, EA will now exit!!");
      return;
     }

   MqlRates mrate[];          // To be used to store the prices, volumes and spread of each bar   

/*
     Let's make sure our arrays values for the Rates and Indicators 
     is stored serially similar to the timeseries array
*/

// the rates arrays
   ArraySetAsSeries(mrate,true);
// the indicator arrays
   ArraySetAsSeries(iBBUp,true);
   ArraySetAsSeries(iBBLow,true);
   ArraySetAsSeries(iBBMidle,true);

//--- Get the details of the latest 3 bars
   if(CopyRates(_Symbol,_Period,0,3,mrate)<0)
     {
      Alert("Error copying rates/history data - error:",GetLastError(),"!!");
      return;
     }
   int err1=0;
   
   err1=CopyBuffer(BolBandsHandle,0,0,3,iBBMidle) || CopyBuffer(BolBandsHandle,1,0,3,iBBUp)
      || CopyBuffer(BolBandsHandle,2,0,3,iBBLow);
      if(err1<0 )
     {
      Print("Failed to copy data from the indicator buffer");
      return;

     }
   double d1=-1.0; //lower limit of the normalization range
   double d2=1.0;  //upper limit of the normalization range
      
      double x_min=MathMin(iBBMidle[ArrayMinimum(iBBMidle)],iBBUp[ArrayMinimum(iBBUp)],iBBLow[ArrayMinimum(iBBLow)]); //minimum value over the range
      double x_max=MathMax(iBBMidle[ArrayMaximum(iBBMidle)],iBBUp[ArrayMaximum(iBBUp)],iBBLow[ArrayMaximum(iBBLow)]); //minimum value ove
         
     for(int i=0;i<ArraySize(inputs);i++)
     {
      inputs[i]=(((((iBBUp[i]-iBBLow[i])/iBBMidle[i])-x_min)*(d2-d1))/(x_max-x_min))+d1;
     }
//--- store the neuron calculation result in the out variable
   out=(inputs,weight);
     
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);   // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);   // Bid price

//--- Declare bool type variables to hold our Buy and Sell Conditions
   bool Buy_Condition =(mrate[1].close > iBBUp[1] && mrate[1].open < iBBUp[1] &&  // White (bull) candle crossed the Lower Band from below to above
                        (iBBUp[0] - iBBLow[0])>(iBBUp[1] - iBBLow[1]) && (iBBUp[1] - iBBLow[1])>(iBBUp[2] - iBBLow[2])); // and Width is growing up

   bool Sell_Condition = (mrate[1].close < iBBLow[1] && mrate[1].open > iBBLow[1] &&  // Black (bear) candle crossed the Upper Band from above to below
                          (iBBUp[0] - iBBLow[0])>(iBBUp[1] - iBBLow[1]) && (iBBUp[1] - iBBLow[1])>(iBBUp[2] - iBBLow[2]));// and Width is falling down

   bool Buy_Close=(mrate[1].close<iBBMidle[1] && mrate[1].open>iBBMidle[1]);              // Black candle crossed the Upper Band from above to below

   bool Sell_Close=(mrate[1].close>iBBMidle[1] && mrate[1].open<iBBMidle[1]);           // White candle crossed the Lower Band from below to above

   if(Buy_Condition && !PositionSelect(_Symbol))    // Open long position
     {                                              // Width is growing up
      LongPositionOpen();                           // and white candle crossed the Lower Band from below to above
     }

   if(Sell_Condition && !PositionSelect(_Symbol))   // Open short position
     {                                              // Width is falling down
      ShortPositionOpen();                          // and Black candle crossed the Upper Band from above to below
     }

   if(Buy_Close && PositionSelect(_Symbol))         // Close long position
     {                                              // Black candle crossed the Upper Band from above to below
      LongPositionClose();
     }

   if(Sell_Close && PositionSelect(_Symbol))        // Close short position
     {                                              // White candle crossed the Lower Band from below to above
      ShortPositionClose();
     }

   return;
  }
//+------------------------------------------------------------------+
//| Open Long position                                               |
//+------------------------------------------------------------------+
void LongPositionOpen()
  {
   MqlTradeRequest mrequest;                             // Will be used for trade requests
   MqlTradeResult mresult;                               // Will be used for results of trade requests
   
   ZeroMemory(mrequest);
   ZeroMemory(mresult);
   
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);    // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);    // Bid price

   if(!PositionSelect(_Symbol))
     {
      mrequest.action = TRADE_ACTION_DEAL;               // Immediate order execution
      mrequest.price = NormalizeDouble(Ask,_Digits);     // Lastest Ask price
      mrequest.sl = 0;                                   // Stop Loss
      mrequest.tp = 0;                                   // Take Profit
      mrequest.symbol = _Symbol;                         // Symbol
      mrequest.volume = Lot;                             // Number of lots to trade
      mrequest.magic = 0;                                // Magic Number
      mrequest.type = ORDER_TYPE_BUY;                    // Buy Order
      mrequest.type_filling = ORDER_FILLING_FOK;         // Order execution type
      mrequest.deviation=5;                              // Deviation from current price
      OrderSend(mrequest,mresult);                       // Send order
     }
  }
//+------------------------------------------------------------------+
//| Open Short position                                              |
//+------------------------------------------------------------------+
void ShortPositionOpen()
  {
   MqlTradeRequest mrequest;                             // Will be used for trade requests
   MqlTradeResult mresult;                               // Will be used for results of trade requests
   
   ZeroMemory(mrequest);
   ZeroMemory(mresult);
   
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);    // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);    // Bid price

   if(!PositionSelect(_Symbol))
     {
      mrequest.action = TRADE_ACTION_DEAL;               // Immediate order execution
      mrequest.price = NormalizeDouble(Bid,_Digits);     // Lastest Bid price
      mrequest.sl = 0;                                   // Stop Loss
      mrequest.tp = 0;                                   // Take Profit
      mrequest.symbol = _Symbol;                         // Symbol
      mrequest.volume = Lot;                             // Number of lots to trade
      mrequest.magic = 0;                                // Magic Number
      mrequest.type= ORDER_TYPE_SELL;                    // Sell order
      mrequest.type_filling = ORDER_FILLING_FOK;         // Order execution type
      mrequest.deviation=5;                              // Deviation from current price
      OrderSend(mrequest,mresult);                       // Send order
     }
  }
//+------------------------------------------------------------------+
//| Close Long position                                              |
//+------------------------------------------------------------------+
void LongPositionClose()
  {
   MqlTradeRequest mrequest;                             // Will be used for trade requests
   MqlTradeResult mresult;                               // Will be used for results of trade requests
   
   ZeroMemory(mrequest);
   ZeroMemory(mresult);
   
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);    // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);    // Bid price

   if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)
     {
      mrequest.action = TRADE_ACTION_DEAL;               // Immediate order execution
      mrequest.price = NormalizeDouble(Bid,_Digits);     // Lastest Bid price
      mrequest.sl = 0;                                   // Stop Loss
      mrequest.tp = 0;                                   // Take Profit
      mrequest.symbol = _Symbol;                         // Symbol
      mrequest.volume = Lot;                             // Number of lots to trade
      mrequest.magic = 0;                                // Magic Number
      mrequest.type= ORDER_TYPE_SELL;                    // Sell order
      mrequest.type_filling = ORDER_FILLING_FOK;         // Order execution type
      mrequest.deviation=5;                              // Deviation from current price
      OrderSend(mrequest,mresult);                       // Send order
     }
  }
//+------------------------------------------------------------------+
//| Close Short position                                             |
//+------------------------------------------------------------------+
void ShortPositionClose()
  {
   MqlTradeRequest mrequest;                             // Will be used for trade requests
   MqlTradeResult mresult;                               // Will be used for results of trade requests
   
   ZeroMemory(mrequest);
   ZeroMemory(mresult);
   
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);    // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);    // Bid price

   if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)
     {
      mrequest.action = TRADE_ACTION_DEAL;               // Immediate order execution
      mrequest.price = NormalizeDouble(Ask,_Digits);     // Latest ask price
      mrequest.sl = 0;                                   // Stop Loss
      mrequest.tp = 0;                                   // Take Profit
      mrequest.symbol = _Symbol;                         // Symbol
      mrequest.volume = Lot;                             // Number of lots to trade
      mrequest.magic = 0;                                // Magic Number
      mrequest.type = ORDER_TYPE_BUY;                    // Buy order
      mrequest.type_filling = ORDER_FILLING_FOK;         // Order execution type
      mrequest.deviation=5;                              // Deviation from current price
      OrderSend(mrequest,mresult);                       // Send order
     }
  }
//+------------------------------------------------------------------+

Alain Verleyen 2013.04.10 18:11 #13

surubabs:
Ich arbeite noch daran, Sir, wenn Sie auf meinen Beitrag reagieren, werde ich Ihnen mitteilen, woran ich arbeite,

Warum haben Sie die Dokumentation nicht gelesen? MathMax und MathMin benötigen nur 2 Argumente.
Was ist out=(inputs,weight);?

surubabs Suresh Kakkattil 2013.04.10 18:31 #14

angevoyageur:

Warum haben Sie die Dokumentation nicht gelesen? MathMax und MathMin benötigen nur 2 Argumente.
Was bedeutet out=(inputs,weight);?

Ich habe versucht, die Docs in mathfunctions zu verstehen, aber ich konnte nicht die richtige finden, weil ich nicht weiß, welche ich benutzen soll.

Ich habe in den letzten Stunden eine nach der anderen ausprobiert, können Sie mir die richtige Methode zeigen?

Multi-Timeframe-Indikatoren Quantenanalyse Duca Korrekte Berechnung von Währungsindizes.

Alain Verleyen 2013.04.10 19:22 #15

surubabs:

Ich habe versucht, Docs in mathfunctions zu verstehen, aber ich konnte nicht die richtige finden, weil ich nicht weiß, welche ich verwenden sollte.

Ich habe versucht, eine nach der anderen letzten viele Stunden können Sie mir zeigen, die richtige Methode?

Die richtige Methode um was zu tun?

Kourosh Davallou 2013.04.11 11:59 #16

Hallo

DieFunktion MathMax gibt den Maximalwert von zwei Werten zurück.

 double x_max=MathMax(iBBMidle[ArrayMaximum(iBBMidle)],iBBUp[ArrayMaximum(iBBUp)]);

Die MathMin-Funktion gibt den Minimalwert zweier Werte zurück.

 double x_min=MathMin(iBBMidle[ArrayMinimum(iBBMidle)],iBBUp[ArrayMinimum(iBBUp)]);

Alain Verleyen 2013.04.11 12:12 #17

kourosh1347:

Hallo

Die Funktion MathMax gibt den Maximalwert von zwei Werten zurück.

Die MathMin-Funktion gibt den Minimalwert zweier Werte zurück.

Ja, gut erkannt ;-)

surubabs Suresh Kakkattil 2013.04.11 14:10 #18

kourosh1347:

Hallo

Die Funktion MathMax gibt den Maximalwert von zwei Werten zurück.

Die MathMin-Funktion gibt den Minimalwert zweier Werte zurück.

Ja, Sie haben Recht,

was ich tun möchte, ist iBBUp-IBBLow/iBBMiddle,

dann Name war es Breite, die Werte zurück zu Breite, wenn der Wert erhöht ex: Breite>0 ein Kauf offen (oben Breakout), Breite<0 ein Verkauf offen (unten Seite Breakout).

Ich kenne den genauen Code nicht, wie man ihn implementiert.

Ich versuche es mit der Nural Network Methode zu kodieren.

wie impliment es bitte helfen.

Fragen Sie! Jede Anfängerfrage, um das [ARCHIV]Alle Fragen von Anfängern,

graziani 2013.04.11 15:59 #19

surubabs:

Ja, Sie haben Recht,

Was ich tun möchte, ist iBBUp-IBBLow/iBBMiddle,

dann Name war es Breite, die Werte zurück zu Breite, wenn der Wert steigt ex: Breite>0 ein Kauf offen (oben Breakout), Breite<0 ein Verkauf offen (unten Seite Breakout).

Ich kenne den genauen Code nicht, wie man ihn implementiert.

Ich versuche es mit der Nural Network Methode zu kodieren.

wie impliment es bitte helfen.

es ist gut, große Ziele im Leben zu haben.

Alain Verleyen 2013.04.11 16:25 #20

surubabs:

Ja, Sie haben Recht,

Was ich tun möchte, ist iBBUp-IBBLow/iBBMiddle,

dann nennen Sie es war Breite, die Werte zurück zu Breite, wenn der Wert erhöht ex: Breite>0 ein Kauf offen (oben Breakout), Breite<0 ein Verkauf offen (unten Seite Breakout).

Ich kenne den genauen Code nicht, wie man ihn implementiert.

Ich versuche es mit der Nural Network Methode zu kodieren.

wie impliment es bitte helfen.

Was hat ein neuronales Netz mit Ihrer "Breite" zu tun? Es ist schwer, Ihnen zu folgen.

EIN EA BASIEREND AUF B BANDS UND B WIDTH, BRAUCHE DRINGEND HILFE!! - Seite 2