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

 

Fonction TakeProfitLastClosePos().

Renvoie le niveau de prix TakeProfit de la dernière position fermée ou -1. La fonction TakeProfitLastClosePos() 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 Magic.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 20.10.2008                                                     |
//|  Описание : Возвращает цену TakeProfit последней закрытой позиций или -1.  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
double TakeProfitLastClosePos(string sy="", int op=-1, int mn=-1) {
  datetime t;
  double   r=-1;
  int      i, k=OrdersHistoryTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (t<OrderCloseTime()) {
                t=OrderCloseTime();
                r=OrderTakeProfit();
              }
            }
          }
        }
      }
    }
  }
  return(r);
}

Fonction MovingInWL().

Déplace le niveau de prix StopLoss des positions ouvertes vers le seuil de rentabilité. La fonction MovingInWL() prend 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.

De plus, la fonction MovingInWL() possède des variables globales (paramètres externes du script ou de l'Expert Advisor) :

  • int LevelProfit - Niveau de profit en points, qu'une position doit atteindre pour que son stop soit déplacé au niveau du Breakeven.
  • int LevelWLoss - Niveau de seuil de rentabilité en points, vers lequel le stop sera transféré lorsque son bénéfice aura atteint le niveau LevelProfit en points.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.09.2008                                                     |
//|  Описание : Перенос уровня стопа в безубыток                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void MovingInWL(string sy="", int op=-1, int mn=-1) {
  double po, pp;
  int    i, k=OrdersTotal();

  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      po=MarketInfo(OrderSymbol(), MODE_POINT);
      if (OrderType()==OP_BUY) {
        if (OrderStopLoss()-OrderOpenPrice()<LevelWLoss*po) {
          pp=MarketInfo(OrderSymbol(), MODE_BID);
          if (pp-OrderOpenPrice()>LevelProfit*po) {
            ModifyOrder(-1, OrderOpenPrice()+LevelWLoss*po, -1);
          }
        }
      }
      if (OrderType()==OP_SELL) {
        if (OrderStopLoss()==0 || OrderOpenPrice()-OrderStopLoss()<LevelWLoss*po) {
          pp=MarketInfo(OrderSymbol(), MODE_ASK);
          if (OrderOpenPrice()-pp>LevelProfit*po) {
            ModifyOrder(-1, OrderOpenPrice()-LevelWLoss*po, -1);
          }
        }
      }
    }
  }
}
 

Fonction SimpleTrailing().

Déplace le niveau de prix StopLoss des positions ouvertes en utilisant l'algorithme TrailingStop. La fonction SimpleTrailing() 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.

En outre, la fonction SimpleTrailing() implique des variables globales (paramètres externes du script ou de l'Expert Advisor) :

  • bool TSProfitOnly - Change la zone dans laquelle le chalut commence. Si True, le chalutage ne commencera à fonctionner que lorsque le profit de la position atteindra la valeur des points TStop.Buy/Sell+TrailingStep. Si Faux, le conseiller expert s'assurera simplement que la position stop par rapport au prix actuel n'est jamais plus loin que TStop.Buy/Sell+TrailingStep pips. En d'autres termes, si Vrai, le Conseiller Expert travaille uniquement dans la zone de profit de la position, alors que si Faux, il travaille dans la zone négative de la position.
  • int TStop.Buy - Taille du trall en points à acheter.
  • intTStop.Sell - Taille du chalut en points pour la vente.
  • int TrailingStep - Étape de suivi en points. Elle est nécessaire pour ne pas déranger le concessionnaire par des demandes fréquentes.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.09.2008                                                     |
//|  Описание : Сопровождение позиций простым тралом                           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void SimpleTrailing(string sy="", int op=-1, int mn=-1) {
  double po, pp;
  int    i, k=OrdersTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
        po=MarketInfo(OrderSymbol(), MODE_POINT);
        if (mn<0 || OrderMagicNumber()==mn) {
          if (OrderType()==OP_BUY) {
            pp=MarketInfo(OrderSymbol(), MODE_BID);
            if (!TSProfitOnly || pp-OrderOpenPrice()>TStop.Buy*po) {
              if (OrderStopLoss()<pp-(TStop.Buy+TrailingStep-1)*po) {
                ModifyOrder(-1, pp-TStop.Buy*po, -1);
              }
            }
          }
          if (OrderType()==OP_SELL) {
            pp=MarketInfo(OrderSymbol(), MODE_ASK);
            if (!TSProfitOnly || OrderOpenPrice()-pp>TStop.Sell*po) {
              if (OrderStopLoss()>pp+(TStop.Sell+TrailingStep-1)*po || OrderStopLoss()==0) {
                ModifyOrder(-1, pp+TStop.Sell*po, -1);
              }
            }
          }
        }
      }
    }
  }
}

