Solo "Características útiles de KimIV". - página 7

 

Función CorrectTF().

Escribí esta función después de descubrir que a veces puedo especificar fácilmente un marco de tiempo incorrecto, que es igual a un número entero de minutos, en los parámetros de entrada de un indicador o un EA. Por ejemplo, introduje 50 por hora en lugar de 60. Bueno... como si se perdiera. Resulta que la función iRSI() devuelve cero para un marco temporal incorrecto. No puedo decir nada sobre otras funciones, porque no las he comprobado. Para evitar malentendidos resultantes de mis propios errores de falta de atención, escribí esta función como una primitiva a prueba de tontos. Ajusta el parámetro de entrada al marco temporal apropiado más cercano y devuelve su valor.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 02.03.2008                                                     |
//|  Описание : Корректирует таймфрейм под ближайший поддерживаемый МТ4.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    TimeFrame - таймфрейм (количество секунд)      (0 - текущий ТФ)         |
//+----------------------------------------------------------------------------+
int CorrectTF(int TimeFrame=0) {
  if (TimeFrame==0) TimeFrame=Period();
  if (TimeFrame< PERIOD_M5                         ) return(PERIOD_M1);
  if (TimeFrame>=PERIOD_M5  && TimeFrame<PERIOD_M15) return(PERIOD_M5);
  if (TimeFrame>=PERIOD_M15 && TimeFrame<PERIOD_M30) return(PERIOD_M15);
  if (TimeFrame>=PERIOD_M30 && TimeFrame<PERIOD_H1 ) return(PERIOD_M30);
  if (TimeFrame>=PERIOD_H1  && TimeFrame<PERIOD_H4 ) return(PERIOD_H1);
  if (TimeFrame>=PERIOD_H4  && TimeFrame<PERIOD_D1 ) return(PERIOD_H4);
  if (TimeFrame>=PERIOD_D1  && TimeFrame<PERIOD_W1 ) return(PERIOD_D1);
  if (TimeFrame>=PERIOD_W1  && TimeFrame<PERIOD_MN1) return(PERIOD_W1);
  if (TimeFrame>=PERIOD_MN1                        ) return(PERIOD_MN1);
}

Función DateBeginQuarter().

Esta función devuelve la fecha de inicio del trimestre por su número. Por ejemplo, si ahora es 27.08.2008, la fecha de inicio del trimestre actual será 01.07.2008. La función sólo toma un parámetro: el número de trimestre relativo al trimestre actual. Por ejemplo, 0 es el trimestre actual, 1 es el trimestre siguiente y -1 es el trimestre anterior. Es decir, los números positivos de los trimestres solicitarán fechas del futuro, mientras que el cero y el negativo solicitarán fechas del pasado. El valor devuelto es el número de segundos transcurridos desde las 00:00 del 1 de enero de 1970.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 12.05.2008                                                     |
//|  Описание : Возвращает дату начала квартала                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|                                    (-2 - позапрошлый)                      |
//|                                    (-1 - прошлый)                          |
//|    nq - номер квартала             ( 0 - текущий)                          |
//|                                    ( 1 - следующий)                        |
//|                                    ( 2 - последующий)                      |
//+----------------------------------------------------------------------------+
datetime DateBeginQuarter(int nq=0) {
  int ye=Year()-MathFloor(nq/4);
  nq=MathMod(nq, 4);
  int mo=Month()-MathMod(Month()+2, 3)+3*nq;
  if (mo<1) {
    mo+=12;
    ye--;
  }
  if (mo>12) {
    mo-=12;
    ye++;
  }

  return(StrToTime(ye+"."+mo+".01"));
}
 

La función DateOfMonday().

