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

 

Función TakeProfitLastClosePos().

Devuelve el nivel de precio TakeProfit de la última posición cerrada o -1. La función TakeProfitLastClosePos() 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 Magia.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 20.10.2008                                                     |
//|  Описание : Возвращает цену TakeProfit последней закрытой позиций или -1.  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double TakeProfitLastClosePos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  double   r=-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 (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (t<OrderCloseTime()) {
                t=OrderCloseTime();
                r=OrderTakeProfit();
              }
            }
          }
        }
      }
    }
  }
  return(r);
}

Función MovingInWL().

Mueve el nivel de precio StopLoss de las posiciones abiertas a Breakeven. La función MovingInWL( ) toma 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.

Además, la función MovingInWL() implica variables globales (parámetros externos del script o de un EA):

  • int LevelProfit - Nivel de beneficio en puntos, que debe alcanzar una posición para que su stop se mueva al nivel de Breakeven.
  • int LevelWLoss - Nivel de equilibrio en puntos, al que se trasladará el stop después de que su beneficio alcance el nivel LevelProfit en puntos.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.09.2008                                                     |
//|  Описание : Перенос уровня стопа в безубыток                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void MovingInWL(string sy="", int op=-1, int mn=-1) {
  double po, pp;
  int    i, k=OrdersTotal();

  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      po=MarketInfo(OrderSymbol(), MODE_POINT);
      if (OrderType()==OP_BUY) {
        if (OrderStopLoss()-OrderOpenPrice()<LevelWLoss*po) {
          pp=MarketInfo(OrderSymbol(), MODE_BID);
          if (pp-OrderOpenPrice()>LevelProfit*po) {
            ModifyOrder(-1, OrderOpenPrice()+LevelWLoss*po, -1);
          }
        }
      }
      if (OrderType()==OP_SELL) {
        if (OrderStopLoss()==0 || OrderOpenPrice()-OrderStopLoss()<LevelWLoss*po) {
          pp=MarketInfo(OrderSymbol(), MODE_ASK);
          if (OrderOpenPrice()-pp>LevelProfit*po) {
            ModifyOrder(-1, OrderOpenPrice()-LevelWLoss*po, -1);
          }
        }
      }
    }
  }
}
 

Función SimpleTrailing().

Mueve el nivel de precio StopLoss de las posiciones abiertas utilizando el algoritmo TrailingStop. La función SimpleTrailing() 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.

Además, la función SimpleTrailing( ) implica variables globales (parámetros externos del script o Asesor Experto):

  • bool TSProfitOnly - Cambia la zona en la que comienza la red de arrastre. Si es True, el arrastre sólo comenzará a funcionar cuando el beneficio de la posición alcance el valor de los puntos TStop.Buy/Sell+TrailingStep. Si es Falso, el Asesor Experto simplemente se asegurará de que la posición de stop relativa al precio actual no esté siempre más allá de TStop.Buy/Sell+TrailingStep pips. En otras palabras, si es Verdadero, el Asesor Experto trabaja sólo en la zona de ganancias de la posición, mientras que si es Falso trabaja en la zona negativa de la posición.
  • int TStop.Buy - Tamaño del trall en puntos a comprar.
  • intTStop.Sell - Tamaño del arrastre en puntos para la venta.
  • int TrailingStep - Paso final en puntos. Es necesario para no molestar al concesionario con peticiones frecuentes.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.09.2008                                                     |
//|  Описание : Сопровождение позиций простым тралом                           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void SimpleTrailing(string sy="", int op=-1, int mn=-1) {
  double po, pp;
  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=="") && (op<0 || OrderType()==op)) {
        po=MarketInfo(OrderSymbol(), MODE_POINT);
        if (mn<0 || OrderMagicNumber()==mn) {
          if (OrderType()==OP_BUY) {
            pp=MarketInfo(OrderSymbol(), MODE_BID);
            if (!TSProfitOnly || pp-OrderOpenPrice()>TStop.Buy*po) {
              if (OrderStopLoss()<pp-(TStop.Buy+TrailingStep-1)*po) {
                ModifyOrder(-1, pp-TStop.Buy*po, -1);
              }
            }
          }
          if (OrderType()==OP_SELL) {
            pp=MarketInfo(OrderSymbol(), MODE_ASK);
            if (!TSProfitOnly || OrderOpenPrice()-pp>TStop.Sell*po) {
              if (OrderStopLoss()>pp+(TStop.Sell+TrailingStep-1)*po || OrderStopLoss()==0) {
                ModifyOrder(-1, pp+TStop.Sell*po, -1);
              }
            }
          }
        }
      }
    }
  }
}

