Funciones útiles de KimIV - página 47

Nuevo comentario
 

Para mí es lo mismo si lo llamas así.

  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]);
  }

Es cierto que los puntos de ambas variantes no se superponen exactamente. Pero lo más probable es que esto sea una peculiaridad de SetArrow()

Aquí hay una foto

 
Prival писал (а) >>
Es cierto que los puntos de ambas variantes no se superponen exactamente. Pero lo más probable es que esto sea una característica de SetArrow()

No, esta es una característica del objeto gráfico OBJ_ARROW. No está anclado por el centro de masa, sino por el centro del límite superior.

 

La función ArrayMo().

Devuelve Modu - el máximo de la curva de densidad de la distribución. La función acepta los siguientes parámetros opcionales:

  • x - Matriz de valores de la serie numérica.
  • d - La precisión de los valores de la serie numérica, el número de decimales.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

Ejemplo de uso de la función ArrayMo().

Determina el nivel de precios más alto que se ha producido con mayor frecuencia entre las últimas 1000 barras del gráfico actual:

#define R 1000
void start() {
  double a[R];
  for (int i=0; i<R; i++) a[i]=High[i];
  Message(ArrayMo(a, 4));
}
SZY. Se adjunta un script para probar la función ArrayMo().
Archivos adjuntos:
test_arraymo.mq4  5 kb
 

La biblioteca de funciones b-Array ha sido publicada en su totalidad y está diseñada para trabajar con arrays.

 

Hay otro, el cálculo de la 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);

corregido.

 
Prival писал (а) >>

Hay otro, el cálculo de la covarianza

añadirlo a la biblioteca. Aunque hay muchas más definiciones de arrays (matrices). Pero creo que lo llenaremos poco a poco.

Hay un par de preguntas:

1. ¿qué es mo_XY?

2. En la línea de acumulación de MOs por X

mo_X +=X[i]-X[0];
¿Por qué quitar X[0]?
 3. ¿Por qué hay que pedir el conjunto X?
 

1. mo_XY puede ser eliminado, comprobado diferentes opciones de cálculo. Esto es lo que queda de la mala variante.

2. Este algoritmo que he citado tiene mínimas posibilidades de obtener error en los cálculos si Time[] entra como X. La multiplicación de números grandes provoca gradualmente la acumulación de errores y éstos aparecerán. Exactamente para este propósito, la eliminación de la posible aparición de este error, X es (adicionalmente) desplazado al origen restando X[0]

3. Estaba pensando demasiado, tal vez estoy fuera de lugar. Lo principal es que los valores escritos en X corresponden a Y

Lo corregiré ahora.

 
mo_X += X[0]; // Olvidado probablemente .
Esta es una operación innecesaria. Puedes comprobarlo dos veces.
 
TheXpert писал (а) >>

No estoy de acuerdo.

Es una buena regla para desconfiar. Compruébalo en cualquier paquete de matemáticas. Publicaremos los resultados. Lo haré en MathCade ahora mismo.

1...404142434445464748495051525354...128
Nuevo comentario