Apenas "Recursos úteis do KimIV". - página 9

Novo comentário
 

A função StringLower().

Esta função converte um fio em minúscula. Todos os caracteres SIGNIFICANTES (grandes) tornam-se letras minúsculas (pequenas). A função StringLower() aceita apenas um parâmetro obrigatório, que é a string de entrada.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

A função StringUpper().

Esta função converte a corda para maiúsculas. Todos os caracteres em minúsculas (pequenos) tornam-se maiúsculas (grandes). A função StringUpper() aceita apenas um parâmetro obrigatório, que é a string 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);
}


A função StringToArrayDouble().

Esta função divide a cadeia em seus números reais componentes, e cada número é adicionado à matriz como um elemento separado. Como muitos números reais aparecem na seqüência, o mesmo número de elementos será adicionado à matriz. Um ponto-e-vírgula é reconhecido como um separador. A função StringToArrayDouble() retorna o número de elementos da matriz, e toma os seguintes parâmetros obrigatórios:

  • st - Uma seqüência de números reais separados por ponto-e-vírgula.
  • ad - Um conjunto de números reais.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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));
}
 

A função StringToArrayInt().

Esta função divide a cadeia em seus inteiros componentes, e cada número é adicionado à matriz como um elemento separado. Tantos números inteiros quanto os que estão na cadeia, o mesmo número de elementos será adicionado à matriz. Uma vírgula é reconhecida como um separador. A função StringToArrayDouble() retorna o número de elementos da matriz, e toma os seguintes parâmetros obrigatórios:

  • st - Cadeia separada por vírgula de valores inteiros.
  • ai - Matriz Inteira.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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));
}

A função StrSplit().

Esta função divide um cordel em seu substrato, de modo que cada substrato se torna um elemento separado da matriz. O separador é especificado por um parâmetro e pode ser arbitrário. A função StrSplit() retorna o número de elementos da matriz e aceita os seguintes parâmetros:

  • st - Cordão com separadores.
  • como - O conjunto de elementos do tipo string.
  • de - Separador. Parâmetro opcional. Valor padrão - "," (vírgula).
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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));
}
 

A função StrTran().

Esta função substitui um substrato. Todas as ocorrências dela são substituídas. Por exemplo, você pode substituir todas as vírgulas por pontos ou vice versa de uma só vez. A função StrSplit() retorna a string resultante e aceita os seguintes parâmetros obrigatórios:

  • str - O cordão no qual o string de substrato está sendo substituído.
  • strFrom - substrato substituído. Se a corda de substratoFrom for encontrada em corda, ela será substituída por corda de substratoTo.
  • strTo - Substrato substituto.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
              }
            }
          }
        }
      }
    }
  }
}
 

Função isTradeTimeString().

Esta função retorna a bandeira permitindo que você negocie por tempo. Na verdade, ela realmente verifica se a hora atual do servidor de negociação está dentro de um determinado intervalo de tempo. Se estiver dentro, a função isTradeTimeString() retorna verdadeiro, caso contrário, retorna falso. A característica desta função é a possibilidade de especificar o intervalo de tempo tanto dentro como fora de um dia. Isto será mostrado em detalhes nos exemplos de uso. A função isTradeTimeString() aceita os seguintes parâmetros opcionais:

  • TimeBegin - String no formato "HH:MM", define a hora de início do comércio. O valor padrão é "00:00".
  • TimeEnd - String no formato "HH:MM", especifica o tempo de fim de comércio. O valor padrão é "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);
}

Função isTradeTimeInt().

Esta função retorna a bandeira permitindo a comercialização por tempo. O valor retornado é verdadeiro ou falso. A função isTradeTimeInt() é semelhante à função isTradeTimeString() pelo princípio do reconhecimento do intervalo de tempo, ou seja, a hora de início da negociação pode ser tanto maior (intervalo de tempo dentro de um dia) quanto menor (intervalo de tempo em dias diferentes). A função isTradeTimeInt() aceita os seguintes parâmetros opcionais:

  • hb - Número, especifica o horário de início do comércio. O valor padrão é 0.
  • mb - Um número, especifica a ata de início do comércio. Valor padrão - 0.
  • um número para especificar o horário de término do comércio. O valor padrão - 0.
  • me - Um número para especificar os minutos do horário de término do comércio. Valor padrão - 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:
O arquivo contém tudo em um único arquivo.
Arquivos anexados:
kimiv.zip  187 kb
 
Igor Kim publicou suas funções tanto aqui como em seu site como "coleções de funções", em um único arquivo. Não foi possível utilizar estas coleções como bibliotecas plug-in nesta forma. Entretanto, é muito conveniente, especialmente no desenvolvimento de EA, utilizar as bibliotecas para simplificar e reduzir o código de uma EA. Além disso, isto elimina todas as dúvidas sobre o uso correto das operações comerciais e permite que você se concentre na estratégia, que é especialmente valiosa para comerciantes com habilidades de programação para iniciantes.
Os arquivos anexos contêm as mesmas coleções de funções, projetadas sob a forma de bibliotecas. As bibliotecas são simplesmente colocadas no diretório .../experts/include, elas não precisam ser compiladas, um exemplo de sua conexão é dado abaixo.
Após sua conexão, é suficiente chamar a função requerida a partir do código EA.
#include <b-Positions_include.mqh>       // Библиотека функций для работы с позициями 
#include <b-KimIV_include.mqh>           // Библиотека дополнительных функций
#include <b-Orders_include.mqh>          // Библиотека функций для работы с ордерами
Arquivos anexados:
b-kimiv_include.mqh  18 kb
b-orders_include.mqh  26 kb
b-positions_include.mqh  26 kb
 

Caro, onde na fila. 

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

satop:

A função isCloseLastPosByStop().

Esta função retorna uma bandeira para fechar a última posição por meio de uma parada. A bandeira está hasteada - Verdadeiro - acionada StopLoss. Bandeira arriada - Falsa - a posição foi fechada por outro motivo. Uma seleção mais precisa das posições a serem levadas em conta é definida usando parâmetros externos:

  • sy - Nome do instrumento de mercado. Se você definir este parâmetro, a função considerará apenas as posições do instrumento especificado. O valor padrão "" significa qualquer instrumento de mercado. NULL significa o instrumento atual.
  • op - Operação comercial, tipo de posição. Valores válidos: OP_BUY, OP_SELL ou -1. O valor padrão -1 significa qualquer posição.
  • mn - Identificador de posição, MagicNumber. O valor padrão -1 significa qualquer identificador.

 
Entendo que as funções foram escritas em uma época em que ainda não havia 5 dígitos. O JPY serviu como uma espécie de exemplo de comparação.
 
hoz:
Entendo que as funções foram escritas em uma época em que ainda não havia 5 dígitos. O JPY serviu como uma espécie de exemplo de comparação.

Não é difícil aumentar em um!
123456789101112
Novo comentário