Solo "Caratteristiche utili di KimIV". - pagina 7

Nuovo commento
 

Funzione CorrectTF().

Ho scritto questa funzione dopo aver scoperto che a volte posso facilmente specificare un timeframe errato, che è uguale a un numero intero di minuti, nei parametri di input di un indicatore o di un EA. Per esempio, ho inserito 50 per l'ora invece di 60. Bene... un po' mancato. Risulta che la funzione iRSI() restituisce zero per un timeframe errato. Non posso dire nulla sulle altre funzioni, perché non le ho controllate. Per evitare malintesi derivanti dai miei errori di disattenzione, ho scritto questa funzione come una primitiva infallibile. Regola il parametro di input all'intervallo di tempo appropriato più vicino e restituisce il suo valore.

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

Funzione DateBeginQuarter().

Questa funzione restituisce la data di inizio del trimestre per il suo numero. Per esempio, se ora è il 27.08.2008, allora la data di inizio del trimestre corrente sarà il 01.07.2008. La funzione prende solo un parametro - il numero del trimestre relativo al trimestre corrente. Per esempio, 0 è il trimestre corrente, 1 è il trimestre successivo e -1 è il trimestre precedente. Cioè, i numeri positivi dei quarti richiederanno date dal futuro, mentre zero e negativi richiederanno date dal passato. Il valore restituito è il numero di secondi trascorsi dalle 00:00 del 1° gennaio 1970.

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

La funzione DateOfMonday().

Questa funzione restituisce la data di inizio della settimana (lunedì) tramite il suo numero. Per esempio, se ora è il 29.08.2008, la data di inizio della settimana corrente sarà il 25.08.2008. La funzione prende solo un parametro - il numero di settimana relativo alla settimana corrente. Per esempio, 0 è la settimana corrente, 1 è la settimana successiva e -1 è la settimana precedente. Cioè, i numeri positivi della settimana richiederanno date dal futuro, mentre i numeri zero e negativi richiederanno date dal passato. Il valore di ritorno è il numero di secondi trascorsi dalle 00:00 del 1° gennaio 1970.

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

La funzione Fibonacci().

Questa funzione restituisce un elemento della serie di Fibonacci per il suo numero di sequenza.

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

Funzione GetNameMA().

Questa funzione restituisce il nome del metodo MA(Moving Averages) tramite il suo identificatore. Questa funzione è comoda da usare nei commenti, indicatori e messaggi di Expert Advisors.

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

Funzione GetPriceDiffInPoint().

Questa funzione restituisce la differenza di prezzo tra due barre, che sono specificate dai loro numeri. Lo scopo di sviluppare questa funzione era quello di determinare il valore e la direzione del movimento del prezzo. La funzione GetPriceDiffInPoint() determina i punti di riferimento (Open o High o Low o Close) delle barre da prendere in considerazione. La funzione accetta i seguenti parametri opzionali:

  • sy - Nome dello strumento. "" o NULL - simbolo corrente. Il valore predefinito è NULL.
  • tf - Timeframe. Valore predefinito 0 - simbolo corrente.
  • n2 - Numero della barra di sinistra. Valore predefinito - 2.
  • n1 - Numero della barra di destra. Valore predefinito - 1.

Valore restituito:

  • positivo - c'è stato un aumento del tasso tra le barre N2 e N1.
  • negativo - c'è stato un deprezzamento tra le barre N2 e 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);
}

La funzione GetTypePrice()

Restituisce il nome del tipo di prezzo. La funzione prende solo un parametro opzionale. Valori validi: PRICE_CLOSE, PRICE_OPEN, PRICE_HIGH, PRICE_LOW, PRICE_MEDIAN, PRICE_TYPICAL, PRICE_WEIGHTED. Il valore predefinito è 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");
  }
}
 

La funzione ArrayLR().

Questa funzione genera un array di valori di regressione lineare. La funzione accetta i seguenti parametri obbligatori:

  • x è un array di valori di serie numeriche. Questo è il parametro di ingresso. Questo array deve contenere i valori prima che la funzione venga chiamata.
  • y è una matrice di valori di regressione lineare. Questo è il parametro di uscita, cioè l'array sarà riempito dopo la chiamata della funzione.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

Funzione ArrayMo().

Restituisce Modu - il massimo della curva di densità della distribuzione. La funzione accetta i seguenti parametri opzionali:

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