Fonction ArrayZ().

Cette fonction calcule et retourne le Z-count d'une série numérique passée dans le tableau par référence.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 27.10.2008                                                     |
//|  Описание : Возвращает Z-счёт числового ряда.                              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    arr - массив значений числового ряда                                    |
//+----------------------------------------------------------------------------+
double ArrayZ(double& arr[]) {
  double x, z;
  int    i, l=0, n=ArraySize(arr), r=1, w=0;

  for (i=0; i<n; i++) {
    if (i==0) r=1;
    else {
      if (arr[i-1]*arr[i]<0) r++;
    }
    if (arr[i]>0) w++; else l++;
  }

  if (n>2) {
    if (w>0 && l>0) {
      x=2*w*l;
      if (x!=n) z=(n*(r-0.5)-x)/MathSqrt(x*(x-n)/(n-1));
    } else {
      if (l==0) z=100; else z=-100;
      Print("ArrayZ(): Нет чередования серий!");
    }
    return(z);
  } else {
    Print("ArrayZ(): В массиве недостаточно элементов!");
    return(0);
  }
}
 

La fonction ArrayDeleteInt()

Exécute la suppression d'un élément du tableau avec l'index donné. Retourne la taille du nouveau tableau ou -1 si rien n'a été supprimé. La fonction ArrayDeleteInt() accepte les paramètres obligatoires suivants :

  • m - Tableau d'éléments.
  • i - Index de l'élément du tableau.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteInt(int& m[], int i) {
  int j, k=ArraySize(m);

  if (i>=0 && i<k) {
    for (j=i; j<k; j++) m[j]=m[j+1];
    k=ArrayResize(m, k-1);
    return(k);
  } else Print("ArrayDeleteInt(): Неверный индекс элемента массива! i=", i);

  return(-1);
}

La fonction ArrayDeleteDouble()

Supprime l'élément du tableau avec l'index donné. Elle renvoie la taille du nouveau tableau ou -1, si rien n'a pu être supprimé. La fonction ArrayDeleteDouble() accepte les paramètres obligatoires suivants :

  • m - Tableau d'éléments de type double.
  • i - Index de l'élément du tableau.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteDouble(double& m[], int i) {
  int j, k=ArraySize(m);

  if (i>=0 && i<k) {
    for (j=i; j<k; j++) m[j]=m[j+1];
    k=ArrayResize(m, k-1);
    return(k);
  } else Print("ArrayDeleteDouble(): Неверный индекс элемента массива! i=", i);

  return(-1);
}
 

La fonction ArrayDeleteString()

Exécute la suppression d'un élément du tableau avec l'index donné. Retourne la taille du nouveau tableau ou -1 si rien n'a pu être enlevé. La fonction ArrayDeleteString() accepte les paramètres obligatoires suivants :

  • m - Tableau d'éléments de type chaîne de caractères.
  • i - Index des éléments du tableau.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteString(string& m[], int i) {
  int j, k=ArraySize(m);

  if (i>=0 && i<k) {
    for (j=i; j<k; j++) m[j]=m[j+1];
    k=ArrayResize(m, k-1);
    return(k);
  } else Print("ArrayDeleteString(): Неверный индекс элемента массива! i=", i);

  return(-1);
}

La fonction ArrayInsertDouble()

Insère un élément du tableau avec l'index spécifié. Elle renvoie le nombre d'éléments (taille) du nouveau tableau. L'insertion s'effectue comme suit. Tout d'abord, la taille du tableau est augmentée de un. Ensuite, tous les éléments dont l'indice est supérieur ou égal à celui qui doit être inséré sont déplacés à la fin du tableau, un par un, pour faire de la place à celui qui doit être inséré. Enfin, la valeur est écrite dans la cellule requise. La fonction ArrayInsertDouble() prend les paramètres suivants :

  • m - Un tableau d'éléments de type double.
  • e - Valeur de l'élément du tableau à insérer.
  • i - Index de l'élément du tableau à insérer. Si la valeur de l'index est inférieure à zéro ou supérieure ou égale à la taille du tableau, l'élément sera ajouté à la fin du tableau. La valeur par défaut est -1.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет вставку элемента массива с заданным индексом.        |
//|             Возвращает размер нового массива.                              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов типа double                                        |
//|    e - значение элемента                                                   |
//|    i - индекс элемента                  (-1 - добавить в конец массива)    |
//+----------------------------------------------------------------------------+
int ArrayInsertDouble(double& m[], double e, int i=-1) {
  int j, k=ArraySize(m);

  ArrayResize(m, k+1);
  if (i>=0 && i<k) {
    for (j=k; j>i; j--) m[j]=m[j-1];
    m[i]=e;
  } else m[k]=e;

  return(k+1);
}
 

La fonction BubbleSort2().

Cette fonction fait sauter les éléments d'un tableau bidimensionnel dans une colonne arbitraire. Vous pouvez également spécifier la direction du tri. La fonction BubbleSort2() prend les paramètres suivants :

  • a - Tableau bidimensionnel d'éléments. Paramètre obligatoire.
  • r - Numéro (index) de la colonne de tri (colonne). La valeur par défaut est 0 - la première colonne (colonne avec un index zéro).
  • m - Sens du tri. Valeurs valides : MODE_ASCEND - ordre ascendant, MODE_DESCEND - ordre descendant. La valeur par défaut est MODE_ASCEND.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 04.11.2008                                                     |
//|  Описание : Выполняет пузырьковую сортировку элементов двумерного массива. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    a - массив элементов                                                    |
//|    r - колонка сортировки          (     0       - первая (с индексом 0))  |
//|    m - направление сортировки      (MODE_ASCEND  - по возрастанию,         |
//|                                     MODE_DESCEND - по убыванию)            |
//+----------------------------------------------------------------------------+
void BubbleSort2(double& a[][], int r=0, int m=MODE_ASCEND) {
  double t;
  int    e, i, j;
  int    k=ArrayRange(a, 1);      // Количество колонок
  int    n=ArrayRange(a, 0);      // Количество строк

  if (r<0) r=0;
  if (r>k) r=k;

  for (i=n-1; i>0; i--) {
    for (j=0; j<i; j++) {
      if (m==MODE_ASCEND) {
        // по возрастанию
        if (a[j][r]>a[j+1][r]) {
          for (e=0; e<k; e++) {
            t=a[j][e];
            a[j][e]=a[j+1][e];
            a[j+1][e]=t;
          }
        }
      } else {
        // по убыванию
        if (a[j][r]<a[j+1][r]) {
          for (e=0; e<k; e++) {
            t=a[j][e];
            a[j][e]=a[j+1][e];
            a[j+1][e]=t;
          }
        }
      }
    }
  }
}

La fonction GetTypeLastDeleted().

