Uniquement "Fonctionnalités utiles de KimIV". - page 7

 

Fonction CorrectTF().

J'ai écrit cette fonction après avoir découvert que parfois je peux facilement spécifier un délai incorrect, qui est égal à un nombre entier de minutes, dans les paramètres d'entrée d'un indicateur ou d'un EA. Par exemple, j'ai entré 50 pour l'heure au lieu de 60. Eh bien... en quelque sorte raté. Il s'avère que la fonction iRSI() renvoie zéro pour un délai incorrect. Je ne peux rien dire sur les autres fonctions, car je ne les ai pas vérifiées. Pour éviter les malentendus résultant de mes propres erreurs d'inattention, j'ai écrit cette fonction comme une primitive infaillible. Il ajuste le paramètre d'entrée à la période appropriée la plus proche et renvoie sa valeur.

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

Fonction DateBeginQuarter().

Cette fonction renvoie la date de début du trimestre par son numéro. Par exemple, si nous sommes le 27.08.2008, la date de début du trimestre en cours sera le 01.07.2008. Cette fonction ne prend qu'un seul paramètre - le numéro de trimestre relatif au trimestre en cours. Par exemple, 0 est le trimestre en cours, 1 est le trimestre suivant et -1 est le trimestre précédent. En d'autres termes, les quarts de chiffre positifs demanderont des dates dans le futur, tandis que les zéros et les négatifs demanderont des dates dans le passé. La valeur renvoyée est le nombre de secondes écoulées depuis 00:00 le 1er janvier 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"));
}
 

La fonction DateOfMonday().

Cette fonction renvoie la date de début de la semaine (lundi) par son numéro. Par exemple, si nous sommes le 29.08.2008, la date du début de la semaine en cours sera le 25.08.2008. Cette fonction ne prend qu'un seul paramètre - le numéro de la semaine par rapport à la semaine en cours. Par exemple, 0 correspond à la semaine en cours, 1 à la semaine suivante et -1 à la semaine précédente. En d'autres termes, les numéros de semaine positifs demanderont des dates dans le futur, tandis que les numéros zéro et négatifs demanderont des dates dans le passé. La valeur de retour est le nombre de secondes écoulées depuis 00:00 le 1er janvier 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);
}

La fonction Fibonacci().

Cette fonction renvoie un élément de la série de Fibonacci par son numéro de séquence.

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

Fonction GetNameMA().

Cette fonction renvoie le nom de la méthode MA(Moving Averages) par son identifiant. Cette fonction est pratique à utiliser dans les commentaires, les indicateurs et les messages des 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");
  }
}
 

Fonction GetPriceDiffInPoint().

Cette fonction renvoie la différence de prix entre deux barres, qui sont spécifiées par leurs numéros. Le but du développement de cette fonction était de déterminer la valeur et la direction du mouvement des prix. La fonction GetPriceDiffInPoint() détermine les points de référence (Open ou High ou Low ou Close) des barres à prendre en compte. La fonction accepte les paramètres facultatifs suivants :

  • sy - Nom de l'instrument. "" ou NULL - symbole actuel. La valeur par défaut est NULL.
  • tf - Période de temps. Valeur par défaut 0 - symbole actuel.
  • n2 - Numéro de barre gauche. Valeur par défaut - 2.
  • n1 - Numéro de la barre de droite. Valeur par défaut - 1.

Valeur retournée :

  • positif - il y a eu une augmentation du taux entre les barres N2 et N1.
  • négatif - il y a eu une dépréciation entre les barres N2 et 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);
}

La fonction GetTypePrice()

Renvoie le nom du type de prix. La fonction ne prend qu'un seul paramètre facultatif. Valeurs valides : PRICE_CLOSE, PRICE_OPEN, PRICE_HIGH, PRICE_LOW, PRICE_MEDIAN, PRICE_TYPICAL, PRICE_WEIGHTED. La valeur par défaut est 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");
  }
}
 

La fonction ArrayLR().

Cette fonction génère un tableau de valeurs de régression linéaire. La fonction accepte les paramètres obligatoires suivants :

  • x est un tableau de valeurs de séries numériques. Il s'agit du paramètre d'entrée. Ce tableau doit contenir les valeurs avant l'appel de la fonction.
  • y est un tableau de valeurs de régression linéaire. C'est le paramètre de sortie, c'est-à-dire que le tableau sera rempli après l'appel de la fonction.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Fonction ArrayMo().

Renvoie Modu - le maximum de la courbe de densité de distribution. La fonction accepte les paramètres facultatifs suivants :

  • x - Tableau de valeurs de séries numériques.
  • d - La précision des valeurs de la série numérique, le nombre de décimales.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Fonction ExistOrdersByPrice().

