Nur "Nützliche Funktionen von KimIV". - Seite 9

 

Die Funktion StringLower().

Diese Funktion wandelt eine Zeichenkette in Kleinbuchstaben um. Alle SIGNIFICANT (großen) Zeichen werden zu Kleinbuchstaben (klein). Die Funktion StringLower() akzeptiert nur einen obligatorischen Parameter, nämlich die eingehende Zeichenkette.

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

Die Funktion StringUpper().

Diese Funktion wandelt die Zeichenkette in Großbuchstaben um. Alle klein geschriebenen Zeichen werden zu Großbuchstaben. Die Funktion StringUpper() akzeptiert nur einen obligatorischen Parameter, nämlich die Eingabezeichenfolge.

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


Die Funktion StringToArrayDouble().

Diese Funktion zerlegt die Zeichenkette in die einzelnen reellen Zahlen, und jede Zahl wird dem Array als separates Element hinzugefügt. So viele reelle Zahlen in der Zeichenkette erscheinen, so viele Elemente werden dem Array hinzugefügt. Ein Semikolon wird als Trennzeichen erkannt. Die Funktion StringToArrayDouble() gibt die Anzahl der Array-Elemente zurück und benötigt die folgenden obligatorischen Parameter:

  • st - Eine Folge von reellen Zahlen, die durch ein Semikolon getrennt sind.
  • ad - Ein Array mit reellen Zahlen.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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));
}
 

Die Funktion StringToArrayInt().

Diese Funktion zerlegt die Zeichenkette in ihre Bestandteile, und jede Zahl wird dem Array als separates Element hinzugefügt. Dem Array werden so viele Elemente hinzugefügt, wie die Zeichenkette Ganzzahlen enthält. Ein Komma wird als Trennzeichen erkannt. Die Funktion StringToArrayDouble() gibt die Anzahl der Array-Elemente zurück und benötigt die folgenden obligatorischen Parameter:

  • st - Durch Kommata getrennte Folge von Ganzzahlwerten.
  • ai - Ganzzahliges Array.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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));
}

Die Funktion StrSplit().

Diese Funktion zerlegt eine Zeichenkette in ihre Teilstrings, so dass jeder Teilstring ein eigenes Element des Arrays wird. Das Trennzeichen wird durch einen Parameter angegeben und kann beliebig sein. Die Funktion StrSplit() gibt die Anzahl der Array-Elemente zurück und akzeptiert die folgenden Parameter:

  • st - Zeichenkette mit Trennzeichen.
  • as - Das Array von Elementen des Typs string.
  • de - Abscheider. Optionaler Parameter. Standardwert - "," (Komma).
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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));
}
 

Die Funktion StrTran().

Diese Funktion ersetzt eine Teilzeichenkette. Alle Vorkommen werden ersetzt. So können Sie zum Beispiel auf einen Schlag alle Kommas durch Punkte oder umgekehrt ersetzen. Die Funktion StrSplit() gibt die resultierende Zeichenkette zurück und nimmt die folgenden obligatorischen Parameter entgegen:

  • str - Die Zeichenkette, in der die Teilzeichenkette strFrom ersetzt werden soll.
  • strFrom - ersetzte Teilzeichenkette. Wenn die Teilzeichenkette strFrom in der Zeichenkette str gefunden wird, wird sie durch die Teilzeichenkette strTo ersetzt.
  • strTo - Ersetzte Teilzeichenkette.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
              }
            }
          }
        }
      }
    }
  }
}
 

Funktion isTradeTimeString().

Diese Funktion gibt das Flag zurück, das Ihnen erlaubt, nach Zeit zu handeln. Eigentlich prüft sie, ob die aktuelle Zeit des Handelsservers innerhalb eines bestimmten Zeitintervalls liegt. Liegt er innerhalb, gibt die Funktion isTradeTimeString() true zurück, andernfalls false. Das Besondere an dieser Funktion ist die Möglichkeit, das Zeitintervall sowohl innerhalb als auch außerhalb eines Tages anzugeben. Dies wird in den Anwendungsbeispielen näher erläutert. Die Funktion isTradeTimeString() akzeptiert die folgenden optionalen Parameter:

  • TimeBegin - String im Format "HH:MM", er legt die Zeit des Handelsbeginns fest. Standardwert ist "00:00".
  • TimeEnd - String im Format "HH:MM", gibt die Endzeit des Geschäfts an. Standardwert ist "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);
}

