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

 

A função PriceOpenLastPos().

Esta função retorna o preço de abertura da última posição aberta. A seleção das posições a serem levadas em consideração é especificada por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão - "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает цену открытия последней открытой позиций.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double PriceOpenLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  double   r=0;
  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=OrderOpenPrice();
              }
            }
          }
        }
      }
    }
  }
  return(r);
}
 

A função PriceOpenLastClosePos().

Esta função retorna o preço de abertura da última posição fechada. A seleção das posições a serem levadas em conta é especificada por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições deste instrumento. O valor padrão - "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 03.06.2008                                                     |
//|  Описание : Возвращает цену открытия последней закрытой позиций.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double PriceOpenLastClosePos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  double   r=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=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (t<OrderCloseTime()) {
                t=OrderCloseTime();
                r=OrderOpenPrice();
              }
            }
          }
        }
      }
    }
  }
  return(r);
}
 

A função PriceOpenNearPos().

Esta função retorna o preço de abertura da posição mais próxima. A distância mínima em pips entre o preço de abertura da posição e o preço de mercado atual serve como critério para a "proximidade" de uma posição. A seleção das posições a serem levadas em consideração é definida por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 04.06.2008                                                     |
//|  Описание : Возвращает цену открытия ближайшей позиции.                    |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double PriceOpenNearPos(string sy="", int op=-1, int mn=-1) {
  double mi, oop=0, p;
  int    i, k=OrdersTotal(), pp=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) {
            if (OrderType()==OP_BUY)  mi=MarketInfo(OrderSymbol(), MODE_ASK);
            if (OrderType()==OP_SELL) mi=MarketInfo(OrderSymbol(), MODE_BID);
            p=MarketInfo(OrderSymbol(), MODE_POINT);
            if (p==0) if (StringFind(sy, "JPY")<0) p=0.0001; else p=0.01;
            if (pp==0 || pp>MathAbs(OrderOpenPrice()-mi)/p) {
              pp=MathAbs(OrderOpenPrice()-mi)/p;
              oop=OrderOpenPrice();
            }
          }
        }
      }
    }
  }
  return(oop);
}
 

A função TicketNearPos().

Esta função devolve o ticket da posição mais próxima ao mercado. A distância mínima em pontos entre o preço de abertura e o preço de mercado atual é usada como critério para a "proximidade" de uma posição. A seleção das posições a serem consideradas é definida por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 05.06.2008                                                     |
//|  Описание : Возвращает тикет ближайшей к рынку позиции по цене открытия.   |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int TicketNearPos(string sy="", int op=-1, int mn=-1) {
  double mi, p;
  int    i, k=OrdersTotal(), pp=0, ti=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) {
            if (OrderType()==OP_BUY)  mi=MarketInfo(OrderSymbol(), MODE_ASK);
            if (OrderType()==OP_SELL) mi=MarketInfo(OrderSymbol(), MODE_BID);
            p=MarketInfo(OrderSymbol(), MODE_POINT);
            if (p==0) if (StringFind(sy, "JPY")<0) p=0.0001; else p=0.01;
            if (pp==0 || pp>MathAbs(OrderOpenPrice()-mi)/p) {
              pp=MathAbs(OrderOpenPrice()-mi)/p;
              ti=OrderTicket();
            }
          }
        }
      }
    }
  }
  return(ti);
}
 

Função TypeNearPos().

Esta função retorna o tipo(0-Buy, 1-Venda) da posição mais próxima ao mercado ao preço de abertura ou -1. A distância mínima em pips entre o preço de abertura de uma posição e o preço de mercado atual serve como critério para a "proximidade" de uma posição. A seleção das posições a serem levadas em consideração é definida por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 07.06.2008                                                     |
//|  Описание : Возвращает тип ближайшей к рынку позиции или -1.               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int TypeNearPos(string sy="", int op=-1, int mn=-1) {
  double mi, p;
  int    i, k=OrdersTotal(), pp=0, ty=-1;

  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) {
            if (OrderType()==OP_BUY)  mi=MarketInfo(OrderSymbol(), MODE_ASK);
            if (OrderType()==OP_SELL) mi=MarketInfo(OrderSymbol(), MODE_BID);
            p=MarketInfo(OrderSymbol(), MODE_POINT);
            if (p==0) if (StringFind(sy, "JPY")<0) p=0.0001; else p=0.01;
            if (pp==0 || pp>MathAbs(OrderOpenPrice()-mi)/p) {
              pp=MathAbs(OrderOpenPrice()-mi)/p;
              ty=OrderType();
            }
          }
        }
      }
    }
  }
  return(ty);
}
 