Renvoie un indicateur de l'existence d'un ordre au prix fixé donné. Vrai - l'ordre existe (fixé), Faux - l'ordre n'existe pas (non fixé). Vous pouvez limiter la liste des ordres à vérifier à l'aide des paramètres de la fonction :

  • sy - Nom de l'instrument de marché. Si ce paramètre est donné, la fonction ne vérifiera que les ordres de l'instrument spécifié. NULL signifie l'instrument actuel, et "" (par défaut) signifie n'importe quel instrument.
  • op - Type de transaction, type d'ordre en attente. Valeurs valides : OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP ou -1. La valeur par défaut de -1 indique tout type de commande.
  • mn - Identifiant de l'ordre (MagicNumber). La valeur par défaut de -1 signifie n'importe quel MagicNumber.
  • pp - Le niveau de prix auquel l'ordre est fixé. La valeur par défaut est -1 - n'importe quel prix.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

La fonction ClosePosBySelect() pour le testeur.

Exécute la fermeture d'une seule position présélectionnée. Il s'agit d'une version simplifiée de la fonction du même nom qui a été décrite précédemment à la page 13. Rien de superflu. Pas de fonctionnalités supplémentaires. Dans ma pratique, je n'ai jamais eu une position qui n'était pas fermée dans le testeur. C'est pourquoi il n'y a pas de contrôles dans cette fonction. Ils sont inutiles dans le testeur.

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

La fonction CountOrders() pour le testeur.

Dans mes versions de test (destinées exclusivement à être utilisées dans le testeur de MT4), la fonction CountOrders() remplace les fonctions suivantes : ExistOrders(), ExistPositions(), NumberOfOrders() et NumberOfPositions(). Ainsi, elle peut donner des informations sur l'existence de toute position ou ordre et sur le nombre de transactions de chaque type. Un tel échange a ses propres avantages, qui s'expriment par une référence unique à la base d'ordres pour un tick et l'obtention de toutes les informations nécessaires en une seule fois. Et les fonctions susmentionnées, surtout lorsqu'elles sont utilisées ensemble, fonctionnent chacune indépendamment avec une seule et même base de commande, de sorte qu'elles effectuent les mêmes appels de manière répétée. En conséquence, la fonction CountOrders() peut réduire le temps d'une passe de plusieurs secondes, ce qui permet de gagner des heures d'optimisation.

La fonction CountOrders() prend les paramètres suivants :

  • mo - Tableau du nombre de commandes par type. Après l'exécution de la fonction, le tableau comportera 6 (six) éléments. Élément zéro - nombre de transactions de type Achat, premier élément - nombre d'ordres de Vente, deuxième élément - BuyLimit, troisième élément - SellLimit, quatrième élément - BuyStop, cinquième élément - SellStop.
  • mn - Identifiant d'une position ou d'un ordre (MagicNumber). La valeur par défaut est -1 - tout 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()]++;
    }
  }
}

La fonction ModifyOrder() pour le testeur.

Il s'agit d'une version allégée de la fonction ModifyOrder(), publiée à la page 7, destinée à modifier les niveaux de prix absolus d'un ordre ou d'une position présélectionnés.

La fonction ModifyOrder() accepte les paramètres suivants :

  • pp - Prix de fixation de la commande. Si vous passez une valeur inférieure ou égale à zéro, la modification de ce niveau de prix ne sera pas effectuée. La valeur par défaut est -1.
  • sl - Niveau de prix d'arrêt. Si vous passez une valeur inférieure à zéro, la modification du niveau de prix ne sera pas effectuée. La valeur par défaut est 0.
  • tp - Niveau de prix de prise. Si vous passez une valeur inférieure à 0, la modification du niveau de prix ne sera pas mise en œuvre. La valeur par défaut est 0.
  • ex - Date d'expiration de l'ordre en cours. La valeur par défaut est 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);
    }
  }
}
 

La fonction IIFc().

Une fonction très pratique en termes de construction de fourches. Si oui, cette couleur. Et si ce n'est pas le cas, alors une autre couleur. La fonction IIFc() prend trois paramètres obligatoires :

  • condition - Une expression logique. Elle peut être vraie ou fausse.
  • ifTrue - La couleur qui sera renvoyée par IIFc() si l'expression de la condition est vraie.
  • ifFalse - La couleur qui sera renvoyée par IIFc() si la condition est fausse.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 18.07.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Fonction IIFd().

Commodité similaire pour les nombres réels. Si c'est le cas, c'est un nombre réel. Et si ce n'est pas le cas, c'est un autre numéro. La fonction IIFd() prend trois paramètres obligatoires :

  • condition - Une expression logique. Elle peut être vraie ou fausse.
  • ifTrue - Le nombre réel qui sera renvoyé par IIFd() si l'expression de la condition est vraie.
  • ifFalse - Un nombre réel qui sera renvoyé par IIFd() si la condition est fausse.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
double IIFd(bool condition, double ifTrue, double ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

La fonction IIFi().

Commodité similaire pour les entiers. Si c'est le cas, il s'agit d'un nombre entier. Et s'il ne l'est pas, alors un autre numéro. La fonction IIFi() prend trois paramètres obligatoires :

  • condition - Une expression logique. Elle peut être vraie ou fausse.
  • ifTrue - Un nombre entier qui sera renvoyé par IIFi() si l'expression de la condition est vraie.
  • ifFalse - Un nombre entier qui sera renvoyé par IIFi() si la condition est fausse.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
int IIFi(bool condition, int ifTrue, int ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Fonction IIFis().

Une commodité similaire pour les chaînes de caractères. Si oui, une telle chaîne. Et si non, alors une autre chaîne. La fonction IIFs() prend trois paramètres obligatoires :

  • condition - Une expression logique. Elle peut être vraie ou fausse.
  • ifTrue - La chaîne qui sera renvoyée par la fonction IIFs(), si l'expression de la condition est vraie.
  • ifFalse - La chaîne qui sera retournée par IIFs( ), si la condition est fausse.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
string IIFs(bool condition, string ifTrue, string ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
 

La fonction ExistInHistoryCloseBetween().

Renvoie un indicateur de l'existence dans l'historique d'une position ou d'un ordre fermé (supprimé) entre deux dates. La fonction ExistInHistoryCloseBetween() reçoit les paramètres suivants :

  • sy - Nom de l'instrument de marché. "" - tout symbole, NULL - symbole actuel. La valeur par défaut est "".
  • op - Opération commerciale. Valeurs valides : -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valeur par défaut -1 - toute opération.
  • mn - Identifiant des opérations commerciales, MagicNumber. Valeur par défaut -1 - tout nombre magique.
  • d1 - Heure de clôture de la position (en attendant la suppression de l'ordre). La valeur par défaut est 0 - toute heure de fermeture (suppression). Le temps d1 doit être plus court que d2.
  • d2 - Heure de clôture de la position (en attendant la suppression de l'ordre). Valeur par défaut - 0 - toute heure de fermeture (suppression). Le temps d2 doit être plus long que le temps 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);
}

Fonction ExistInHistoryOpenBetween().

Renvoie le drapeau d'existence dans l'historique d'une position ou d'un ordre ouvert (fixé) entre les dates. La fonction ExistInHistoryOpenBetween() reçoit les paramètres suivants :

  • sy - Nom de l'instrument. "" - tout caractère, NULL - le symbole actuel. La valeur par défaut est "".
  • op - Opération commerciale. Valeurs valides : -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valeur par défaut -1 - toute opération.
  • mn - Identifiant des opérations commerciales, MagicNumber. Valeur par défaut -1 - tout nombre magique.
  • d1 - Heure d'ouverture de la position(en attendant le passage de l'ordre). La valeur par défaut est 0 - tout temps d'ouverture (de réglage). Le temps d1 doit être inférieur au temps d2.
  • d2 - Heure d'ouverture de la position (en attente du passage de l'ordre). La valeur par défaut est 0 - n'importe quel temps ouvert (défini). Le temps d2 doit être plus long que le temps 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);
}
 

Fonction ExistInHistoryToDay().

Renvoie le drapeau d'existence dans l'historique d'une position ou d'un ordre ouvert (fixé) aujourd'hui. La fonction ExistInHistoryToDay() reçoit les paramètres suivants :

  • sy - Nom de l'instrument. "" - tout symbole, NULL - le symbole actuel. La valeur par défaut est "".
  • op - Opération commerciale. Valeurs valides : -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valeur par défaut -1 - toute opération.
  • mn - Identifiant des opérations commerciales, MagicNumber. La valeur par défaut est -1 - n'importe quel Magic.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Fonction TakeProfitLastPos().

Cette fonction renvoie le niveau de prix du TakeProfit de la dernière position ouverte ou -1. La fonction TakeProfitLastPos() accepte les paramètres facultatifs suivants :

  • sy - Nom de l'instrument. "" - tout symbole, NULL - symbole actuel. La valeur par défaut est "".
  • op - Opération commerciale. Valeurs valables : -1, OP_BUY, OP_SELL. La valeur par défaut est -1 - tout commerce.
  • mn - Identifiant du commerce, MagicNumber. Valeur par défaut -1 - n'importe quel 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);
}
Raison: