Escribir EAs gratuitos

[Eliminado] 2021.06.02 04:17 #121

SanAlex:

TOTAL : Indicador "ADX de ida y vuelta" de marzo a abril - no tiene éxito por alguna razón

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Este es el indicador propiamente dicho

Aquí hay un mejor resultado - filtro añadido (MA y RSI)

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Con un lote de 0,10

Archivos adjuntos:

MA_Back_and_forth_ADX.mq5 17 kb

MrBrooklin 2021.06.02 17:34 #122

SanAlex:

Aquí hay un mejor resultado - filtro añadido (MA y RSI)

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Con el lote 0,10

Buenas noches, me he dado cuenta de que tenéis una gran biblioteca de códigos ya hechos. ¿Tal vez tenga algún código que determine el precio de apertura de la barra anterior en el momento de crear una nueva? Saludos, Vladimir.

Cualquier pregunta de los [¡Archivo!] Cualquier pregunta de ¿A quiénes ilumina JAPAN

[Eliminado] 2021.06.02 18:41 #123

MrBrooklin:

Buenas noches, me he dado cuenta de que tienen una rica biblioteca de códigos ya hechos. ¿Tal vez tenga algún código que determine el precio de apertura de la barra anterior en el momento de crear una nueva? Saludos, Vladimir.

Por ejemplo, el resultado del trabajo del Asesor Experto es el precio de una barra en la barra anterior.

Por ejemplo, a partir de esta función - el resultado del Asesor Experto es peor

//+------------------------------------------------------------------+
//| Expert new tick handling function                                |
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0; // last trade processing time + timeout
//--- don't process if timeout
   if(TimeCurrent()>=limit_time)
     {
      //--- check for data
      if(Bars(Symbol(),Period())>2)
        {
         //--- change limit time by timeout in seconds if processed
         if(ExtExpert.Processing())
            limit_time=TimeCurrent()+ExtTimeOut;
        }
     }
  }
//+------------------------------------------------------------------+

Ni siquiera entiendo qué he estropeado aquí, pero el Asesor Experto da un mejor resultado apoyándose en el pinchazo.

//+------------------------------------------------------------------+
//| Expert new tick handling function                                |
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0,ExtTimeOut=0; // last trade processing time + timeout
//--- don't process if timeout
   limit_time=iTime(Symbol(),Period(),0);
   if(ExtTimeOut==limit_time)
      return;
//--- change limit time by timeout in seconds if processed
   if(ExtExpert.Processing())
      ExtTimeOut=limit_time;
  }
//+------------------------------------------------------------------+

[Eliminado] 2021.06.02 19:00 #124

SanAlex :

¡Buenas noches! Soy autodidacta y tomo códigos de ejemplos y logro la tarea que me propongo por el método de la punción científica.

Por ejemplo, de esta función: el resultado del experto es peor

y aquí yo mismo no entiendo qué hice trampa, pero al hurgar, el experto muestra mejor el resultado.

Aquí puede verificar la diferencia: reemplace solo el ejemplo anterior con la publicación

- en este EA

 //+------------------------------------------------------------------+
//|                                    EXP MA Back and forth ADX.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright    "Copyright 2021, MetaQuotes Ltd."
#property link          " https://www.mql5.com "
#property version      "1.00"
#property description "It is important to make sure that the expert works with a normal"
#property description "chart and the user did not make any mistakes setting input"
#property description "variables (Lots, TakeProfit, TrailingStop) in our case,"
#property description "we check TakeProfit on a chart of more than 2*trend_period bars"

