uma estratégia comercial baseada na Teoria da Onda de Elliott - página 10
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
E eu não vou compartilhar a SOLUÇÃO FEITA, mas a metodologia - por favor, sem problemas.
Boa sorte e tendências felizes.
Em geral, é claro. Tudo é como na tese. Há de tudo, exceto aquele esquema simples, sem o qual nada vai funcionar ;o)! E o esquema é conhecido apenas por aqueles que o inventaram, e tudo o mais sem ele é apenas papel, que está tão ao redor. Mas atenção, estou apenas afirmando um fato, sem qualquer outro significado. Cada um tem que andar com sua própria bicicleta de qualquer maneira. Afinal de contas é FOREX!)
E aqui vai outra pergunta. Tudo isso é implementado em quê? No MT4?
Ou seja, o MT4 tem o indicador Murray que você mencionou. É claro.
Mas o que você usa para calcular canais e Hearst? Você usa o MT4 também? Uma vez você mencionou o tamanho de código de 0,5M. O que você quer dizer com isso? O peso do texto de um programa de cálculo em mql4? Se assim for, francamente falando, dificilmente consigo imaginar tal volume. Porque, de acordo com minha estimativa conservadora, o texto de tal programa deveria ser cerca de 10.000 linhas. Uma simples estratégia de ruído branco que uso leva apenas 1000 linhas, embora eu simplesmente lance 6 linhas comerciais em paralelo que usam informações de diferentes prazos e é mais fácil (mais conveniente para modificações posteriores) deixar peças de tal código como estão agora do que convertê-las em 400-500 linhas usando matrizes (embora tais planos também sejam possíveis no futuro). Ou seja, a execução de uma linha por um período de tempo levará 400-500 linhas. Estou utilizando um Expert Advisor totalmente funcional que não precisa ser monitorado. É claro que não recuso sua melhoria adicional, mas até agora já otimizei tudo o que poderia ser otimizado nele no testador. Mas há um certo interesse em seus métodos e eu tentarei aplicar algo, se eu tiver sucesso, é claro.
PS: E o fato de eu usar não um fio de comércio com um grande lote, mas vários fios paralelos em diferentes intervalos de tempo com lotes pequenos é explicado apenas pelo fato de que neste tipo de comércio aparece algo como um efeito máximo de filtragem por drawdown. Isto é, se você tiver vários processos aleatórios (dinâmica de saldo de um fio), então ao somar os saldos em uma conta, o drawdown máximo será igual à soma dos drawdowns de cada fio dividido pela raiz quadrada do número de fios, não a soma dos drawdowns de cada um! Assim, eu tento diminuir o drawdown máximo total. Ou seja, se você tiver 6 fios, cada um com drawdown de 50USD em 1,5 anos de história, logicamente o drawdown total de 6 fios deve ser de 300USD, mas na prática, esta quantidade deve ser dividida pela raiz quadrada de 6 = 2,45. Isto é mais ou menos o que o testador mostra. O testador mostra que você deve dividir por cerca de 2,2. O que eu acho que concorda bem com minha idéia de reduzir ao máximo o saque.
Boa sorte e boas tendências.
Permito-me discordar com você. Este tópico só se tornou interessante quando você decidiu compartilhar suas experiências e idéias.
Como físico, entendo tudo sobre o campo, potencialidades, etc. Tudo está claro também com a otimização - é um problema não trivial e interessante. Quanto às estatísticas matemáticas, infelizmente só pude entender o que se trata em termos gerais. Mas o assunto é interessante. Especialmente em parte da estimativa a priori de níveis de significância e possibilidade de previsão não aleatória.
Minha abordagem (até agora) tem se concentrado em torno da definição de períodos de tendência do mercado. Não usei o índice Hearst na forma dada no artigo acima, nem de qualquer outra forma. Entretanto, eu também tento confiar em uma medida de fractalidade de mercado que tem meu próprio algoritmo de cálculo. A idéia de que os períodos de contra-tendência podem ser usados tão bem quanto os períodos de tendência me surpreendeu completamente. Às vezes é difícil ver até mesmo o que está por baixo. :-)
Portanto, eu ficaria feliz em continuar o diálogo, se não neste fórum, então através de seu e-mail dado no indicador de níveis Murray, ou na aranha na mensagem privada.
De qualquer forma, eu gostaria de dizer: seu trabalho me impressionou! Pela primeira vez vi o trabalho não de "pensamento figurativo" de um amador (do qual me incluo), mas de matemática nas mãos de um matemático.
Eu gostei especialmente deste:
A convergência de resultados em diferentes fluxos de dados e sem utilizar suavização significa que sua metodologia chegou à natureza do processo!
Sem problemas .
A convergência de resultados em diferentes fluxos de dados e sem utilizar suavização significa que sua metodologia chegou à natureza do processo!
Eu diria um pouco mais modestamente - isso significa que os métodos matemáticos funcionam - eles só precisam ser aplicados corretamente, e que muitos métodos de AT ainda têm justificativa. (ou seja, existem áreas de movimento pré-determinado no mercado). Os métodos qualitativos como Elliott ou Gann, embora, como escrevi - não gosto muito do Elliott devido à falta de estimativas quantitativas.
De qualquer forma, boa sorte e boas tendências.
Procure a "Enciclopédia de Estratégias Comerciais" de McCormick e a "Estatística para Comerciantes" de Bulashev - muito útil em um sentido aplicado - a lógica dos métodos é mostrada.
Experimente DCT-transformação com núcleo de difração - suaviza muito bem, não retarda em nada. IMHO, funciona melhor que a LCF tradicional. Abaixo estão alguns trechos de código em C++. A forma de utilizá-la, creio, está clara a partir dos comentários.
//*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Прямое дискретное косинус-преобразование (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; } //E este é o método de aplicação:
// //*************************************************************************// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Сглаживание методом 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); } //Tente, por exemplo, os parâmetros Eye = 2,5, Alfa = 0,5. É importante lembrar que a combinação (Eye !=0, Alfa == 0) não é permitida. O EPS é usado para evitar incertezas como 0/0. Eu tomo EPS = 1.0E-09.
A matriz alisada deve ser normalizada para a faixa de variação de preço em barras de nn_tot:
// ///////////////////////////////////////////////////////////////////////////// //+-----------------------------------------------------------------------+// //| Нормировка результов вычислений на заданный диапазон значений |// //+-----------------------------------------------------------------------+// ///////////////////////////////////////////////////////////////////////////// /* Входные глобальные переменные: 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); } //As variáveis v_max e v_min devem ser obtidas mais cedo, ao formar a matriz de preços para processamento.
Entendo seu desejo de dispensar grandes palavras e sua atitude em relação aos métodos das estatísticas matemáticas.
No entanto, tenho uma opinião diferente.
O mercado é um processo não estacionário e caótico. E as estatísticas matemáticas tratam principalmente de processos estacionários. A transição para o limite é um dos principais métodos de comprovação das declarações. E qual é o estado limite do mercado? O movimento browniano é um fenômeno em um sistema fechado, enquanto o mercado é um sistema substancialmente aberto. Por outro lado, o mercado é um processo de auto-organização, portanto, existem leis desta auto-organização.
Do meu ponto de vista, seu sucesso não se deve à aplicação de métodos matemáticos,
mas às LIMITAÇÕES sobre os métodos matemáticos por parte da parte construtiva de sua estratégia.
Estas limitações são o que ajudou a capturar algo importante, sem deixar o método (ou seja, a ferramenta) dissolvê-lo nos detalhes de aplicação.
Obrigado pelos livros, sem dúvida, darão uma olhada.
Seu apelido na aranha é o mesmo?
Na aranha, é VG .
Boa sorte e boa sorte com as trnds.
Estas três fontes significam que você está usando-as em conjunto com o MT4 (parece que sim). E como se sentiria se não houvesse um ambiente C para compilar?
Estas três fontes significam que você está usando-as em conjunto com o MT4 (parece que sim). E como se sentiria se não houvesse um ambiente C para compilar?
Você poderia tentar em MT. Originalmente eles eram programados em MQL para depuração, e depois eram movidos com mudanças mínimas para C. E a versão mais antiga estava em assembler.