Assista a como baixar robôs de negociação gratuitos

Roteiro interessante?
Então poste um link sobre isto -
deixe que outros avaliem

Você gostou do roteiro? Experimente no terminal MetaTrader 5

Bibliotecas

Biblioteca de funções e conselheiros para trailing, por Yury Dzyubán - biblioteca para MetaTrader 4

I_D | Portuguese English Español Русский 中文 Deutsch 日本語

Visualizações:
662
Classificação:
votos: 42
Publicado:
2016.06.10 15:08

O algoritmo de controle e fechamento de posições, como é conhecido, é quase mais importante do que as regras da sua abertura. E, às vezes, alterar o sistema de trailing pode afetar dramaticamente o desempenho ao negociar, tanto para melhor como para pior. Esta é uma libraria de funções, que eu utilizo ao traçar os meus SNM (Sistema de Negociação Mecanizado), para controlar a posição aberta.


As funções apresentadas foram escritas segundo alguns dos algoritmos mais populares para trailing. As funções são fáceis de ligar/desligar, isso permite que sejam implementadas eficientemente no sistema de entrada para testar diferentes cenários de trailing. As funções apresentadas são básicas e permitem, se for necessário, construir com base nelas algoritmos de trailing mais complexos. As funções são muito diferentes, foram escritas por mim para facilitar o procedimento de construção de novos SNM.


Aqui estão as funções:

1. Trailing pelas sombras das últimas N barras.

void TrailingByShadows(int ticket,int tmfrm,int bars_n, 
                       int indent,bool trlinloss)

A função implementa stop loss trailing de acordo com o Low mínimo (para posições longas) ou segundo o High máximo (para posições curtas) do número de barras especificado, no timeframe quer atual quer diferente.

Parâmetros:

ticket - número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
tmfrm - timeframes das barras utilizadas para realizar o trailing (opções - 1, 5, 15, 30, 60, 240, 1440, 10080, 43200);
bars_n - número de barras que são usadas para determinar o nível de perda do stop loss (superior a 1);
indent - recua (pontos) a partir do high/low especificado, no qual será colocado o stop loss (superior a 0);
trlinloss - indica se vale a pena ou não deslocar o stop loss para área "não rentável", isto é, no intervalo entre o stop loss inicial e o preço de abertura (true - trail, false - o trailing começará, se o novo stop loss "for melhor" do que o preço de apertura, "no lucro").

Eu encontrei pela primeira vez esse tipo de trailing na descrição das táticas de V. Barishpolts "Rompimento da média em gráficos diários", nele é sugerido fazer o trail do stop loss segundo o Low (para compras) ou High (para vendas) das 2 últimas barras (velas) no timeframe diário. Fazer trail com esse algoritmo resulta às vezes surpreendentemente "lindo" (tente "caminhar" todo o gráfico com os seus "olhos"), ele permite sobreviver as recuas (a profundidade depende do número de barras especificado, bars_n) e períodos de enfraquecimento da volatilidade. Por definição, ativa-se pelo fechamento da próxima barra, mesmo se você o usar em cada tick. Eu utilizo-o principalmente nos gráficos diários, realizo o trail segundo as 2-4 (na maioria das vezes) últimas barras.


2. Trailing de acordo com o fractal de Х-barras.

void TrailingByFractals(int ticket,int tmfrm,int frktl_bars,
                        int indent,bool trlinloss)

A função executa o trailing stop loss segundo os extremos dos fractais do tamanho especificado (isto é, do número de barras contidas no fractal) no timeframe determinado. Como é conhecido, o fractal "clássico" (de Williams, se não estou enganado) é uma combinação de 5 barras, então, ai eu pensei que seria bom usar os "outros" tamanhos, ou seja, a partir de 3 de barras para cima, incluído números pares de barras (neste último caso, o número de barras depois do extremo, será maior do que antes, quando o extremo se movia "para o passado").

Parâmetros:

ticket - número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
tmfrm - timeframes das barras utilizadas para realizar o trailing (opções - 1, 5, 15, 30, 60, 240, 1440, 10080, 43200);
bars_n - número de barras contidas no fractal (pelo menos 3);
indent - recua (pontos) a partir do extremo do último fractal, no qual será colocado o stop loss (pelo menos 0);
trlinloss - indica se vale a pena ou não deslocar o stop loss para área "não rentável", isto é, no intervalo entre o stop loss inicial e o preço de abertura (true - trail, false - o trailing começará, se o novo stop loss "for melhor" do que o preço de apertura, "no lucro").

Em vários fóruns relacionados com o Forex russo já ouvi falar que "um bom trailing é aquele que se faz segundo os fractais no timeframe mais pequeno". Como os fractais são essencialmente extremos locais, o trailing segundo eles é também basicamente trailing segundo os extremos locais. A ideia é racional, mas não é algo novo, pois tem sido utilizada por muitos traders famosos (como o Williams acima mencionado, se não estou enganado). Permite tanto sobreviver aos recuos como “escolher” movimentos notáveis. Por experiência própria, não funciona bem no plano (fase de correção). Tal como a anterior, essa função "executa o trailing" segundo as barras formadas. Se desejar, é possível (dentro dos limites de "vida" da função) alterar dinamicamente os parâmetros, por exemplo, durante um rápido "crescimento" do lucro (por exemplo, durante uma tendência forte), "asfixiar" a sua sensibilidade, alternando para um timeframe maior ou aumentando o número de barras no fractal, ou, inversamente, aumentar a sensibilidade durante quedas de volatilidade, alternando para um timeframe mais pequeno ou reduzindo o número de barras no fractal. Outras opções também são possíveis.


3. Trailing padrão, “em degraus”..

void TrailingStairs(int ticket,int trldistance,int trlstep)

Esse tipo de trailing é uma melhoria do padrão. Se não estou enganado, um semelhante foi escrito por KimIV (mas “o que é próprio é mais precioso”,... :) É diferente do padrão em que a deslocação do stop loss não é realizada ponto-a-ponto (quando o trailing está numa distância de 30 pontos, ao atingir +31 o stop loss será deslocado +1, +32 será deslocado +2, etc.), mas sim por "passos" (incrementos) do comprimento especificado (quando o trailing está numa distância de 10 pontos e 10 passos, ao atingir +40 o stop loss será deslocado +10, assim, até que ele atinja o lucro +50 (40 + passos) nada voi mudar (nós damos ao preço uma certa liberdade, que, na verdade, é a essência deste algoritmo), e apenas em +50, o stop loss +10 será deslocado um passo, +10 +20 passos, +60 +30 passos, etc.

Parâmetros:
ticket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
trldistance - distância a partir do preço atual (pontos), no qual "executarmos o trailing" (pelo menos MarketInfo(Symbol(),MODE_STOPLEVEL));
trlstep - "passo" (incremento) de alteração o stop loss (pontos) (pelo menos 1).

При trlstep=1 данная функция не будет отличаться от стандартного трейлинга. Основная "фишка" данного алгоритма, повторюсь, в предоставлении курсу некоторой "свободы движений" - стоплосс подтягивается только после того, как цена "побродив, определилась". Eu encontrei pela primeira vez esse tipo de trailing na descrição do "Moving channels" de V.Barishpoltsa.


4. Trailing padrão - "estrangulamento".

void TrailingUdavka(int ticket,int trl_dist_1,int level_1,
                    int trl_dist_2,int level_2,int trl_dist_3)

Como se sabe, não existem movimentos sem recuo de duração ilimitada (O...). E depois de uma certo "solavanco" (o valor médio que pode ser determinado, por exemplo, estatisticamente) o preço, como regra, forma uma consolidação ou um recuo. A ideia deste algoritmo de manutenção é diminuir a distância do trailing em correspondência com o aumento do lucro de tal forma que seja possível a "tomar posse" de mais lucro quando chegar à área de uma provável reversão/consolidação. Além de negociação os mencionado acima "solavancos" (que normalmente ocorrem durante a notícia ou em rompimentos dos níveis históricos), a função também pode ser usada para trabalhar dentro de canais, diminuindo a distância do trailing quando for atingindo o limite oposto (em relação à abertura) do canal.


Parâmetros:
ticket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
trl_dist_1 - distância inicial do trailing (pontos) (pelo menos MarketInfo(Symbol(),MODE_STOPLEVEL), superior a trl_dist_2 e trl_dist_3);
level_1 - nível de lucro (pontos) em que a distância do trailing será reduzida de trl_dist_1 para trl_dist_2 (inferior a level_2; superior a trl_dist_1);
trl dist_2 - distância do trailing (pontos) depois de o preço atingir o nível de lucro no level_1 de pontos (pelo menos MarketInfo(Symbol(),MODE_STOPLEVEL));
level_2 - nível de lucro (pontos) em que a distância do trailing será reduzida de trl_dist_2 para trl_dist_3 pontos (superior a trl_dist_1 e superior a level_1);
trl dist_3 - distância do trailing (pontos) depois de o preço atingir o nível de lucro no level_2 de pontos (pelo menos MarketInfo(Symbol(),MODE_STOPLEVEL)).


Por exemplo, tendo os parâmetros "ticket#, 30, 50, 20, 70, 10", inicialmente executamos o trailing a uma distância de 30 pontos, logo que o preço se afasta do preço de abertura em 50 pontos, começamos a executar o trailing "fortemente", isto é, a uma distância de 20 pontos, mas se ele for capaz de superar as 70 pontos na direção do aumento do lucro, "apertamos" (daí o nome) a uma distância de trailing de 10 pontos (isto provavelmente levará ao fechamento precoce da posição)

5. Trailing segundo o tempo.

void TrailingByTime(int ticket,int interval,int trlstep,
                    bool trlinloss)

Executamos o trailing de acordo com o tempo, independentemente do resultado atual da posição e disposição do mercado. Em intervalos de tempo pré-determinados (minutos) (se possível) tentamos mover o stop loss, o passo especificado. Usar esse método de trailing separadamente não foi muito bem-sucedido (pelo menos para mim, talvez seja diferente para outra pessoa), embora, combinado com outros métodos de trailing, ou ativando por uma determinada condição, ele pode ser útil.

Parâmetros:
ticket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
interval - número de minutos inteiros, a partir da abertura da posição, para colocar o stop loss no passo de trlstep pontos;
trlstep - passo (pontos), para colocar stop loss cada interval de minutos;
trlinloss - neste caso, se trlinloss==true, executamos o trailing a partir do stop loss, ou então a partir do preço de abertura (se o stop loss não estiver colocado, ==0, executamos sempre o trailing a partir do preço de abertura).


6. Trailing segundo a ATR.

void TrailingByATR(int ticket,int atr_timeframe,int atr1_period,
                   int atr1_shift,int atr2_period,int atr2_shift,
                   double coeff,bool trlinloss)
A ATR - (Average True Range, Amplitude Média Verdadeira) - é um dos indicadores de volatilidade; quanto maior o valor, maior a volatilidade média durante o período especificado (do indicador); medido em pontos. O trailing segundo a ATR na maioria dos casos permite alterar o stop loss de acordo com ("adequadamente", "adaptativamente") o comportamento do preço - em alta volatilidade (picos visíveis), "deixamos ir" o preço, quando "marca passo" mantemos de modo "apertado". No trailing usamos 2 ATR, que supostamente têm períodos diferentes - um curto (por exemplo, 5), o outro longo (por exemplo, 20). O cálculo do stop loss sempre usa o valor maior das 2 ATR, isto é feito para evitar várias barras de baixa volatilidade em uma linha (por exemplo, antes da liberação da notícia) para mover o stop loss muito perto do preço atual.

Parâmetros:
ticket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
atr_timeframe - timeframe no qual é calculado o valor da ATR (opções - 1, 5, 15, 30, 60, 240, 1440, 10080, 43200);
atr1_period - timeframe da primeira ATR (superior a 0; pode ser igual ao atr2_period, adicionalmente, recomenda-se defini-la como um valor diferente, como foi mencionado acima);
atr1_shift - para a primeira ATR, a mudança da "janela", na qual é calculado o valor da ATR, em relação à barra atual para o número de barras especificado atrás (um número inteiro não negativo);
atr2_period - timeframe da segunda ATR (superior a 0);
atr2_shift - para a segunda ATR, a mudança da "janela", na qual é calculado o valor da ATR, em relação à barra atual para o número de barras especificado atrás (um número inteiro não negativo);
coeff - o stop loss é calculado como a ATR*coeff, ou seja, este é o coeficiente para definir a distância entre a ATR e o preço atual para colocar o stop loss;
trlinloss - indica se é preciso colocar o stop loss para a área "não rentável", ou seja, no intervalo entre o stop loss inicial e o preço de abertura (true - executamos o trailing, false - o trailing começará, se o novo stop loss "for melhor" do que o preço de apertura, "no lucro").

Também é uma maneira popular de trailing (rentável na maioria dos casos) que se diferencia do padrão com "adaptação" à situação actual do mercado.


7. Trading de catraca (segundo o Barishpolts).

void TrailingRatchetB(int ticket,int pf_level_1,int pf_level_2,
                      int pf_level_3,int ls_level_1,
                      int ls_level_2,int ls_level_3,
                      bool trlinloss)

Uma chave, roda de catraca (Engl. ratchet) é aquilo que "gira apenas numa direção". O nome é meu, na descrição de Barishpolts é mencionado como a "segunda tática de trailing" (em oposição à "primeira", com "padrão" - ainda mais stop losses), na versão de KimIV chamada de trailing de "três níveis". A idéia: rápida transferência para o ponto de break-even e trailing em degraus num pequeno lucro (depois disso diferentes métodos de trailing são sugeridos, por exemplo, um padrão, ou meu padrão-"em degraus" ou qualquer um dos de acima). A viabilidade de tal trailing - "a maioria absoluta das posições fazem lucro, pelo menos por algum tempo", portanto, é necessário mover o stop loss para brea-keven logo que possível. Se "fecha" prematuramente, mas os sinais de abertura ainda estão presentes, é possível uma reentrada. Em geral, haverá inúmeras negociações fechadas em break-even e, possivelmente, alguns com bom lucro, isto é, nas negociações que teve um forte movimento na direção rentável após a abertura. O autor enfatiza que o trailing não é para "escalpamento", mas para a realização de negociação com baixa % de negócios rentáveis.

Parâmetros:
ticket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
pf_level_1 - nível de lucro (pontos) no qual deslocamos o stop loss para o breakeven + 1 pontos;
pf_level_2 - nível de lucro (pontos), no qual deslocamos o stop los a partir de +1 para a distância pf_level_1 pontos a partir do preço de abertura;
pf_level_3 - nível de lucro (pontos), no qual deslocamos o stop los a partir de pf_level_1 para pf_level_2 pontos a partir do preço de abertura (isto conclui a operação da função);
ls_level_1 - distância a partir do preço de abertura, na direção do "loss", no qual vai ser colocado o stop, ao ser atingida a posição +1 pelo lucro (a partir +1 o stop loss será deslocado para o ls_level_1);
ls_level_2 - distância a partir do preço de abertura na direção do "loss", no qual vai ser colocado o stop, com a condição de que o preço primeiro tinha caído para baixo do ls_level_1 e, a seguir, subido para cima dele (tendo um loss, ele começa a cair, mas não permitimos que suba novamente);
ls_level_3 - distância a partir do preço de abertura, na direção do "loss", no qual vai ser colocado o stop, com a condição de que o preço fique abaixo do ls_level_2 e, em seguida, fique acima dele;
trlinloss - indica se é preciso colocar o stop loss para a área "não rentável", ou seja, no intervalo entre o stop loss inicial e o preço de abertura (true - executamos o trailing, false - o trailing começará, se o novo stop loss "for melhor" do que o preço de apertura, "no lucro").

O autor da idéia sugeriu para usar os seguintes valores no par EURUSD: "5, 10, 25", ou seja, + 5 ("compensado" o spread e ganhos mais 5 pontos de lucro) o stop loss é movido para + 1 (durante a negociação manual recomenda "manter este número na cabeça", para não seduzir o dealer mais uma vez), + 10 pontos o stop loss é movido para + 5 , em + 25 pontos de lucro o stop loss é movido para + 10, e o preço é "soltado" (pode ser apertado por outros métodos). A parte semelhante da função para o intervalo de perda não foi descrita pelo autor, ela foi desenvolvida pelos seus seguidores na discussão. Há evidências de que o autor (com bastante sucesso) usa esta metodologia para negociação no seu projecto de investimento, que é possivelmente um dos fatores de % de lucro muito alta na sua negociação. Ao mesmo tempo, deve notar-se que este algoritmo de trailing é bastante específico e não pode convir a todos.


8. Trailing de acordo com o canal de preço (sugerido por rebus).

void TrailingByPriceChannel(int iTicket,int iBars_n,int iIndent)

Parâmetros:
iTicket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
iBars_n - - timeframe do canal (numero de barras para encontrar o High máximo e o Low mínimo, isto é, as bordas superior e inferior do canal, respetivamente);
iIndent - espaço (pontos), para colocar stop loss a partir da borda do canal.

Os resultados do trailing, segundo o canal do preço, praticamente coincidem com o trailing segundo as sobras das velas (veja acima), e em certa medida se assemelham ao trailing segundo os fractais, embora se distinga no "conceito" e "viabilidade"


9. Trailing de acordo com a moving average (média móvel).

void TrailingByMA(int iTicket,int iTmFrme,int iMAPeriod,int iMAShift,
                  int MAMethod,int iApplPrice,int iShift,int iIndent)
A idéia é basicamente está a "meio passo" do trailing segundo o canal de preço. A função é transferida para a posição do ticket, o timeframe necessário, o recuo a partir da MA (pontos) para colocar o stop loss, e parâmetros reais da MA (semelhante aos padrões para a iMA()). Considerando a natureza das médias móveis, é fácil de adivinhar que este algoritmo é capaz de gerar uma boa tendência, na fase de correção (plano), mas, ao "confundir" o preço, muitas vezes leva ao fechamento prematuro. No entanto, é possível alterar os parâmetros do trailing (em particular, o método e período da média) para atender adequadamente a situação de mercado (tendo em conta a volatilidade, por exemplo).

Parâmetros:
iTicket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
iTmFrme - timeframes das barras utilizadas para realizar o trailing; opções 1 (M1), 5 (M5), 15 (M15), 30 (M30), 60 (H1), 240 (H4), 1440 (D), 10080 (W), 43200 (MN);
iMAPeriod - período médio para calcular a média móvel;
iMAShift - mudança do indicador em relação ao gráfico de preço;
iMAMethod - método da média; opções: 0 (MODE_SMA), 1 (MODE_EMA), 2 (MODE_SMMA), 3 (MODE_LWMA);
iApplPrice - epreço utilizado; opções: 0 (PRICE_CLOSE), 1 (PRICE_OPEN), 2 (PRICE_HIGH), 3 (PRICE_LOW), 4 (PRICE_MEDIAN), 5 (PRICE_TYPICAL), 6 (PRICE_WEIGHTED);
iShift - mudança em relação à barra atual para o número de barras especificado atrás;
iIndent - espaço (pontos) a partir do valor da média para colocar o stop loss.


10. Trailing "meio a meio" (Fifty-fifty trailing).

void TrailingFiftyFifty(int iTicket,int iTmFrme,double dCoeff,
                        bool bTrlinloss)

A idéia é a seguinte: quando outro bar fecha, diminuir a distância entre o stop loss e o preço atual dCoeff vezes (o valor inicial foi de 0,5, daí o nome). Por exemplo, há uma posição de compra aberta com um stop loss de 40 pontos. Quando é fechado o bar onde foi feita a entrada no mercado, a oferta torna-se superior ao preço de abertura por 42 pontos. Se o único "no lucro" (bTrlinloss = = true) modo de trailing foi selecionado, pegue a distância entre o preço de abertura para o preço atual, 42 pontos, multiplique-o por dCoeff (por exemplo, 0,5) e obtendo 21 pontos, mova o stop loss para + 21. Suponha que o lucro foi de 71 pontos no fechamento da barra seguinte. Então a diferença entre o atual stop loss e o preço é 71-21=50, a metade desse valor é 50*0.5=25, então o novo stop loss deve ser colocado em 25 pontos acima em relação ao anterior (21+25=46 pontos a partir do preço de abertura).

Ao usar o modo descrito de trailing, "no lucro" (bTrlinloss==true), o stop loss é movido apenas na condição de que o novo stop loss seja "melhor" do que o preço de abertura. Se bTrlinloss for definido como false, então o trailing será também executado numa área de perda (ou seja, no intervalo entre o preço de abertura e o stop loss, que, aliás, deve ser necessariamente definido (não é igual a 0) para este elemento trabalhar). Ou seja, se a variante descrita acima é usada, então aquando do encerramento da próxima barra de stop loss será movida para distância 0.5 não entre o preço de abertura e o atual, mas entre o stop loss e o preço atual (em um stop loss de 40 pontos e lucro de 42 pontos esta distância será igual a (40+42)/2 = 82/2 = 41 pontos , o stop loss será colocado em + 1 ponto a partir do preço de abertura. Na segunda barra, no lucro de 71 pontos: a) 71 - 1 = 70, b) 70*0.5 = 35, c) 1 + 35 = 36 pontos Pode ser visto que esta variante vai começar a maior "distância" e vai cair por trás da primeira. A sua principal função é de apertar o stop loss durante a evolução negativa. Por exemplo, se após o encerramento da primeira barra o lucro foi de -10 pontos, então no bTrlinloss==true : a) encontramos a distância entre o preço para o stop loss, |-40 + (-10)| = 30 pontos, b) calculamos a metade desse valor - 30 * 0,5 = 15 pontos e c) mover o stop loss para o lucro a esta distância: - 30*0.5 = 15 pontos e c) movemos o stop loss para o lucro a esta distância: -40 + 15 = -25.

No trailing, uma perda faz com que aumente o número de fechamentos prematuros (com uma pequena perda também), embora a conta esteja protegida contra grandes perdas.

Parâmetros:
iTicket -
número ordinal exclusivo (selecionado antes da chamada para a função usando OrderSelect());
iTmFrme - timeframes das barras utilizadas para realizar o trailing; opções: 1 (M1), 5 (M5), 15 (M15), 30 (M30), 60 (H1), 240 (H4), 1440 (D), 10080 (W), 43200 (MN);

dCoeff - coeficiente que determina o número de vezes que diminui a distância entre o preço no momento do fechamento da barra e o stop loss atual;

bTrlinloss - indica quanto realizar o trailing na área de loss.


11. Trailing "KillLoss".

void KillLoss(int iTicket,double dSpeedCoeff)
A idéia de tal manutenção veio-me durante o desenvolvimento de um tipo combinado de trailing, que incluía várias das opções acima descritas (ou seja o trailing de "catraca" segundo Barishpolts e o trailing por fractais). De acordo com a ideia, ele foi projetado para funcionar somente em áreas de perda (quando a posição está numa perda). Por exemplo, se a entrada foi evidentemente incorreta, a perda aumenta rapidamente, o preço aproxima-se rapidamente ao stop loss inicial, é aconselhável limitar a perda possível, movendo o stop loss em direção do preço, com uma velocidade igual à do preço (ou maior). Isto é o que faz a função KillLoss. Uma vez iniciado, ele "lembra" a distância entre o stop loss e o preço em uma variável global do terminal, e no futuro, se o preço se aproximar ao stop loss de X pontos, moverá o stop loss para X pontos * coeficiente de dSpeedCoeff em direção a ela. O coeficiente mencionado pode ser tanto uma constante (por exemplo, 1 - o stop loss será movido 1 ponto por cada ponto da abordagem do preço, ou 1.5 - o stop loss se moverá para o preço 1,5 vezes mais rápido do que o preço do último), como um valor de uma variável que muda dependendo das condições de mercado (por exemplo, a sua volatilidade - "se o mercado for volátil e a perda estiver crescendo, cortaremos mais rápido o stop loss"). Quando o preço se reverte na direção do lucro (diminui a perda), a função KillLoss não faz nada. PS Lembre-se de que a função usa 2 variáveis globais do terminal durante a sua operação, isto é, sldiff e zeticket, a última das quais é também utilizada em algumas das funções de trailing descritas acima. Cuidado, se necessário (por exemplo, durante um uso alternativo ou conjunto dessas funções) mudar o nome da variável global numa delas.

Todas as funções acima estão coletadas no arquivo da biblioteca TrailingFuncLib.mq4, anexado ao cabeçalho do artigo. De alguma forma, é mais conveniente para mim usar uma biblioteca, embora seja um pouco mais lento, no entanto, você pode incluir as funções nos seus programas. Anexei o conselheiro MyFractals com as funções incluídas Alguém pode também estar interessado no conselheiro.


11.08.2007. Para aqueles, que negociam de modo "semi-automático", controlando parte da negociação manualmente (por exemplo, a posição de abertura, simplesmente porque algumas táticas são complicadas de mostrar em forma de algoritmos) e outra parte da negociação com o uso de scripts e conselheiros MQL4 (por exemplo, manutenção de posições e encerramento), tenho desenvolvido conselheiros com base em cada uma das funções de trailing, descritas acima, da biblioteca. Eles estão no arquivo TrailingExperts.zip. Agora, depois de abrir manualmente, você pode simplesmente executar uma conselheiro com o tipo de trailing necessário, especificando o bilhete (número único da posição) e definindo os parâmetros necessários. E, se necessário, você pode facilmente alterar um tipo de trailing para outro, dependendo das mudanças de situação de mercado, simplesmente executando outro conselheiro. Mais instruções detalhadas podem ser encontradas nos comentários de cada um dos conselheiros. Eu realmente espero que esses programas sejam úteis no seu trabalho.


