Apenas &quot;Recursos úteis do KimIV&quot;.

Iurii Tokman 2011.02.18 08:50 #71

Função TakeProfitLastClosePos().

Retorna o nível de preço TakeProfit da última posição fechada ou -1. A função TakeProfitLastClosePos() aceita os seguintes parâmetros opcionais:

sy - Nome do instrumento. "" - qualquer símbolo, NULL - símbolo atual. O valor padrão é "".
op - Operação comercial. Valores válidos: -1, OP_BUY, OP_SELL. O valor padrão é -1 - qualquer comércio.
mn - Identificador comercial, MagicNumber. Valor por default -1 - qualquer 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);
}

Função MovingInWL().

Move o nível de preço StopLoss das posições abertas para Breakeven. A função MovingInWL() toma os seguintes parâmetros opcionais:

sy - Nome do instrumento. "" - qualquer símbolo, NULL - símbolo atual. O valor padrão é "".
op - Operação comercial. Valores válidos: -1, OP_BUY, OP_SELL. O valor padrão é -1 - qualquer comércio.
mn - Identificador comercial, MagicNumber. Valor por default -1 - qualquer magik.

Além disso, a função MovingInWL() tem variáveis globais (parâmetros externos de script ou Expert Advisor):

int LevelProfit - Nível de lucro em pontos, que uma posição deve alcançar para ter sua parada movida para o nível de Breakeven.
int LevelWLoss - Nível de equilíbrio em pontos, para o qual a parada será transferida após seu lucro atingir o nível LevelProfit em pontos.

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

Características úteis da KimIV E vamos fazer um Quaisquer perguntas de recém-chegados

Iurii Tokman 2011.02.18 08:51 #72

Função SimpleTrailing().

Move o nível de preço StopLoss das posições abertas usando o algoritmo TrailingStop. A função SimpleTrailing() aceita os seguintes parâmetros opcionais:

sy - Nome do instrumento. "" - qualquer símbolo, NULL - símbolo atual. O valor padrão é "".
op - Operação comercial. Valores válidos: -1, OP_BUY, OP_SELL. O valor padrão é -1 - qualquer comércio.
mn - Identificador comercial, MagicNumber. Valor por default -1 - qualquer magik.

Além disso, a função SimpleTrailing() implica em variáveis globais (parâmetros externos do script ou Expert Advisor):

bool TSProfitOnly - Altera a zona em que a rede de arrasto começa. Se Verdadeiro, a rede de arrasto só começará a funcionar quando o lucro da posição atingir o valor de TStop.Buy/Sell+TrailingStep points. Se falso, o Expert Advisor simplesmente se certificará de que a posição de parada em relação ao preço atual não seja sempre maior que TStop.Buy/Sell+TrailingStep pips. Em outras palavras, se Verdadeiro, o Expert Advisor trabalha somente na zona de lucro da posição enquanto que se Falso, trabalha na zona negativa da posição.
int TStop.Buy - Tamanho do carrinho em pontos para comprar.
intTStop.Sell - Tamanho da rede de arrasto em pontos de venda.
int TrailingStep - Passo de trilha em pontos. É necessário a fim de não perturbar o revendedor com pedidos frequentes.

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

Função ArrayZ().

Esta função calcula e retorna a contagem Z de uma série numérica passada na matriz por referência.

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

Características úteis da KimIV E vamos fazer um Quaisquer perguntas de recém-chegados

Iurii Tokman 2011.02.18 08:52 #73

A função ArrayDeleteInt()

Executa a exclusão de um elemento de matriz com o índice dado. Devolve o tamanho da nova matriz ou -1 se nada tiver sido removido. A função ArrayDeleteInt() aceita os seguintes parâmetros obrigatórios:

m - Conjunto de elementos.
i - Índice do elemento da 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);
}

A função ArrayDeleteDouble()

Elimina o elemento da matriz com o índice dado. Ele retorna o tamanho da nova matriz ou -1, se nada pudesse ser apagado. A função ArrayDeleteDouble() aceita os seguintes parâmetros obrigatórios:

m - Matriz de elementos do tipo duplo.
i - Índice do elemento da 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);
}

Características úteis da KimIV Erros, bugs, perguntas Quaisquer perguntas de recém-chegados

Iurii Tokman 2011.02.18 08:53 #74

A função ArrayDeleteString()