Cette fonction renvoie le type du dernier ordre supprimé, ou -1. Il y a des situations où nous devons lier la logique de l'opération EA au type de l'ordre qui vient d'être supprimé. Par exemple, si vous venez de supprimer BuyStop, vous devriez le faire, mais si BuyLimit, vous devriez faire autre chose, etc. La fonction GetTypeLastDeleted() accepte les paramètres facultatifs suivants :

  • sy - Nom de l'instrument. "" - tout caractère, NULL - caractère actuel. La valeur par défaut est "".
  • mn - identifiant de la commande de l'utilisateur (MagicNumber). Valeur par défaut -1 - n'importe quel Magic.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 13.10.2008                                                     |
//|  Описание : Возвращает тип последнего удалённого ордера или -1             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastDeleted(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersHistoryTotal(), r=-1;

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
      if ((OrderSymbol()==sy || sy=="") && (mn<0 || OrderMagicNumber()==mn)) {
        if (OrderType()>1 && OrderType()<6 && t<OrderCloseTime()) {
          t=OrderCloseTime();
          r=OrderType();
        }
      }
    }
  }
  return(r);
}
 

La fonction iBarLargest().

Cette fonction renvoie l'indice de la plus grande barre ou -1. La taille de la barre est mesurée par la fonction de l'une des deux manières suivantes, déterminée par le paramètre d'entrée ty - type d'éléments de recherche. Soit juste la taille du corps, soit avec les ombres. La fonction iBarLargest() accepte les paramètres facultatifs suivants :

  • sy - Nom de l'outil. "" ou NULL - le symbole actuel. La valeur par défaut est "".
  • tf - Période de temps. La valeur par défaut est 0 - l'horizon temporel actuel.
  • ty - Type d'éléments de recherche. Valeurs valides - 0 - High-Low, 1 - abs(Open-Close).
  • co - Nombre d'éléments de la série chronologique. Valeur par défaut - 0 - tous les éléments.
  • in - Index de la barre initiale. Valeur par défaut - 0 - barre actuelle.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.03.2008                                                     |
//|  Описание : Возвращает индекс наибольшего бара или -1.                     |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (          0 - текущий таймфрейм)       |
//|    ty - тип элементов поиска       (          0 - H-L, 1 - O-C)            |
//|    co - число элементов таймсерии  (          0 - все элементы)            |
//|    in - индекс начального бара     (          0 - текущий бар)             |
//+----------------------------------------------------------------------------+
int iBarLargest(string sy="", int tf=0, int ty=0, int co=0, int in=0) {
  if (sy=="" || sy=="0") sy=Symbol();
  if (tf<=0) tf=Period();
  if (in< 0) in=0;
  if (co<=0) co=iBars(sy, tf)-in;

  double r, rb=0;       // размер бара
  int    i, nb=-1;      // счётчик и номер бара

  for (i=co+in; i>=in; i--) {
    if (ty>0) r=MathAbs(iOpen(sy, tf, i)-iClose(sy, tf, i));
    else r=iHigh(sy, tf, i)-iLow(sy, tf, i);
    if (rb<r) {
      rb=r;
      nb=i;
    }
  }

  return(nb);
}

La fonction iBarOfDayCalc().

Cette fonction renvoie le numéro calculé de la barre depuis le début de la journée. Les barres sont numérotées à partir de un, c'est-à-dire que la barre ayant le temps d'ouverture le plus court dans la journée donnée sera la numéro un, la barre suivante sera la numéro deux, etc. Cette fonction est utile pour optimiser les temps d'entrée/sortie. Si quelqu'un est intéressé par les détails, il peut poser des questions. Je ferai de mon mieux pour y répondre. La fonction iBarOfDayCalc() prend les paramètres optionnels suivants :

  • tf - Période de temps. La valeur par défaut est 0 - l'horizon temporel actuel.
  • dt - Date et heure d'ouverture de la barre. Valeur par défaut - 0 - heure actuelle.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 26.02.2008                                                     |