Funktion isTradeTimeInt().

Diese Funktion gibt das Flag zurück, das den Handel nach Zeit erlaubt. Der zurückgegebene Wert ist true oder false. Die Funktion isTradeTimeInt() ähnelt der Funktion isTradeTimeString() durch das Prinzip der Zeitintervallerkennung, d.h. der Handelsstartzeitpunkt kann sowohl größer (Zeitintervall innerhalb eines Tages) als auch kleiner (Zeitintervall in verschiedenen Tagen) sein. Die Funktion isTradeTimeInt() akzeptiert die folgenden optionalen Parameter:

  • hb - Zahl, gibt die Uhrzeit des Handelsbeginns an. Der Standardwert ist 0.
  • mb - Eine Zahl, die die Minuten der Handelsstartzeit angibt. Standardwert - 0.
  • he - Eine Zahl zur Angabe der Stunden des Handelsendes. Der Standardwert ist 0.
  • me - Eine Zahl zur Angabe der Minuten des Handelsendes. Standardwert - 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:
Die Datei enthält alles in einem einzigen Archiv.
Dateien:
kimiv.zip  187 kb
 
Igor Kim hat seine Funktionen sowohl hier als auch auf seiner Website als "Funktionssammlungen" in einer Datei veröffentlicht. Es war nicht möglich, diese Sammlungen in dieser Form als Plug-in-Bibliotheken zu verwenden. Es ist jedoch sehr praktisch, insbesondere bei der Entwicklung von EAs, die Bibliotheken zu verwenden, um den Code eines EAs zu vereinfachen und zu reduzieren. Außerdem werden dadurch alle Fragen über die korrekte Verwendung von Handelsoperationen beseitigt, und Sie können sich auf die Strategie konzentrieren, was besonders für Händler mit geringen Programmierkenntnissen wertvoll ist.
Die angehängten Dateien enthalten dieselben Funktionssammlungen, die in Form von Bibliotheken gestaltet sind. Die Bibliotheken werden einfach in das Verzeichnis .../experts/include gelegt, sie müssen nicht kompiliert werden, ein Beispiel für ihre Verbindung ist unten angegeben.
Nach deren Verbindung genügt es, die gewünschte Funktion aus dem EA-Code aufzurufen.
#include <b-Positions_include.mqh>       // Библиотека функций для работы с позициями 
#include <b-KimIV_include.mqh>           // Библиотека дополнительных функций
#include <b-Orders_include.mqh>          // Библиотека функций для работы с ордерами
 

Lieber, wo in der Schlange.

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

satop:

Die Funktion isCloseLastPosByStop().

Diese Funktion gibt ein Flag zurück, mit dem die letzte Position durch Stopp geschlossen wird. Flagge ist oben - Wahr - ausgelöster StopLoss. Flagge gesenkt - Falsch - die Position wurde aus einem anderen Grund geschlossen. Eine genauere Auswahl der zu berücksichtigenden Positionen wird über externe Parameter eingestellt:

  • sy - Bezeichnung des Marktinstruments. Wenn Sie diesen Parameter setzen, berücksichtigt die Funktion nur Positionen des angegebenen Instruments. Der Standardwert "" bedeutet ein beliebiges Marktinstrument. NULL bedeutet das aktuelle Instrument.
  • op - Handelsoperation, Positionsart. Gültige Werte: OP_BUY, OP_SELL oder -1. Der Standardwert -1 bedeutet eine beliebige Position.
  • mn - Positionsbezeichner, MagicNumber. Der Standardwert -1 bedeutet einen beliebigen Bezeichner.

 
Soweit ich weiß, wurden die Funktionen zu einer Zeit geschrieben, als es noch keine 5 Ziffern gab. Der JPY diente als eine Art Vergleichsbeispiel.
 
hoz:
Soweit ich weiß, wurden die Funktionen zu einer Zeit geschrieben, als es noch keine 5 Ziffern gab. Der JPY diente als eine Art Vergleichsbeispiel.

Es ist nicht schwer, die Zahl um eins zu erhöhen!
Grund der Beschwerde: