Toute question de débutant, afin de ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 6. - MQL4 et MetaTrader 4 - Forum de programmation MQL4

Alexey Viktorov 2015.12.25 15:55 #9861

mario_SC--:

Je ne sais pas ce que vous essayez de prouver avec ce code, mais je sais pertinemment que je ne peux pas entrer dans la catégorie des examinateurs... Donc si vous voulez de l'aide, vous allez devoir devenir vous-même un questionneur. Un tel cycle peut facilement, sous certaines conditions, se boucler, et seul le hasard peut l'empêcher de se produire.

L'apprentissage automatique dans la Championnat d'optimisation des algorithmes. Aide au codage

[Supprimé] 2015.12.25 17:31 #9862

Pourquoi le débogueur "plante" lors du débogage de l'indicateur (parce qu'il accède aux limites du tableau), alors que tout est dessiné normalement sur le graphique ?

MT4 build 950, Alpari demo.

L'indicateur est joint.

//+------------------------------------------------------------------+
//|                                     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);
  }
//+------------------------------------------------------------------+

Toute question des nouveaux Questions d'un "mannequin Questions des débutants MQL5

Vladimir 2015.12.27 04:54 #9863

r772ra:

Dans votre question sur la recherche du taux le plus élevé dans le reste de la journée après une bougie haussière, la partie concernant le fuseau horaire de l'heure du serveur a été omise pour une raison quelconque. La tâche est strictement liée à la limite de la journée, et ces limites sont différentes selon les entreprises. Les chandeliers appartenant à des jours différents sont différents. En fonction du fuseau horaire du serveur, les valeurs les plus élevées que vous trouverez appartiendront à des jours différents. Est-ce normal dans votre cas ?

À la recherche de Caractéristiques du langage mql5, Aide au codage

mt4trade 2015.12.27 17:39 #9864

Bonjour à tous !

Je ne suis pas un débutant, mais j'ai une question "bête", car je n'ai pratiquement jamais rencontré une telle situation.

Supposons qu'il y ait déjà un ordre en attente.
Nous utilisons l'indicateur pour faire bouger son prix.
À un moment donné, l'ordre ne peut pas être modifié parce que le nouveau prix est entré dans la fourchette interdite en raison des signes d'arrêt comme Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Mais l'ordre doit être ouvert "par le marché".

Que pouvons-nous faire dans ce cas ?

Peut-on supprimer l'ordre en attente et en ouvrir un nouveau par le marché ?

Ou bien, est-il possible de transformer l'ordre en attente en un ordre ouvert ?

Toute question des nouveaux La tâche de recherche [ARCHIVE !] Toute question

Boris 2015.12.27 20:09 #9865

mt4trade:
Bonjour à tous !

Je ne suis pas un débutant, mais il y a une question "idiote", car je n'ai pratiquement jamais rencontré une telle situation.

Supposons qu'il y ait déjà un ordre en attente.
Nous utilisons l'indicateur pour faire bouger son prix.
À un moment donné, l'ordre ne peut pas être modifié parce que le nouveau prix est entré dans la fourchette interdite en raison des signes d'arrêt comme Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Mais l'ordre doit être ouvert "par le marché".

Que pouvons-nous faire dans ce cas ?

Peut-on supprimer l'ordre en attente et en ouvrir un nouveau par le marché ?

Ou l'ordre en attente peut être transformé en un ordre ouvert ?

S'il est si proche du prix, le prix le trouvera, mais non, il vaut peut-être mieux que ce soit un arrêt ! Et si c'est une limite, alors la patience. Essayez d'expérimenter dans le testeur et l'optimisation déterminera la meilleure variante ! Bonne chance !

Où se situe la Achètent-ils des conseillers pour Personnes expérimentées en matière

IIcuX0naT 2015.12.28 05:20 #9866

Aidez-moi, s'il vous plaît.

Lorsque j'installe un EA sur un graphique autonome, l'EA ne fonctionne pas, car la fonction start() n'est pas lancée.

