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

Novo comentário
 

Função CorrectTF().

Escrevi esta função depois de descobrir que às vezes posso facilmente especificar um prazo incorreto, que é igual a um número inteiro de minutos, nos parâmetros de entrada de um indicador ou de um EA. Por exemplo, eu inscrevi 50 por hora em vez de 60. Bem... meio que falhou. Acontece que a função iRSI() retorna zero por um período de tempo incorreto. Eu não posso dizer nada sobre outras funções, porque não as verifiquei. Para evitar mal-entendidos resultantes de meus próprios erros desatentos, escrevi esta função como uma função primitiva à prova de tolices. Ele ajusta o parâmetro de entrada para o período de tempo apropriado mais próximo e retorna seu valor.

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

Função DataBeginQuarter().

Esta função retorna a data de início do trimestre por seu número. Por exemplo, se for agora 27.08.2008, então a data de início do trimestre atual será 01.07.2008. A função leva apenas um parâmetro - o número do trimestre relativo ao trimestre atual. Por exemplo, 0 é o trimestre atual, 1 é o trimestre seguinte e -1 é o trimestre anterior. Ou seja, números positivos de trimestre solicitarão datas do futuro, enquanto zero e negativos solicitarão datas do passado. O valor retornado é o número de segundos decorridos desde 00:00 de 1 de janeiro de 1970.

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

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

A função DateOfMonday().

Esta função retorna a data de início da semana (segunda-feira) por seu número. Por exemplo, se for agora 29.08.2008, a data de início da semana atual será 25.08.2008. A função leva apenas um parâmetro - o número de semanas em relação à semana atual. Por exemplo, 0 é a semana atual, 1 é a próxima semana e -1 é a semana anterior. Ou seja, números positivos da semana solicitarão datas do futuro, enquanto números zero e números negativos solicitarão datas do passado. O valor de retorno é o número de segundos transcorridos desde 00:00 de 1 de janeiro de 1970.

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

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

  return (dt);
}

A função Fibonacci().

Esta função retorna um elemento da série Fibonacci por seu número seqüencial.

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

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

Função GetNameMA().

Esta função retorna o nome do método MA(Moving Averages) por seu identificador. Esta função é conveniente para ser usada em comentários, indicadores e mensagens de Expert Advisors.

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

Função GetPriceDiffInPoint().

Esta função retorna a diferença de preço entre duas barras, que são especificadas por seus números. O objetivo de desenvolver esta função era determinar o valor e a direção do movimento de preços. A função GetPriceDiffInPoint() determina os pontos de referência (Aberto ou Alto ou Baixo ou Fechado) das barras a serem levados em conta. A função aceita os seguintes parâmetros opcionais:

  • sy - Nome do instrumento. "" ou NULL - símbolo atual. O valor padrão é NULL.
  • tf - Cronograma. Valor padrão 0 - símbolo atual.
  • n2 - Número de barra esquerda. Valor padrão - 2.
  • n1 - Número de barras à direita. Valor padrão - 1.

Valor devolvido:

  • positivo - houve um aumento da taxa entre as barras N2 e N1.
  • negativo - houve uma depreciação entre as barras N2 e N1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает ценовую разницу в пунктах между двумя барами.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента        ("" или NULL - текущий символ)     |
//|    tf - таймфрейм                       (    0       - текущий таймфрейм)  |
//|    n2 - номер левого бара               (    2       - второй бар)         |
//|    n1 - номер правого бара              (    1       - первый бар)         |
//|  Возвращаемое значение:                                                    |
//|    положительное - между барами N2 и N1 был рост курса                     |
//|    отрицательное - между барами N2 и N1 было снижение курса                |
//+----------------------------------------------------------------------------+
int GetPriceDiffInPoint(string sy="0", int tf=0, int n2=2, int n1=1) {
  if (sy=="" || sy=="0") sy=Symbol();
  double p=MarketInfo(sy, MODE_POINT);
  int    d=MarketInfo(sy, MODE_DIGITS);
  int    dd=0, k=iBars(sy, tf);

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

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

  return(dd);
}

A função GetTypePrice()

Devolve o nome do tipo de preço. A função leva apenas um parâmetro opcional. Valores válidos: PRICE_CLOSE, PRICE_OPEN, PRICE_HIGH, PRICE_LOW, PRICE_MEDIAN, PRICE_TYPICAL, PRICE_WEIGHTED. O valor padrão é 0 - PRICE_CLOSE.

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

A função ArrayLR().

Esta função gera um conjunto de valores de regressão linear. A função aceita os seguintes parâmetros obrigatórios:

  • x é um conjunto de valores de séries numéricas. Este é o parâmetro de entrada. Esta matriz deve conter os valores antes que a função seja chamada.
  • y é um conjunto de valores de regressão linear. Este é o parâmetro de saída, ou seja, a matriz será preenchida depois que a função for chamada.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 20.05.2008                                                     |
//|  Описание : Формирует массив значений линейной регрессии.                  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    x - массив значений числового ряда                                      |
//|    y - массив значений линейной регрессии                                  |
//+----------------------------------------------------------------------------+
void ArrayLR(double& x[], double& y[]) {
  double a, b, c, sx=0, sx2=0, sxy=0, sy=0;
  int    i, n=ArraySize(x);

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

Função ArrayMo().

Retorna Modu - o máximo da curva de densidade de distribuição. A função aceita os seguintes parâmetros opcionais:

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

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

  return(s);
}
 

Função ExistOrdersByPrice().

Devolve uma bandeira para a existência de um pedido ao preço determinado. Verdadeiro - a ordem existe (conjunto), Falso - a ordem não existe (não conjunto). Você pode limitar a lista de ordens a serem verificadas usando os parâmetros da função:

  • sy - Nome do instrumento de mercado. Se este parâmetro for dado, a função somente verificará as ordens do instrumento especificado. NULL significa o instrumento atual, e "" (por padrão) significa qualquer instrumento.
  • op - Tipo de comércio, tipo de ordem pendente. Valores válidos: OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP ou -1. O valor padrão de -1 indica qualquer tipo de pedido.
  • mn - Identificador do pedido (MagicNumber). O valor padrão de -1 significa qualquer MagicNumber.
  • pp - O nível de preço em que o pedido é estabelecido. O valor padrão é -1 - qualquer preço.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 30.07.2008                                                     |
//|  Описание : Возвращает флаг существования ордеров по цене установки        |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//|    pp - цена                       (-1   - любая цена)                     |
//+----------------------------------------------------------------------------+
bool ExistOrdersByPrice(string sy="", int op=-1, int mn=-1, double pp=-1) {
  int d, i, k=OrdersTotal();

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

A função ClosePosBySelect() para o testador.

Executa o fechamento de uma única posição pré-selecionada. Esta é uma versão simplificada da função do mesmo nome que foi descrita anteriormente na página 13. Nada supérfluo. Sem características extras. Em minha prática, nunca tive uma posição que não estivesse fechada no testador. É por isso que não há verificações nesta função. Eles são desnecessários no testador.

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

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

A função CountOrders() para o testador.

Em minhas versões de teste (destinadas exclusivamente para uso no testador do MT4), a função CountOrders() substitui as seguintes funções: ExistOrders(), ExistPositions(), NumberOfOrders() e NumberOfPositions(). Assim, ela pode dar informações sobre a existência de qualquer posição ou ordem e a quantidade de negócios de cada tipo. Tal intercâmbio tem suas próprias vantagens, que se expressam em uma referência única à base de pedidos por um tick e na obtenção de todas as informações necessárias de uma só vez. E as funções mencionadas acima, especialmente quando usadas em conjunto, cada uma delas trabalha com uma e a mesma base de ordem independentemente, de modo que repetidamente fazem as mesmas chamadas. Como resultado, a função CountOrders() pode reduzir o tempo de uma passagem em vários segundos, o que permite economizar horas de otimização.

A função CountOrders() toma os seguintes parâmetros:

  • mo - Número de pedidos por tipo. Após a função ter sido executada, a matriz terá 6 (seis) elementos. Elemento zero - número de operações do tipo Compra, primeiro elemento - número de ordens de Venda, segundo elemento - BuyLimit, terceiro elemento - SellLimit, quarto elemento - BuyStop, quinto elemento - SellStop.
  • mn - Identificador de um cargo ou ordens (MagicNumber). O valor padrão é -1 - qualquer MagicNumber.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 03.08.2008                                                     |
//|  Описание : Рассчитывает количество ордеров по типам.                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    mo - массив количества ордеров по типам                                 |
//|    mn - MagicNumber                          (-1 - любой магик)            |
//+----------------------------------------------------------------------------+
void CountOrders(int& mo[], int mn=-1) {
  int i, k=OrdersTotal();

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

A função ModifyOrder() para o testador.

Esta é uma versão leve da função ModifyOrder(), publicada na página 7, e destina-se a alterar os níveis de preços absolutos de uma ordem ou posição pré-selecionada.

A função ModifyOrder() aceita os seguintes parâmetros:

  • pp - Preço de fixação do pedido. Se você passar um valor menor ou igual a zero, a modificação deste nível de preço não será realizada. O valor padrão é -1.
  • sl - Parar nível de preço. Se você passar um valor inferior a zero, a modificação do nível de preço não será realizada. O valor padrão é 0.
  • tp - Take price level. Se você passar um valor inferior a 0, a modificação do nível de preço não será implementada. O valor padrão é 0.
  • ex - Data de expiração da ordem pendente. O valor padrão é 0.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.03.2008                                                     |
//|  Описание : Модификация ордера. Версия функции для тестов на истории.      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    pp - цена открытия позиции, установки ордера                            |
//|    sl - ценовой уровень стопа                                              |
//|    tp - ценовой уровень тейка                                              |
//|    ex - дата истечения                                                     |
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0) {
  int    dg=MarketInfo(OrderSymbol(), MODE_DIGITS), er;
  double op=NormalizeDouble(OrderOpenPrice() , dg);
  double os=NormalizeDouble(OrderStopLoss()  , dg);
  double ot=NormalizeDouble(OrderTakeProfit(), dg);
  color  cl;

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

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

A função IIFc().

Uma função muito útil em termos de construção de garfos. Se for o caso, esta cor. E se não for, então outra cor. A função IIFc() leva três parâmetros obrigatórios:

  • condição - Uma expressão lógica. Pode ser verdadeiro ou falso.
  • ifTrue - A cor que será devolvida pela IIFc() se a expressão da condição for verdadeira.
  • ifFalse - A cor que será devolvida pela IIFc() se a condição for falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 18.07.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Função IIFd().

Conveniência semelhante para números reais. Se assim for, é um número real. Se não for, é um número diferente. A função IIFd() leva em conta três parâmetros obrigatórios:

  • condição - Uma expressão lógica. Pode ser verdadeiro ou falso.
  • ifTrue - O número real que será devolvido pelo IIFd() se a expressão da condição for verdadeira.
  • ifFalse - Um número real que será devolvido pelo IIFd() se a condição for falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
double IIFd(bool condition, double ifTrue, double ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

A função IIFi().

Conveniência semelhante para os inteiros. Se assim for, é um número inteiro. E se não for, então outro número. A função IIFi() leva em conta três parâmetros obrigatórios:

  • condição - Uma expressão lógica. Pode ser verdadeiro ou falso.
  • ifTrue - Um número inteiro que será devolvido pelo IIFi() se a expressão da condição for verdadeira.
  • ifFalse - Um número inteiro que será devolvido pelo IIFi() se a condição for falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
int IIFi(bool condition, int ifTrue, int ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Função IIFis().

Uma conveniência semelhante para as cordas. Se for o caso, tal corda. E se não, então outra corda. A função IIFs() leva em conta três parâmetros obrigatórios:

  • condição - Uma expressão lógica. Pode ser verdadeiro ou falso.
  • ifTrue - A cadeia que será devolvida pela função IIFs(), se a expressão da condição for verdadeira.
  • ifFalse - O fio que será devolvido pelos IIFs( ), se a condição for falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
string IIFs(bool condition, string ifTrue, string ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
 

A função ExistInHistoryCloseBetween().

Retorna uma bandeira para a existência no histórico de uma posição ou ordem fechada (apagada) entre datas. Função ExistInHistoryCloseBetween() recebe os seguintes parâmetros:

  • sy - Nome do instrumento de mercado. "" - qualquer símbolo, NULL - símbolo atual. O valor padrão é "".
  • op - Operação comercial. Valores válidos: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLLIMIT, OP_SELLSTOP. Valor por default -1 - qualquer operação.
  • mn - Identificador de operações comerciais, MagicNumber. Valor por default -1 - qualquer número mágico.
  • d1 - Horário de fechamento da posição (eliminação de ordem pendente). O valor padrão é 0 - qualquer hora de fechamento (apagar). O tempo d1 deve ser menor que d2.
  • d2 - Horário de fechamento da posição (ordem pendente de exclusão). Valor padrão - 0 - qualquer tempo de fechamento (apagar). O tempo d2 deve ser maior que o tempo d1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 27.08.2008                                                     |
//|  Описание : Возвращает флаг существования в истории позиции или ордера,    |
//|           : закрытой (удалённого) между датами.                            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая операция)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//|    d1 - время закрытия             ( 0   - любое время закрытия)           |
//|    d2 - время закрытия             ( 0   - любое время закрытия)           |
//+----------------------------------------------------------------------------+
bool ExistInHistoryCloseBetween(string sy="", int op=-1, int mn=-1,
                                datetime d1=0, datetime d2=0) {
  int i, k=OrdersHistoryTotal();

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

Função ExistInHistoryOpenBetween().

Devolve a bandeira de existência na história de uma posição ou ordem aberta (definida) entre datas. Função ExistInHistoryOpenBetween() recebe os seguintes parâmetros:

  • sy - Nome do instrumento. "" - qualquer caractere, NULL - o símbolo atual. O valor padrão é "".
  • op - Operação comercial. Valores válidos: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLLIMIT, OP_SELLSTOP. Valor por default -1 - qualquer operação.
  • mn - Identificador comercial, MagicNumber. Valor por default -1 - qualquer número mágico.
  • d1 - Tempo de abertura da posição(espera para fazer o pedido). O valor padrão é 0 - qualquer tempo de abertura (configuração). O tempo d1 deve ser menor do que o tempo d2.
  • d2 - Hora de abertura da posição (pendente de ordem de colocação). O valor padrão é 0 - qualquer tempo aberto (definido). O tempo d2 deve ser maior que o tempo d1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 27.08.2008                                                     |
//|  Описание : Возвращает флаг существования в истории позиции или ордера,    |
//|           : открытой (установленного) между датами.                        |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//|    d1 - время открытия             ( 0   - любое время открытия)           |
//|    d2 - время открытия             ( 0   - любое время открытия)           |
//+----------------------------------------------------------------------------+
bool ExistInHistoryOpenBetween(string sy="", int op=-1, int mn=-1,
                               datetime d1=0, datetime d2=0) {
  int i, k=OrdersHistoryTotal();

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

Função ExistInHistoryToDay().

Devolve a bandeira de existência na história de uma posição ou ordem aberta (conjunto) hoje. Função ExistInHistoryToDay() recebe os seguintes parâmetros:

  • sy - Nome do instrumento. "" - qualquer símbolo, NULL - o símbolo atual. O valor padrão é "".
  • op - Operação comercial. Valores válidos: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLLIMIT, OP_SELLSTOP. Valor por default -1 - qualquer operação.
  • mn - Identificador de operações comerciais, MagicNumber. O valor padrão é -1 - qualquer magia.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 06.08.2008                                                     |
//|  Описание : Возвращает флаг наличия ордера или позиции в истории за сегодня|
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
bool ExistInHistoryToDay(string sy="", int op=-1, int mn=-1) {
  int i, k=OrdersHistoryTotal();

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

Função TakeProfitLastPos().

Esta função retorna o nível de preço do TakeProfit da última posição aberta ou -1. A função TakeProfitLastPos() 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 06.08.2008                                                     |
//|  Описание : Возвращает цену TakeProfit последней открытой позиций или -1.  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double TakeProfitLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  double   r=-1;
  int      i, k=OrdersTotal();

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