Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - MQL4 e MetaTrader 4 - Forum sulla programmazione MQL4

Alexey Viktorov 2015.12.25 16:55 #9861

mario_SC--:

Non so cosa cerchi di dimostrare con questo codice, ma so per certo che non posso rientrare nella categoria degli esaminatori... Quindi, se vuoi aiuto, dovrai diventare tu stesso un interrogatore. Un ciclo del genere facilmente, in certe condizioni, si chiude, e solo il caso può impedire che accada.

Aiuto: Perché l'EA non F Tutte le domande dei

[Deleted] 2015.12.25 18:31 #9862

Perché il debugger si "blocca" durante il debug dell'indicatore (perché accede ai confini dell'array), ma allo stesso tempo tutto viene disegnato normalmente sul grafico?

MT4 build 950, demo Alpari.

L'indicatore è allegato.

//+------------------------------------------------------------------+
//|                                     FX5_MACD_Divergence_V1.1.mq4 |
//|                                                              FX5 |
//|                                                    hazem@uk2.net |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, FX5"
#property link      "hazem@uk2.net"
//----
#property indicator_separate_window
#property indicator_buffers 4
#property  indicator_color1 Green
#property  indicator_color2 Red
#property  indicator_color3 Magenta
#property  indicator_color4 Blue
//----
#define  arrowsDisplacement 0.0001
//---- input parameters
extern string separator1 = "*** MACD Settings ***";
extern int    fastEMA = 12;
extern int    slowEMA = 26;
extern int    signalSMA = 9;
extern string separator2 = "*** Indicator Settings ***";
extern bool   drawIndicatorTrendLines = true;
extern bool   drawPriceTrendLines = true;
extern bool   displayAlert = true;
//---- buffers
double bullishDivergence[];
double bearishDivergence[];
double macd[];
double signal[];
//----
static datetime lastAlertTime;
static string   indicatorName;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   SetIndexStyle(0, DRAW_ARROW);
   SetIndexStyle(1, DRAW_ARROW);
   SetIndexStyle(2, DRAW_LINE);
   SetIndexStyle(3, DRAW_LINE);
//----   
   SetIndexBuffer(0, bullishDivergence);
   SetIndexBuffer(1, bearishDivergence);
   SetIndexBuffer(2, macd);
   SetIndexBuffer(3, signal);   
//----   
   SetIndexArrow(0, 233);
   SetIndexArrow(1, 234);
//----
   indicatorName = "FX5_MACD_Divergence_v1.1(" + fastEMA + ", " + 
                                 slowEMA + ", " + signalSMA + ")";
   SetIndexDrawBegin(3, signalSMA);
   IndicatorDigits(Digits + 2);
   IndicatorShortName(indicatorName);

   return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   for(int i = ObjectsTotal() - 1; i >= 0; i--)
     {
       string label = ObjectName(i);
       if(StringSubstr(label, 0, 19) != "MACD_DivergenceLine")
           continue;
       ObjectDelete(label);   
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int countedBars = IndicatorCounted();
   if(countedBars < 0)
       countedBars = 0;
   CalculateIndicator(countedBars);
//---- 
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateIndicator(int countedBars)
  {
   for(int i = Bars - countedBars; i >= 0; i--)
     {
       CalculateMACD(i);
       CatchBullishDivergence(i + 2);
       CatchBearishDivergence(i + 2);
     }              
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CalculateMACD(int i)
  {
   macd[i] = iMACD(NULL, 0, fastEMA, slowEMA, signalSMA, 
                   PRICE_CLOSE, MODE_MAIN, i);
   
   signal[i] = iMACD(NULL, 0, fastEMA, slowEMA, signalSMA, 
                     PRICE_CLOSE, MODE_SIGNAL, i);         
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CatchBullishDivergence(int shift)
  {
   if(IsIndicatorTrough(shift) == false)
       return;  
   int currentTrough = shift;
   int lastTrough = GetIndicatorLastTrough(shift);
//----   
   if(macd[currentTrough] > macd[lastTrough] && 
      Low[currentTrough] < Low[lastTrough])
     {
       bullishDivergence[currentTrough] = macd[currentTrough] - 
                                          arrowsDisplacement;
       //----
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentTrough], Time[lastTrough], 
                              Low[currentTrough], 
                             Low[lastTrough], Green, STYLE_SOLID);
       //----
       if(drawIndicatorTrendLines == true)
          DrawIndicatorTrendLine(Time[currentTrough], 
                                 Time[lastTrough], 
                                 macd[currentTrough],
                                 macd[lastTrough], 
                                 Green, STYLE_SOLID);
       //----
       if(displayAlert == true)
          DisplayAlert("Classical bullish divergence on: ", 
                        currentTrough);  
     }
//----   
   if(macd[currentTrough] < macd[lastTrough] && 
      Low[currentTrough] > Low[lastTrough])
     {
       bullishDivergence[currentTrough] = macd[currentTrough] - 
                                          arrowsDisplacement;
       //----
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentTrough], Time[lastTrough], 
                              Low[currentTrough], 
                              Low[lastTrough], Green, STYLE_DOT);
       //----
       if(drawIndicatorTrendLines == true)                            
           DrawIndicatorTrendLine(Time[currentTrough], 
                                  Time[lastTrough], 
                                  macd[currentTrough],
                                  macd[lastTrough], 
                                  Green, STYLE_DOT);
       //----
       if(displayAlert == true)
           DisplayAlert("Reverse bullish divergence on: ", 
                        currentTrough);   
     }      
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CatchBearishDivergence(int shift)
  {
   if(IsIndicatorPeak(shift) == false)
       return;
   int currentPeak = shift;
   int lastPeak = GetIndicatorLastPeak(shift);
//----   
   if(macd[currentPeak] < macd[lastPeak] && 
      High[currentPeak] > High[lastPeak])
     {
       bearishDivergence[currentPeak] = macd[currentPeak] + 
                                        arrowsDisplacement;
      
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentPeak], Time[lastPeak], 
                              High[currentPeak], 
                              High[lastPeak], Red, STYLE_SOLID);
                            
       if(drawIndicatorTrendLines == true)
           DrawIndicatorTrendLine(Time[currentPeak], Time[lastPeak], 
                                  macd[currentPeak],
                                  macd[lastPeak], Red, STYLE_SOLID);

       if(displayAlert == true)
           DisplayAlert("Classical bearish divergence on: ", 
                        currentPeak);  
     }
   if(macd[currentPeak] > macd[lastPeak] && 
      High[currentPeak] < High[lastPeak])
     {
       bearishDivergence[currentPeak] = macd[currentPeak] + 
                                        arrowsDisplacement;
       //----
       if(drawPriceTrendLines == true)
           DrawPriceTrendLine(Time[currentPeak], Time[lastPeak], 
                              High[currentPeak], 
                              High[lastPeak], Red, STYLE_DOT);
       //----
       if(drawIndicatorTrendLines == true)
           DrawIndicatorTrendLine(Time[currentPeak], Time[lastPeak], 
                                  macd[currentPeak],
                                  macd[lastPeak], Red, STYLE_DOT);
       //----
       if(displayAlert == true)
           DisplayAlert("Reverse bearish divergence on: ", 
                        currentPeak);   
     }   
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsIndicatorPeak(int shift)
  {
   if(macd[shift] >= macd[shift+1] && macd[shift] > macd[shift+2] && 
      macd[shift] > macd[shift-1])
       return(true);
   else 
       return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool IsIndicatorTrough(int shift)
  {
   if(macd[shift] <= macd[shift+1] && macd[shift] < macd[shift+2] && 
      macd[shift] < macd[shift-1])
       return(true);
   else 
       return(false);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetIndicatorLastPeak(int shift)
  {
   for(int i = shift + 5; i < Bars; i++)
     {
       if(signal[i] >= signal[i+1] && signal[i] >= signal[i+2] &&
          signal[i] >= signal[i-1] && signal[i] >= signal[i-2])
         {
           for(int j = i; j < Bars; j++)
             {
               if(macd[j] >= macd[j+1] && macd[j] > macd[j+2] &&
                  macd[j] >= macd[j-1] && macd[j] > macd[j-2])
                   return(j);
             }
         }
     }
   return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int GetIndicatorLastTrough(int shift)
  {
    for(int i = shift + 5; i < Bars; i++)
      {
        if(signal[i] <= signal[i+1] && signal[i] <= signal[i+2] &&
           signal[i] <= signal[i-1] && signal[i] <= signal[i-2])
          {
            for (int j = i; j < Bars; j++)
              {
                if(macd[j] <= macd[j+1] && macd[j] < macd[j+2] &&
                   macd[j] <= macd[j-1] && macd[j] < macd[j-2])
                    return(j);
              }
          }
      }
    return(-1);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DisplayAlert(string message, int shift)
  {
   if(shift <= 2 && Time[shift] != lastAlertTime)
     {
       lastAlertTime = Time[shift];
       Alert(message, Symbol(), " , ", Period(), " minutes chart");
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawPriceTrendLine(datetime x1, datetime x2, double y1, 
                        double y2, color lineColor, double style)
  {
   string label = "MACD_DivergenceLine_v1.0# " + DoubleToStr(x1, 0);
   ObjectDelete(label);
   ObjectCreate(label, OBJ_TREND, 0, x1, y1, x2, y2, 0, 0);
   ObjectSet(label, OBJPROP_RAY, 0);
   ObjectSet(label, OBJPROP_COLOR, lineColor);
   ObjectSet(label, OBJPROP_STYLE, style);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DrawIndicatorTrendLine(datetime x1, datetime x2, double y1, 
                            double y2, color lineColor, double style)
  {
   int indicatorWindow = WindowFind(indicatorName);
   if(indicatorWindow < 0)
       return;
   string label = "MACD_DivergenceLine_v1.0$# " + DoubleToStr(x1, 0);
   ObjectDelete(label);
   ObjectCreate(label, OBJ_TREND, indicatorWindow, x1, y1, x2, y2, 
                0, 0);
   ObjectSet(label, OBJPROP_RAY, 0);
   ObjectSet(label, OBJPROP_COLOR, lineColor);
   ObjectSet(label, OBJPROP_STYLE, style);
  }
//+------------------------------------------------------------------+

[Qualsiasi domanda da principiante, Domande dai principianti MQL5 [ARCHIVIO] Qualsiasi domanda da

Vladimir 2015.12.27 05:54 #9863

r772ra:

Nella tua domanda su come trovare il tasso più alto nel resto della giornata dopo una candela rialzista, la parte sul fuso orario dell'ora del server è stata omessa per qualche motivo. Il compito è strettamente legato al confine del giorno, e questi confini sono diversi in diverse aziende. I candelieri appartenenti a diversi giorni sono diversi. A seconda del fuso orario del server, i valori più alti che troverete apparterranno a giorni diversi. È normale nel suo caso?

Come codificare? Domande dai principianti MQL5 Cosa funziona davvero da

mt4trade 2015.12.27 18:39 #9864

Ciao a tutti!

Non sono un novellino, ma c'è una domanda "sciocca", dato che non ho quasi mai incontrato una situazione simile.

Supponiamo che ci sia un ordine pendente già impostato.
Usiamo l'indicatore per muovere il suo prezzo.
In un momento, l'ordine non può essere modificato perché il nuovo prezzo è entrato nell'intervallo proibito a causa degli stop come Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Ma l'ordine deve essere aperto "dal mercato".

Cosa possiamo fare in questo caso?

Possiamo cancellare l'ordine pendente e aprirne uno nuovo dal mercato?

Oppure, è possibile cambiare l'ordine pendente in uno aperto?

Tutte le domande dei Errori, bug, domande Dalla teoria alla pratica

Boris 2015.12.27 21:09 #9865

mt4trade:
Ciao a tutti!

Non sono un novellino, ma c'è una domanda "sciocca", dato che non ho quasi mai incontrato una situazione del genere.

Supponiamo che ci sia un ordine pendente già impostato.
Usiamo l'indicatore per muovere il suo prezzo.
In un momento, l'ordine non può essere modificato perché il nuovo prezzo è entrato nell'intervallo proibito a causa degli stop come Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Ma l'ordine deve essere aperto "dal mercato".

Cosa possiamo fare in questo caso?

Possiamo cancellare l'ordine pendente e aprirne uno nuovo dal mercato?

O l'ordine pendente può essere in qualche modo trasformato in un ordine aperto?

Se è così vicino al prezzo, il prezzo lo troverà, ma non, forse è meglio se è una fermata! E se si tratta di un limite, pazienza. Prova a sperimentare nel tester e l'ottimizzazione determinerà la migliore variante! Buona fortuna!

La sfida: cosa è EURUSD - Tendenze, previsioni [Qualsiasi domanda da principiante,

IIcuX0naT 2015.12.28 06:20 #9866

Per favore, aiutatemi.

Quando installo un EA su un grafico standalone, l'EA non funziona, perché la funzione start() non viene avviata.

Come posso implementare un aggiornamento del grafico da un EA che lo costruisce, o da un EA che è collegato a questo grafico?

MetaTrader 4 Build 529 Domande dai principianti MQL5 Auguri per MT5

mt4trade 2015.12.28 07:27 #9867

borilunad:
Se è così vicino al prezzo, il prezzo lo troverà da solo, e se non lo è, forse è meglio che sia una fermata! E quello del limite, poi la pazienza. Prova a sperimentare nel tester, e l'ottimizzazione determinerà la migliore variante! Buona fortuna!

Grazie! È tutto così chiaro. Ma voglio sapere la risposta alla mia domanda - cosa fare, se devo assolutamente far funzionare l'ordine, non importa dove andrà il prezzo? Devo cancellare l'ordine pendente e aprirne uno regolare o avere qualche altra variante?

[Qualsiasi domanda da principiante, Teoria del mercato Ordine pendente EA

Boris 2015.12.28 08:17 #9868

mt4trade:
Grazie! Ma ho bisogno di una risposta alla mia domanda - se un ordine deve essere attivato indipendentemente da dove va il prezzo ora, cosa dovrei fare? Devo cancellare l'ordine pendente e aprirne uno regolare?

Per me, se seguite la vostra strategia, allora fatelo! Non vi consiglio di cambiarla a metà strada, altrimenti senza risultati certi (positivi o negativi), non potete essere sicuri della razionalità della vostra strategia. Questo è tutto!

Segni di un sistema Assiomi del trading. Il protezione dalla decompilazione

mt4trade 2015.12.28 09:27 #9869

borilunad:
Per me, se segui la tua strategia, allora seguila! Non ti consiglio di cambiarla a metà strada, altrimenti senza risultati certi (positivi o negativi), non puoi essere sicuro della razionalità della tua strategia. Questo è tutto!

Di nuovo, grazie! Dici cose giuste, ma irrilevanti per la domanda. Ancora una volta: se il prezzo calcolato dell'ordine pendente ha colpito il range proibito, e non può essere modificato, ma deve (secondo la strategia) scattare al prezzo calcolato - come si fa a "trasformarlo" in uno scatenato? Per cancellarlo e aprirlo come uno normale? O ci sono altre opzioni? Per favore, rispondete esattamente a questa domanda.

Tutte le domande dei Cosa fare con il Dalla teoria alla pratica.

Paladin80 2015.12.28 10:12 #9870

mt4trade:
Grazie ancora! Dici cose giuste, ma irrilevanti per la domanda. :) Ancora una volta: se il prezzo calcolato di un ordine pendente ha colpito l'intervallo proibito e non può essere modificato, ma deve (secondo la strategia) scattare al prezzo calcolato - come faccio a "trasformarlo" in un trigger? Per cancellarlo e aprirlo come uno normale? O ci sono altre opzioni? Per favore, rispondete esattamente a questa domanda.

C'è incoerenza in questo approccio. Se ci si aspetta che una posizione venga aperta già nella zona di congelamento (non può essere modificata) da un ordine pendente, allora l'ordine dovrebbe essere inizialmente collocato a un prezzo diverso, al confine di questa zona di congelamento. Ecco perché il suo approccio non è accettato da molte persone.

Per essere specifico alla tua domanda. Prima rimuovi l'ordine pendente e poi apri immediatamente una posizione al prezzo corrente. Il problema è che durante queste azioni, il prezzo può muoversi fuori dalla zona di congelamento (in peggio) e la posizione sarà aperta ad un prezzo sbagliato. Un'altra opzione è quella di non creare un ordine pendente e memorizzare il valore per aprire la posizione in una variabile nel programma. Lo confronti con il prezzo attuale e se la condizione è soddisfatta (tenendo conto della zona di congelamento), apri una posizione.

Un consulente che seguirebbe Tutte le domande dei Domande dai principianti MQL5

Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - pagina 987