Funciones útiles de KimIV - página 46

 
SK. писал (а) >>

Eso es lo que quiero decir. Hay que tener en cuenta las limitaciones existentes, que, por lo general, cambian constantemente.

¿Existe alguna función que analice todas las restricciones posibles?

Lo mismo para las modificaciones.

--

(Tengo 16 funciones - 3 para cada orden buena (OP,SL,TP) y 2 para cada orden de mercado (SL,TP),

y luego algunas funciones más que analizan las combinaciones de permisos).

sí, también tengo una función separada para establecer un orden comprobando todas las posibles limitaciones y otra (parcialmente similar a la primera) para las modificaciones. no voy a dar el código - hay tantas cosas "dejadas" allí que sólo yo necesito, que - ouch. :-) pero en general - es difícil sin ella en el comercio real Asesores Expertos. :-)

 
Shu писал (а) >>

Sí, también tengo una función separada para establecer un orden, que comprueba todas las posibles limitaciones y otra (parcialmente similar a la primera) para la modificación. No te daré el código - hay tantos trucos "de izquierda", que sólo yo necesito, que - ouch. :-) pero en general - es difícil sin ella en el comercio real Asesores Expertos. :-)

En realidad, quería comprobar yo mismo si he tenido en cuenta todo. Si no los compruebas, puedes encontrarte con una serie de rebotes (a veces con la posibilidad de ser baneado).

Voy a enumerar brevemente mis comprobaciones.

1) StopLevel. Por ejemplo, al modificar el SL BuyStop.

No sólo comprueba la distancia. Debe analizar la posición actual de StopLevel y la dirección del movimiento de la orden de stop.

Si SL está fuera del corredor de StopLevel, puede acercarse o moverse indefinidamente.

Si el SL está dentro del corredor, se rechaza el movimiento ascendente. Se acepta el movimiento hacia abajo, pero teniendo en cuenta el StopLevel: si la distancia de modificación dentro del corredor de distancia se establece en 3 p, y el corredor es de 30 p, entonces el valor real aceptado para la ejecución está definido por el límite del corredor StopLevel.

2) FreezeLevel.

3. relación entre StopLevel y TICKSIZE. La orden puede estar fuera de todos los corredores, pero no es múltiple de TICKSIZE - entonces es un problema. Tiene que ser redondeado hacia la dirección de la modificación. Crítico para la "no-divisa".

4. Lotes. Minlote +/- minlote. Hay que tener en cuenta que los cierres parciales y de ventanilla se limitan también a los minlots (aunque en mi opinión es ilógico, pero es así).

Después de los cheques personales, la orden se emite si cada cheque terminó positivamente (sin prohibición).

 

Bibliotecas de funciones totalmente publicadas:

b-Graphics.rar - trabajar con objetos gráficos.

b-Indicadores.rar - trabajar con indicadores.

 

La función ArrayLR().

Esta función genera una matriz de valores de regresión lineal. La función acepta los siguientes parámetros obligatorios:

  • x es un array de valores de series numéricas. Este es el parámetro de entrada. Este array debe contener los valores antes de llamar a la función.
  • y es una matriz de valores de regresión lineal. Este es el parámetro de salida, es decir, el array se llenará después de la ejecución de la función.
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. 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);
}
 

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

Marquemos los niveles de precios de la regresión lineal para las 30 barras anteriores.

#define r 30
double x[r], y[];
for (int i=0; i<r; i++) x[i]=Close[i+1];
ArrayLR(x, y);
for (i=0; i<r; i++) SetArrow(170, Red, "arr"+i, Time[i+1], y[i]);

P.D. Se adjunta un script para probar la función ArrayLR().

Archivos adjuntos:
 
KimIV писал (а) >>

Bibliotecas de funciones totalmente publicadas:

b-Graphics.rar - trabajar con objetos gráficos.

b-Indicadores.rar - trabajar con indicadores.

¡Muy bien! >> Gracias.

 
Parabellum писал (а) >>

Igor, hay un buen indicador que puede combinar varias velas en una. Pero sólo funciona en el gráfico horario. ¿Es posible hacerla universal?

Gracias.

?

 
Parabellum писал (а) >>

?

ooh... Lo siento...

Tal indicador ya ha sido escrito, no recuerdo por quién y no recuerdo dónde lo vi... Pensé que lo encontrarías tú mismo o que alguien te daría el enlace...

 

La función ArrayLR() no funciona con precisión.

1. No tiene en cuenta la ubicación temporal de las barras. Funciona incorrectamente cuando faltan barras.

2. el algoritmo utilizado para calcular los coeficientes tiene un inconveniente en forma de acumulación de errores de redondeo, véase "Ayúdame a escribir una regresión lineal" (la parte inferior de la página de Rosh confirma este escollo).

3. Propongo un algoritmo sin estos inconvenientes.

4. Si se sustituye X[i]=Time[i+1]; por X[i]=i+1; el algoritmo es similar, pero sin acumulación de errores.

5. Los bares se saltan no sólo los fines de semana :-((

Esta es mi variante

//+----------------------------------------------------------------------------+
//|  Автор    : Сергей Привалов aka Prival,  Skype: privalov-sv                |
//+----------------------------------------------------------------------------+
//|  Версия   : 10.09.2008                                                     |
//|  Описание : Формирует массив значений линейной регрессии y(x)=A*x+B.       |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    X    - массив значений числового ряда, ось X                            |
//|    Y    - массив значений числового ряда, ось Y                            |
//+----------------------------------------------------------------------------+

void Array_LR(double &X[], double& Y[])
{
      double mo_X = 0, mo_Y = 0, var_0 = 0, var_1 = 0;
      int    i,N=ArraySize(X);
      double A,B;
     
      if(N>1)  {
         for ( i = 0; i < N; i ++ ) {
            mo_X +=X[i];
          mo_Y +=Y[i];
      }
      mo_X /=N;
      mo_Y /=N;
        
      for ( i = 0; i < N; i ++ )   {
         var_0 +=(X[i]-mo_X)*(Y[i]-mo_Y);
         var_1 +=(X[i]-mo_X)*(X[i]-mo_X);
      }
      // значение коэффициента A
      if(var_1!=0)   A = var_0 / var_1; else A=0;
      // значение коэффициента B
      B = mo_Y - A * mo_X;
      ArrayResize(Y, N);
     for (i=0; i<N; i++) Y[i]=A*X[i]+B;
    } else Print("ArrayLR(): Недостаточное количество элементов ряда! n=", N);
    
}

aquí hay una foto

Ejemplo de trabajo

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

Se adjunta el script de comprobación

Archivos adjuntos:
 
Prival писал (а) >>
Esta es mi variante

¡Bien, Sergei! Que haya dos variantes de esta función.

Mi variante es buena porque es idéntica al objeto gráfico incorporado OBJ_REGRESSION. Si alguien necesita tomar precios de este objeto, mi función le ayudará, mientras que la tuya, por desgracia... Pero podría usarse para otra cosa... Gracias.