//|  Описание : Возвращает расчётный номер бара от начала суток.               |
//|           : Нумерация баров начинается с 1 (единица).                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    tf - таймфрейм                       (0 - текущий таймфрейм)            |
//|    dt - дата и время открытия бара      (0 - текущее время)                |
//+----------------------------------------------------------------------------+
int iBarOfDayCalc(int tf=0, datetime dt=0) {
  if (tf<=0) tf=Period();
  if (dt<=0) dt=TimeCurrent();
  if (tf>PERIOD_D1) {
    Print("iBarOfDayCalc(): Таймфрейм должен быть меньше или равен D1");
    return(0);
  }
  double ms=MathMod(dt/60, 1440);      // количество минут от начала суток
  int    bd=MathFloor(ms/tf)+1;        // номер бара от начала суток

  return(bd);
}
 

Fonction iBarOfDayReal().

Cette fonction renvoie le numéro de barre actuel depuis le début de la journée. Les barres sont numérotées de un en un, c'est-à-dire que la barre ayant le temps d'ouverture le plus court dans une journée donnée aura le numéro un, la barre suivante aura le numéro deux, etc. Je n'ai pas encore trouvé d'utilisation pratique de cette fonction. Mais je l'ai écrit pour l'avoir :-) avec la fonction iBarOfDayCalc(). La fonction iBarOfDayReal() accepte les paramètres optionnels suivants :

  • sy - Nom de l'instrument de négociation. NULL ou "" - symbole actuel. La valeur par défaut est "".
  • tf - Période de temps. Valeur par défaut - 0 - période actuelle.
  • dt - Date et heure d'ouverture du bar. Valeur par défaut - 0 - heure actuelle.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 26.02.2008                                                     |
//|  Описание : Возвращает реальный номер бара от начала суток.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (          0 - текущий таймфрейм)       |
//|    dt - дата и время открытия бара (          0 - текущее время)           |
//+----------------------------------------------------------------------------+
int iBarOfDayReal(string sy="", int tf=0, datetime dt=0) {
  if (sy=="" || sy=="0") sy=Symbol();
  if (tf<=0) tf=Period();
  if (dt<=0) dt=TimeCurrent();
  if (tf>PERIOD_D1) {
    Print("iBarOfDayReal(): Таймфрейм должен быть меньше или равен D1");
    return(0);
  }

  int cd=TimeDay(dt);                       // текущий день месяца
  int nb=iBarShift(sy, tf, dt, False);      // номер текущего бара
  int bd=0;                                 // номер бара от начала суток

  while(TimeDay(iTime(sy, tf, nb))==cd) {
    nb++;
    bd++;
  }

  return(bd);
}

Fonction NameDayOfWeek()

Renvoie le nom du jour de la semaine par le numéro passé en paramètre :

  • ndw - Numéro du jour de la semaine. Paramètre requis.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование дня недели                             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    ndw - номер дня недели                                                  |
//+----------------------------------------------------------------------------+
string NameDayOfWeek(int ndw) {
  if (ndw==0) return("Воскресенье");
  if (ndw==1) return("Понедельник");
  if (ndw==2) return("Вторник");
  if (ndw==3) return("Среда");
  if (ndw==4) return("Четверг");
  if (ndw==5) return("Пятница");
  if (ndw==6) return("Суббота");
}
 

Fonction NormalizeLot().

Cette fonction renvoie la valeur normalisée du lot en cours de négociation. Outre la normalisation, elle permet également de faire entrer la taille du lot dans les limites fixées par le centre de négociation (les valeurs minimale et maximale du lot et le pas de changement de lot sont vérifiés). La fonction NormalizeLot() accepte les paramètres suivants :

  • lo - Valeur de NormalizeLot. Paramètre requis.
  • ro - Méthode d'arrondi. Faux - pour le petit côté, Vrai - pour le grand côté. Valeur par défaut - Faux - vers le bas.
  • sy - Nom de l'instrument commercial. NULL ou "" - symbole actuel. Valeur par défaut - "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 16.05.2008                                                     |