#define MACD_MAGIC 7234102
//---
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//---
input double InpLots          = 0.01 ; // Lots
input int     InpTakeProfit    = 500 ;   // Take Profit (in pips)
input int     InpTrailingStop  = 300 ;   // Trailing Stop Level (in pips)
input int     InpBars          = 1 ;     // Bars
input int     InpMATrendPeriod = 14 ;   // MA trend period
//+------------------------------------------------------------------+
//| MACD Sample expert class                                         |
//+------------------------------------------------------------------+
class CSampleExpert
  {
protected :
   double             m_adjusted_point;             // point value adjusted for 3 or 5 points
   CTrade            m_trade;                       // trading object
   CSymbolInfo       m_symbol;                     // symbol info object
   CPositionInfo     m_position;                   // trade position object
   CAccountInfo      m_account;                     // account info wrapper
   //--- indicators
   int                m_handle_macd;                 // MACD indicator handle
   int                m_handle_ema;                 // moving average indicator handle
   int                m_handle_emas;                 // moving average indicator handle
   //--- indicator buffers
   double             m_buff_MACD_main[];           // MACD indicator main buffer
   double             m_buff_MACD_signal[];         // MACD indicator signal buffer
   double             m_buff_EMA[];                 // EMA indicator buffer
   double             m_buff_EMAS[];                 // EMA indicator buffer
   //--- indicator data for processing
   double             m_macd_current;
   double             m_signal_current;
   double             m_ema_current;
   double             m_ema_previous;
   //---
   double             m_traling_stop;
   double             m_take_profit;

public :
                     CSampleExpert( void );
                    ~CSampleExpert( void );
   bool               Init( void );
   void               Deinit( void );
   bool               Processing( void );

protected :
   bool               InitCheckParameters( const int digits_adjust);
   bool               InitIndicators( void );
   bool               LongClosed( void );
   bool               ShortClosed( void );
   bool               LongModified( void );
   bool               ShortModified( void );
   bool               LongOpened( void );
   bool               ShortOpened( void );
  };
//--- global expert
CSampleExpert ExtExpert;
//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CSampleExpert::CSampleExpert( void ) : m_adjusted_point( 0 ),
   m_handle_macd( INVALID_HANDLE ),
   m_handle_ema( INVALID_HANDLE ),
   m_handle_emas( INVALID_HANDLE ),
   m_macd_current( 0 ),
   m_signal_current( 0 ),
   m_ema_current( 0 ),
   m_ema_previous( 0 ),
   m_traling_stop( 0 ),
   m_take_profit( 0 )
  {
   ArraySetAsSeries (m_buff_MACD_main, true );
   ArraySetAsSeries (m_buff_MACD_signal, true );
   ArraySetAsSeries (m_buff_EMA, true );
   ArraySetAsSeries (m_buff_EMAS, true );
  }
//+------------------------------------------------------------------+
//| Destructor                                                       |
//+------------------------------------------------------------------+
CSampleExpert::~CSampleExpert( void )
  {
  }
//+------------------------------------------------------------------+
//| Initialization and checking for input parameters                 |
//+------------------------------------------------------------------+
bool CSampleExpert::Init( void )
  {
//--- initialize common information
   m_symbol.Name( Symbol ());                   // symbol
   m_trade.SetExpertMagicNumber(MACD_MAGIC); // magic
   m_trade.SetMarginMode();
   m_trade.SetTypeFillingBySymbol( Symbol ());
//--- tuning for 3 or 5 digits
   int digits_adjust= 1 ;
   if (m_symbol. Digits ()== 3 || m_symbol. Digits ()== 5 )
      digits_adjust= 10 ;
   m_adjusted_point=m_symbol. Point ()*digits_adjust;
//--- set default deviation for trading in adjusted points
   m_traling_stop    =InpTrailingStop*m_adjusted_point;
   m_take_profit     =InpTakeProfit*m_adjusted_point;
//--- set default deviation for trading in adjusted points
   m_trade.SetDeviationInPoints( 3 *digits_adjust);
//---
   if (!InitCheckParameters(digits_adjust))
       return ( false );
   if (!InitIndicators())
       return ( false );
//--- succeed
   return ( true );
  }
//+------------------------------------------------------------------+
//| Checking for input parameters                                    |
//+------------------------------------------------------------------+
bool CSampleExpert::InitCheckParameters( const int digits_adjust)
  {
//--- initial data checks
   if (InpTakeProfit*digits_adjust<m_symbol.StopsLevel())
     {
       printf ( "Take Profit must be greater than %d" ,m_symbol.StopsLevel());
       return ( false );
     }
   if (InpTrailingStop*digits_adjust<m_symbol.StopsLevel())
     {
       printf ( "Trailing Stop must be greater than %d" ,m_symbol.StopsLevel());
       return ( false );
     }
//--- check for right lots amount
   if (InpLots<m_symbol.LotsMin() || InpLots>m_symbol.LotsMax())
     {
       printf ( "Lots amount must be in the range from %f to %f" ,m_symbol.LotsMin(),m_symbol.LotsMax());
       return ( false );
     }
   if ( MathAbs (InpLots/m_symbol.LotsStep()- MathRound (InpLots/m_symbol.LotsStep()))> 1.0 E- 10 )
     {
       printf ( "Lots amount is not corresponding with lot step %f" ,m_symbol.LotsStep());
       return ( false );
     }
//--- warning
   if (InpTakeProfit<=InpTrailingStop)
       printf ( "Warning: Trailing Stop must be less than Take Profit" );
//--- succeed
   return ( true );
  }
//+------------------------------------------------------------------+
//| Initialization of the indicators                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::InitIndicators( void )
  {
//--- create MACD indicator
   if (m_handle_macd== INVALID_HANDLE )
       if ((m_handle_macd= iADX ( NULL , 0 , 14 ))== INVALID_HANDLE )
        {
         printf ( "Error creating MACD indicator" );
         return ( false );
        }
//--- create EMA indicator and add it to collection
   if (m_handle_ema== INVALID_HANDLE )
       if ((m_handle_ema= iMA ( NULL , 0 ,InpMATrendPeriod, 0 , MODE_LWMA , PRICE_CLOSE ))== INVALID_HANDLE )
        {
         printf ( "Error creating EMA indicator" );
         return ( false );
        }
//--- create EMA indicator and add it to collection
   if (m_handle_emas== INVALID_HANDLE )
       if ((m_handle_emas= iMA ( NULL , 0 ,InpMATrendPeriod, 0 , MODE_SMA , PRICE_OPEN ))== INVALID_HANDLE )
        {
         printf ( "Error creating EMA indicator" );
         return ( false );
        }
//--- succeed
   return ( true );
  }