Esta función devuelve la fecha de inicio de la semana (lunes) por su número. Por ejemplo, si ahora es 29.08.2008, la fecha de inicio de la semana actual será 25.08.2008. La función sólo toma un parámetro: el número de semana relativo a la semana actual. Por ejemplo, 0 es la semana actual, 1 es la semana siguiente y -1 es la semana anterior. Es decir, los números de semana positivos solicitarán fechas del futuro, mientras que los números cero y negativos solicitarán fechas del pasado. El valor de retorno es el número de segundos transcurridos desde las 00:00 del 1 de enero de 1970.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 13.05.2008                                                     |
//|  Описание : Возвращает дату понедельника по номеру недели                  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|                                    (-2 - предпредыдущая неделя)            |
//|                                    (-1 - предыдущая неделя)                |
//|    nn - номер недели               ( 0 - текущая неделя)                   |
//|                                    ( 1 - следующая неделя)                 |
//|                                    ( 2 - последующая неделя)               |
//+----------------------------------------------------------------------------+
datetime DateOfMonday(int nn=0) {
  datetime dt=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE));

  while (TimeDayOfWeek(dt)!=1) dt-=24*60*60;
  dt+=nn*7*24*60*60;

  return (dt);
}

La función Fibonacci().

Esta función devuelve un elemento de la serie de Fibonacci por su número de secuencia.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.08.2008                                                     |
//|  Описание : Возвращает элемент ряда Фибоначчи по его порядковому номеру.   |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    n - номер элемента ряда                                                 |
//+----------------------------------------------------------------------------+
int Fibonacci(int n) {
  int a=0, b=0, i=1, s=0;

  if (n==1) s=1;
  if (n>1) {
    s=1;
    while (i<n) {
      i++;
      a=b;
      b=s;
      s=a+b;
    }
  }
  return(s);
}
 

Función GetNameMA().

Esta función devuelve el nombre del método MA(Moving Averages) por su identificador. Esta función es conveniente utilizarla en los comentarios, indicadores y mensajes de los Asesores Expertos.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование метода МА.                             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    mm - идентификатор метода МА                                            |
//+----------------------------------------------------------------------------+
string GetNameMA(int mm) {
  switch (mm) {
    case MODE_SMA : return("SMA");
    case MODE_EMA : return("EMA");
    case MODE_SMMA: return("SMMA");
    case MODE_LWMA: return("LWMA");
    default       : return("Unknown Method");
  }
}
 

Función GetPriceDiffInPoint().

Esta función devuelve la diferencia de precio entre dos barras, que se especifican por sus números. El propósito de desarrollar esta función era determinar el valor y la dirección del movimiento del precio. La función GetPriceDiffInPoint() determina los puntos de referencia (Apertura o Alta o Baja o Cierre) de las barras a tener en cuenta. La función acepta los siguientes parámetros opcionales:

  • sy - Nombre del instrumento. "" o NULL - símbolo actual. El valor por defecto es NULL.
  • tf - Marco temporal. Valor por defecto 0 - símbolo actual.
  • n2 - Número de barra izquierda. Valor por defecto - 2.
  • n1 - Número de barra derecha. Valor por defecto - 1.

Valor devuelto:

  • positivo : hubo un aumento de la tasa entre las barras N2 y N1.
  • negativo - hubo una depreciación entre las barras N2 y N1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает ценовую разницу в пунктах между двумя барами.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента        ("" или NULL - текущий символ)     |