Comecei a estudar a linguagem MQL4 relativamente há pouco tempo (no final de março de 2007). Portanto, aceitarei quaisquer comentários construtivos, dicas, sugestões, idéias, etc. sobre as funções acima. Espero que eles sejam úteis para vocês.

Com os melhores cumprimentos,
Yuri Dzyuban

Traduzido do russo por MetaQuotes Software Corp
código original: https://www.mql5.com/ru/code/7108

Dealers Trade v 7.74 MACD Dealers Trade v 7.74 MACD

O algoritmo de scalping multi-lotes está baseado no conselheiro Dealers Trade v 7.74 MACD. O conselheiro foi testado repetidamente em contas reais.

Dealers Trade v 7.51 RIVOT Dealers Trade v 7.51 RIVOT

O conselheiro Dealers Trade v 7.51 RIVOT foi feito com base no algoritmo de scpalping multi-lotes. O conselheiro foi testado repetidamente em contas reais.

SymbolLister SymbolLister

Função simples que cria uma lista de símbolos disponíveis de pares de moedas.

ZZ_All Quotings 0-0050 ZZ_All Quotings 0-0050

O script ZZ_All Quotings 0-0050 foi projetado para carregar o histórico de todos os pares de moedas, metais, índices populares, CFD e controlar segundo os "buracos" no histórico.