//|  Описание : Возвращает нормализованное значение торгуемого лота.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    lo - нормализуемое значение лота.                                       |
//|    ro - способ округления          (   False    - в меньшую,               |
//|                                        True     - в большую сторону)       |
//|    sy - наименование инструмента   ("" или NULL - текущий символ)          |
//+----------------------------------------------------------------------------+
double NormalizeLot(double lo, bool ro=False, string sy="") {
  double l, k;
  if (sy=="" || sy=="0") sy=Symbol();
  double ls=MarketInfo(sy, MODE_LOTSTEP);
  double ml=MarketInfo(sy, MODE_MINLOT);
  double mx=MarketInfo(sy, MODE_MAXLOT);

  if (ml==0) ml=0.1;
  if (mx==0) mx=100;

  if (ls>0) k=1/ls; else k=1/ml;
  if (ro) l=MathCeil(lo*k)/k; else l=MathFloor(lo*k)/k;

  if (l<ml) l=ml;
  if (l>mx) l=mx;

  return(l);
}

Fonction NormalizePrice().

Cette fonction renvoie la valeur normalisée du prix. La normalisation est effectuée en appliquant les valeurs de la fonction MarketInfo(MODE_TICKSIZE || MODE_DIGITS). La fonction NormalizePrice( ) prend les paramètres suivants :

  • np - Valeur normalisée du lot. Paramètre requis.
  • sy - Nom de l'instrument commercial. NULL ou "" - symbole actuel. La valeur par défaut est "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 21.08.2008                                                     |
//|  Описание : Возвращает нормализованное под размер тика значение цены.      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    np - нормализуемое значение цены.                                       |
//|    sy - наименование инструмента        ("" или NULL - текущий символ)     |
//+----------------------------------------------------------------------------+
double NormalizePrice(double np, string sy="") {
  if (sy=="" || sy=="0") sy=Symbol();
  double pp, ts=MarketInfo(Symbol(), MODE_TICKSIZE);
  int    di=MarketInfo(Symbol(), MODE_DIGITS);

  if (ts>0) pp=NormalizeDouble(np/ts, 0)*ts;
  else {
    if (di>0) pp=NormalizeDouble(np*di, 0)/di; else pp=np;
  }
  return(pp);
}
 

La fonction WeekOfMonth().

Cette fonction renvoie la semaine du mois par date. Accepte un seul paramètre facultatif :

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 12.08.2008                                                     |
//|  Описание : Возвращает номер недели месяца по дате                         |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    dt - дата, время           (0 - сейчас по времени торгового сервера)    |
//+----------------------------------------------------------------------------+
int WeekOfMonth(datetime dt=0) {
  if (dt<=0) dt=TimeCurrent();
  datetime d;
  int      i, kd=TimeDay(dt), nn=1;

  for (i=2; i<=kd; i++) {
    d=StrToTime(TimeYear(dt)+"."+TimeMonth(dt)+"."+i);
    if (TimeDayOfWeek(d)==1) nn++;
  }
  return(nn);
}

Fonction ClosePosBySortLots().

Cette fonction ferme les positions dans l'ordre de tri par taille de lot. C'est-à-dire qu'à l'aide de cette fonction, vous pouvez clôturer des positions dans l'ordre croissant ou décroissant des tailles de lot. La fonction ClosePosBySortLots() accepte les paramètres facultatifs suivants :

  • sy - Nom de l'instrument de négociation. "" - tout instrument, NULL - instrument actuel. Valeur par défaut - "".
  • op - Type d'opération commerciale. Valeurs valables -1 - toute position, OP_BUY - achat, OP_SELL - vente. La valeur par défaut est -1.
  • mn - MagicNumber, identifiant unique d'une opération commerciale. Valeur par défaut -1 - tout MagicNumber.
  • sd - Sens de tri de la taille du lot. Valeurs valides MODE_ASCEND - ascendant, MODE_DESCEND - descendant. La valeur par défaut est MODE_DESCEND.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.12.2008                                                     |
//|  Описание : Закрытие позиций в порядке сортировки по размерам лотов.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента        (    ""       - любой символ,      |
//|                                             NULL      - текущий символ)    |
//|    op - операция                        (    -1       - любая позиция)     |
//|    mn - MagicNumber                     (    -1       - любой магик)       |
//|    sd - Направление сортировки лотов    (MODE_ASCEND  - возрастание,       |
//|                                          MODE_DESCEND - убывание)          |
//+----------------------------------------------------------------------------+
void ClosePosBySortLots(string sy="", int op=-1, int mn=-1, int sd=MODE_DESCEND) {
  double a[][2];                  // Массив лотов и тикетов
  int    i, k=OrdersTotal();      // Счётчик и количество ордеров
  int    p=0;                     // Количество позиций

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (mn<0 || OrderMagicNumber()==mn) {
            p++;
            ArrayResize(a, p);
            a[p-1][0]=OrderLots();
            a[p-1][1]=OrderTicket();
          }
        }
      }
    }
  }

  // вдруг позиций нету, тогда и закрывать нечего
  if (p>0) {
    ArraySort(a, WHOLE_ARRAY, 0, sd);
    for (i=0; i<p; i++) {
      if (OrderSelect(a[i][1], SELECT_BY_TICKET)) {
        // проверим незакрытость на всякий случай,
        // может какая-то позиция уже закрылась по стопу/тейку
        if (OrderCloseTime()==0) ClosePosBySelect();
      }
    }
  }
}
 

La fonction AddLeadingZero().

Cette fonction ajoute autant de zéros de tête (à gauche) "0" à la chaîne de caractères pour que la longueur de la chaîne soit égale à une valeur donnée. La fonction AddLeadingZero() prend les paramètres obligatoires suivants :

  • s - La chaîne à laquelle les zéros de tête doivent être ajoutés.
  • k - La longueur de la chaîne de caractères résultante S.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Добавляет к строке S столько лидирующих нулей "0",             |
//|           : чтобы длина строки S стала равна K.                            |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    s - строка                                                              |
//|    k - длина строки S                                                      |
//+----------------------------------------------------------------------------+
string AddLeadingZero(string s, int k) {
  while(StringLen(s)<k) s=StringConcatenate("0", s);
  return(s);
}

Fonction toTime().

Cette fonction convertit deux/trois entiers en une chaîne de caractères au format horaire. Si vous passez deux nombres dans la fonction, le premier sera utilisé comme heures et le second comme minutes. La chaîne de format renvoyée sera "HH:MM". S'il y a trois chiffres, le troisième sera remplacé par les secondes et la fonction renverra la chaîne "HH:MM:SS". La fonction toTime() accepte les paramètres facultatifs suivants :

  • h - Horloge. La valeur par défaut est 0.
  • m - Procès-verbal. La valeur par défaut est 0.
  • s - Secondes. 0 - Ne pas utiliser. Valeur par défaut : 0.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Преобразует два/три целых числа в строку в формате времени     |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    h - часы                                                                |
//|    m - минуты                                                              |
//|    s - секунды           (0 - не использовать)                             |
//+----------------------------------------------------------------------------+
string toTime(int h=0, int m=0, int s=0) {
  string st="";

  if (h==0) st="00:";
  else      st=StringConcatenate(AddLeadingZero(h, 2), ":");

  if (m==0) st=StringConcatenate(st, "00");
  else      st=StringConcatenate(st, AddLeadingZero(m, 2));

  if (s!=0) st=StringConcatenate(st, ":", AddLeadingZero(s, 2));

  return(st);
}
Raison: