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

 

Funktion CorrectTF().

Ich habe diese Funktion geschrieben, nachdem ich festgestellt habe, dass ich in den Eingabeparametern eines Indikators oder eines EAs manchmal leicht einen falschen Zeitrahmen angeben kann, der einer ganzen Zahl von Minuten entspricht. Ich habe zum Beispiel 50 statt 60 für den Stundenlohn eingegeben. Na ja... irgendwie vermisst. Es stellt sich heraus, dass die Funktion iRSI() bei einem falschen Zeitrahmen Null zurückgibt. Über andere Funktionen kann ich nichts sagen, da ich sie nicht überprüft habe. Um Missverständnisse zu vermeiden, die aus meinen eigenen Unachtsamkeiten resultieren, habe ich diese Funktion als primitive, narrensichere Funktion geschrieben. Sie passt den Eingabeparameter an den nächstgelegenen geeigneten Zeitrahmen an und gibt dessen Wert zurück.

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

Funktion DateBeginQuarter().

Diese Funktion gibt das Anfangsdatum des Quartals anhand seiner Nummer zurück. Wenn wir jetzt zum Beispiel den 27.08.2008 haben, dann ist das Datum des Beginns des laufenden Quartals der 01.07.2008. Die Funktion benötigt nur einen Parameter - die Quartalsnummer bezogen auf das aktuelle Quartal. So steht beispielsweise 0 für das aktuelle Quartal, 1 für das nächste Quartal und -1 für das vorherige Quartal. Das heißt, dass positive Quartalszahlen Daten aus der Zukunft anfordern, während Null und negative Zahlen Daten aus der Vergangenheit anfordern. Der zurückgegebene Wert ist die Anzahl der seit 00:00 Uhr am 1. Januar 1970 verstrichenen Sekunden.

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

Die Funktion DateOfMonday().

Diese Funktion gibt das Datum des Wochenbeginns (Montag) durch seine Nummer zurück. Wenn wir zum Beispiel heute den 29.08.2008 haben, ist das Datum des Beginns der aktuellen Woche der 25.08.2008. Die Funktion benötigt nur einen Parameter - die Nummer der Woche im Verhältnis zur aktuellen Woche. Zum Beispiel steht 0 für die aktuelle Woche, 1 für die nächste Woche und -1 für die vorherige Woche. Das heißt, dass positive Wochenzahlen Daten aus der Zukunft anfordern, während Null und negative Zahlen Daten aus der Vergangenheit anfordern. Der Rückgabewert ist die Anzahl der seit 00:00 Uhr am 1. Januar 1970 verstrichenen Sekunden.

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

Die Funktion Fibonacci().

Diese Funktion gibt ein Element der Fibonacci-Reihe anhand seiner Folgenummer zurück.

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

GetNameMA() Funktion.

Diese Funktion gibt den Namen der MA-Methode(gleitende Durchschnitte) anhand ihres Bezeichners zurück. Diese Funktion lässt sich bequem in Kommentaren, Indikatoren und Expert Advisors-Nachrichten verwenden.

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

GetPriceDiffInPoint() Funktion.

Diese Funktion gibt die Preisdifferenz zwischen zwei Balken zurück, die durch ihre Nummern angegeben werden. Der Zweck der Entwicklung dieser Funktion bestand darin, den Wert und die Richtung der Kursbewegung zu bestimmen. Die Funktion GetPriceDiffInPoint() bestimmt die Referenzpunkte (Open oder High oder Low oder Close) der zu berücksichtigenden Bars. Die Funktion akzeptiert die folgenden optionalen Parameter:

  • sy - Name des Instruments. "" oder NULL - aktuelles Symbol. Der Standardwert ist NULL.
  • tf - Zeitrahmen. Standardwert 0 - aktuelles Symbol.
  • n2 - Nummer des linken Balkens. Standardwert - 2.
  • n1 - Rechte Taktnummer. Standardwert - 1.

Zurückgegebener Wert:

  • positiv - zwischen den Balken N2 und N1 gab es einen Anstieg der Rate.
  • negativ - es gab eine Abwertung zwischen den Balken N2 und 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);
}

Die Funktion GetTypePrice()

Gibt den Namen des Preistyps zurück. Die Funktion benötigt nur einen optionalen Parameter. Gültige Werte: PRICE_CLOSE, PRICE_OPEN, PRICE_HIGH, PRICE_LOW, PRICE_MEDIAN, PRICE_TYPICAL, PRICE_WEIGHTED. Der Standardwert ist 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");
  }
}
 

Die Funktion ArrayLR().

Diese Funktion erzeugt ein Array von linearen Regressionswerten. Die Funktion akzeptiert die folgenden obligatorischen Parameter:

  • x ist ein Array mit numerischen Reihenwerten. Dies ist der Eingabeparameter. Dieses Array muss die Werte enthalten, bevor die Funktion aufgerufen wird.
  • y ist ein Array von linearen Regressionswerten. Dies ist der Ausgabeparameter, d.h. das Array wird nach dem Aufruf der Funktion gefüllt.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

ArrayMo() Funktion.

Gibt Modu - das Maximum der Verteilungsdichtekurve - zurück. Die Funktion akzeptiert die folgenden optionalen Parameter:

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

Function ExistOrdersByPrice().

Gibt ein Flag für das Vorhandensein eines Auftrags zum angegebenen Preis zurück. True - Auftrag existiert (gesetzt), False - Auftrag existiert nicht (nicht gesetzt). Sie können die Liste der zu prüfenden Aufträge mit Hilfe der Funktionsparameter einschränken:

  • sy - Bezeichnung des Marktinstruments. Wenn dieser Parameter angegeben wird, prüft die Funktion nur die Aufträge des angegebenen Instruments. NULL bedeutet das aktuelle Instrument, und "" (standardmäßig) bedeutet ein beliebiges Instrument.
  • op - Art des Geschäfts, Art des schwebenden Auftrags. Gültige Werte: OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP oder -1. Der Standardwert -1 steht für einen beliebigen Auftragstyp.
  • mn - Kennung der Bestellung (MagicNumber). Der Standardwert von -1 bedeutet eine beliebige MagicNumber.
  • pp - Das Preisniveau, auf das der Auftrag festgelegt wird. Der Standardwert ist -1 - ein beliebiger Preis.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Die Funktion ClosePosBySelect() für das Prüfgerät.

Führt die Schließung einer einzelnen vorgewählten Position aus. Dies ist eine vereinfachte Version der gleichnamigen Funktion, die bereits auf Seite 13 beschrieben wurde. Nichts Überflüssiges. Keine zusätzlichen Funktionen. In meiner Praxis habe ich noch nie eine Position gehabt, die im Tester nicht geschlossen wurde. Deshalb gibt es in dieser Funktion auch keine Prüfungen. Sie sind im Prüfgerät nicht erforderlich.

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

Die Funktion CountOrders() für das Prüfgerät.

In meinen Testversionen (die ausschließlich für die Verwendung im MT4-Tester bestimmt sind) ersetzt die Funktion CountOrders() die folgenden Funktionen: ExistOrders(), ExistPositions(), NumberOfOrders() und NumberOfPositions(), so dass sie Informationen über das Vorhandensein von Positionen oder Aufträgen und die Anzahl der Trades jedes Typs liefern kann. Ein solcher Austausch hat seine eigenen Vorteile, die sich darin äußern, dass man einmalig für einen Tick auf die Auftragsbasis zugreifen kann und alle notwendigen Informationen auf einmal erhält. Und die oben genannten Funktionen, insbesondere wenn sie zusammen verwendet werden, arbeiten alle unabhängig voneinander mit ein und derselben Auftragsbasis, so dass sie immer wieder dieselben Aufrufe tätigen. Infolgedessen kann die Funktion CountOrders() die Zeit eines Durchlaufs um mehrere Sekunden verkürzen, wodurch Stunden der Optimierung eingespart werden können.

Die Funktion CountOrders() hat die folgenden Parameter:

  • mo - Array mit der Anzahl der Bestellungen nach Typ. Nach der Ausführung der Funktion hat das Array 6 (sechs) Elemente. Null-Element - Anzahl der Kaufgeschäfte, erstes Element - Anzahl der Verkaufsaufträge, zweites Element - BuyLimit, drittes Element - SellLimit, viertes Element - BuyStop, fünftes Element - SellStop.
  • mn - Kennung einer Position oder von Aufträgen (MagicNumber). Der Standardwert ist -1 - eine beliebige 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()]++;
    }
  }
}

Die Funktion ModifyOrder() für das Prüfgerät.

Dies ist eine abgespeckte Version der Funktion ModifyOrder(), die auf Seite 7 veröffentlicht wurde, und ist für die Änderung der absoluten Preisniveaus einer vorausgewählten Order oder Position gedacht.

Die Funktion ModifyOrder() akzeptiert die folgenden Parameter:

  • pp - Preis für die Bestellung. Wenn Sie einen Wert kleiner oder gleich Null angeben, wird die Änderung dieses Preisniveaus nicht durchgeführt. Der Standardwert ist -1.
  • sl - Stoppkursniveau. Wenn Sie einen Wert kleiner als Null angeben, wird die Änderung des Preisniveaus nicht durchgeführt. Der Standardwert ist 0.
  • tp - Preisniveau nehmen. Wenn Sie einen Wert kleiner als 0 angeben, wird die Änderung des Preisniveaus nicht durchgeführt. Der Standardwert ist 0.
  • ex - Verfallsdatum des schwebenden Auftrags. Der Standardwert ist 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);
    }
  }
}
 

Die Funktion IIFc().

Eine sehr praktische Funktion für die Konstruktion von Gabeln. Wenn ja, dann diese Farbe. Und wenn nicht, dann eine andere Farbe. Die Funktion IIFc() benötigt drei obligatorische Parameter:

  • condition - Ein logischer Ausdruck. Sie kann wahr oder falsch sein.
  • ifTrue - Die Farbe, die von IIFc() zurückgegeben wird, wenn der Bedingungsausdruck wahr ist.
  • ifFalse - Die Farbe, die von IIFc() zurückgegeben wird, wenn die Bedingung falsch ist.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 18.07.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

IIFd()-Funktion.

Ähnlicher Komfort für reelle Zahlen. Wenn ja, ist es eine reelle Zahl. Und wenn nicht, ist es eine andere Zahl. Die Funktion IIFd() benötigt drei obligatorische Parameter:

  • condition - Ein logischer Ausdruck. Sie kann wahr oder falsch sein.
  • ifTrue - Eine reelle Zahl, die von IIFd() zurückgegeben wird, wenn der Bedingungsausdruck wahr ist.
  • ifFalse - Eine reelle Zahl, die von IIFd() zurückgegeben wird, wenn die Bedingung falsch ist.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
