una estrategia de negociación basada en la teoría de las ondas de Elliott - página 10
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
Y no voy a compartir la SOLUCIÓN HECHA, sino la metodología, por favor, no hay problema.
Buena suerte y felices tendencias.
En general está claro. Todo es como en la tesis. ¡Hay de todo, excepto ese simple esquema, sin el cual nada funcionará ;o)! Y el esquema sólo lo conoce quien lo ha inventado, y todo lo demás, sin él, es sólo papel, que hay mucho por ahí. No obstante, sólo estoy exponiendo un hecho, sin ningún otro significado. De todos modos, todo el mundo tiene que ir en su propia bicicleta. Al fin y al cabo, se trata de FOREX)
Y aquí hay otra pregunta. ¿Todo esto se implementa en qué? ¿En MT4?
Es decir, MT4 tiene el indicador Murray que mencionas. Está claro.
Pero, ¿con qué se calculan los canales y el Hearst? ¿Utilizas también MT4? Una vez mencionaste el tamaño del código de 0,5M. ¿Qué quieres decir con eso? ¿El peso del texto de un programa de cálculo en mql4? Si es así, francamente hablando, me cuesta imaginar tal volumen. Porque, según mi estimación conservadora, el texto de un programa de este tipo debería tener unas 10000 líneas. Una simple estrategia de ruido blanco que utilizo ocupa sólo 1000 líneas, a pesar de que simplemente lanzo 6 hilos de negociación en paralelo que utilizan información de diferentes marcos temporales y es más fácil (más conveniente para la modificación posterior) dejar piezas de dicho código como están ahora que convertirlas en 400-500 líneas utilizando arrays (aunque tales planes también son posibles en el futuro). Es decir, la ejecución de un hilo por un marco de tiempo tomará 400-500 líneas. Estoy usando un Asesor Experto completamente funcional que no necesita ser monitoreado. Por supuesto que no me niego a que siga mejorando, pero hasta ahora ya he optimizado todo lo que se podía optimizar en él en el probador. Pero hay un cierto interés en sus métodos y trataré de aplicar algo, si lo consigo, claro.
PD: Y el hecho de que no utilice un hilo de trading con un lote grande, sino varios hilos paralelos en diferentes timeframes con lotes pequeños se explica únicamente por el hecho de que en este tipo de operaciones aparece algo así como un efecto de filtración de drawdown máximo. Es decir, si tienes varios procesos aleatorios (dinámica de saldos de un hilo), entonces al sumar los saldos en una cuenta, la reducción máxima será igual a la suma de las reducciones de cada hilo dividida por la raíz cuadrada del número de hilos, ¡no la suma de las reducciones de cada uno! Así, intento disminuir la reducción máxima total. Es decir, si tienes 6 hilos, cada uno con una reducción de 50USD en el historial de 1,5 años, lógicamente la reducción total de 6 hilos debería ser de 300USD, pero en la práctica, esta cantidad debería dividirse por la raíz cuadrada de 6 = 2,45. Esto es más o menos lo que muestra el probador. El comprobador muestra que hay que dividir por unos 2,2. Lo que creo que concuerda bien con mi idea de reducir la detracción máxima.
Buena suerte y buenas tendencias.
Siento discrepar con usted. Este hilo se volvió interesante sólo cuando decidiste compartir tus experiencias e ideas.
Como físico, entiendo todo sobre el campo, la potencialidad, etc. Todo está claro con la optimización también - es un problema no trivial e interesante. En cuanto a la estadística matemática, sólo he podido entender de qué se trata en términos generales, por desgracia. Pero el tema es interesante. Especialmente en parte de la estimación a priori de los niveles de significación y la posibilidad de predicción no aleatoria.
Mi enfoque (hasta ahora) se ha centrado en la definición de los periodos de mercado tendencial. No he utilizado el índice Hearst en la forma que se indica en el artículo anterior, ni de ninguna otra manera. Sin embargo, yo también intento basarme en una medida de fractalidad del mercado que tiene mi propio algoritmo de cálculo. La idea de que los periodos de contratendencia pueden utilizarse tan bien como los de tendencia me ha sorprendido por completo. A veces es difícil ver incluso lo que hay debajo. :-)
Así que estaría encantado de continuar el diálogo, si no en este foro, entonces a través de su correo electrónico dado en el indicador de niveles Murray, o en la araña en el mensaje privado.
En cualquier caso, me gustaría decir que su trabajo me ha impresionado. Por primera vez vi el trabajo no del "pensamiento figurativo" de un aficionado (entre los que me incluyo), sino de las matemáticas en manos de un matemático.
Me ha gustado especialmente este:
¡La convergencia de los resultados en diferentes flujos de datos y sin utilizar el suavizado significa que su metodología ha llegado a la naturaleza del proceso !
No hay problema.
¡La convergencia de los resultados en diferentes flujos de datos y sin utilizar el suavizado significa que su metodología ha llegado a la naturaleza del proceso !
Yo lo diría de forma un poco más modesta: significa que los métodos de la matestadística funcionan, sólo hay que aplicarlos correctamente, y que todavía muchos métodos de AT tienen justificación. (es decir, hay zonas de movimiento predeterminado en el mercado). Los métodos cualitativos como Elliott o Gann, aunque, como he escrito - no me gusta mucho Elliott debido a la falta de estimaciones cuantitativas.
De todos modos, buena suerte y buenas tendencias.
Busque la "Enciclopedia de Estrategias de Trading" de McCormick y la "Estadística para Comerciantes" de Bulashev - muy útil en un sentido aplicado - se muestra la lógica de los métodos.
Pruebe la transformación DCT con el núcleo de difracción - suaviza muy bien, no se retrasa en absoluto. En mi opinión, funciona mejor que la LCF tradicional. A continuación se muestran algunos fragmentos de código en C++. La forma de utilizarlo, creo, queda clara en los comentarios.
//*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Прямое дискретное косинус-преобразование (DCT) x[] --> y[] |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // входной массив Входные локальные переменные: int n_bars // полное число баров для DCT-преобразования Выходные локальные переменные: нет Выходные глобальные переменные: double y[] // массив гармоник */ void DCT(int n_bars, double x [], double y []) { int k; // счетчик строк матрицы коэффициентов int n; // счетчик столбцов матрицы коэффициентов double sum; // накопитель double PIN2 = PI / (n_bars * 2.0); double wgt_zero = 1.0 / sqrt(n_bars); // вес при 0-м коэффициенте double wgt_nzero = sqrt(2.0) * wgt_zero; // вес при всех остальных //---- // dct-преобразование for (k = 0; k < n_bars; k++) { // цикл по k sum = 0.0; // обнуляем накопитель for (n = 0; n < n_bars; n++) { sum += x[n] * cos(PIN2 * (2.0 * n + 1.0) * k); } // цикл по n if (k != 0) { y[k] = wgt_nzero * sum; } else { y[k] = wgt_zero * sum; } } // цикл по k //---- return; } // //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Обратное дискретное косинус-преобразование (IDCT) y[] --> x[] |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double y[] // массив гармоник Входные локальные переменные: int n_bars // полное число баров для DCT-преобразования Выходные локальные переменные: нет Выходные глобальные переменные: double x[] // выходной массив */ void IDCT(int n_bars, double x [], double y []) { int k; // счетчик строк матрицы коэффициентов int n; // счетчик столбцов матрицы коэффициентов double sum; // накопитель double PIN2 = PI / (n_bars * 2.0); double wgt_zero = 1.0 / sqrt(n_bars); // вес при 0-м коэффициенте double wgt_nzero = sqrt(2.0) * wgt_zero; // вес при всех остальных //---- // idct-преобразование for (n = 0; n < n_bars; n++) { // цикл по n sum = 0.0; // обнуляем накопитель for (k = 0; k < n_bars; k++) { // цикл по k if (k != 0) { sum += wgt_nzero * y[k] * cos(PIN2 * (2.0 * n + 1.0) * k); } else { sum += wgt_zero * y[k] * cos(PIN2 * (2.0 * n + 1.0) * k); } } // цикл по k x[n] = sum; } // цикл по n //---- return; } // //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Вычисление левой части уравнения y[] --> y[] (диффракционное ядро) |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double y[] // массив гармоник Входные локальные переменные: int n_bars // полное число баров для расчета double eye // размер "окна" double alfa // параметр регуляризации Выходные локальные переменные: нет Выходные глобальные переменные: double y[] // массив значений левой части уравнения */ void GetDiffrLeftSide(int n_bars, double eye, double alfa, double y []) { double kern; // double omega; // double domega; // double omega2; // 1 + omega^2 double delta = 2.0 * PI / (n_bars - 1); int i; //---- for (i = 0; i < n_bars; i++) { omega = i * delta; domega = omega * eye; omega2 = 1.0 + omega * omega; // 1. + omega^2 kern = (sin(domega) + EPS) / (domega + EPS); // sin(arg)/arg y[i] = (kern * y[i]) / (kern * kern + alfa * omega2); } //---- return; } // //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Линейное сглаживание массива x[] по 5 точкам; результат - y[] |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // входной массив - аргумент; Входные локальные переменные: int n_beg // номер начального бара int n_end // номер конечного бара Выходные локальные переменные: нет Выходные глобальные переменные: double y[] // выходной массив - ответ; */ void GetSmooth5(int n_beg, int n_end, double x [], double y []) { int i; //---- y[n_beg] = (3.0 * x[n_beg] + 2.0 * x[n_beg+1] + x[n_beg+2] - x[n_beg+4]) / 5.0; y[n_beg+1] = (4.0 * x[n_beg] + 3.0 * x[n_beg+1] + 2.0 * x[n_beg+2] + x[n_beg+3]) / 10.0; for (i = n_beg + 2; i < n_end - 2; i++) { y[i] = (x[i-2] + x[i-1] + x[i] + x[i+1] + x[i+2]) / 5.0; } y[n_end-2] = (x[n_end-4] + 2.0 * x[n_end-3] + 3.0 * x[n_end-2] + 4.0 * x[n_end-1]) / 10.0; y[n_end-1] = (3.0 * x[n_end-1] + 2.0 * x[n_end-2] + x[n_end-3] - x[n_end-5]) / 5.0; //---- return; } //Y este es el método de aplicación:
// //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Сглаживание методом DCT-преобразования (без запаздывания) |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // несглаженный массив значений аргумента (цена); Входные локальные переменные: int n_bars // полное число баров для преобразования double eye // размер "окна" double alfa // параметр регуляризации Выходные локальные переменные: int nn_tot // число сглаженных баров Выходные глобальные переменные: double x[] // ответ - сглаженный массив значений аргумента; */ MT4_EXPFUNC int __stdcall GetDiffrDCTS (int nn_tot, double eye, double alfa, double x []) { int err_code = 0; // код ошибки int i; // счетчик // // ########################### Error Definitions ########################### // *** Ошибка: если превышено максимальное число баров, выход *** if (nn_tot > NN_MAX) { err_code = -1; return(err_code); } // *** Ошибка: для преобразования задано слишком мало баров, выход *** if (nn_tot < NN_MIN) { err_code = -2; return(err_code); } // *** Ошибка: параметр alfa = 0 при eye <> 0, выход *** if ((alfa == 0.0) && (eye != 0.0)) { err_code = -3; return(err_code); } // *** Ошибка: параметр eye_size < 0, выход *** if (eye < 0.0) { err_code = -4; return(err_code); } // *** Ошибка: параметр eye_alfa < 0, выход *** if (alfa < 0.0) { err_code = -5; return(err_code); } // ######################################################################### // //---- // DCT (nn_tot, x, y); // x[] --> y[] GetDiffrLeftSide (nn_tot, eye, alfa, y); // y[] --> y[] IDCT (nn_tot, x, y); // y[] --> x[] GetSmooth5 (0, nn_tot, x, y); // x[] --> y[] for (i = 0; i < nn_tot; i++) { x[i] = y[i]; } // y[] --> x[] // //---- err_code = nn_tot; return(err_code); } //Pruebe, por ejemplo, los parámetros Eye = 2,5, Alfa = 0,5. Es importante recordar que la combinación (Ojo !=0, Alfa == 0) no está permitida. El EPS se utiliza para evitar incertidumbres como el 0/0. Tomo EPS = 1.0E-09.
La matriz suavizada debe ser normalizada al rango de cambio de precio sobre nn_barras:
// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Нормировка результов вычислений на заданный диапазон значений |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: double x[] // неномированный массив значений аргумента; Входные локальные переменные: int n_beg // номер начального бара int n_end // номер конечного бара double v_max // максимальное значение диапазона для нормировки; double v_min // минимальное значение диапазона для нормировки; Выходные локальные переменные: нет Выходные глобальные переменные: double x[] // ответ - нормированный массив значений аргумента; */ MT4_EXPFUNC int __stdcall NormRange(int n_beg, int n_end, double v_max, double v_min, double x []) { int err_code = 0; // возвращаемый код ошибки double x_max; // максимальное значение в нормируемом массиве double x_min; // минимальное значение в нормируемом массиве double x_curr; // текущее ненормированное значение double x_norm; // текущее нормированное значение double coef_1; // 1-й нормировочный коэффициент double coef_2; // 2-й нормировочный коэффициент double diff_x; // разность x_max - x_min int n_bars; // n_end - n_beg int i; // счетчик // n_bars = n_end - n_beg; // ########################### Error Definitions ########################### // *** Ошибка: если перепутаны местами начальный и конечный бары, выход *** if (n_bars < 0) { err_code = -6; return(err_code); } // *** Ошибка: если превышено максимальное число баров, выход *** if ((n_bars > 0) && (n_bars > NN_MAX)) { err_code = -1; return(err_code); } // *** Ошибка: для преобразования задано слишком мало баров, выход *** if ((n_bars > 0) && (n_bars < NN_MIN)) { err_code = -2; return(err_code); } // ######################################################################### // //---- // находим максимумы и минимумы в массиве результата x_min = 999999999.0; x_max = -999999999.0; for (i = n_beg; i < n_end; i++) { x_curr = x[i]; if (x_curr >= x_max) { x_max = x_curr; } if (x_curr <= x_min) { x_min = x_curr; } } diff_x = x_max - x_min; // // ########################### Error Definitions ########################### // *** Ошибка: diff_x = 0 *** if (diff_x == 0.0) { err_code = -7; return(err_code); } // ######################################################################### // // находим коэффициенты пересчета coef_1 = (v_min * x_max - v_max * x_min) / diff_x; coef_2 = (v_max - v_min) / diff_x; // нормируем результат на заданный диапазон for (i = n_beg; i < n_end; i++) { x_curr = x[i]; x_norm = coef_1 + x_curr * coef_2; x[i] = x_norm; } //---- return(err_code); } //Las variables v_max y v_min deben obtenerse antes, al formar la matriz de precios para su procesamiento.
entiendo su deseo de prescindir de las grandes palabras y su actitud ante los métodos de la matestadística.
Sin embargo, yo tengo una opinión diferente.
El mercado es un proceso no estacionario y caótico. Y la matestadística se ocupa principalmente de los procesos estacionarios. La transición al límite es uno de los principales métodos para demostrar afirmaciones. ¿Y cuál es el estado límite del mercado? El movimiento browniano es un fenómeno en un sistema cerrado, mientras que el mercado es un sistema sustancialmente abierto. Por otro lado, el mercado es un proceso de autoorganización, por lo que existen leyes de esta autoorganización.
Desde mi punto de vista, su éxito no se debe a la aplicación de los métodos de la matestadística,
sino a las LIMITACIONES de los métodos de la matestadística por parte de la parte constructiva de su estrategia.
Estas limitaciones son las que han ayudado a captar algo importante, sin dejar que el método (es decir, la herramienta) lo disuelva en los detalles de la aplicación.
Gracias por los libros, definitivamente les echaré un vistazo.
¿Su apodo en la araña es el mismo?
En la araña es VG .
Buena suerte y buena suerte con los trnds.
Estas tres fuentes significan que las estás usando en conjunto con MT4 (parece que sí). ¿Y cómo se sentiría si no hay un entorno C para compilar?
Estas tres fuentes significan que las estás usando en conjunto con MT4 (parece que sí). ¿Y cómo se sentiría si no hubiera un entorno C para compilar?
Puedes probarlo en MT. Originalmente se programaron en MQL para su depuración, y luego se trasladaron con mínimos cambios a C. Y la versión más antigua estaba en ensamblador.