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

 

TakeProfitLastClosePos() Funktion.

Gibt das TakeProfit-Kursniveau der letzten geschlossenen Position oder -1 zurück. Die Funktion TakeProfitLastClosePos() 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                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 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);
}

Funktion MovingInWL().

Verschiebt das StopLoss-Kursniveau der offenen Positionen auf Breakeven. Die Funktion MovingInWL() benötigt 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.

Außerdem hat die Funktion MovingInWL() globale Variablen (externe Parameter des Skripts oder des Expert Advisors):

  • int LevelProfit - Höhe des Gewinns in Punkten, den eine Position erreichen muss, damit ihr Stop auf das Breakeven-Niveau verschoben wird.
  • int LevelWLoss - Breakeven-Niveau in Punkten, auf das der Stopp übertragen wird, nachdem sein Gewinn das LevelProfit-Niveau in Punkten erreicht hat.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
          }
        }
      }
    }
  }
}
 

SimpleTrailing() Funktion.

Verschiebt das StopLoss-Kursniveau offener Positionen unter Verwendung des TrailingStop-Algorithmus. Die Funktion SimpleTrailing() 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.

Darüber hinaus impliziert die Funktion SimpleTrailing() globale Variablen (externe Parameter des Skripts oder Expert Advisors):

  • bool TSProfitOnly - Schaltet die Zone um, in der das Schleppnetz beginnt. Bei True beginnt die Schleppnetzfischerei erst, wenn der Positionsgewinn den Wert von TStop.Buy/Sell+TrailingStep-Punkten erreicht. Wenn False, stellt der Expert Advisor lediglich sicher, dass die Stop-Position relativ zum aktuellen Kurs immer nicht weiter als TStop.Buy/Sell+TrailingStep Pips entfernt ist. Mit anderen Worten: Bei "True" arbeitet der Expert Advisor nur in der Gewinnzone der Position, bei "False" arbeitet er in der negativen Zone der Position.
  • int TStop.Buy - Größe des zu kaufenden Kurses in Punkten.
  • intTStop.Sell - Schleppnetzgröße in Punkten für den Verkauf.
  • int TrailingStep - Nachlaufschritt in Punkten. Dies ist notwendig, um den Händler nicht durch häufige Anfragen zu stören.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
              }
            }
          }
        }
      }
    }
  }
}

ArrayZ() Funktion.

Diese Funktion berechnet die Z-Zahl einer numerischen Reihe, die im Array per Referenz übergeben wird, und gibt sie zurück.

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

Die Funktion ArrayDeleteInt()

Führt die Löschung eines Array-Elements mit dem angegebenen Index aus. Gibt die Größe des neuen Arrays zurück oder -1, wenn nichts entfernt wurde. Die Funktion ArrayDeleteInt() akzeptiert die folgenden obligatorischen Parameter:

  • m - Array von Elementen.
  • i - Index des Array-Elements.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Die Funktion ArrayDeleteDouble()

Löscht das Array-Element mit dem angegebenen Index. Sie gibt die Größe des neuen Arrays zurück oder -1, wenn nichts gelöscht werden konnte. Die Funktion ArrayDeleteDouble() akzeptiert die folgenden obligatorischen Parameter:

  • m - Array von Elementen des Typs double.
  • i - Index des Array-Elements.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Die Funktion ArrayDeleteString()

Führt die Löschung eines Array-Elements mit dem angegebenen Index aus. Gibt die Größe des neuen Arrays zurück oder -1, wenn nichts entfernt werden konnte. Die Funktion ArrayDeleteString() akzeptiert die folgenden obligatorischen Parameter:

  • m - Array von Elementen des Typs string.
  • i - Index der Array-Elemente.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Die Funktion ArrayInsertDouble()

Fügt ein Element des Arrays mit dem angegebenen Index ein. Sie gibt die Anzahl der Elemente (Größe) des neuen Arrays zurück. Das Einfügen wird wie folgt durchgeführt. Zunächst wird die Größe des Arrays um eins erhöht. Dann werden alle Elemente, deren Index größer oder gleich dem einzufügenden Element ist, einzeln an das Ende des Arrays verschoben, um Platz für das einzufügende Element zu schaffen. Schließlich wird der Wert in die gewünschte Zelle geschrieben. Die Funktion ArrayInsertDouble() benötigt die folgenden Parameter:

  • m - Ein Array von Elementen des Typs double.
  • e - Wert des einzufügenden Array-Elements.
  • i - Index des einzufügenden Array-Elements. Wenn der Indexwert kleiner als Null oder größer oder gleich der Array-Größe ist, wird das Element an das Ende des Arrays angefügt. Der Standardwert ist -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);
}
 

Die Funktion BubbleSort2().

Diese Funktion blendet die Elemente eines zweidimensionalen Arrays in eine beliebige Spalte ein. Sie können auch die Sortierrichtung angeben. Die Funktion BubbleSort2() benötigt die folgenden Parameter:

  • a - Zweidimensionales Feld von Elementen. Obligatorischer Parameter.
  • r - Nummer (Index) der Sortierspalte (Spalte). Der Standardwert ist 0 - die erste Spalte (Spalte mit einem Nullindex).
  • m - Sortierrichtung. Gültige Werte: MODE_ASCEND - aufsteigende Reihenfolge, MODE_DESCEND - absteigende Reihenfolge. Der Standardwert ist 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;
          }
        }
      }
    }
  }
}

Die Funktion GetTypeLastDeleted().

Diese Funktion gibt den Typ des zuletzt gelöschten Auftrags oder -1 zurück. Es gibt Situationen, in denen wir die EA-Operationslogik an den Typ des gerade gelöschten Auftrags binden müssen. Wenn Sie z. B. gerade BuyStop gelöscht haben, sollten Sie das tun, aber wenn BuyLimit, sollten Sie etwas anderes tun, usw. Die Funktion GetTypeLastDeleted() akzeptiert die folgenden optionalen Parameter:

  • sy - Name des Instruments. "" - beliebiges Zeichen, NULL - aktuelles Zeichen. Der Standardwert ist "".
  • mn - Kennung der Benutzerbestellung (MagicNumber). Standardwert -1 - beliebige Magie.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Die Funktion iBarLargest().

Diese Funktion gibt den Index des größten Balkens oder -1 zurück. Die Größe des Balkens wird von der Funktion auf eine von zwei Arten gemessen, die durch den Eingabeparameter ty - Art der Suchbegriffe - bestimmt wird. Entweder nur die Größe des Körpers oder zusammen mit den Schatten. Die Funktion iBarLargest() akzeptiert die folgenden optionalen Parameter:

  • sy - Name des Werkzeugs. "" oder NULL - das aktuelle Symbol. Der Standardwert ist "".
  • tf - Zeitrahmen. Der Standardwert ist 0 - der aktuelle Zeitrahmen.
  • ty - Art der Suchbegriffe. Gültige Werte - 0 - High-Low, 1 - abs(Open-Close).
  • co - Anzahl der Zeitreihenelemente. Standardwert - 0 - alle Elemente.
  • in - Index des Anfangsbalken. Standardwert - 0 - aktueller Balken.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Die Funktion iBarOfDayCalc().

Diese Funktion gibt die berechnete Nummer des Balkens vom Tagesbeginn an zurück. Die Balken werden von eins an nummeriert, d. h. der Balken mit der kürzesten Öffnungszeit an einem bestimmten Tag ist die Nummer eins, der nächste Balken ist die Nummer zwei usw. Diese Funktion ist nützlich, um die Ein- und Ausstiegszeiten zu optimieren. Wenn jemand an Details interessiert ist, kann er Fragen stellen. Ich werde mein Bestes tun, um sie zu beantworten. Die Funktion iBarOfDayCalc() benötigt die folgenden optionalen Parameter:

  • tf - Zeitrahmen. Der Standardwert ist 0 - der aktuelle Zeitrahmen.
  • dt - Datum und Uhrzeit der Öffnung der Bar. Standardwert - 0 - aktuelle Zeit.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Funktion iBarOfDayReal().

Diese Funktion gibt die aktuelle Taktnummer vom Beginn des Tages an zurück. Die Balken sind mit eins beginnend nummeriert, d.h. der Balken mit der kürzesten Öffnungszeit an einem bestimmten Tag hat die Nummer eins, der nächste Balken die Nummer zwei usw. Ich habe noch keinen praktischen Nutzen für diese Funktion gefunden. Aber ich habe es geschrieben, um es zu haben :-) zusammen mit der Funktion iBarOfDayCalc(). Die Funktion iBarOfDayReal() akzeptiert die folgenden optionalen Parameter:

  • sy - Name des Handelsinstruments. NULL oder "" - aktuelles Symbol. Der Standardwert ist "".
  • tf - Zeitrahmen. Standardwert - 0 - aktueller Zeitrahmen.
  • dt - Datum und Uhrzeit der Bareröffnung. Standardwert - 0 - aktuelle Zeit.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

NameDayOfWeek() Funktion

Gibt den Namen des Wochentags mit der als Parameter übergebenen Zahl zurück:

  • ndw - Nummer des Wochentags. Erforderlicher Parameter.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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("Суббота");
}
 

Funktion NormalizeLot().

Diese Funktion gibt den normalisierten Wert des gehandelten Loses zurück und passt die Losgröße an die vom Handelszentrum gesetzten Grenzen an (Mindest- und Höchstwert des Loses und Schritt der Losänderung werden überprüft). Die Funktion NormalizeLot() nimmt die folgenden Parameter an:

  • lo - NormalizeLot-Wert. Erforderlicher Parameter.
  • ro - Rundungsmethode. Falsch - für die kleinere Seite, Wahr - für die größere Seite. Standardwert - False - auf der unteren Seite.
  • sy - Bezeichnung des Handelsinstruments. NULL oder "" - aktuelles Symbol. Standardwert - "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

NormalizePrice() Funktion.

Diese Funktion gibt den normalisierten Preiswert zurück. Die Normalisierung wird anhand der Werte der Funktion MarketInfo(MODE_TICKSIZE || MODE_DIGITS) durchgeführt. Die Funktion NormalizePrice() benötigt die folgenden Parameter:

  • np - Normalisierter Wert der Partie. Erforderlicher Parameter.
  • sy - Bezeichnung des Handelsinstruments. NULL oder "" - aktuelles Symbol. Der Standardwert ist "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Die Funktion WeekOfMonth().

Diese Funktion gibt die Woche des Monats nach Datum zurück. Akzeptiert nur einen optionalen Parameter:

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

Funktion ClosePosBySortLots().

Diese Funktion schließt die Positionen in der Reihenfolge der Sortierung nach Losgröße. Das heißt, mit dieser Funktion können Sie Positionen in auf- oder absteigender Reihenfolge der Losgrößen schließen. Die Funktion ClosePosBySortLots() akzeptiert die folgenden optionalen Parameter:

  • sy - Name des Handelsinstruments. "" - beliebiges Instrument, NULL - aktuelles Instrument. Standardwert - "".
  • op - Art der Handelsoperation. Gültige Werte -1 - beliebige Position, OP_BUY - kaufen, OP_SELL - verkaufen. Der Standardwert ist -1.
  • mn - MagicNumber, eindeutiger Bezeichner eines Handelsvorgangs. Standardwert -1 - eine beliebige MagicNumber.
  • sd - Sortierrichtung der Losgröße. Gültige Werte MODE_ASCEND - aufsteigend, MODE_DESCEND - absteigend. Der Standardwert ist 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();
      }
    }
  }
}
 

Die Funktion AddLeadingZero().

Diese Funktion fügt so viele führende (linke) Nullen "0" an die Zeichenkette an, dass die Länge der Zeichenkette einem bestimmten Wert entspricht. Die Funktion AddLeadingZero() benötigt die folgenden obligatorischen Parameter:

  • s - Die Zeichenkette, zu der die führenden Nullen hinzugefügt werden sollen.
  • k - Die Länge der resultierenden Zeichenfolge 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);
}

Funktion toTime().

Diese Funktion wandelt zwei/drei Ganzzahlen in eine Zeichenkette im Zeitformat um. Wenn Sie zwei Zahlen in die Funktion eingeben, wird die erste als Stunden und die zweite als Minuten verwendet. Der zurückgegebene Formatstring ist "HH:MM". Bei drei Zahlen wird die dritte durch die Sekunden ersetzt und die Funktion gibt die Zeichenfolge "HH:MM:SS" zurück. Die Funktion toTime() akzeptiert die folgenden optionalen Parameter:

  • h - Uhr. Der Standardwert ist 0.
  • m - Protokoll. Der Standardwert ist 0.
  • s - Sekunden. 0 - Nicht verwenden. Standardwert 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);
}