ForumSezioni

Solo "Caratteristiche utili di KimIV". - pagina 8

Nuovo commento

Funzione TakeProfitLastClosePos().

Restituisce il livello di prezzo TakeProfit dell'ultima posizione chiusa o -1. La funzione TakeProfitLastClosePos() accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento. "" - qualsiasi simbolo, NULL - simbolo corrente. Il valore predefinito è "".
  • op - operazione commerciale. Valori validi: -1, OP_BUY, OP_SELL. Il valore predefinito è -1 - qualsiasi commercio.
  • mn - Identificatore commerciale, MagicNumber. Valore predefinito -1 - qualsiasi magia.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Funzione MovingInWL().

Sposta il livello di prezzo StopLoss delle posizioni aperte a Breakeven. La funzione MovingInWL() prende i seguenti parametri opzionali:

  • sy - Nome dello strumento. "" - qualsiasi simbolo, NULL - simbolo corrente. Il valore predefinito è "".
  • op - operazione commerciale. Valori validi: -1, OP_BUY, OP_SELL. Il valore predefinito è -1 - qualsiasi commercio.
  • mn - Identificatore commerciale, MagicNumber. Valore predefinito -1 - qualsiasi magia.

Inoltre, la funzione MovingInWL() ha variabili globali (parametri esterni dello script o dell'Expert Advisor):

  • int LevelProfit - Livello di profitto in punti, che una posizione deve raggiungere per far spostare il suo stop al livello di Breakeven.
  • int LevelWLoss - Livello di pareggio in punti, a cui lo stop sarà trasferito dopo che il suo profitto raggiunge il livello LevelProfit in punti. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
          }
        }
      }
    }
  }
}

Funzione SimpleTrailing().

Sposta il livello di prezzo StopLoss delle posizioni aperte utilizzando l'algoritmo TrailingStop. La funzione SimpleTrailing() accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento. "" - qualsiasi simbolo, NULL - simbolo corrente. Il valore predefinito è "".
  • op - operazione commerciale. Valori validi: -1, OP_BUY, OP_SELL. Il valore predefinito è -1 - qualsiasi commercio.
  • mn - Identificatore commerciale, MagicNumber. Valore predefinito -1 - qualsiasi magia.

Inoltre, la funzione SimpleTrailing() implica variabili globali (parametri esterni dello script o dell'Expert Advisor):

  • bool TSProfitOnly - Cambia la zona in cui inizia la pesca a strascico. Se True, il trawl inizierà a lavorare solo quando il profitto della posizione raggiunge il valore dei punti TStop.Buy/Sell+TrailingStep. Se Falso, l'Expert Advisor si assicurerà semplicemente che la posizione di stop rispetto al prezzo corrente non sia sempre oltre TStop.Buy/Sell+TrailingStep pips. In altre parole, se True, l'Expert Advisor lavora solo nella zona di profitto della posizione, mentre se False lavora nella zona negativa della posizione.
  • int TStop.Buy - Dimensione del trall in punti da comprare.
  • intTStop.Sell - Dimensione dello strascico in punti per la vendita.
  • int TrailingStep - Passo finale in punti. È necessario per non disturbare il rivenditore con richieste frequenti. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
              }
            }
          }
        }
      }
    }
  }
}

Funzione ArrayZ().

Questa funzione calcola e restituisce il conteggio Z di una serie numerica passata nell'array per riferimento.

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

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

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

La funzione ArrayDeleteInt()

Esegue la cancellazione di un elemento dell'array con l'indice dato. Restituisce la dimensione del nuovo array o -1 se non è stato rimosso nulla. La funzione ArrayDeleteInt() accetta i seguenti parametri obbligatori:

  • m - Matrice di elementi.
  • i - Indice dell'elemento della matrice.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteInt(int& m[], int i) {
  int j, k=ArraySize(m);

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

  return(-1);
}

La funzione ArrayDeleteDouble()

Cancella l'elemento dell'array con l'indice dato. Restituisce la dimensione del nuovo array o -1, se non è stato possibile cancellare nulla. La funzione ArrayDeleteDouble() accetta i seguenti parametri obbligatori:

  • m - Matrice di elementi di tipo doppio.
  • i - Indice dell'elemento della matrice.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteDouble(double& m[], int i) {
  int j, k=ArraySize(m);

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

  return(-1);
}

La funzione ArrayDeleteString()

Esegue la cancellazione di un elemento dell'array con l'indice dato. Restituisce la dimensione del nuovo array o -1 se non è stato possibile rimuovere nulla. La funzione ArrayDeleteString() accetta i seguenti parametri obbligatori:

  • m - Matrice di elementi di tipo stringa.
  • i - Indice degli elementi dell'array. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет удаление элемента массива с заданным индексом.       |
//|             Возвращает размер нового массива или -1,                       |
//|             если не удалось ничего удалить.                                |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов                                                    |
//|    i - индекс элемента                                                     |
//+----------------------------------------------------------------------------+
int ArrayDeleteString(string& m[], int i) {
  int j, k=ArraySize(m);

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

  return(-1);
}

La funzione ArrayInsertDouble()

Inserisce un elemento dell'array con l'indice specificato. Restituisce il numero di elementi (dimensione) della nuova matrice. L'inserimento viene eseguito come segue. In primo luogo, la dimensione dell'array viene aumentata di uno. Poi tutti gli elementi che hanno un indice maggiore o uguale a quello da inserire vengono spostati alla fine dell'array uno per uno, facendo spazio a quello da inserire. Infine, il valore viene scritto nella cella richiesta. La funzione ArrayInsertDouble() prende i seguenti parametri:

  • m - Una matrice di elementi di tipo doppio.
  • e - Valore dell'elemento dell'array da inserire.
  • i - Indice dell'elemento dell'array da inserire. Se il valore dell'indice è minore di zero o maggiore o uguale alla dimensione dell'array, l'elemento verrà aggiunto alla fine dell'array. Il valore predefinito è -1. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 31.10.2008                                                     |
//|  Описание : Выполняет вставку элемента массива с заданным индексом.        |
//|             Возвращает размер нового массива.                              |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - массив элементов типа double                                        |
//|    e - значение элемента                                                   |
//|    i - индекс элемента                  (-1 - добавить в конец массива)    |
//+----------------------------------------------------------------------------+
int ArrayInsertDouble(double& m[], double e, int i=-1) {
  int j, k=ArraySize(m);

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

  return(k+1);
}

La funzione BubbleSort2().

Questa funzione bolla gli elementi di una matrice bidimensionale in una colonna arbitraria. Potete anche specificare la direzione di ordinamento. La funzione BubbleSort2() prende i seguenti parametri:

  • a - Matrice bidimensionale di elementi. Parametro obbligatorio.
  • r - Numero (indice) della colonna di ordinamento (colonna). Il valore predefinito è 0 - la prima colonna (colonna con indice zero).
  • m - Direzione di ordinamento. Valori validi: MODE_ASCEND - ordine ascendente, MODE_DESCEND - ordine discendente. Il valore predefinito è MODE_ASCEND.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 04.11.2008                                                     |
