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

 

La fonction StringLower().

Cette fonction convertit une chaîne de caractères en minuscules. Tous les caractères SIGNIFICATIFS (grands) deviennent des minuscules (petits). La fonction StringLower() n'accepte qu'un seul paramètre obligatoire, qui est la chaîne entrante.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает строку в нижнем регистре                            |
//+----------------------------------------------------------------------------+
string StringLower(string s) {
  int c, i, k=StringLen(s), n;
  for (i=0; i<k; i++) {
    n=0;
    c=StringGetChar(s, i);
    if (c>64 && c<91) n=c+32;     // A-Z -> a-z
    if (c>191 && c<224) n=c+32;   // А-Я -> а-я
    if (c==168) n=184;            //  Ё  ->  ё
    if (n>0) s=StringSetChar(s, i, n);
  }
  return(s);
}
 

La fonction StringUpper().

Cette fonction convertit la chaîne de caractères en majuscules. Tous les caractères minuscules (petits) deviennent des majuscules (grands). La fonction StringUpper() n'accepte qu'un seul paramètre obligatoire, qui est la chaîne de caractères d'entrée.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает строку в ВЕРХНЕМ регистре                           |
//+----------------------------------------------------------------------------+
string StringUpper(string s) {
  int c, i, k=StringLen(s), n;
  for (i=0; i<k; i++) {
    n=0;
    c=StringGetChar(s, i);
    if (c>96 && c<123) n=c-32;    // a-z -> A-Z
    if (c>223 && c<256) n=c-32;   // а-я -> А-Я
    if (c==184) n=168;            //  ё  ->  Ё
    if (n>0) s=StringSetChar(s, i, n);
  }
  return(s);
}


La fonction StringToArrayDouble().

Cette fonction divise la chaîne en ses composants réels, et chaque nombre est ajouté au tableau comme un élément séparé. Autant de nombres réels apparaissent dans la chaîne, autant d'éléments seront ajoutés au tableau. Le point-virgule est reconnu comme un séparateur. La fonction StringToArrayDouble() renvoie le nombre d'éléments du tableau et prend les paramètres obligatoires suivants :

  • st - Une chaîne de nombres réels séparés par un point-virgule.
  • ad - Un tableau de nombres réels.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 10.10.2008                                                     |
//|  Описание : Перенос вещественных чисел из строки в массив                  |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    st - строка вещественных чисел через точку с запятой                    |
//|    ad - массив вещественных чисел                                          |
//+----------------------------------------------------------------------------+
//|  Возврат:                                                                  |
//|    Количество элементов в массиве                                          |
//+----------------------------------------------------------------------------+
int StringToArrayDouble(string st, double& ad[]) {
  int    i=0, np;
  string stp;

  ArrayResize(ad, 0);
  while (StringLen(st)>0) {
    np=StringFind(st, ";");
    if (np<0) {
      stp=st;
      st="";
    } else {
      stp=StringSubstr(st, 0, np);
      st=StringSubstr(st, np+1);
    }
    i++;
    ArrayResize(ad, i);
    ad[i-1]=StrToDouble(stp);
  }
  return(ArraySize(ad));
}
 

La fonction StringToArrayInt().

Cette fonction divise la chaîne en ses composants entiers, et chaque nombre est ajouté au tableau comme un élément séparé. Autant d'entiers qu'il y a dans la chaîne, le même nombre d'éléments sera ajouté au tableau. Une virgule est reconnue comme un séparateur. La fonction StringToArrayDouble() renvoie le nombre d'éléments du tableau et prend les paramètres obligatoires suivants :

  • st - Chaîne de valeurs entières séparées par des virgules.
  • ai - Tableau de nombres entiers.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Перенос целочисленных значений из строки в массив              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    st - строка целочисленных значений через запятую                        |
//|    ai - целочисленный массив                                               |
//+----------------------------------------------------------------------------+
//|  Возврат:                                                                  |
//|    Количество элементов в массиве                                          |
//+----------------------------------------------------------------------------+
int StringToArrayInt(string st, int& ai[]) {
  int    i=0, np;
  string stp;

  ArrayResize(ai, 0);
  while (StringLen(st)>0) {
    np=StringFind(st, ",");
    if (np<0) {
      stp=st;
      st="";
    } else {
      stp=StringSubstr(st, 0, np);
      st=StringSubstr(st, np+1);
    }
    i++;
    ArrayResize(ai, i);
    ai[i-1]=StrToInteger(stp);
  }
  return(ArraySize(ai));
}

La fonction StrSplit().