Comment puis-je mettre en œuvre une mise à jour du graphique à partir d'un EA qui le construit, ou d'un EA qui est attaché à ce graphique ?

Aide au codage [Toute question de débutant, Existe-t-il une assistance en

mt4trade 2015.12.28 06:27 #9867

borilunad:
S'il est si proche du prix, le prix le trouvera de lui-même, et sinon, c'est peut-être mieux s'il s'agit d'un arrêt ! Et celui de la limite, puis la patience. Essayez d'expérimenter dans le testeur, et l'optimisation déterminera la meilleure variante ! Bonne chance !

Merci ! C'est tellement clair. Mais je veux connaître la réponse à la question : que faire, si je dois absolument faire fonctionner la commande, quel que soit le prix ? Dois-je supprimer l'ordre en attente et en ouvrir un régulier ou avoir d'autres variantes ?

Toute question des nouveaux Aide au codage Fichier de queue

Boris 2015.12.28 07:17 #9868

mt4trade:
Merci ! Mais j'ai besoin d'une réponse à ma question : si un ordre doit être déclenché quelle que soit l'évolution du cours actuel, que dois-je faire ? Dois-je supprimer l'ordre en attente et en ouvrir un régulier ?

Pour moi, si vous suivez votre stratégie, alors faites-le ! Je ne recommanderais pas de la changer à mi-chemin, sinon sans certains résultats (positifs ou négatifs), vous ne pouvez pas être sûr de la rationalité de votre stratégie. C'est ça !

FOREX - Tendances, prévisions De la théorie à De la pratique à

mt4trade 2015.12.28 08:27 #9869

borilunad:
Pour moi, si vous suivez votre stratégie, alors suivez-la ! Je ne recommande pas de la changer à mi-parcours, sinon sans résultats certains (positifs ou négatifs), vous ne pouvez pas être sûr de la rationalité de votre stratégie. C'est ça !

Encore une fois, merci ! Vous dites les bonnes choses, mais sans rapport avec la question. Une fois de plus : si le prix calculé de l'ordre en attente a atteint la fourchette interdite, et qu'il ne peut pas être modifié, mais doit (selon la stratégie) être déclenché au prix calculé - comment le "transformer" en ordre déclenché ? Pour l'effacer et l'ouvrir comme une version normale ? Ou y a-t-il d'autres options ? Veuillez répondre exactement à cette question.

Toute question des nouveaux [ARCHIVE] Toute question de Un conseiller qui suivrait

Paladin80 2015.12.28 09:12 #9870

mt4trade:
Merci encore ! Vous dites les bonnes choses, mais sans rapport avec la question. :) Encore une fois : si le prix calculé d'un ordre en attente a atteint la fourchette interdite et qu'il ne peut pas être modifié, mais doit (selon la stratégie) se déclencher au prix calculé - comment puis-je le "transformer" en ordre déclenché ? Pour l'effacer et l'ouvrir comme une version normale ? Ou y a-t-il d'autres options ? Veuillez répondre exactement à cette question.

Il y a une incohérence dans cette approche. Si l'on s'attend à ce qu'une position soit déjà ouverte dans la zone de gel (elle ne peut pas être modifiée) à partir d'un ordre en attente, alors l'ordre doit être initialement placé à un prix différent, à la limite de cette zone de gel. C'est pourquoi votre approche n'est pas acceptée par beaucoup de gens.

Pour être plus précis sur votre question. Retirez d'abord l'ordre en attente, puis ouvrez immédiatement une position au prix actuel. Le problème est que pendant ces actions, le prix peut sortir de la zone de gel (à la baisse) et la position sera ouverte à un mauvais prix. Une autre option consiste à ne pas créer un ordre en suspens et à stocker la valeur d'ouverture de la position dans une variable du programme. Comparez-le avec le prix actuel et si la condition est remplie (en tenant compte de la zone de gel), vous ouvrez une position.

Toute question des nouveaux Conseiller Ivan - le [ARCHIVE] Toute question de

Toute question de débutant, afin de ne pas encombrer le forum. Professionnels, ne passez pas à côté. Nulle part sans toi - 6. - page 987