//|    tf - таймфрейм                       (    0       - текущий таймфрейм)  |
//|    n2 - номер левого бара               (    2       - второй бар)         |
//|    n1 - номер правого бара              (    1       - первый бар)         |
//|  Возвращаемое значение:                                                    |
//|    положительное - между барами N2 и N1 был рост курса                     |
//|    отрицательное - между барами N2 и N1 было снижение курса                |
//+----------------------------------------------------------------------------+
int GetPriceDiffInPoint(string sy="0", int tf=0, int n2=2, int n1=1) {
  if (sy=="" || sy=="0") sy=Symbol();
  double p=MarketInfo(sy, MODE_POINT);
  int    d=MarketInfo(sy, MODE_DIGITS);
  int    dd=0, k=iBars(sy, tf);

  if (n1>k || n2>k)
    Print("GetPriceDiffInPoint(): Недостаточно баров для ",sy," ",GetNameTF(tf));
  else {
    if (n1>0 && n2>0) {
      int d1=NormalizeDouble((iHigh(sy, tf, n1)-iLow(sy, tf, n2))/p, d);
      int d2=NormalizeDouble((iLow(sy, tf, n1)-iHigh(sy, tf, n2))/p, d);

      if (MathAbs(d1)>MathAbs(d2)) dd=d1;
      if (MathAbs(d1)<MathAbs(d2)) dd=d2;
      if (MathAbs(d1)==MathAbs(d2)) {
        if (iOpen(sy, tf, n2)>iClose(sy, tf, n1)) dd=d2; else dd=d1;
      }
    }
  }

  return(dd);
}

La función GetTypePrice()

Devuelve el nombre del tipo de precio. La función sólo toma un parámetro opcional. Valores válidos: PRICE_CLOSE, PRICE_OPEN, PRICE_HIGH, PRICE_LOW, PRICE_MEDIAN, PRICE_TYPICAL, PRICE_WEIGHTED. El valor por defecto es 0 - PRICE_CLOSE.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование типа цены.                             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    Applied_Price - тип цены                                                |
//+----------------------------------------------------------------------------+
string GetTypePrice(int Applied_Price=0) {
  switch (Applied_Price) {
    case PRICE_CLOSE   : return("Close");
    case PRICE_OPEN    : return("Open");
    case PRICE_HIGH    : return("High");
    case PRICE_LOW     : return("Low");
    case PRICE_MEDIAN  : return("Median");
    case PRICE_TYPICAL : return("Typical");
    case PRICE_WEIGHTED: return("Weighted");
    default            : return("Unknown Type Price");
  }
}
 

La función ArrayLR().

Esta función genera una matriz de valores de regresión lineal. La función acepta los siguientes parámetros obligatorios:

  • x es una matriz de valores de series numéricas. Este es el parámetro de entrada. Este array debe contener los valores antes de llamar a la función.
  • y es una matriz de valores de regresión lineal. Este es el parámetro de salida, es decir, el array se llenará después de llamar a la función.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 20.05.2008                                                     |
//|  Описание : Формирует массив значений линейной регрессии.                  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    x - массив значений числового ряда                                      |
//|    y - массив значений линейной регрессии                                  |
//+----------------------------------------------------------------------------+
void ArrayLR(double& x[], double& y[]) {
  double a, b, c, sx=0, sx2=0, sxy=0, sy=0;
  int    i, n=ArraySize(x);

  if (n>1) {
    for (i=0; i<n; i++) {
      sx+=i+1;
      sy+=x[i];
      sxy+=(i+1)*x[i];
      sx2+=(i+1)*(i+1);
    }
    a=sx*sy-n*sxy;
    c=sx*sx-n*sx2;
    if (c!=0) a=a/c; else a=0;
    b=(sy-a*sx)/n;
    ArrayResize(y, n);
    for (i=0; i<n; i++) y[i]=a*(i+1)+b;
  } else Print("ArrayLR(): Недостаточное количество элементов ряда! n=", n);
}

Función ArrayMo().

Devuelve Modu - el máximo de la curva de densidad de la distribución. La función acepta los siguientes parámetros opcionales:

  • x - Matriz de valores de la serie numérica.
  • d - La precisión de los valores de la serie numérica, el número de decimales.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 21.06.2008                                                     |