Cette fonction divise une chaîne de caractères en ses sous-chaînes, de sorte que chaque sous-chaîne devienne un élément distinct du tableau. Le séparateur est spécifié par un paramètre et peut être arbitraire. La fonction StrSplit() renvoie le nombre d'éléments du tableau et accepte les paramètres suivants :

  • st - Chaîne de caractères avec des séparateurs.
  • as - Le tableau des éléments du type chaîne de caractères.
  • de - Séparateur. Paramètre facultatif. Valeur par défaut - "," (virgule).
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 23.06.2008                                                     |
//|  Описание : Разбиение строки на массив элементов                           |
//+----------------------------------------------------------------------------+
//|  Возврат:                                                                  |
//|    Количество элементов в массиве                                          |
//|  Параметры:                                                                |
//|    st - строка с разделителями                                             |
//|    as - строковый массив                                                   |
//|    de - разделитель                                                        |
//+----------------------------------------------------------------------------+
int StrSplit(string st, string& as[], string de=",") { 
  int    i=0, np;
  string stp;

  ArrayResize(as, 0);
  while (StringLen(st)>0) {
    np=StringFind(st, ",");
    if (np<0) {
      stp=st;
      st="";
    } else {
      stp=StringSubstr(st, 0, np);
      st=StringSubstr(st, np+1);
    }
    i++;
    ArrayResize(as, i);
    as[i-1]=stp;
  }
  return(ArraySize(as));
}
 

La fonction StrTran().

Cette fonction remplace une sous-chaîne. Toutes ses occurrences sont remplacées. Par exemple, vous pouvez remplacer toutes les virgules par des points ou vice versa d'un seul coup. La fonction StrSplit() renvoie la chaîne de caractères résultante et accepte les paramètres obligatoires suivants :

  • str - La chaîne dans laquelle la sous-chaîne strFrom est remplacée.
  • strFrom - sous-chaîne substituée. Si la sous-chaîne strFrom est trouvée dans la chaîne str, elle sera remplacée par la sous-chaîne strTo.
  • strTo - Sous-chaîne substituée.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  описание : Замена подстроки                                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    str     - текстовая строка, в которой производится замена               |
//|    strFrom - заменяемая подстрока                                          |
//|    strTo   - заменяющая подстрока                                          |
//+----------------------------------------------------------------------------+
string StrTran(string str, string strFrom, string strTo) {
  int    n;
  string strOut="", strTemp;

  for (n=0; n<StringLen(str); n++) {
    strTemp=StringSubstr(str, n, StringLen(strFrom));
    if (strTemp==strFrom) {
      strOut=StringConcatenate(strOut, strTo);
      n=n+StringLen(strFrom)-1;
    } else strOut=StringConcatenate(strOut, StringSubstr(str, n, 1));
  }
  return(strOut);
}
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 23.04.2009                                                     |
//|  Описание : Перенос уровня стопа в безубыток                               |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void MovingInWL(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)) {
        if (mn<0 || OrderMagicNumber()==mn) {
          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 isTradeTimeString().

Cette fonction renvoie l'indicateur qui vous permet de négocier en fonction de l'heure. En fait, elle vérifie si l'heure actuelle du serveur de négociation est comprise dans un certain intervalle de temps. Si elle est à l'intérieur, la fonction isTradeTimeString() renvoie true, sinon elle renvoie false. La caractéristique de cette fonction est la possibilité de spécifier l'intervalle de temps à l'intérieur et à l'extérieur d'un jour. Ceci sera montré en détail dans les exemples d'utilisation. La fonction isTradeTimeString() accepte les paramètres facultatifs suivants :

  • TimeBegin - Chaîne au format "HH:MM", elle définit l'heure de début de la transaction. La valeur par défaut est "00:00".
  • TimeEnd - Chaîne au format "HH:MM", spécifie l'heure de fin de la transaction. La valeur par défaut est "00:00".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 29.04.2009                                                     |
//|  Описание : Возвращает флаг разрешения торговли по времени.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    TimeBegin - время начала торговли         (ЧЧ:ММ)                       |
//|    TimeEnd   - время окончания торговли      (ЧЧ:ММ)                       |
//+----------------------------------------------------------------------------+
bool isTradeTimeString(string TimeBegin="00:00", string TimeEnd="00:00") {
  datetime dtBegin, dtEnd;        // Время начала и окончания работы
  int      hc, he;                // Часы текущего времени и окончания работы

  dtBegin=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+TimeBegin);
  dtEnd  =StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+TimeEnd);
  hc     =TimeHour(TimeCurrent());
  he     =TimeHour(dtEnd);
  if (dtBegin>=dtEnd) {
    if (hc>=he) dtEnd+=24*60*60; else dtBegin-=24*60*60;
  }

  if (TimeCurrent()>=dtBegin && TimeCurrent()<=dtEnd) return(True);
  else return(False);
}