double IIFd(bool condition, double ifTrue, double ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Die Funktion IIFi().

Ähnlicher Komfort für ganze Zahlen. Wenn ja, ist es eine ganze Zahl. Und wenn nicht, dann eine andere Nummer. Die Funktion IIFi() benötigt drei obligatorische Parameter:

  • condition - Ein logischer Ausdruck. Sie kann wahr oder falsch sein.
  • ifTrue - Eine ganzzahlige Zahl, die von IIFi() zurückgegeben wird, wenn der Bedingungsausdruck wahr ist.
  • ifFalse - Eine ganze Zahl, die von IIFi() zurückgegeben wird, wenn die Bedingung falsch ist.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
int IIFi(bool condition, int ifTrue, int ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

IIFis()-Funktion.

Ein ähnlicher Komfort für Strings. Wenn ja, eine solche Zeichenfolge. Und wenn nicht, dann eine andere Zeichenfolge. Die Funktion IIFs() benötigt drei obligatorische Parameter:

  • condition - Ein logischer Ausdruck. Sie kann wahr oder falsch sein.
  • ifTrue - Die Zeichenkette, die von der Funktion IIFs() zurückgegeben wird, wenn der Bedingungsausdruck wahr ist.
  • ifFalse - Die Zeichenkette, die von IIFs( ) zurückgegeben wird, wenn die Bedingung falsch ist.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
string IIFs(bool condition, string ifTrue, string ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
 

Die Funktion ExistInHistoryCloseBetween().

Gibt ein Kennzeichen für das Vorhandensein einer Position oder eines Auftrags in der Historie zurück, der zwischen den Daten geschlossen (gelöscht) wurde. Die Funktion ExistInHistoryCloseBetween() erhält die folgenden Parameter:

  • sy - Bezeichnung des Marktinstruments. "" - beliebiges Symbol, NULL - aktuelles Symbol. Der Standardwert ist "".
  • op - Handelsoperation. Gültige Werte: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Standardwert -1 - beliebiger Vorgang.
  • mn - Handelskennzeichen, MagicNumber. Standardwert -1 - eine beliebige magische Zahl.
  • d1 - Zeitpunkt des Positionsschlusses (anstehende Auftragslöschung). Der Standardwert ist 0 - beliebige Schließzeit (löschen). Die Zeit d1 muss kürzer sein als d2.
  • d2 - Schließungszeit der Position (Löschung des Auftrags steht noch aus). Standardwert - 0 - beliebige Schließzeit (Löschen). Die Zeit d2 muss länger sein als die Zeit 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);
}

Function ExistInHistoryOpenBetween().

Gibt das Kennzeichen für das Vorhandensein einer Position oder eines Auftrags in der Historie zurück, die/der zwischen den Daten geöffnet (gesetzt) wurde. Die Funktion ExistInHistoryOpenBetween() erhält die folgenden Parameter:

  • sy - Name des Instruments. "" - ein beliebiges Zeichen, NULL - das aktuelle Symbol. Der Standardwert ist "".
  • op - Handelsoperation. Gültige Werte: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Standardwert -1 - beliebiger Vorgang.
  • mn - Kennung der Handelsgeschäfte, MagicNumber. Standardwert -1 - eine beliebige magische Zahl.
  • d1 - Zeitpunkt der Positionseröffnung(in Erwartung der Auftragserteilung). Der Standardwert ist 0 - eine beliebige Öffnungszeit (Einstellzeit). Die d1-Zeit sollte kürzer sein als die d2-Zeit.
  • d2 - Zeitpunkt der Positionseröffnung (in Erwartung der Ordererteilung). Der Standardwert ist 0 - eine beliebige offene (eingestellte) Zeit. Die Zeit d2 muss länger sein als die Zeit 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);
}
 

Function ExistInHistoryToDay().

Gibt das Kennzeichen für das Vorhandensein einer heute eröffneten (gesetzten) Position oder Order in der Historie zurück. Die Funktion ExistInHistoryToDay() erhält die folgenden Parameter:

  • sy - Name des Instruments. "" - ein beliebiges Symbol, NULL - das aktuelle Symbol. Der Standardwert ist "".
  • op - Handelsoperation. Gültige Werte: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Standardwert -1 - beliebiger Vorgang.
  • mn - Kennung der Handelsgeschäfte, MagicNumber. Der Standardwert ist -1 - eine beliebige Magie.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

TakeProfitLastPos() Funktion.

Diese Funktion gibt das Kursniveau des TakeProfit der letzten offenen Position oder -1 zurück. Die Funktion TakeProfitLastPos() akzeptiert die folgenden optionalen Parameter:

  • sy - Name des Instruments. "" - beliebiges Symbol, NULL - aktuelles Symbol. Der Standardwert ist "".
  • op - Handelsoperation. Gültige Werte: -1, OP_BUY, OP_SELL. Der Standardwert ist -1 - beliebiger Handel.
  • mn - Handelskennzeichen, MagicNumber. Standardwert -1 - beliebige Magie.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}