A função TimeOpenLastPos().

Esta função retorna o tempo da última posição aberta. A seleção das posições a serem levadas em consideração é definida por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se você definir este parâmetro, a função considerará apenas as posições deste instrumento. O valor padrão "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает время открытия последней открытой позиций.          |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
datetime TimeOpenLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  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();
            }
          }
        }
      }
    }
  }
  return(t);
}
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 10.06.2008                                                     |
//|  Описание : Выполняет пузырьковую сортировку элементов массива.            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    a - массив элементов                                                    |
//+----------------------------------------------------------------------------+
void BubbleSort(double& a[]) {
  double t;
  int    i, j, n=ArraySize(a);

  for (i=n-1; i>0; i--) {
    for (j=0; j<i; j++) {
      if (a[j]>a[j+1]) {
        t=a[j];
        a[j]=a[j+1];
        a[j+1]=t;
      }
    }
  }
}
 

A função BarsBetweenLastFractals().

Esta função retorna o número de barras entre os dois últimos fractais ou -1. O instrumento de mercado e o cronograma a partir do qual os fractais devem ser retirados são especificados pelos parâmetros:

  • sy - Nome do instrumento de mercado. O valor padrão é "" ou NULL para o instrumento de mercado atual.
  • tf - Prazo (número de minutos por barra). O valor padrão 0 significa o período de tempo atual.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 10.06.2008                                                     |
//|  Описание : Возвращает количество баров между двумя последними фракталами. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента        ("" или NULL - текущий символ)     |
//|    tf - таймфрейм                       (    0       - текущий ТФ)         |
//+----------------------------------------------------------------------------+
int BarsBetweenLastFractals(string sy="", int tf=0) {
  double fu=0, fd=0;
  int    i, nu=0, nd=0;

  if (sy=="" || sy=="0") sy=Symbol();
  for (i=2; i<100; i++) {
    fu=iFractals(sy, tf, MODE_UPPER, i);
    if (fu!=0) {
      if (nu==0) nu=i;
    }
    fd=iFractals(sy, tf, MODE_LOWER, i);
    if (fd!=0) {
      if (nd==0) nd=i;
    }
    if (nu>0 && nd>0) return(MathAbs(nu-nd));
  }
  Print("BarsBetweenLastFractals(): Фракталы не найдены");
  return(-1);
}

Função SegundosPósFecharLastPos().

Esta função retorna o número de segundos depois que a última posição foi fechada. A seleção das posições a serem levadas em conta é especificada por parâmetros:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão - "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает количество секунд после закрытия последней позиций. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
datetime SecondsAfterCloseLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  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();
            }
          }
        }
      }
    }
  }
  return(TimeCurrent()-t);
}
 

A função SecondsAfterOpenLastPos().

Esta função retorna o número de segundos depois que a última posição foi aberta. A seleção das posições a serem levadas em conta é especificada por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão - "" significa qualquer instrumento de mercado. O valor 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 de -1 significa qualquer identificador.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает количество секунд после открытия последней позиций. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
datetime SecondsAfterOpenLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  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();
            }
          }
        }
      }
    }
  }
  return(TimeCurrent()-t);
}

Função DeleteOppositeOrders().

Esta função apaga uma ou mais ordens que são opostas à posição, cujo tipo é especificado na op. Por exemplo, as ordens opostas à posição Comprar seriam SellLimit e SellStop. A eliminação da ordem oposta torna-se necessária se, por exemplo, duas ordens opostas forem estabelecidas e uma delas acionar.

  • sy - Nome do instrumento de mercado. Se você definir este parâmetro, a função considerará apenas as posições do símbolo especificado. O valor padrão "" significa qualquer instrumento de mercado. O valor 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.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 16.06.2008                                                     |
//|  Описание : Удаление ордеров, противоположных позиции                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
void DeleteOppositeOrders(string sy="", int op=-1, int mn=-1) {
  bool eb, es;

  switch (op) {
    case OP_BUY : eb=ExistPositions(sy, OP_BUY , mn); break;
    case OP_SELL: es=ExistPositions(sy, OP_SELL, mn); break;
    default:      eb=ExistPositions(sy, OP_BUY , mn);
                  es=ExistPositions(sy, OP_SELL, mn); break;
  }

  if (eb) {
    DeleteOrders(sy, OP_SELLLIMIT, mn);
    DeleteOrders(sy, OP_SELLSTOP , mn);
  }
  if (es) {
    DeleteOrders(sy, OP_BUYLIMIT, mn);
    DeleteOrders(sy, OP_BUYSTOP , mn);
  }
}
 

A função ArraySearchDouble().

Esta função procura um elemento de matriz usando um valor de tipo duplo e retorna o índice do elemento encontrado ou -1. A função encontra apenas um elemento e pára a busca se o resultado for positivo.

  • m - A matriz na qual o elemento é procurado.
  • e - Valor do tipo duplo que pode ser encontrado na matriz m.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Выполняет поиск элемента массива по значению                   |
//|             и возвращает индекс найденного элемента или -1.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    e - значение элемента                                                   |
//+----------------------------------------------------------------------------+
int ArraySearchDouble(double& m[], double e) {
  for (int i=0; i<ArraySize(m); i++) {
    if (m[i]==e) return(i);
  }
  return(-1);
}

A função ArraySearchInt().

Esta função procura um elemento da matriz por um valor do tipo int-type e retorna o índice do elemento encontrado ou -1. A função encontra apenas um elemento, e pára de procurar se o resultado for positivo.

  • m - O conjunto de elementos do tipo "int-type", que está sendo pesquisado.
  • e - Valor do tipo int a ser pesquisado em array m.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Выполняет поиск элемента массива по значению                   |
//|             и возвращает индекс найденного элемента или -1.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    e - значение элемента                                                   |
//+----------------------------------------------------------------------------+
int ArraySearchInt(int& m[], int e) {
  for (int i=0; i<ArraySize(m); i++) {
    if (m[i]==e) return(i);
  }
  return(-1);
}

A função ArraySearchString().

Esta função busca na matriz um elemento do tipo string e retorna o índice do elemento encontrado ou -1. A função encontra apenas um elemento, e interrompe a busca se o resultado for positivo.

  • m - O conjunto de elementos do tipo string, no qual a busca é realizada.
  • e - O valor do tipo de fio, que pode ser encontrado na matriz m.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 04.03.2008                                                     |
//|  Описание : Выполняет поиск элемента массива по значению                   |
//|             и возвращает индекс найденного элемента или -1.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    e - значение элемента                                                   |
//+----------------------------------------------------------------------------+
int ArraySearchString(string& m[], string e) {
  for (int i=0; i<ArraySize(m); i++) {
    if (m[i]==e) return(i);
  }
  return(-1);
}
 

A função GetLotLastClosePos().

Esta função retorna o tamanho do lote da última posição fechada ou -1. A seleção das posições a serem levadas em conta é definida por parâmetros externos:

  • sy - Nome do instrumento de mercado. Se este parâmetro for definido, a função considerará apenas as posições do instrumento especificado. O valor padrão "" significa qualquer instrumento de mercado. O valor 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 de -1 significa qualquer identificador.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 16.06.2008                                                     |
//|  Описание : Возвращает размер лота последней закрытой позиции или -1       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double GetLotLastClosePos(string sy="", int op=-1, int mn=-1) {
  datetime o;
  double   l=-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 (o<OrderCloseTime()) {
                o=OrderCloseTime();
                l=OrderLots();
              }
            }
          }
        }
      }
    }
  }
  return(l);
}

A função ArrayMax().

Esta função retorna o valor do elemento máximo da matriz.

  • x - O conjunto de elementos do tipo duplo, no qual o elemento máximo por valor é procurado.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 17.05.2008                                                     |
//|  Описание : Возвращает значение максимального элемента массива.            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    x - массив значений числового ряда                                      |
//+----------------------------------------------------------------------------+
double ArrayMax(double& x[]) {
  if (ArraySize(x)>0) return(x[ArrayMaximum(x)]);
  else {
    Print("ArrayMax(): Массив пуст!");
    return(0);
  }
}