Funzione ExistOrdersByPrice().

Restituisce un flag per l'esistenza di un ordine al prezzo impostato dato. True - l'ordine esiste (impostato), False - l'ordine non esiste (non impostato). Puoi limitare la lista degli ordini da controllare usando i parametri della funzione:

  • sy - Nome dello strumento di mercato. Se questo parametro è dato, la funzione controllerà solo gli ordini dello strumento specificato. NULL significa lo strumento corrente, e "" (di default) significa qualsiasi strumento.
  • op - Tipo di commercio, tipo di ordine pendente. Valori validi: OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP o -1. Il valore predefinito di -1 indica qualsiasi tipo di ordine.
  • mn - Identificatore dell'ordine (MagicNumber). Il valore predefinito di -1 significa qualsiasi MagicNumber.
  • pp - Il livello di prezzo a cui è impostato l'ordine. Il valore predefinito è -1 - qualsiasi prezzo.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}

La funzione ClosePosBySelect() per il tester.

Esegue la chiusura di una singola posizione preselezionata. Questa è una versione semplificata della funzione con lo stesso nome che è stata precedentemente descritta a pagina 13. Niente di superfluo. Nessuna caratteristica extra. Nella mia pratica, non ho mai avuto una posizione che non fosse chiusa nel tester. Ecco perché non ci sono controlli in questa funzione. Non sono necessari nel tester.

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

La funzione CountOrders() per il tester.

Nelle mie versioni di prova (destinate esclusivamente all'uso nel tester di MT4), la funzione CountOrders() sostituisce le seguenti funzioni: ExistOrders(), ExistPositions(), NumberOfOrders() e NumberOfPositions(). Quindi, può dare informazioni sull'esistenza di qualsiasi posizione o ordine e la quantità di operazioni di ogni tipo. Un tale scambio ha i suoi vantaggi, che si esprime in un riferimento unico alla base di ordini per un tick e ottenendo tutte le informazioni necessarie in una sola volta. E le funzioni di cui sopra, specialmente se usate insieme, ognuna di esse lavora con una e la stessa base d'ordine in modo indipendente, quindi fanno ripetutamente le stesse chiamate. Di conseguenza, la funzione CountOrders() può ridurre il tempo di un passaggio di diversi secondi, il che permette di risparmiare ore di ottimizzazione.

La funzione CountOrders() prende i seguenti parametri:

  • mo - Array del numero di ordini per tipo. Dopo l'esecuzione della funzione, l'array avrà 6 (sei) elementi. Elemento zero - numero di compravendite di tipo Buy, primo elemento - numero di ordini Sell, secondo elemento - BuyLimit, terzo elemento - SellLimit, quarto elemento - BuyStop, quinto elemento - SellStop.
  • mn - Identificatore di una posizione o di ordini (MagicNumber). Il valore predefinito è -1 - qualsiasi 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()]++;
    }
  }
}

La funzione ModifyOrder() per il tester.

Questa è una versione leggera della funzione ModifyOrder(), pubblicata a pagina 7, ed è destinata a cambiare i livelli assoluti di prezzo di un ordine o posizione preselezionata.

La funzione ModifyOrder() accetta i seguenti parametri:

  • pp - Prezzo di impostazione dell'ordine. Se si passa un valore inferiore o uguale a zero, la modifica di questo livello di prezzo non sarà eseguita. Il valore predefinito è -1.
  • sl - Livello di prezzo di stop. Se si passa un valore inferiore a zero, la modifica del livello dei prezzi non verrà eseguita. Il valore predefinito è 0.
  • tp - Prendi il livello dei prezzi. Se si passa un valore inferiore a 0, la modifica del livello di prezzo non sarà implementata. Il valore predefinito è 0.
  • ex - Data di scadenza dell'ordine in sospeso. Il valore predefinito è 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);
    }
  }
}
 

La funzione IIFc().

Una funzione molto utile in termini di costruzione di forchette. Se è così, questo colore. E se non lo è, allora un altro colore. La funzione IIFc() prende tre parametri obbligatori:

  • condizione - Un'espressione logica. Può essere vero o falso.
  • ifTrue - Il colore che sarà restituito da IIFc() se l'espressione di condizione è vera.
  • ifFalse - Il colore che sarà restituito da IIFc() se la condizione è falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 18.07.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Funzione IIFd().