//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool CSampleExpert::LongClosed( void )
  {
   bool res= false ;
//--- should it be closed?
   if (m_macd_current<m_signal_current && m_ema_current<m_ema_previous)
     {
       //--- close position
       if (m_trade.PositionClose( Symbol ()))
         printf ( "Long position by %s to be closed" , Symbol ());
       else
         printf ( "Error closing position by %s : '%s'" , Symbol (),m_trade.ResultComment());
       //--- processed and cannot be modified
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position closing                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortClosed( void )
  {
   bool res= false ;
//--- should it be closed?
   if (m_macd_current>m_signal_current && m_ema_current>m_ema_previous)
     {
       //--- close position
       if (m_trade.PositionClose( Symbol ()))
         printf ( "Short position by %s to be closed" , Symbol ());
       else
         printf ( "Error closing position by %s : '%s'" , Symbol (),m_trade.ResultComment());
       //--- processed and cannot be modified
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for long position modifying                                |
//+------------------------------------------------------------------+
bool CSampleExpert::LongModified( void )
  {
   bool res= false ;
//--- check for trailing stop
   if (InpTrailingStop> 0 )
     {
       if (m_symbol.Bid()-m_position.PriceOpen()>m_adjusted_point*InpTrailingStop)
        {
         double sl= NormalizeDouble (m_symbol.Bid()-m_traling_stop,m_symbol. Digits ());
         double tp=m_position.TakeProfit();
         if (m_position.StopLoss()<sl || m_position.StopLoss()== 0.0 )
           {
             //--- modify position
             if (m_trade.PositionModify( Symbol (),sl,tp))
               printf ( "Long position by %s to be modified" , Symbol ());
             else
              {
               printf ( "Error modifying position by %s : '%s'" , Symbol (),m_trade.ResultComment());
               printf ( "Modify parameters : SL=%f,TP=%f" ,sl,tp);
              }
             //--- modified and must exit from expert
            res= true ;
           }
        }
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position modifying                               |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortModified( void )
  {
   bool    res= false ;
//--- check for trailing stop
   if (InpTrailingStop> 0 )
     {
       if ((m_position.PriceOpen()-m_symbol.Ask())>(m_adjusted_point*InpTrailingStop))
        {
         double sl= NormalizeDouble (m_symbol.Ask()+m_traling_stop,m_symbol. Digits ());
         double tp=m_position.TakeProfit();
         if (m_position.StopLoss()>sl || m_position.StopLoss()== 0.0 )
           {
             //--- modify position
             if (m_trade.PositionModify( Symbol (),sl,tp))
               printf ( "Short position by %s to be modified" , Symbol ());
             else
              {
               printf ( "Error modifying position by %s : '%s'" , Symbol (),m_trade.ResultComment());
               printf ( "Modify parameters : SL=%f,TP=%f" ,sl,tp);
              }
             //--- modified and must exit from expert
            res= true ;
           }
        }
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for long position opening                                  |
//+------------------------------------------------------------------+
bool CSampleExpert::LongOpened( void )
  {
   bool res= false ;
//--- check for long position (BUY) possibility
   if (m_macd_current>m_signal_current && m_ema_current>m_ema_previous)
     {
       double price=m_symbol.Ask();
       double tp   =m_symbol.Bid()+m_take_profit;
       //--- check for free money
       if (m_account.FreeMarginCheck( Symbol (), ORDER_TYPE_BUY ,InpLots,price)< 0.0 )
         printf ( "We have no money. Free Margin = %f" ,m_account.FreeMargin());
       else
        {
         //--- open position
         if (m_trade.PositionOpen( Symbol (), ORDER_TYPE_BUY ,InpLots,price, 0.0 ,tp))
             printf ( "Position by %s to be opened" , Symbol ());
         else
           {
             printf ( "Error opening BUY position by %s : '%s'" , Symbol (),m_trade.ResultComment());
             printf ( "Open parameters : price=%f,TP=%f" ,price,tp);
           }
        }
       //--- in any case we must exit from expert
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| Check for short position opening                                 |
//+------------------------------------------------------------------+
bool CSampleExpert::ShortOpened( void )
  {
   bool res= false ;
//--- check for short position (SELL) possibility
   if (m_macd_current<m_signal_current && m_ema_current<m_ema_previous)
     {
       double price=m_symbol.Bid();
       double tp   =m_symbol.Ask()-m_take_profit;
       //--- check for free money
       if (m_account.FreeMarginCheck( Symbol (), ORDER_TYPE_SELL ,InpLots,price)< 0.0 )
         printf ( "We have no money. Free Margin = %f" ,m_account.FreeMargin());
       else
        {
         //--- open position
         if (m_trade.PositionOpen( Symbol (), ORDER_TYPE_SELL ,InpLots,price, 0.0 ,tp))
             printf ( "Position by %s to be opened" , Symbol ());
         else
           {
             printf ( "Error opening SELL position by %s : '%s'" , Symbol (),m_trade.ResultComment());
             printf ( "Open parameters : price=%f,TP=%f" ,price,tp);
           }
        }
       //--- in any case we must exit from expert
      res= true ;
     }
//--- result
   return (res);
  }
//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool CSampleExpert::Processing( void )
  {
//--- refresh rates
   if (!m_symbol.RefreshRates())
       return ( false );
//--- refresh indicators
   if ( BarsCalculated (m_handle_macd)< 2 || BarsCalculated (m_handle_ema)< 2 || BarsCalculated (m_handle_emas)< 2 )
       return ( false );
   if ( CopyBuffer (m_handle_macd, 1 ,InpBars, 2 ,m_buff_MACD_main)  != 2 ||
       CopyBuffer (m_handle_macd, 2 ,InpBars, 2 ,m_buff_MACD_signal)!= 2 ||
       CopyBuffer (m_handle_ema, 0 ,InpBars, 2 ,m_buff_EMA)         != 2 ||
       CopyBuffer (m_handle_emas, 0 ,InpBars, 2 ,m_buff_EMAS)       != 2 )
       return ( false );
//   m_indicators.Refresh();
//--- to simplify the coding and speed up access
//--- data are put into internal variables
   m_macd_current   =m_buff_MACD_main[ 0 ];
   m_signal_current =m_buff_MACD_signal[ 0 ];
   m_ema_current    =m_buff_EMA[ 0 ];
   m_ema_previous   =m_buff_EMAS[ 0 ];
//--- it is important to enter the market correctly,
//--- but it is more important to exit it correctly...
//--- first check if position exists - try to select it
   if (m_position.Select( Symbol ()))
     {
       if (m_position.PositionType()== POSITION_TYPE_BUY )
        {
         //--- try to close or modify long position
         if (LongClosed())
             return ( true );
         if (LongModified())
             return ( true );
        }
       else
        {
         //--- try to close or modify short position
         if (ShortClosed())
             return ( true );
         if (ShortModified())
             return ( true );
        }
     }
//--- no opened position identified
   else
     {
       //--- check for long position (BUY) possibility
       if (LongOpened())
         return ( true );
       //--- check for short position (SELL) possibility
       if (ShortOpened())
         return ( true );
     }
//--- exit without position processing
   return ( false );
  }
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit ( void )
  {
//--- create all necessary objects
   if (!ExtExpert.Init())
       return ( INIT_FAILED );
//--- secceed
   return ( INIT_SUCCEEDED );
  }
//+------------------------------------------------------------------+
//| Expert new tick handling function                                |
//+------------------------------------------------------------------+
void OnTick ( void )
  {
   static datetime limit_time= 0 ,ExtTimeOut= 0 ; // last trade processing time + timeout
//--- don't process if timeout
   limit_time= iTime ( Symbol (), Period (), 0 );
   if (ExtTimeOut==limit_time)
       return ;
//--- change limit time by timeout in seconds if processed
   if (ExtExpert.Processing())
      ExtTimeOut=limit_time;
  }
//+------------------------------------------------------------------+

MrBrooklin 2021.06.02 19:43 #125

SanAlex:

Aquí hay una manera de comprobar la diferencia - reemplazar sólo el puesto de ejemplo anterior

- en este experto.

Gracias. Lo intentaré. Saludos, Vladimir.

эдуард фершт 2021.06.13 03:25 #126

Todos tienen su propia visión sobre la entrada y salida de las cerraduras. Asesores que me he encontrado en el camino luego trabajó torcido luego de repente eliminado el orden, entonces de repente lo puso no está claro en qué principio.

le gustaría escribir a mí mismo, pero no puede entender la programación . tomar el consejo y decidió abrir una rama separada .

condiciones de trabajo para el asesor

1.sí no el comercio de todas las transacciones manualmente (compra y venta)

2. 2.Si la operación se cierra en + entonces la orden pendiente se elimina.

en el conjunto de órdenes pendientes toma en min + (posibilidad de ajustar)

3. Cuando la orden pendiente se dispara --- otra orden pendiente se establece en el nivel de 1 orden (es decir, el total debe ser igual)

4. si el precio vuelve y forma un bloqueo --- entonces todos los takei se eliminan.

5 Al abrir cualquier parte del cierre, la orden pendiente se abre en el volumen igual a esta parte. en 15 -20 puntos (ajuste) es decir, si abro compra, la orden pendiente para compra y viceversa.

todo está listo. me gustaría recibir cualquier sugerencia.

Redactaré un asesor de Cualquier pregunta de los [¡Archivo!] Escribiré cualquier experto

kichkin46 2021.06.21 11:32 #127

¡Hola señores desarrolladores! Soy discapacitado 1g, después de un accidente cerebrovascular. Y me resulta sencillamente imposible escribir un búho yo mismo debido a las circunstancias. Necesito un bot bastante simple. Lo que abriría la pose de los niveles que he creado. No tengo paradas, sólo tratos opuestos. Algoritmo interesante por favor ayuda. El segundo bot será la bomba, y la noticia será única, todo puramente mi desarrollo .

Voy a escribir el Deseos para MQL5 Redactaré un asesor de

yura droba 2021.06.23 10:15 #128

Buenos días, queridos programadores.

Esta idea ha estado en mi cabeza durante mucho tiempo. He intentado hacerlo manualmente, pero me confundo. Estoy seguro de que no existe tal algoritmo en ninguna parte del comercio (punto 3).

1. El Asesor Experto abre órdenes en cada desglose de una vela Alta - Compra, Baja - Venta.

2. El TP es igual a un ATR en un marco de tiempo de trabajo.

3. Tras el cierre de la orden en el TP, el Asesor Experto toma la orden menos rentable y el 30% del TP de la orden cerrada (que se imprimirá en las variables del Asesor Experto)

Arrastrar el TP de la orden perdedora a la zona negativa (siguiendo el principio de tomar primero y luego renunciar a un porcentaje de beneficio)

y, por lo tanto, lleva a la orden deficitaria a su cierre con pérdidas. A continuación, vuelve a encontrar la orden menos rentable y continúa modificándola hasta que se cierra con pérdidas.

En cada una de estas series, obtendremos al menos un 60% de beneficio teniendo en cuenta el swap y las comisiones.

Redactaré un asesor de FOREX - Tendencias, previsiones [ARCHIVO]Cualquier pregunta de novato,

Hi-Fi 2021.06.28 16:32 #129

Ayuda para encontrar la última señal de ZigZag

double ZigUp, ZigFrDn;
     ZigUp = iCustom(NULL,0,IndName,ExtDepth,ExtDeviation,ExtBackstep,0,1);
   for (int i=1; i<500; i++) 
     ZigDn = iCustom(NULL,0,IndName,ExtDepth,ExtDeviation,ExtBackstep,0,i);

Por condición si la última venta ascendente, Dn-compra.

Funciona y luego no... (Puede que no funcione en absoluto)

Vitaly Muzichenko 2021.06.28 16:40 #130

Hi-Fi:

Ayuda para encontrar la última señal de ZigZag

Por condición si la última venta ascendente, Dn-compra.

Funciona y luego no... (Puede que no funcione en absoluto)

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.10.2006                                                     |
//|  Описание : Возвращает номер бара экстремума ЗигЗага по его номеру.        |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (      0     - текущий ТФ)              |
//|    ne - номер экстремума           (      0     - последний)               |
//|    dp - ExtDepth                                                           |
//|    dv - ExtDeviation                                                       |
//|    bs - ExtBackstep                                                        |
//+----------------------------------------------------------------------------+
int GetExtremumZZBar(string sy="", int tf=0, int ne=0, int dp=12, int dv=5, int bc=3) {
  if (sy=="" || sy=="0") sy=Symbol();
  double zz;
  int    i, k=iBars(sy, tf), ke=0;

  for (i=0; i<k; i++) {
    zz=iCustom(sy, tf, "ZigZag", dp, dv, bc, 0, i);
    if (zz!=0) {
      ke++;
      if (ke>ne) return(i);
    }
  }
  Print("GetExtremumZZBar(): Экстремум ЗигЗага номер ",ne," не найден");
  return(-1);
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.10.2006                                                     |
//|  Описание : Возвращает экстремум ЗигЗага по его номеру.                    |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (      0     - текущий ТФ)              |
//|    ne - номер экстремума           (      0     - последний)               |
//|    dp - ExtDepth                                                           |
//|    dv - ExtDeviation                                                       |
//|    bs - ExtBackstep                                                        |
//+----------------------------------------------------------------------------+
double GetExtremumZZPrice(string sy="", int tf=0, int ne=0, int dp=12, int dv=5, int bs=3) {
  if (sy=="" || sy=="0") sy=Symbol();
  double zz;
  int    i, k=iBars(sy, tf), ke=0;

  for (i=1; i<k; i++) {
    zz=iCustom(sy, tf, "ZigZag", dp, dv, bs, 0, i);
    if (zz!=0) {
      ke++;
      if (ke>ne) return(zz);
    }
  }
  Print("GetExtremumZZPrice(): Экстремум ЗигЗага номер ",ne," не найден");
  return(0);
}

Escribir EAs gratuitos - página 13