Función ArrayZ().

Esta función calcula y devuelve el recuento Z de una serie numérica pasada en el array por referencia.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 27.10.2008                                                     |
//|  Описание : Возвращает Z-счёт числового ряда.                              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    arr - массив значений числового ряда                                    |
//+----------------------------------------------------------------------------+
double ArrayZ(double& arr[]) {
  double x, z;
  int    i, l=0, n=ArraySize(arr), r=1, w=0;

  for (i=0; i<n; i++) {
    if (i==0) r=1;
    else {
      if (arr[i-1]*arr[i]<0) r++;
    }
    if (arr[i]>0) w++; else l++;
  }

  if (n>2) {
    if (w>0 && l>0) {
      x=2*w*l;
      if (x!=n) z=(n*(r-0.5)-x)/MathSqrt(x*(x-n)/(n-1));
    } else {
      if (l==0) z=100; else z=-100;
      Print("ArrayZ(): Нет чередования серий!");
    }
    return(z);
  } else {
    Print("ArrayZ(): В массиве недостаточно элементов!");
    return(0);
  }
}
 

La función ArrayDeleteInt()

Ejecuta el borrado de un elemento del array con el índice dado. Devuelve el tamaño del nuevo array o -1 si no se ha eliminado nada. La función ArrayDeleteInt() acepta los siguientes parámetros obligatorios:

  • m - Matriz de elementos.
  • i - Índice del elemento de la matriz.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteInt(int& m[], int i) {
  int j, k=ArraySize(m);

  if (i>=0 && i<k) {
    for (j=i; j<k; j++) m[j]=m[j+1];
    k=ArrayResize(m, k-1);
    return(k);
  } else Print("ArrayDeleteInt(): Неверный индекс элемента массива! i=", i);

  return(-1);
}

La función ArrayDeleteDouble()

Elimina el elemento del array con el índice dado. Devuelve el tamaño del nuevo array o -1, si no se ha podido borrar nada. La función ArrayDeleteDouble() acepta los siguientes parámetros obligatorios:

  • m - Matriz de elementos de tipo double.
  • i - Índice del elemento de la matriz.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteDouble(double& m[], int i) {
  int j, k=ArraySize(m);

  if (i>=0 && i<k) {
    for (j=i; j<k; j++) m[j]=m[j+1];
    k=ArrayResize(m, k-1);
    return(k);
  } else Print("ArrayDeleteDouble(): Неверный индекс элемента массива! i=", i);

  return(-1);
}
 

La función ArrayDeleteString()

Ejecuta el borrado de un elemento del array con el índice dado. Devuelve el tamaño del nuevo array o -1 si no se ha podido eliminar nada. La función ArrayDeleteString() acepta los siguientes parámetros obligatorios:

  • m - Matriz de elementos de tipo cadena.
  • i - Índice de los elementos de la matriz.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteString(string& m[], int i) {
  int j, k=ArraySize(m);

  if (i>=0 && i<k) {
    for (j=i; j<k; j++) m[j]=m[j+1];
    k=ArrayResize(m, k-1);
    return(k);
  } else Print("ArrayDeleteString(): Неверный индекс элемента массива! i=", i);

  return(-1);
}

La función ArrayInsertDouble()

Inserta un elemento del array con el índice especificado. Devuelve el número de elementos (tamaño) del nuevo array. La inserción se realiza de la siguiente manera. En primer lugar, el tamaño de la matriz se incrementa en uno. A continuación, todos los elementos que tienen un índice mayor o igual que el que se va a insertar se desplazan al final de la matriz uno a uno, dejando espacio para el que se va a insertar. Finalmente, el valor se escribe en la celda requerida. La función ArrayInsertDouble( ) toma los siguientes parámetros:

  • m - Una matriz de elementos de tipo double.
  • e - Valor del elemento de la matriz que se va a insertar.
  • i - Índice del elemento de la matriz que se va a insertar. Si el valor del índice es menor que cero o mayor o igual que el tamaño del array, el elemento se añadirá al final del array. El valor por defecto es -1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет вставку элемента массива с заданным индексом.        |