//|  Описание : Выполняет пузырьковую сортировку элементов двумерного массива. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    a - массив элементов                                                    |
//|    r - колонка сортировки          (     0       - первая (с индексом 0))  |
//|    m - направление сортировки      (MODE_ASCEND  - по возрастанию,         |
//|                                     MODE_DESCEND - по убыванию)            |
//+----------------------------------------------------------------------------+
void BubbleSort2(double& a[][], int r=0, int m=MODE_ASCEND) {
  double t;
  int    e, i, j;
  int    k=ArrayRange(a, 1);      // Количество колонок
  int    n=ArrayRange(a, 0);      // Количество строк

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

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

La funzione GetTypeLastDeleted().

Questa funzione restituisce il tipo dell' ultimo ordine cancellato, o -1. Ci sono situazioni in cui abbiamo bisogno di legare la logica dell'operazione EA al tipo dell'ordine appena cancellato. Per esempio, se avete appena cancellato BuyStop, dovreste fare quello, ma se BuyLimit, dovreste fare qualcos'altro, ecc. La funzione GetTypeLastDeleted() accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento. "" - qualsiasi carattere, NULL - carattere corrente. Il valore predefinito è "".
  • mn - identificatore dell'ordine dell'utente (MagicNumber). Valore predefinito -1 - qualsiasi magia.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 13.10.2008                                                     |
//|  Описание : Возвращает тип последнего удалённого ордера или -1             |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
int GetTypeLastDeleted(string sy="", int mn=-1) {
  datetime t;
  int      i, k=OrdersHistoryTotal(), r=-1;

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

La funzione iBarLargest().

Questa funzione restituisce l'indice della barra più grande o -1. La dimensione della barra è misurata dalla funzione in uno dei due modi, determinata dal parametro di input ty - tipo di elementi di ricerca. O solo le dimensioni del corpo o insieme alle ombre. La funzione iBarLargest() accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento. "" o NULL - il simbolo corrente. Il valore predefinito è "".
  • tf - Timeframe. Il valore predefinito è 0 - l'intervallo di tempo corrente.
  • ty - Tipo di elementi di ricerca. Valori validi - 0 - High-Low, 1 - abs(Open-Close).
  • co - Numero di elementi della serie temporale. Valore predefinito - 0 - tutti gli elementi.
  • in - Indice della barra iniziale. Valore predefinito - 0 - barra attuale.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.03.2008                                                     |
//|  Описание : Возвращает индекс наибольшего бара или -1.                     |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (NULL или "" - текущий символ)          |
//|    tf - таймфрейм                  (          0 - текущий таймфрейм)       |
//|    ty - тип элементов поиска       (          0 - H-L, 1 - O-C)            |
//|    co - число элементов таймсерии  (          0 - все элементы)            |
//|    in - индекс начального бара     (          0 - текущий бар)             |
//+----------------------------------------------------------------------------+
int iBarLargest(string sy="", int tf=0, int ty=0, int co=0, int in=0) {
  if (sy=="" || sy=="0") sy=Symbol();
  if (tf<=0) tf=Period();
  if (in< 0) in=0;
  if (co<=0) co=iBars(sy, tf)-in;

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

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

  return(nb);
}

La funzione iBarOfDayCalc().

Questa funzione restituisce il numero calcolato della barra dall'inizio del giorno. Le barre sono numerate a partire da uno, cioè la barra con il tempo di apertura più breve in un dato giorno sarà la numero uno, la barra successiva sarà la numero due, ecc. Questa funzione è utile per ottimizzare i tempi di entrata/uscita. Se qualcuno è interessato ai dettagli, faccia domande. Farò del mio meglio per rispondere. La funzione iBarOfDayCalc() accetta i seguenti parametri opzionali:

  • tf - Timeframe. Il valore predefinito è 0 - l'intervallo di tempo corrente.
  • dt - Data e ora di apertura della barra. Valore predefinito - 0 - ora corrente. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Funzione iBarOfDayReal().

Questa funzione restituisce il numero di barra attuale dall'inizio del giorno. Le barre sono numerate con uno, cioè la barra con il tempo di apertura più breve in un dato giorno avrà il numero uno, la barra successiva avrà il numero due, ecc. Non ho ancora trovato un uso pratico per questa funzione. Ma l'ho scritto per averlo :-) insieme alla funzione iBarOfDayCalc(). La funzione iBarOfDayReal() accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento di trading. NULL o "" - simbolo corrente. Il valore predefinito è "".
  • tf - Timeframe. Valore predefinito - 0 - l'intervallo di tempo corrente.
  • dt - Data e ora di apertura della barra. Valore predefinito - 0 - ora corrente. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Funzione NameDayOfWeek()

Restituisce il nome del giorno della settimana per il numero passato come parametro:

  • ndw - Numero del giorno della settimana. Parametro richiesto.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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("Суббота");
}

Funzione NormalizeLot().

Questa funzione restituisce il valore normalizzato del lotto che si sta negoziando. Oltre alla normalizzazione, inserisce la dimensione del lotto nei limiti stabiliti dal centro dealing (vengono controllati i valori minimi e massimi del lotto e il passo di cambio del lotto). La funzione NormalizeLot() accetta i seguenti parametri:

  • lo - Valore di NormalizeLot. Parametro richiesto.
  • ro - Metodo di arrotondamento. Falso - al lato minore, Vero - al lato maggiore. Valore predefinito - Falso - al lato inferiore.
  • sy - Nome dello strumento commerciale. NULL o "" - simbolo corrente. Valore predefinito - "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Funzione NormalizePrice().

