Cualquier pregunta de novato, para no saturar el foro. Profesionales, no pasen de largo. En ninguna parte sin ti - 6. - página 987

Nuevo comentario
 
mario_SC--:

No sé lo que está tratando de demostrar con este código, pero sé a ciencia cierta que no puedo encajar en la categoría de examinadores... Así que si quieres ayuda, tendrás que convertirte tú mismo en un preguntón. Un ciclo de este tipo fácilmente, bajo ciertas condiciones, hace un bucle, y sólo el azar puede evitar que ocurra.
 

¿Por qué el depurador se "cuelga" al depurar el indicador (porque accede a los límites del array), pero al mismo tiempo todo se dibuja normalmente en el gráfico?

MT4 build 950, Alpari demo.

Se adjunta el indicador.

//+------------------------------------------------------------------+
//|                                     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);
  }
//+------------------------------------------------------------------+
 
r772ra:
En su pregunta sobre la búsqueda de la tasa más alta en el resto del día después de una vela alcista, la parte sobre la zona horaria de la hora del servidor fue omitida por alguna razón. La tarea está estrictamente ligada al límite del día, y estos límites son diferentes en las distintas empresas. Los candelabros que pertenecen a los distintos días son diferentes. Dependiendo de la zona horaria del servidor, los valores más altos que encuentres pertenecerán a diferentes días. ¿Es esto normal en su caso?
 
Hola a todos!

No es un novato, pero hay una pregunta "tonta", ya que casi nunca me he encontrado con una situación así.

Supongamos que hay una orden pendiente ya establecida.
Utilizamos el indicador para mover su precio.
En un momento dado, la orden no puede ser modificada porque el nuevo precio ha entrado en el rango prohibido debido a las señales de parada como Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Pero la orden tiene que ser abierta "por el mercado".

¿Qué podemos hacer en este caso?

¿Podemos eliminar la orden pendiente y abrir una nueva por el mercado?

¿O es posible cambiar la orden pendiente por una abierta?
 
mt4trade:
Hola a todos.

No es un novato, pero hay una pregunta "tonta", ya que casi nunca me he encontrado con una situación así.

Supongamos que hay una orden pendiente ya establecida.
Utilizamos el indicador para mover su precio.
En un momento dado, la orden no puede ser modificada porque el nuevo precio ha entrado en el rango prohibido debido a las señales de parada como Ask/Bid +/- MarketInfo(Symbol(), MODE_STOPLEVEL / MODE_FREEZELEVEL).

Pero la orden tiene que ser abierta "por el mercado".

¿Qué podemos hacer en este caso?

¿Podemos eliminar la orden pendiente y abrir una nueva por el mercado?

¿O la orden pendiente puede transformarse de alguna manera en una orden abierta?
Si está tan cerca del precio, el precio lo encontrará, pero no, ¡tal vez sea mejor que sea un tope! Y si se trata de un límite, pues paciencia. Pruebe a experimentar en el probador y la optimización determinará la mejor variante. Buena suerte.
 

Por favor, ayuda.

Cuando instalo un EA en un gráfico independiente, el EA no funciona, porque la función start() no se inicia.

¿Cómo puedo implementar una actualización del gráfico desde un EA que lo construye, o desde un EA que se adjunta a este gráfico?

 
borilunad:
Si está tan cerca del precio, éste lo encontrará por sí mismo, y si no, ¡quizá sea lo mejor si se trata de una parada! Y la del límite, pues paciencia. Intenta experimentar en el probador y la optimización determinará la mejor variante. Buena suerte.
Gracias. Todo está muy claro. Pero quiero saber la respuesta a mi pregunta: ¿qué debo hacer si necesito absolutamente que la orden se active independientemente de la dirección del precio? ¿Debo eliminar la orden pendiente y abrir una normal o tener otras variantes?
 
mt4trade:
Gracias. Pero necesito una respuesta a mi pregunta: si una orden tiene que activarse independientemente de dónde vaya el precio ahora, ¿qué debo hacer? ¿Debo eliminar la orden pendiente y abrir una normal?
Para mí, si sigues tu estrategia, ¡hazlo! No recomendaría cambiarla a medias, ya que de lo contrario, sin resultados ciertos (positivos o negativos), no puedes estar seguro de la racionalidad de tu estrategia. ¡Eso es!
 
borilunad:
Para mí, si sigues tu estrategia, ¡síguela! No recomiendo cambiarla a mitad de camino, ya que de lo contrario, sin resultados ciertos (positivos o negativos), no puedes estar seguro de la racionalidad de tu estrategia. ¡Eso es!
De nuevo, ¡gracias! Dices cosas correctas, pero irrelevantes para la pregunta. Una vez más: si el precio calculado de la orden pendiente ha alcanzado el rango prohibido, y no puede ser modificada, sino que debe (según la estrategia) dispararse al precio calculado - ¿cómo se "convierte" en disparada? ¿Para borrarlo y abrirlo como uno normal? ¿O hay otras opciones? Por favor, responda exactamente a esta pregunta.
 
mt4trade:
Gracias de nuevo. Dices cosas correctas, pero irrelevantes para la pregunta. :) Una vez más: si el precio calculado de una orden pendiente ha alcanzado el rango prohibido y no puede modificarse, sino que debe (según la estrategia) dispararse al precio calculado, ¿cómo puedo "convertirla" en disparada? ¿Para borrarlo y abrirlo como uno normal? ¿O hay otras opciones? Por favor, responda exactamente a esta pregunta.
Este enfoque es incoherente. Si se espera abrir una posición en la zona de congelación (no puede ser modificada) de una orden pendiente, entonces la orden debe colocarse inicialmente a un precio diferente, en el límite de esta zona de congelación. Por eso su enfoque no es aceptado por mucha gente.

Para concretar su pregunta. Primero elimine la orden pendiente y luego abra inmediatamente una posición al precio actual. El problema es que durante estas acciones, el precio puede salirse de la zona de congelación (a peor) y la posición se abrirá a un precio equivocado. Otra opción es no crear una orden pendiente y almacenar el valor para abrir la posición en una variable del programa. Se compara con el precio actual y si se cumple la condición (teniendo en cuenta la zona de congelación), se abre una posición.
1...980981982983984985986987988989990991992993994...1179
Nuevo comentario