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

 

La función StringLower().

Esta función convierte una cadena en minúsculas. Todos los caracteres SIGNIFICATIVOS (grandes) se convierten en minúsculas. La función StringLower() sólo acepta un parámetro obligatorio, que es la cadena entrante.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает строку в нижнем регистре                            |
//+----------------------------------------------------------------------------+
string StringLower(string s) {
  int c, i, k=StringLen(s), n;
  for (i=0; i<k; i++) {
    n=0;
    c=StringGetChar(s, i);
    if (c>64 && c<91) n=c+32;     // A-Z -> a-z
    if (c>191 && c<224) n=c+32;   // А-Я -> а-я
    if (c==168) n=184;            //  Ё  ->  ё
    if (n>0) s=StringSetChar(s, i, n);
  }
  return(s);
}
 

La función StringUpper().

Esta función convierte la cadena en mayúsculas. Todos los caracteres en minúscula (pequeños) se convierten en mayúsculas (grandes). La función StringUpper() sólo acepta un parámetro obligatorio, que es la cadena de entrada.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает строку в ВЕРХНЕМ регистре                           |
//+----------------------------------------------------------------------------+
string StringUpper(string s) {
  int c, i, k=StringLen(s), n;
  for (i=0; i<k; i++) {
    n=0;
    c=StringGetChar(s, i);
    if (c>96 && c<123) n=c-32;    // a-z -> A-Z
    if (c>223 && c<256) n=c-32;   // а-я -> А-Я
    if (c==184) n=168;            //  ё  ->  Ё
    if (n>0) s=StringSetChar(s, i, n);
  }
  return(s);
}


La función StringToArrayDouble().

Esta función divide la cadena en los números reales que la componen, y cada número se añade a la matriz como un elemento separado. Se añadirán a la matriz tantos números reales como aparezcan en la cadena, el mismo número de elementos. El punto y coma se reconoce como separador. La función StringToArrayDouble() devuelve el número de elementos del array, y toma los siguientes parámetros obligatorios:

  • st - Una cadena de números reales separados por un punto y coma.
  • ad - Una matriz de números reales.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 10.10.2008                                                     |
//|  Описание : Перенос вещественных чисел из строки в массив                  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    st - строка вещественных чисел через точку с запятой                    |
//|    ad - массив вещественных чисел                                          |
//+----------------------------------------------------------------------------+
//|  Возврат:                                                                  |
//|    Количество элементов в массиве                                          |
//+----------------------------------------------------------------------------+
int StringToArrayDouble(string st, double& ad[]) {
  int    i=0, np;
  string stp;

  ArrayResize(ad, 0);
  while (StringLen(st)>0) {
    np=StringFind(st, ";");
    if (np<0) {
      stp=st;
      st="";
    } else {
      stp=StringSubstr(st, 0, np);
      st=StringSubstr(st, np+1);
    }
    i++;
    ArrayResize(ad, i);
    ad[i-1]=StrToDouble(stp);
  }
  return(ArraySize(ad));
}
 

La función StringToArrayInt().

Esta función divide la cadena en los enteros que la componen, y cada número se añade a la matriz como un elemento separado. Se añadirán al array tantos enteros como haya en la cadena, el mismo número de elementos. La coma se reconoce como separador. La función StringToArrayDouble() devuelve el número de elementos del array, y toma los siguientes parámetros obligatorios:

  • st - Cadena de valores enteros separados por comas.
  • ai - Matriz de números enteros.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Перенос целочисленных значений из строки в массив              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    st - строка целочисленных значений через запятую                        |
//|    ai - целочисленный массив                                               |
//+----------------------------------------------------------------------------+
//|  Возврат:                                                                  |
//|    Количество элементов в массиве                                          |
//+----------------------------------------------------------------------------+
int StringToArrayInt(string st, int& ai[]) {
  int    i=0, np;
  string stp;

  ArrayResize(ai, 0);
  while (StringLen(st)>0) {
    np=StringFind(st, ",");
    if (np<0) {
      stp=st;
      st="";
    } else {
      stp=StringSubstr(st, 0, np);
      st=StringSubstr(st, np+1);
    }
    i++;
    ArrayResize(ai, i);
    ai[i-1]=StrToInteger(stp);
  }
  return(ArraySize(ai));
}

La función StrSplit().

Esta función divide una cadena en su subcadena, de modo que cada subcadena se convierte en un elemento independiente de la matriz. El separador se especifica mediante un parámetro y puede ser arbitrario. La función StrSplit() devuelve el número de elementos de la matriz y acepta los siguientes parámetros:

  • st - Cadena con separadores.
  • as - La matriz de elementos de tipo cadena.
  • de - Separador. Parámetro opcional. Valor por defecto - "," (coma).
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 23.06.2008                                                     |
//|  Описание : Разбиение строки на массив элементов                           |
//+----------------------------------------------------------------------------+
//|  Возврат:                                                                  |
//|    Количество элементов в массиве                                          |
//|  Параметры:                                                                |
//|    st - строка с разделителями                                             |
//|    as - строковый массив                                                   |
//|    de - разделитель                                                        |
//+----------------------------------------------------------------------------+
int StrSplit(string st, string& as[], string de=",") { 
  int    i=0, np;
  string stp;

  ArrayResize(as, 0);
  while (StringLen(st)>0) {
    np=StringFind(st, ",");
    if (np<0) {
      stp=st;
      st="";
    } else {
      stp=StringSubstr(st, 0, np);
      st=StringSubstr(st, np+1);
    }
    i++;
    ArrayResize(as, i);
    as[i-1]=stp;
  }
  return(ArraySize(as));
}
 

La función StrTran().

Esta función sustituye una subcadena. Se sustituyen todas las apariciones de la misma. Por ejemplo, puede sustituir todas las comas por puntos o viceversa de un plumazo. La función StrSplit() devuelve la cadena resultante y acepta los siguientes parámetros obligatorios:

  • str - La cadena en la que se sustituye la subcadena strFrom.
  • strFrom - subcadena sustituida. Si la subcadena strFrom se encuentra en la cadena str, se sustituirá por la subcadena strTo.
  • strTo - Subcadena sustituida.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  описание : Замена подстроки                                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    str     - текстовая строка, в которой производится замена               |
//|    strFrom - заменяемая подстрока                                          |
//|    strTo   - заменяющая подстрока                                          |
//+----------------------------------------------------------------------------+
string StrTran(string str, string strFrom, string strTo) {
  int    n;
  string strOut="", strTemp;

  for (n=0; n<StringLen(str); n++) {
    strTemp=StringSubstr(str, n, StringLen(strFrom));
    if (strTemp==strFrom) {
      strOut=StringConcatenate(strOut, strTo);
      n=n+StringLen(strFrom)-1;
    } else strOut=StringConcatenate(strOut, StringSubstr(str, n, 1));
  }
  return(strOut);
}
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 23.04.2009                                                     |
//|  Описание : Перенос уровня стопа в безубыток                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void MovingInWL(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)) {
        if (mn<0 || OrderMagicNumber()==mn) {
          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 isTradeTimeString().

Esta función devuelve la bandera que permite comerciar por tiempo. En realidad, comprueba si la hora actual del servidor de comercio está dentro de un determinado intervalo de tiempo. Si está dentro, la función isTradeTimeString() devuelve true, en caso contrario devuelve false. La característica de esta función es la posibilidad de especificar el intervalo de tiempo tanto dentro como fuera de un día. Esto se mostrará en detalle en los ejemplos de uso. La función isTradeTimeString() acepta los siguientes parámetros opcionales:

  • TimeBegin - Cadena en el formato "HH:MM", establece la hora de inicio de la operación. El valor por defecto es "00:00".
  • TimeEnd - Cadena en el formato "HH:MM", especifica la hora de finalización de la operación. El valor por defecto es "00:00".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 29.04.2009                                                     |
//|  Описание : Возвращает флаг разрешения торговли по времени.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    TimeBegin - время начала торговли         (ЧЧ:ММ)                       |
//|    TimeEnd   - время окончания торговли      (ЧЧ:ММ)                       |
//+----------------------------------------------------------------------------+
bool isTradeTimeString(string TimeBegin="00:00", string TimeEnd="00:00") {
  datetime dtBegin, dtEnd;        // Время начала и окончания работы
  int      hc, he;                // Часы текущего времени и окончания работы

  dtBegin=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+TimeBegin);
  dtEnd  =StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+TimeEnd);
  hc     =TimeHour(TimeCurrent());
  he     =TimeHour(dtEnd);
  if (dtBegin>=dtEnd) {
    if (hc>=he) dtEnd+=24*60*60; else dtBegin-=24*60*60;
  }

  if (TimeCurrent()>=dtBegin && TimeCurrent()<=dtEnd) return(True);
  else return(False);
}

Función isTradeTimeInt().

Esta función devuelve la bandera que permite negociar por tiempo. El valor devuelto es verdadero o falso. La función isTradeTimeInt() es similar a la función isTradeTimeString() por el principio de reconocimiento del intervalo de tiempo, es decir, la hora de inicio de la operación puede ser tanto mayor (intervalo de tiempo dentro de un día) como menor (intervalo de tiempo en diferentes días). La función isTradeTimeInt() acepta los siguientes parámetros opcionales:

  • hb - Número, especifica la hora de inicio de la operación. El valor por defecto es 0.
  • mb - Un número, especifica los minutos de inicio de la operación. Valor por defecto - 0.
  • he - Un número para especificar las horas de finalización del comercio. El valor por defecto es 0.
  • me - Un número para especificar los minutos de finalización de la operación. Valor por defecto - 0.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 30.04.2009                                                     |
//|  Описание : Возвращает флаг разрешения торговли по времени.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    hb - часы времени начала торговли                                       |
//|    mb - минуты времени начала торговли                                     |
//|    he - часы времени окончания торговли                                    |
//|    me - минуты времени окончания торговли                                  |
//+----------------------------------------------------------------------------+
bool isTradeTimeInt(int hb=0, int mb=0, int he=0, int me=0) {
  datetime db, de;           // Время начала и окончания работы
  int      hc;               // Часы текущего времени торгового сервера

  db=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+hb+":"+mb);
  de=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+he+":"+me);
  hc=TimeHour(TimeCurrent());
  if (db>=de) {
    if (hc>=he) de+=24*60*60; else db-=24*60*60;
  }

  if (TimeCurrent()>=db && TimeCurrent()<=de) return(True);
  else return(False);
}
 
satop:
El fichero contiene todo en un solo archivo.
Archivos adjuntos:
kimiv.zip  187 kb
 
Igor Kim publicó sus funciones tanto aquí como en su sitio web como "colecciones de funciones", en un solo archivo. No era posible utilizar estas colecciones como bibliotecas de complementos de esta forma. Sin embargo, es muy conveniente, especialmente cuando se desarrollan EAs, utilizar las bibliotecas para simplificar y reducir el código de un EA. Además, esto elimina todas las preguntas sobre el uso correcto de las operaciones de comercio, y le permite centrarse en la estrategia, lo que es especialmente valioso para los comerciantes con conocimientos de programación principiantes.
Los archivos adjuntos contienen las mismas colecciones de funciones, diseñadas en forma de bibliotecas. Las librerías se colocan simplemente en el directorio .../experts/include, no es necesario compilarlas, a continuación se da un ejemplo de su conexión.
Tras su conexión, basta con llamar a la función requerida desde el código EA.
#include <b-Positions_include.mqh>       // Библиотека функций для работы с позициями 
#include <b-KimIV_include.mqh>           // Библиотека дополнительных функций
#include <b-Orders_include.mqh>          // Библиотека функций для работы с ордерами
Archivos adjuntos:
 

Querido, donde en la línea.

if (dg==0) if (StringFind(OrderSymbol(), "JPY")<0) dg=4; else dg=2;
появляется "JPY"??????

satop:

La función isCloseLastPosByStop().

Esta función devuelve una bandera para cerrar la última posición por parada. La bandera está arriba - Verdadero - activó el StopLoss. Bandera bajada - Falso - la posición ha sido cerrada por otra razón. La selección más precisa de las posiciones a tener en cuenta se establece mediante parámetros externos:

  • sy - Nombre del instrumento de mercado. Si establece este parámetro, la función sólo tendrá en cuenta las posiciones del instrumento especificado. El valor por defecto "" significa cualquier instrumento de mercado. NULL significa el instrumento actual.
  • op - Operación comercial, tipo de posición. Valores válidos: OP_BUY, OP_SELL o -1. El valor por defecto -1 significa cualquier posición.
  • mn - Identificador de posición, MagicNumber. El valor por defecto -1 significa cualquier identificador.

 
Tengo entendido que las funciones se escribieron en una época en la que aún no existían los 5 dígitos. El JPY sirvió como ejemplo de comparación.
 
hoz:
Tengo entendido que las funciones se escribieron en una época en la que aún no existían los 5 dígitos. El JPY sirvió como ejemplo de comparación.

No es difícil aumentar en uno.