//|  Описание : Возвращает Моду - максимум кривой плотности распределения.     |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    x - массив значений числового ряда                                      |
//|    d - точность значений числового ряда, количество знаков после запятой   |
//+----------------------------------------------------------------------------+
double ArrayMo(double& x[], int d=4) {
  double e, s=0;
  double m[][2];             // временный массив:
                             //  столбец 1 - количество значений
                             //  столбец 2 - значения
  int    i, k=ArraySize(x);
  int    n;                  // номер строки временного массива m
  int    r;                  // количество строк во временном массиве m

  if (k>0) {
    for (i=0; i<k; i++) {
      e=NormalizeDouble(x[i], d);
      n=ArraySearchDouble(m, e);
      if (n<0) {
        r=ArrayRange(m, 0);
        ArrayResize(m, r+1);
        m[r][0]++;
        m[r][1]=e;
      } else m[n][0]++;
    }
    ArraySort(m, WHOLE_ARRAY, 0, MODE_DESCEND);
    s=m[0][1];
  } else Print("ArrayMo(): Массив пуст!");

  return(s);
}
 

Función ExistOrdersByPrice().

Devuelve un indicador de la existencia de una orden al precio establecido. Verdadero - el orden existe (establecido), Falso - el orden no existe (no establecido). Puede limitar la lista de órdenes a comprobar mediante los parámetros de la función:

  • sy - Nombre del instrumento de mercado. Si se da este parámetro, la función sólo comprobará las órdenes del instrumento especificado. NULL significa el instrumento actual, y "" (por defecto) significa cualquier instrumento.
  • op - Tipo de operación, tipo de orden pendiente. Valores válidos: OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP o -1. El valor por defecto de -1 indica cualquier tipo de orden.
  • mn - Identificador del pedido (MagicNumber). El valor por defecto de -1 significa cualquier MagicNumber.
  • pp - El nivel de precio al que se establece la orden. El valor por defecto es -1 - cualquier precio.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 30.07.2008                                                     |
//|  Описание : Возвращает флаг существования ордеров по цене установки        |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//|    pp - цена                       (-1   - любая цена)                     |
//+----------------------------------------------------------------------------+
bool ExistOrdersByPrice(string sy="", int op=-1, int mn=-1, double pp=-1) {
  int d, i, k=OrdersTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
        if (OrderType()>1 && OrderType()<6) {
          d=MarketInfo(OrderSymbol(), MODE_DIGITS);
          pp=NormalizeDouble(pp, d);
          if (pp<0 || pp==NormalizeDouble(OrderOpenPrice(), d)) {
            if (mn<0 || OrderMagicNumber()==mn) return(True);
          }
        }
      }
    }
  }
  return(False);
}

La función ClosePosBySelect() para el probador.

Ejecuta el cierre de una única posición preseleccionada. Se trata de una versión simplificada de la función del mismo nombre descrita anteriormente en la página 13. Nada superfluo. No hay características adicionales. En mi práctica, nunca he tenido una posición que no estuviera cerrada en el probador. Por eso no hay comprobaciones en esta función. Son innecesarios en el probador.

//+----------------------------------------------------------------------------+
//|  Автор   : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                    |
//+----------------------------------------------------------------------------+
//|  Версия  : 13.06.2007                                                      |
//|  Описание: Закрытие одной предварительно выбранной позиции                 |
//+----------------------------------------------------------------------------+
void ClosePosBySelect() {
  double pp;

  if (OrderType()==OP_BUY) {
    pp=MarketInfo(OrderSymbol(), MODE_BID);
    OrderClose(OrderTicket(), OrderLots(), pp, Slippage, clCloseBuy);
  }
  if (OrderType()==OP_SELL) {
    pp=MarketInfo(OrderSymbol(), MODE_ASK);
    OrderClose(OrderTicket(), OrderLots(), pp, Slippage, clCloseSell);
  }
}
 

La función CountOrders() para el probador.

En mis versiones de prueba (destinadas exclusivamente al uso en el probador de MT4), la función CountOrders() sustituye a las siguientes funciones: ExistOrders(), ExistPositions(), NumberOfOrders() y NumberOfPositions(). Así, puede dar información sobre la existencia de cualquier posición u orden y la cantidad de operaciones de cada tipo. Este tipo de intercambio tiene sus propias ventajas, que se expresan en una referencia única a la base de órdenes para un tick y la obtención de toda la información necesaria de una sola vez. Y las funciones mencionadas, especialmente cuando se utilizan juntas, cada una de ellas trabaja con una misma base de órdenes de forma independiente, por lo que realizan repetidamente las mismas llamadas. Como resultado, la función CountOrders() puede reducir el tiempo de una pasada en varios segundos, lo que permite ahorrar horas de optimización.

La función CountOrders() toma los siguientes parámetros:

  • mo - Matriz del número de pedidos por tipo. Una vez ejecutada la función, el array tendrá 6 (seis) elementos. Elemento cero - número de operaciones de tipo Buy, primer elemento - número de órdenes Sell, segundo elemento - BuyLimit, tercer elemento - SellLimit, cuarto elemento - BuyStop, quinto elemento - SellStop.
  • mn - Identificador de una posición u órdenes (MagicNumber). El valor por defecto es -1 - cualquier MagicNumber.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 03.08.2008                                                     |
//|  Описание : Рассчитывает количество ордеров по типам.                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    mo - массив количества ордеров по типам                                 |
//|    mn - MagicNumber                          (-1 - любой магик)            |
//+----------------------------------------------------------------------------+
void CountOrders(int& mo[], int mn=-1) {
  int i, k=OrdersTotal();

  if (ArraySize(mo)!=6) ArrayResize(mo, 6);
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if (mn<0 || OrderMagicNumber()==mn) mo[OrderType()]++;
    }
  }
}

La función ModifyOrder() para el probador.

Esta es una versión ligera de la función ModifyOrder(), publicada en la página 7, y está pensada para cambiar los niveles de precios absolutos de una orden o posición preseleccionada.

La función ModifyOrder() acepta los siguientes parámetros:

  • pp - Precio de fijación del pedido. Si pasa un valor menor o igual a cero, no se realizará la modificación de este nivel de precios. El valor por defecto es -1.
  • sl - Nivel de precio de parada. Si pasa un valor inferior a cero, la modificación del nivel de precios no se realizará. El valor por defecto es 0.
  • tp - Toma el nivel de precios. Si pasa un valor inferior a 0, la modificación del nivel de precios no se llevará a cabo. El valor por defecto es 0.
  • ex - Fecha de vencimiento de la orden pendiente. El valor por defecto es 0.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.03.2008                                                     |
//|  Описание : Модификация ордера. Версия функции для тестов на истории.      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    pp - цена открытия позиции, установки ордера                            |
//|    sl - ценовой уровень стопа                                              |
//|    tp - ценовой уровень тейка                                              |
//|    ex - дата истечения                                                     |
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0) {
  int    dg=MarketInfo(OrderSymbol(), MODE_DIGITS), er;
  double op=NormalizeDouble(OrderOpenPrice() , dg);
  double os=NormalizeDouble(OrderStopLoss()  , dg);
  double ot=NormalizeDouble(OrderTakeProfit(), dg);
  color  cl;

  if (pp<=0) pp=OrderOpenPrice();
  if (sl<0 ) sl=OrderStopLoss();
  if (tp<0 ) tp=OrderTakeProfit();
  
  pp=NormalizeDouble(pp, dg);
  sl=NormalizeDouble(sl, dg);
  tp=NormalizeDouble(tp, dg);

  if (pp!=op || sl!=os || tp!=ot) {
    if (MathMod(OrderType(), 2)==0) cl=clModifyBuy; else cl=clModifySell;
    if (!OrderModify(OrderTicket(), pp, sl, tp, ex, cl)) {
      er=GetLastError();
      Print("Error(",er,") modifying order: ",ErrorDescription(er));
      Print("Ask=",Ask," Bid=",Bid," sy=",OrderSymbol(),
            " op="+GetNameOP(OrderType())," pp=",pp," sl=",sl," tp=",tp);
    }
  }
}
 

La función IIFc().

Una función muy práctica en cuanto a la construcción de horquillas. Si es así, este color. Y si no lo es, entonces otro color. La función IIFc() toma tres parámetros obligatorios:

  • condición - Una expresión lógica. Puede ser verdadero o falso.
  • ifTrue - El color que devolverá IIFc() si la expresión de la condición es verdadera.
  • ifFalse - El color que devolverá IIFc() si la condición es falsa.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 18.07.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Función IIFd().

Una comodidad similar para los números reales. Si es así, es un número real. Y si no lo es, es un número diferente. La función IIFd( ) toma tres parámetros obligatorios:

  • condición - Una expresión lógica. Puede ser verdadero o falso.
  • ifTrue - Un número real que será devuelto por IIFd() si la expresión de la condición es verdadera.
  • ifFalse - Un número real que será devuelto por IIFd() si la condición es falsa.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
double IIFd(bool condition, double ifTrue, double ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

La función IIFi().

Una comodidad similar para los enteros. Si es así, es un número entero. Y si no lo es, entonces otro número. La función IIFi( ) toma tres parámetros obligatorios:

  • condición - Una expresión lógica. Puede ser verdadero o falso.
  • ifTrue - Un número entero que será devuelto por IIFi() si la expresión de la condición es verdadera.
  • ifFalse - Un entero que será devuelto por IIFi() si la condición es falsa.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
int IIFi(bool condition, int ifTrue, int ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Función IIFis().

Una comodidad similar para las cadenas. Si es así, tal cadena. Y si no lo es, entonces otra cadena. La función IIFs( ) toma tres parámetros obligatorios:

  • condición - Una expresión lógica. Puede ser verdadero o falso.
  • ifTrue - La cadena que será devuelta por la función IIFs(), si la expresión de la condición es verdadera.
  • ifFalse - La cadena que será devuelta por IIFs( ), si la condición es falsa.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
string IIFs(bool condition, string ifTrue, string ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
 

La función ExistInHistoryCloseBetween().

Devuelve un indicador de la existencia en el historial de una posición u orden cerrada (borrada) entre fechas. La función ExistInHistoryCloseBetween() recibe los siguientes parámetros:

  • sy - Nombre del instrumento de mercado. "" - cualquier símbolo, NULL - símbolo actual. El valor por defecto es "".
  • op - Operación comercial. Valores válidos: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valor por defecto -1 - cualquier operación.
  • mn - Identificador de las operaciones comerciales, MagicNumber. Valor por defecto -1 - cualquier número mágico.
  • d1 - Hora de cierre de la posición (pendiente de borrar la orden). El valor por defecto es 0 - cualquier hora de cierre (borrar). El tiempo d1 debe ser más corto que d2.
  • d2 - Hora de cierre de la posición (pendiente de eliminar la orden). Valor por defecto - 0 - cualquier tiempo de cierre (borrado). El tiempo d2 debe ser mayor que el tiempo d1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 27.08.2008                                                     |
//|  Описание : Возвращает флаг существования в истории позиции или ордера,    |
//|           : закрытой (удалённого) между датами.                            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая операция)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//|    d1 - время закрытия             ( 0   - любое время закрытия)           |
//|    d2 - время закрытия             ( 0   - любое время закрытия)           |
//+----------------------------------------------------------------------------+
bool ExistInHistoryCloseBetween(string sy="", int op=-1, int mn=-1,
                                datetime d1=0, datetime d2=0) {
  int i, k=OrdersHistoryTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
        if (mn<0 || OrderMagicNumber()==mn) {
          if (d1<=OrderCloseTime() && (d2==0 || d2>=OrderCloseTime())) return(True);
        }
      }
    }
  }
  return(False);
}

