Caratteristiche utili da KimIV - pagina 47

Nuovo commento
 

Per me è lo stesso se lo chiami così.

  for (int i=0; i<r; i++)  {
    Y[i]=Close[i+1];
    X[i]=i;
  }
    
  Array_LR(X, Y);
  for (i=0; i<r; i++) {
    SetArrow(170, Blue, "arr"+i+r, Time[i+1], Y[i]);
  }

È vero, i punti in entrambe le varianti non si sovrappongono esattamente. Ma questa è molto probabilmente una peculiarità di SetArrow()

Ecco una foto

 
Prival писал (а) >>
È vero, i punti delle due varianti non si sovrappongono esattamente. Ma questa è molto probabilmente una caratteristica di SetArrow()

No, questa è una caratteristica dell'oggetto grafico OBJ_ARROW. Non è ancorato al centro di massa, ma al centro del confine superiore.

 

La funzione ArrayMo().

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

  • x - Matrice di valori numerici della serie.
  • d - La precisione dei valori delle serie numeriche, il numero di cifre decimali.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Esempio di utilizzo della funzione ArrayMo().

Determina il livello di prezzo alto più frequente tra le ultime 1000 barre circa del grafico corrente:

#define R 1000
void start() {
  double a[R];
  for (int i=0; i<R; i++) a[i]=High[i];
  Message(ArrayMo(a, 4));
}
SZY. In allegato c'è uno script per testare la funzione ArrayMo().
File:
test_arraymo.mq4  5 kb
 

La libreria di funzioni b-Array è stata pubblicata per intero ed è progettata per lavorare con gli array.

 

Ce n'è un altro, il calcolo della covarianza

//+----------------------------------------------------------------------------+
//|  Автор    : Сергей Привалов aka Prival,  Skype: privalov-sv                |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.09.2008                                                     |
//|  Описание : Рассчет ковариации массива cvar(X,Y)                           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    X    - массив значений числового ряда, ось X                            |
//|    Y    - массив значений числового ряда, ось Y                            |
//+----------------------------------------------------------------------------+

double cvar(double &X[], double &Y[])
{
      double mo_X = 0, mo_Y = 0, res = 0;
      int    i,N=ArraySize(X);
     
      if(N>1 && ArraySize(Y)==N)  {
        for( i = 0; i < N; i ++ ) {
            mo_X +=X[i]-X[0];
          mo_Y +=Y[i];
      }
      mo_X /=N;
      mo_Y /=N;
      for( i = 0; i < N; i ++ ) res +=(X[i]-mo_X)*(Y[i]-mo_Y);
      res /=N;
    } else Print("cvar(): Недостаточное количество элементов ряда! N=", N, " или не совпадает размерность");
   return(res);

corretto.

 
Prival писал (а) >>

Ce n'è un altro, il calcolo della covarianza

aggiungerlo alla libreria. Anche se ci sono molte più definizioni di array (matrici). Ma penso che lo riempiremo gradualmente.

Ci sono un paio di domande:

1. cos'è mo_XY?

2. Nella linea di accumulo di MO da parte di X

mo_X +=X[i]-X[0];
Perché togliere X[0]?
 3. Perché si dovrebbe ordinare la matrice X?
 

1. mo_XY può essere rimosso, controllato diverse opzioni di calcolo. Questo è un residuo di una cattiva variante.

2. Questo algoritmo che ho citato ha possibilità minime di ottenere errori nei calcoli se Time[] entra come X. La moltiplicazione di grandi numeri provoca gradualmente l'accumulo di un errore e questo apparirà. Esattamente a questo scopo, eliminando la possibile comparsa di questo errore, X viene (inoltre) spostato verso l'origine sottraendo X[0]

3. Ho pensato troppo, forse sono fuori luogo. La cosa principale è che i valori digitati in X corrispondono a Y

Lo correggerò ora.

 
mo_X += X[0]; // Dimenticato probabilmente .
Questa è un'operazione inutile. Puoi ricontrollare.
 
TheXpert писал (а) >>

Non sono d'accordo.

È una buona regola per diffidare. Controllate in qualsiasi pacchetto di matematica. Pubblicheremo i risultati. Lo faccio subito in MathCade.

1...404142434445464748495051525354...128
Nuovo commento