Questa funzione restituisce il valore del prezzo normalizzato. La normalizzazione viene eseguita applicando i valori della funzione MarketInfo(MODE_TICKSIZE || MODE_DIGITS). La funzione NormalizePrice() prende i seguenti parametri:

  • np - Valore del lotto normalizzato. Parametro richiesto.
  • sy - Nome dello strumento commerciale. NULL o "" - simbolo corrente. Il valore predefinito è "".
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 21.08.2008                                                     |
//|  Описание : Возвращает нормализованное под размер тика значение цены.      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    np - нормализуемое значение цены.                                       |
//|    sy - наименование инструмента        ("" или NULL - текущий символ)     |
//+----------------------------------------------------------------------------+
double NormalizePrice(double np, string sy="") {
  if (sy=="" || sy=="0") sy=Symbol();
  double pp, ts=MarketInfo(Symbol(), MODE_TICKSIZE);
  int    di=MarketInfo(Symbol(), MODE_DIGITS);

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

La funzione WeekOfMonth().

Questa funzione restituisce la settimana del mese per data. Accetta solo un parametro opzionale:

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

Funzione ClosePosBySortLots().

Questa funzione chiude le posizioni nell'ordine di ordinamento per dimensione del lotto. Cioè, usando questa funzione, potete chiudere le posizioni in ordine crescente o decrescente di dimensioni del lotto. La funzione ClosePosBySortLots() accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento di trading. "" - qualsiasi strumento, NULL - strumento corrente. Valore predefinito - "".
  • op - Tipo di operazione commerciale. Valori validi -1 - qualsiasi posizione, OP_BUY - comprare, OP_SELL - vendere. Il valore predefinito è -1.
  • mn - MagicNumber, identificatore unico di un'operazione commerciale. Valore predefinito -1 - qualsiasi MagicNumber.
  • sd - Direzione di ordinamento delle dimensioni del lotto. Valori validi MODE_ASCEND - ascendente, MODE_DESCEND - discendente. Il valore predefinito è MODE_DESCEND. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.12.2008                                                     |
//|  Описание : Закрытие позиций в порядке сортировки по размерам лотов.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента        (    ""       - любой символ,      |
//|                                             NULL      - текущий символ)    |
//|    op - операция                        (    -1       - любая позиция)     |
//|    mn - MagicNumber                     (    -1       - любой магик)       |
//|    sd - Направление сортировки лотов    (MODE_ASCEND  - возрастание,       |
//|                                          MODE_DESCEND - убывание)          |
//+----------------------------------------------------------------------------+
void ClosePosBySortLots(string sy="", int op=-1, int mn=-1, int sd=MODE_DESCEND) {
  double a[][2];                  // Массив лотов и тикетов
  int    i, k=OrdersTotal();      // Счётчик и количество ордеров
  int    p=0;                     // Количество позиций

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

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

La funzione AddLeadingZero().

Questa funzione aggiunge tanti zeri iniziali (a sinistra) "0" alla stringa in modo che la lunghezza della stringa diventi uguale a un dato valore. La funzione AddLeadingZero() prende i seguenti parametri obbligatori:

  • s - La stringa a cui devono essere aggiunti gli zeri iniziali.
  • k - La lunghezza della stringa risultante 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);
}

Funzione toTime().

Questa funzione converte due/tre interi in una stringa nel formato tempo. Se si passano due numeri nella funzione, il primo sarà usato come ore e il secondo come minuti. La stringa di formato restituita sarà "HH:MM". Se ci sono tre numeri, il terzo sarà sostituito dai secondi e la funzione restituirà la stringa "HH:MM:SS". La funzione toTime() accetta i seguenti parametri opzionali:

  • h - Orologio. Il valore predefinito è 0.
  • m - Verbale. Il valore predefinito è 0.
  • s - Secondi. 0 - Non usare. Valore predefinito 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);
}
123456789101112
Nuovo commento