Fonction isTradeTimeInt().

Cette fonction renvoie le drapeau permettant de négocier par temps. La valeur renvoyée est true ou false. La fonction isTradeTimeInt() est similaire à la fonction isTradeTimeString() par le principe de reconnaissance de l'intervalle de temps, c'est-à-dire que l'heure de début de la transaction peut être à la fois plus grande (intervalle de temps dans une journée) et plus petite (intervalle de temps dans des jours différents). La fonction isTradeTimeInt() accepte les paramètres facultatifs suivants :

  • hb - Nombre, spécifie les heures de début du commerce. La valeur par défaut est 0.
  • mb - Un nombre, spécifie les minutes de l'heure de début de la transaction. Valeur par défaut - 0.
  • he - Un nombre pour spécifier les heures de fin de transaction. La valeur par défaut - 0.
  • me - Un nombre pour spécifier les minutes de l'heure de fin de la transaction. Valeur par défaut - 0.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 30.04.2009                                                     |
//|  Описание : Возвращает флаг разрешения торговли по времени.                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    hb - часы времени начала торговли                                       |
//|    mb - минуты времени начала торговли                                     |
//|    he - часы времени окончания торговли                                    |
//|    me - минуты времени окончания торговли                                  |
//+----------------------------------------------------------------------------+
bool isTradeTimeInt(int hb=0, int mb=0, int he=0, int me=0) {
  datetime db, de;           // Время начала и окончания работы
  int      hc;               // Часы текущего времени торгового сервера

  db=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+hb+":"+mb);
  de=StrToTime(TimeToStr(TimeCurrent(), TIME_DATE)+" "+he+":"+me);
  hc=TimeHour(TimeCurrent());
  if (db>=de) {
    if (hc>=he) de+=24*60*60; else db-=24*60*60;
  }

  if (TimeCurrent()>=db && TimeCurrent()<=de) return(True);
  else return(False);
}
 
satop:
Le fichier contient tout dans une seule archive.
Dossiers :
kimiv.zip  187 kb
 
Igor Kim a publié ses fonctions ici et sur son site web sous forme de "collections de fonctions", dans un seul fichier. Il n'était pas possible d'utiliser ces collections comme des bibliothèques de plug-in sous cette forme. Cependant, il est très pratique, notamment lors du développement d'EA, d'utiliser les bibliothèques pour simplifier et réduire le code d'une EA. En outre, cela élimine toutes les questions relatives à l'utilisation correcte des opérations de trading, et vous permet de vous concentrer sur la stratégie, ce qui est particulièrement précieux pour les traders ayant des compétences de programmation débutantes.
Les fichiers joints contiennent les mêmes collections de fonctions, conçues sous forme de bibliothèques. Les bibliothèques sont simplement placées dans le répertoire .../experts/include, elles n'ont pas besoin d'être compilées, un exemple de leur connexion est donné ci-dessous.
Après leur connexion, il suffit d'appeler la fonction requise à partir du code EA.
#include <b-Positions_include.mqh>       // Библиотека функций для работы с позициями 
#include <b-KimIV_include.mqh>           // Библиотека дополнительных функций
#include <b-Orders_include.mqh>          // Библиотека функций для работы с ордерами
 

Chéri, où dans la ligne.

if (dg==0) if (StringFind(OrderSymbol(), "JPY")<0) dg=4; else dg=2;
появляется "JPY"??????

satop:

La fonction isCloseLastPosByStop().

Cette fonction renvoie un drapeau pour fermer la dernière position par arrêt. Le drapeau est levé - Vrai - déclenché StopLoss. Drapeau abaissé - Faux - le poste a été fermé pour une autre raison. Une sélection plus précise des positions à prendre en compte est établie à l'aide de paramètres externes :

  • sy - Nom de l'instrument de marché. Si vous définissez ce paramètre, la fonction ne prendra en compte que les positions de l'instrument spécifié. La valeur par défaut "" signifie tout instrument de marché. NULL signifie l'instrument actuel.
  • op - Opération commerciale, type de poste. Valeurs valables : OP_BUY, OP_SELL ou -1. La valeur par défaut -1 signifie une position quelconque.
  • mn - Identificateur de position, MagicNumber. La valeur par défaut -1 signifie n'importe quel identifiant.

 
Je comprends que les fonctions ont été écrites à une époque où il n'y avait pas encore de 5 chiffres. Le JPY a servi en quelque sorte d'exemple de comparaison.
 
hoz:
Je comprends que les fonctions ont été écrites à une époque où il n'y avait pas encore de 5 chiffres. Le JPY a servi en quelque sorte d'exemple de comparaison.

Il n'est pas difficile d'augmenter d'une unité !