Función ExistInHistoryOpenBetween().

Devuelve el indicador de existencia en el historial de una posición u orden abierta (establecida) entre fechas. La función ExistInHistoryOpenBetween() recibe los siguientes parámetros:

  • sy - Nombre del instrumento. "" - cualquier carácter, NULL - el símbolo actual. El valor por defecto es "".
  • op - Operación comercial. Valores válidos: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valor por defecto -1 - cualquier operación.
  • mn - Identificador de las operaciones comerciales, MagicNumber. Valor por defecto -1 - cualquier número mágico.
  • d1 - Tiempo de apertura de la posición(pendiente de colocar la orden). El valor por defecto es 0 - cualquier tiempo de apertura (ajuste). El tiempo d1 debe ser menor que el tiempo d2.
  • d2 - Hora de apertura de la posición (pendiente de colocar la orden). El valor por defecto es 0 - cualquier tiempo de apertura (establecido). El tiempo d2 debe ser mayor que el tiempo d1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 27.08.2008                                                     |
//|  Описание : Возвращает флаг существования в истории позиции или ордера,    |
//|           : открытой (установленного) между датами.                        |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//|    d1 - время открытия             ( 0   - любое время открытия)           |
//|    d2 - время открытия             ( 0   - любое время открытия)           |
//+----------------------------------------------------------------------------+
bool ExistInHistoryOpenBetween(string sy="", int op=-1, int mn=-1,
                               datetime d1=0, datetime d2=0) {
  int i, k=OrdersHistoryTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
        if (mn<0 || OrderMagicNumber()==mn) {
          if (d1<=OrderOpenTime() && (d2==0 || d2>=OrderOpenTime())) return(True);
        }
      }
    }
  }
  return(False);
}
 

Función ExistInHistoryToDay().

Devuelve el indicador de existencia en el historial de una posición u orden abierta (establecida) hoy. La función ExistInHistoryToDay() recibe los siguientes parámetros:

  • sy - Nombre del instrumento. "" - cualquier símbolo, NULL - el símbolo actual. El valor por defecto es "".
  • op - Operación comercial. Valores válidos: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valor por defecto -1 - cualquier operación.
  • mn - Identificador de las operaciones comerciales, MagicNumber. El valor por defecto es -1 - cualquier Magic.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 06.08.2008                                                     |
//|  Описание : Возвращает флаг наличия ордера или позиции в истории за сегодня|
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
bool ExistInHistoryToDay(string sy="", int op=-1, int mn=-1) {
  int i, k=OrdersHistoryTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if (OrderSymbol()==sy || sy=="") {
        if (op<0 || OrderType()==op) {
          if (mn<0 || OrderMagicNumber()==mn) {
            if (TimeDay  (OrderOpenTime())==Day()
            &&  TimeMonth(OrderOpenTime())==Month()
            &&  TimeYear (OrderOpenTime())==Year()) return(True);
          }
        }
      }
    }
  }
  return(False);
}

Función TakeProfitLastPos().

Esta función devuelve el nivel de precio del TakeProfit de la última posición abierta o -1. La función TakeProfitLastPos() acepta los siguientes parámetros opcionales:

  • sy - Nombre del instrumento. "" - cualquier símbolo, NULL - símbolo actual. El valor por defecto es "".
  • op - Operación comercial. Valores válidos: -1, OP_BUY, OP_SELL. El valor por defecto es -1 - cualquier comercio.
  • mn - Identificador comercial, MagicNumber. Valor por defecto -1 - cualquier magik.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 06.08.2008                                                     |
//|  Описание : Возвращает цену TakeProfit последней открытой позиций или -1.  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double TakeProfitLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  double   r=-1;
  int      i, k=OrdersTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (t<OrderOpenTime()) {
                t=OrderOpenTime();
                r=OrderTakeProfit();
              }
            }
          }
        }
      }
    }
  }
  return(r);
}