Executa a exclusão de um elemento de matriz com o índice dado. Devolve o tamanho da nova matriz ou -1 se nada puder ser removido. A função ArrayDeleteString() aceita os seguintes parâmetros obrigatórios:

m - Conjunto de elementos do tipo corda.
i - Índice dos itens da 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);
}

A função ArrayInsertDouble()

Insere um elemento da matriz com o índice especificado. Ele retorna o número de elementos (tamanho) da nova matriz. A inserção é feita da seguinte forma. Primeiro, o tamanho da matriz é aumentado em um. Então todos os elementos que têm um índice maior ou igual ao a ser inserido são deslocados para o final da matriz um a um, abrindo espaço para o que deve ser inserido. Finalmente, o valor é escrito na célula necessária. A função ArrayInsertDouble() toma os seguintes parâmetros:

m - Um conjunto de elementos do tipo duplo.
e - Valor do elemento de matriz a ser inserido.
i - Índice do elemento da matriz a ser inserido. Se o valor do índice for menor que zero ou maior ou igual ao tamanho da matriz, o elemento será adicionado ao final da matriz. O valor padrão é -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);
}

Características úteis da KimIV Desejos para MQL5 Sugestões para a sintaxe

Iurii Tokman 2011.02.18 08:54 #75

A função BubbleSort2().

Esta função borbulha os elementos de uma matriz bidimensional em uma coluna arbitrária. Você também pode especificar a direção de classificação. A função BubbleSort2() toma os seguintes parâmetros:

a - Conjunto bidimensional de elementos. Parâmetro obrigatório.
r - Número (índice) da coluna de ordenação (coluna). O valor padrão é 0 - a primeira coluna (coluna com um índice zero).
m - Direção de classificação. Valores válidos: MODE_ASCEND - ordem ascendente, MODE_DESCEND - ordem descendente. O valor padrão é 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;
          }
        }
      }
    }
  }
}

A função GetTypeLastDeleted().

Esta função retorna o tipo da última ordem eliminada, ou -1. Há situações em que precisamos vincular a lógica de operação da EA ao tipo da ordem apenas eliminada. Por exemplo, se você acabou de excluir o BuyStop, você deve fazer isso, mas se BuyLimit, você deve fazer outra coisa, etc. A função GetTypeLastDeleted() aceita os seguintes parâmetros opcionais:

sy - Nome do instrumento. "" - qualquer caráter, NULL - caráter atual. O valor padrão é "".
mn - identificador de pedido do usuário (MagicNumber). Valor por default -1 - qualquer magia.

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

Características úteis da KimIV [ARQUIVO!] Qualquer pergunta de Código de redação em

Iurii Tokman 2011.02.18 08:55 #76

A função iBarLargest().

Esta função retorna o índice da maior barra ou -1. O tamanho da barra é medido pela função em uma de duas maneiras, determinada pelo tipo de parâmetro de entrada - tipo de itens de busca. Seja apenas o tamanho do corpo ou junto com as sombras. A função iBarLargest() aceita os seguintes parâmetros opcionais:

sy - Nome da ferramenta. "" ou NULL - o símbolo atual. O valor padrão é "".
tf - Cronograma. O valor padrão é 0 - o período de tempo atual.
ty - Tipo de itens de busca. Valores válidos - 0 - Alto-Baixo, 1 - abs(Open-Close).
co - Número de itens de séries cronológicas. Valor padrão - 0 - todos os elementos.
em - Índice da barra inicial. Valor padrão - 0 - barra de corrente.

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

A função iBarOfDayCalc().

Esta função retorna o número calculado da barra desde o início do dia. As barras são numeradas a partir de uma, ou seja, a barra com o menor tempo de abertura em determinado dia será a número um, a próxima barra será a número dois, etc. Esta função é útil para otimizar os tempos de entrada/saída. Se alguém estiver interessado em detalhes, faça perguntas. Farei o meu melhor para respondê-las. A função iBarOfDayCalc() tem os seguintes parâmetros opcionais:

tf - Cronograma. O valor padrão é 0 - o período de tempo atual.
dt - Data e hora de abertura do bar. Valor padrão - 0 - hora atual.

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

Características úteis da KimIV Quaisquer perguntas de recém-chegados [ARQUIVO!] Qualquer pergunta de

Iurii Tokman 2011.02.18 08:56 #77

Função iBarOfDayReal().

Esta função retorna o número real da barra desde o início do dia. As barras são numeradas começando por uma, ou seja, a barra com o menor tempo de abertura em um determinado dia terá o número um, a próxima barra terá o número dois, etc. Ainda não encontrei nenhum uso prático para esta função. Mas eu o escrevi para tê-lo :-) junto com a função iBarOfDayCalc(). A função iBarOfDayReal() aceita os seguintes parâmetros opcionais:

sy - Nome do instrumento comercial. NULL ou "" - símbolo atual. O valor padrão é "".
tf - Cronograma. Valor padrão - 0 - prazo atual.
dt - Data e hora de abertura do bar. Valor padrão - 0 - hora atual.

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

Função NameDayOfWeek()

Retorna o nome do dia da semana pelo número passado como parâmetro:

ndw - Número do dia da semana. Parâmetro necessário.

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

Características úteis da KimIV Quaisquer perguntas de recém-chegados [AVISO FECHADO!] Qualquer pergunta

Iurii Tokman 2011.02.18 08:58 #78

Função NormalizeLot().

Esta função retorna o valor normalizado do lote sendo negociado. Além da normalização, ela também se ajusta ao tamanho do lote nos limites estabelecidos pelo centro de negociação (os valores mínimo e máximo do lote e a etapa de mudança de lote são verificados). A função NormalizeLot() aceita os seguintes parâmetros:

lo - NormalizarValor da lote. Parâmetro necessário.
ro - Método de arredondamento. Falso - para o lado menor, Verdadeiro - para o lado maior. Valor por defeito - Falso - para o lado inferior.
sy - Nome do instrumento comercial. NULL ou "" - símbolo atual. Valor padrão - "".

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

Função NormalizePreço().

Esta função retorna o valor do preço normalizado. A normalização é realizada utilizando a função MarketInfo(MODE_TICKSIZE || MODE_DIGITS). A função NormalizePreço() toma os seguintes parâmetros:

np - Valor de lote normalizado. Parâmetro necessário.
sy - Nome do instrumento comercial. NULL ou "" - símbolo atual. O valor padrão é "".

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

Características úteis da KimIV Quaisquer perguntas de recém-chegados [AVISO FECHADO!] Qualquer pergunta

Iurii Tokman 2011.02.18 08:59 #79

A função WeekOfMonth().

Esta função retorna na semana do mês por data. Aceita apenas um parâmetro opcional:

dt - Data, hora. Valor padrão - 0 - data e hora atual do servidor comercial.

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

Função ClosePosBySortLots().

Esta função fecha posições na ordem de classificação por tamanho de lote. Ou seja, usando esta função, você pode fechar posições em ordem ascendente ou descendente de tamanhos de lote. Função ClosePosBySortLots() aceita os seguintes parâmetros opcionais:

sy - Nome do instrumento comercial. "" - qualquer instrumento, NULL - instrumento atual. Valor padrão - "".
op - Tipo de operação comercial. Valores válidos -1 - qualquer posição, OP_BUY - comprar, OP_SELL - vender. O valor padrão é -1.
mn - MagicNumber, identificador único de uma operação comercial. Valor por default -1 - qualquer MagicNumber.
sd - Direção da classificação do tamanho do lote. Valores válidos MODE_ASCEND - ascendente, MODE_DESCEND - descendente. O valor padrão é 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();
      }
    }
  }
}

Iurii Tokman 2011.02.18 09:00 #80

A função AddLeadingZero().

Esta função adiciona o mesmo número de zeros à corda (esquerda), de modo que o comprimento da corda se torna igual a algum valor dado. A função AddLeadingZero() toma os seguintes parâmetros obrigatórios:

s - O fio ao qual os zeros principais devem ser adicionados.
k - O comprimento da corda S resultante.

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

Função toTime().

Esta função converte dois/três inteiros em uma cadeia no formato de tempo. Se você passar dois números para a função, o primeiro será usado como horas e o segundo como minutos. A cadeia de formato retornada será "HH:MM". Se houver três números, o terceiro será substituído pelos segundos e a função retornará a string "HH:MM:SS". A função toTime() aceita os seguintes parâmetros opcionais:

h - Relógio. O valor padrão é 0.
m - Minutos. O valor padrão é 0.
s - Segundos. 0 - Não usar. Valor padrão 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);
}

Características úteis da KimIV [ARQUIVO!] Qualquer pergunta de MetaTrader 5 build 2121:

Apenas &quot;Recursos úteis do KimIV&quot;. - página 8