//|             Возвращает размер нового массива.                              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов типа double                                        |
//|    e - значение элемента                                                   |
//|    i - индекс элемента                  (-1 - добавить в конец массива)    |
//+----------------------------------------------------------------------------+
int ArrayInsertDouble(double& m[], double e, int i=-1) {
  int j, k=ArraySize(m);

  ArrayResize(m, k+1);
  if (i>=0 && i<k) {
    for (j=k; j>i; j--) m[j]=m[j-1];
    m[i]=e;
  } else m[k]=e;

  return(k+1);
}
 

La función BubbleSort2().

Esta función burbujea los elementos de una matriz bidimensional en una columna arbitraria. También puede especificar la dirección de la ordenación. La función BubbleSort2( ) toma los siguientes parámetros:

  • a - Matriz bidimensional de elementos. Parámetro obligatorio.
  • r - Número (índice) de la columna de clasificación (columna). El valor por defecto es 0 - la primera columna (columna con índice cero).
  • m - Dirección de clasificación. Valores válidos: MODE_ASCEND - orden ascendente, MODE_DESCEND - orden descendente. El valor por defecto es MODE_ASCEND.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 04.11.2008                                                     |
//|  Описание : Выполняет пузырьковую сортировку элементов двумерного массива. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    a - массив элементов                                                    |
//|    r - колонка сортировки          (     0       - первая (с индексом 0))  |
//|    m - направление сортировки      (MODE_ASCEND  - по возрастанию,         |
//|                                     MODE_DESCEND - по убыванию)            |
//+----------------------------------------------------------------------------+
void BubbleSort2(double& a[][], int r=0, int m=MODE_ASCEND) {
  double t;
  int    e, i, j;
  int    k=ArrayRange(a, 1);      // Количество колонок
  int    n=ArrayRange(a, 0);      // Количество строк

  if (r<0) r=0;
  if (r>k) r=k;

  for (i=n-1; i>0; i--) {
    for (j=0; j<i; j++) {
      if (m==MODE_ASCEND) {
        // по возрастанию
        if (a[j][r]>a[j+1][r]) {
          for (e=0; e<k; e++) {
            t=a[j][e];
            a[j][e]=a[j+1][e];
            a[j+1][e]=t;
          }
        }
      } else {
        // по убыванию
        if (a[j][r]<a[j+1][r]) {
          for (e=0; e<k; e++) {
            t=a[j][e];
            a[j][e]=a[j+1][e];
            a[j+1][e]=t;
          }
        }
      }
    }
  }
}

La función GetTypeLastDeleted().

Esta función devuelve el tipo de la última orden eliminada, o -1. Hay situaciones en las que necesitamos vincular la lógica de la operación EA al tipo de la orden recién eliminada. Por ejemplo, si acaba de eliminar BuyStop, debería hacerlo, pero si BuyLimit, debería hacer otra cosa, etc. La función GetTypeLastDeleted() acepta los siguientes parámetros opcionales:

  • sy - Nombre del instrumento. "" - cualquier carácter, NULL - carácter actual. El valor por defecto es "".
  • mn - identificador de la orden del usuario (MagicNumber). Valor por defecto -1 - cualquier MagicNumber.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 13.10.2008                                                     |
//|  Описание : Возвращает тип последнего удалённого ордера или -1             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastDeleted(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersHistoryTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if ((OrderSymbol()==sy || sy=="") && (mn<0 || OrderMagicNumber()==mn)) {
        if (OrderType()>1 && OrderType()<6 && t<OrderCloseTime()) {
          t=OrderCloseTime();
          r=OrderType();
        }
      }
    }
  }
  return(r);
}
 

La función iBarLargest().

Esta función devuelve el índice de la barra más grande o -1. El tamaño de la barra es medido por la función de una de las dos maneras, determinada por el parámetro de entrada ty - tipo de elementos de búsqueda. Ya sea sólo el tamaño del cuerpo o junto con las sombras. La función iBarLargest() acepta los siguientes parámetros opcionales:

  • sy - Nombre de la herramienta. "" o NULL - el símbolo actual. El valor por defecto es "".
  • tf - Marco temporal. El valor por defecto es 0 - el marco temporal actual.
  • ty - Tipo de elementos de búsqueda. Valores válidos - 0 - Alto-Bajo, 1 - abs(Abierto-Cerrado).
  • co - Número de elementos de la serie temporal. Valor por defecto - 0 - todos los elementos.
  • in - Índice de la barra inicial. Valor por defecto - 0 - barra actual.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.03.2008                                                     |
//|  Описание : Возвращает индекс наибольшего бара или -1.                     |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (          0 - текущий таймфрейм)       |
//|    ty - тип элементов поиска       (          0 - H-L, 1 - O-C)            |
//|    co - число элементов таймсерии  (          0 - все элементы)            |
//|    in - индекс начального бара     (          0 - текущий бар)             |
//+----------------------------------------------------------------------------+
int iBarLargest(string sy="", int tf=0, int ty=0, int co=0, int in=0) {
  if (sy=="" || sy=="0") sy=Symbol();
  if (tf<=0) tf=Period();
  if (in< 0) in=0;
  if (co<=0) co=iBars(sy, tf)-in;

  double r, rb=0;       // размер бара
  int    i, nb=-1;      // счётчик и номер бара

  for (i=co+in; i>=in; i--) {
    if (ty>0) r=MathAbs(iOpen(sy, tf, i)-iClose(sy, tf, i));
    else r=iHigh(sy, tf, i)-iLow(sy, tf, i);
    if (rb<r) {
      rb=r;
      nb=i;
    }
  }

  return(nb);
}

La función iBarOfDayCalc().

Esta función devuelve el número calculado de la barra desde el principio del día. Las barras se numeran empezando por el uno, es decir, la barra con el menor tiempo de apertura en el día dado será la número uno, la siguiente barra será la número dos, etc. Esta función es útil para optimizar los tiempos de entrada/salida. Si alguien está interesado en los detalles, que pregunte. Haré todo lo posible por responder a ellas. La función iBarOfDayCalc( ) toma los siguientes parámetros opcionales:

  • tf - Marco temporal. El valor por defecto es 0 - el marco temporal actual.
  • dt - Fecha y hora de apertura del bar. Valor por defecto - 0 - hora actual.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 26.02.2008                                                     |
//|  Описание : Возвращает расчётный номер бара от начала суток.               |
//|           : Нумерация баров начинается с 1 (единица).                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    tf - таймфрейм                       (0 - текущий таймфрейм)            |
//|    dt - дата и время открытия бара      (0 - текущее время)                |
//+----------------------------------------------------------------------------+
int iBarOfDayCalc(int tf=0, datetime dt=0) {
  if (tf<=0) tf=Period();
  if (dt<=0) dt=TimeCurrent();
  if (tf>PERIOD_D1) {
    Print("iBarOfDayCalc(): Таймфрейм должен быть меньше или равен D1");
    return(0);
  }
  double ms=MathMod(dt/60, 1440);      // количество минут от начала суток
  int    bd=MathFloor(ms/tf)+1;        // номер бара от начала суток

  return(bd);
}
 

Función iBarOfDayReal().

Esta función devuelve el número de compás actual desde el principio del día. Las barras se numeran empezando por el uno, es decir, la barra con el menor tiempo de apertura en un día determinado tendrá el número uno, la siguiente barra tendrá el número dos, etc. Todavía no he encontrado ningún uso práctico para esta función. Pero lo he escrito para tenerlo :-) junto con la función iBarOfDayCalc(). La función iBarOfDayReal() acepta los siguientes parámetros opcionales:

  • sy - Nombre del instrumento de negociación. NULL o "" - símbolo actual. El valor por defecto es "".
  • tf - Marco temporal. Valor por defecto - 0 - marco temporal actual.
  • dt - Fecha y hora de apertura del bar. Valor por defecto - 0 - hora actual.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 26.02.2008                                                     |
//|  Описание : Возвращает реальный номер бара от начала суток.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (          0 - текущий таймфрейм)       |
//|    dt - дата и время открытия бара (          0 - текущее время)           |
//+----------------------------------------------------------------------------+
int iBarOfDayReal(string sy="", int tf=0, datetime dt=0) {
  if (sy=="" || sy=="0") sy=Symbol();
  if (tf<=0) tf=Period();
  if (dt<=0) dt=TimeCurrent();
  if (tf>PERIOD_D1) {
    Print("iBarOfDayReal(): Таймфрейм должен быть меньше или равен D1");
    return(0);
  }

  int cd=TimeDay(dt);                       // текущий день месяца
  int nb=iBarShift(sy, tf, dt, False);      // номер текущего бара
  int bd=0;                                 // номер бара от начала суток

  while(TimeDay(iTime(sy, tf, nb))==cd) {
    nb++;
    bd++;
  }

  return(bd);
}

Función NameDayOfWeek()

Devuelve el nombre del día de la semana por el número pasado como parámetro:

  • ndw - Número de día de la semana. Parámetro obligatorio.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование дня недели                             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    ndw - номер дня недели                                                  |
//+----------------------------------------------------------------------------+
string NameDayOfWeek(int ndw) {
  if (ndw==0) return("Воскресенье");
  if (ndw==1) return("Понедельник");
  if (ndw==2) return("Вторник");
  if (ndw==3) return("Среда");
  if (ndw==4) return("Четверг");
  if (ndw==5) return("Пятница");
  if (ndw==6) return("Суббота");
}
 

Función NormalizarLote().

Esta función devuelve el valor normalizado del lote que se está negociando. Además de la normalización, también ajusta el tamaño del lote a los límites establecidos por el centro de negociación (se comprueban los valores mínimo y máximo del lote y el paso de cambio del lote). La función NormalizeLot() acepta los siguientes parámetros:

  • lo - Valor de normalización del lote. Parámetro obligatorio.
  • ro - Método de redondeo. Falso - al lado menor, Verdadero - al lado mayor. Valor por defecto - Falso - hacia el lado inferior.
  • sy - Nombre del instrumento comercial. NULL o "" - símbolo actual. Valor por defecto - "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 16.05.2008                                                     |
//|  Описание : Возвращает нормализованное значение торгуемого лота.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    lo - нормализуемое значение лота.                                       |
//|    ro - способ округления          (   False    - в меньшую,               |
//|                                        True     - в большую сторону)       |
//|    sy - наименование инструмента   ("" или NULL - текущий символ)          |
//+----------------------------------------------------------------------------+
double NormalizeLot(double lo, bool ro=False, string sy="") {
  double l, k;
  if (sy=="" || sy=="0") sy=Symbol();
  double ls=MarketInfo(sy, MODE_LOTSTEP);
  double ml=MarketInfo(sy, MODE_MINLOT);
  double mx=MarketInfo(sy, MODE_MAXLOT);

  if (ml==0) ml=0.1;
  if (mx==0) mx=100;

  if (ls>0) k=1/ls; else k=1/ml;
  if (ro) l=MathCeil(lo*k)/k; else l=MathFloor(lo*k)/k;

  if (l<ml) l=ml;
  if (l>mx) l=mx;

  return(l);
}

Función NormalizePrice().

Esta función devuelve el valor del precio normalizado. La normalización se realiza utilizando los valores de la función MarketInfo(MODE_TICKSIZE || MODE_DIGITS). La función NormalizePrice( ) toma los siguientes parámetros:

  • np - Valor normalizado del lote. Parámetro obligatorio.
  • sy - Nombre del instrumento comercial. NULL o "" - símbolo actual. El valor por defecto es "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 21.08.2008                                                     |
//|  Описание : Возвращает нормализованное под размер тика значение цены.      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    np - нормализуемое значение цены.                                       |
//|    sy - наименование инструмента        ("" или NULL - текущий символ)     |
//+----------------------------------------------------------------------------+
double NormalizePrice(double np, string sy="") {
  if (sy=="" || sy=="0") sy=Symbol();
  double pp, ts=MarketInfo(Symbol(), MODE_TICKSIZE);
  int    di=MarketInfo(Symbol(), MODE_DIGITS);

  if (ts>0) pp=NormalizeDouble(np/ts, 0)*ts;
  else {
    if (di>0) pp=NormalizeDouble(np*di, 0)/di; else pp=np;
  }
  return(pp);
}
 

La función WeekOfMonth().

Esta función devuelve la semana del mes por fecha. Sólo acepta un parámetro opcional:

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 12.08.2008                                                     |
//|  Описание : Возвращает номер недели месяца по дате                         |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    dt - дата, время           (0 - сейчас по времени торгового сервера)    |
//+----------------------------------------------------------------------------+
int WeekOfMonth(datetime dt=0) {
  if (dt<=0) dt=TimeCurrent();
  datetime d;
  int      i, kd=TimeDay(dt), nn=1;

  for (i=2; i<=kd; i++) {
    d=StrToTime(TimeYear(dt)+"."+TimeMonth(dt)+"."+i);
    if (TimeDayOfWeek(d)==1) nn++;
  }
  return(nn);
}

Función ClosePosBySortLots().

Esta función cierra las posiciones en el orden de clasificación por tamaño de lote. Es decir, con esta función se pueden cerrar posiciones en orden ascendente o descendente de tamaños de lote. La función ClosePosBySortLots() acepta los siguientes parámetros opcionales:

  • sy - Nombre del instrumento de negociación. "" - cualquier instrumento, NULL - instrumento actual. Valor por defecto - "".
  • op - Tipo de operación comercial. Valores válidos -1 - cualquier posición, OP_BUY - comprar, OP_SELL - vender. El valor por defecto es -1.
  • mn - MagicNumber, identificador único de una operación comercial. Valor por defecto -1 - cualquier MagicNumber.
  • sd - Dirección de clasificación del tamaño del lote. Valores válidos MODE_ASCEND - ascendente, MODE_DESCEND - descendente. El valor por defecto es MODE_DESCEND.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.12.2008                                                     |
//|  Описание : Закрытие позиций в порядке сортировки по размерам лотов.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента        (    ""       - любой символ,      |
//|                                             NULL      - текущий символ)    |
//|    op - операция                        (    -1       - любая позиция)     |
//|    mn - MagicNumber                     (    -1       - любой магик)       |
//|    sd - Направление сортировки лотов    (MODE_ASCEND  - возрастание,       |
//|                                          MODE_DESCEND - убывание)          |
//+----------------------------------------------------------------------------+
void ClosePosBySortLots(string sy="", int op=-1, int mn=-1, int sd=MODE_DESCEND) {
  double a[][2];                  // Массив лотов и тикетов
  int    i, k=OrdersTotal();      // Счётчик и количество ордеров
  int    p=0;                     // Количество позиций

  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()==OP_BUY || OrderType()==OP_SELL) {
          if (mn<0 || OrderMagicNumber()==mn) {
            p++;
            ArrayResize(a, p);
            a[p-1][0]=OrderLots();
            a[p-1][1]=OrderTicket();
          }
        }
      }
    }
  }

  // вдруг позиций нету, тогда и закрывать нечего
  if (p>0) {
    ArraySort(a, WHOLE_ARRAY, 0, sd);
    for (i=0; i<p; i++) {
      if (OrderSelect(a[i][1], SELECT_BY_TICKET)) {
        // проверим незакрытость на всякий случай,
        // может какая-то позиция уже закрылась по стопу/тейку
        if (OrderCloseTime()==0) ClosePosBySelect();
      }
    }
  }
}
 

La función AddLeadingZero().

Esta función añade tantos ceros a la izquierda "0" a la cadena para que la longitud de la cadena sea igual a un valor dado. La función AddLeadingZero( ) toma los siguientes parámetros obligatorios:

  • s - La cadena a la que hay que añadir los ceros a la izquierda.
  • k - La longitud de la cadena resultante S.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Добавляет к строке S столько лидирующих нулей "0",             |
//|           : чтобы длина строки S стала равна K.                            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    s - строка                                                              |
//|    k - длина строки S                                                      |
//+----------------------------------------------------------------------------+
string AddLeadingZero(string s, int k) {
  while(StringLen(s)<k) s=StringConcatenate("0", s);
  return(s);
}

Función toTime().

Esta función convierte dos/tres enteros en una cadena en formato de tiempo. Si pasa dos números a la función, el primero se utilizará como horas y el segundo como minutos. La cadena de formato devuelta será "HH:MM". Si hay tres números, el tercero será sustituido por los segundos y la función devolverá la cadena "HH:MM:SS". La función toTime() acepta los siguientes parámetros opcionales:

  • h - Reloj. El valor por defecto es 0.
  • m - Minutos. El valor por defecto es 0.
  • s - Segundos. 0 - No utilizar. Valor por defecto 0.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Преобразует два/три целых числа в строку в формате времени     |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    h - часы                                                                |
//|    m - минуты                                                              |
//|    s - секунды           (0 - не использовать)                             |
//+----------------------------------------------------------------------------+
string toTime(int h=0, int m=0, int s=0) {
  string st="";

  if (h==0) st="00:";
  else      st=StringConcatenate(AddLeadingZero(h, 2), ":");

  if (m==0) st=StringConcatenate(st, "00");
  else      st=StringConcatenate(st, AddLeadingZero(m, 2));

  if (s!=0) st=StringConcatenate(st, ":", AddLeadingZero(s, 2));

  return(st);
}