Convenienza simile per i numeri reali. Se è così, è un numero reale. Se non lo è, è un numero diverso. La funzione IIFd() prende tre parametri obbligatori:

  • condizione - Un'espressione logica. Può essere vero o falso.
  • ifTrue - Il numero reale che sarà restituito da IIFd() se l'espressione di condizione è vera.
  • ifFalse - Un numero reale che sarà restituito da IIFd() se la condizione è falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
double IIFd(bool condition, double ifTrue, double ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

La funzione IIFi().

Convenienza simile per gli interi. Se è così, è un intero. E se non lo è, allora un altro numero. La funzione IIFi() prende tre parametri obbligatori:

  • condizione - Un'espressione logica. Può essere vero o falso.
  • ifTrue - Un numero intero che sarà restituito da IIFi() se l'espressione di condizione è vera.
  • ifFalse - Un intero che sarà restituito da IIFi() se la condizione è falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
int IIFi(bool condition, int ifTrue, int ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

Funzione IIFis().

Una comodità simile per le stringhe. Se è così, una tale stringa. E se no, un'altra stringa. La funzione IIFs() prende tre parametri obbligatori:

  • condizione - Un'espressione logica. Può essere vero o falso.
  • ifTrue - La stringa che sarà restituita dalla funzione IIFs(), se l'espressione di condizione è vera.
  • ifFalse - La stringa che sarà restituita da IIFs( ), se la condizione è falsa. 
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
string IIFs(bool condition, string ifTrue, string ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}
 

La funzione ExistInHistoryCloseBetween().

Restituisce un flag per l'esistenza nella storia di una posizione o di un ordine chiuso (cancellato) tra le date. La funzione ExistInHistoryCloseBetween() accetta i seguenti parametri:

  • sy - Nome dello strumento di mercato. "" - qualsiasi simbolo, NULL - simbolo corrente. Il valore predefinito è "".
  • op - operazione commerciale. Valori validi: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valore predefinito -1 - qualsiasi operazione.
  • mn - Identificatore commerciale, MagicNumber. Valore predefinito -1 - qualsiasi numero magico.
  • d1 - Tempo di chiusura della posizione (in attesa di cancellazione dell'ordine). Il valore predefinito è 0 - qualsiasi orario di chiusura (cancellare). Il tempo d1 deve essere più breve di d2.
  • d2 - Tempo di chiusura della posizione (in attesa di cancellazione dell'ordine). Valore predefinito - 0 - qualsiasi tempo di chiusura (cancellazione). Il tempo d2 deve essere più lungo del tempo 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);
}

Funzione ExistInHistoryOpenBetween().

Restituisce il flag di esistenza nella storia di una posizione o di un ordine aperto (impostato) tra le date. La funzione ExistInHistoryOpenBetween() riceve i seguenti parametri:

  • sy - Nome dello strumento. "" - qualsiasi carattere, NULL - il simbolo corrente. Il valore predefinito è "".
  • op - operazione commerciale. Valori validi: -1, OP_BUY, OP_SELL, OP_BUYLIMIT, OP_BUYSTOP, OP_SELLLIMIT, OP_SELLSTOP. Valore predefinito -1 - qualsiasi operazione.
  • mn - Identificatore delle operazioni commerciali, MagicNumber. Valore predefinito -1 - qualsiasi numero magico.
  • d1 - Tempo di apertura della posizione(in attesa dell'ordine). Il valore predefinito è 0 - qualsiasi tempo di apertura (impostazione). Il tempo d1 dovrebbe essere inferiore al tempo d2.
  • d2 - Ora di apertura della posizione (in attesa dell'ordine). Il valore predefinito è 0 - qualsiasi tempo aperto (impostato). Il tempo d2 deve essere più lungo del tempo 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);
}
 

Funzione ExistInHistoryToDay().

Restituisce il flag di esistenza nella storia di una posizione o di un ordine aperto (impostato) oggi. La funzione ExistInHistoryToDay() riceve i seguenti parametri:

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

Funzione TakeProfitLastPos().

Questa funzione restituisce il livello di prezzo di TakeProfit dell'ultima posizione aperta o -1. La funzione TakeProfitLastPos() 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                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 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);
}
123456789101112
Nuovo commento
Motivazione: