Geração automática de linhas de suporte e resistência
18 556
0
Introdução
Neste artigo, examinaremos a construção automática linhas de suporte e resistência. A análise técnica de instrumentos Forex é uma parte importante da negociação, nos mercados financeiros. Por isso, a construção automática dessas linhas facilitará o trabalho de analistas financeiros e traders, e será uma oportunidade para acelerar a análise técnica. Além disso, você pode criar EAs com base no indicador aqui examinado.
Encontrando todos os máximos e mínimos locais
As linhas de suporte e resistência são construídas atravessando máximos e mínimos locais, em gráficos de preços. Para definir estes extremos, utilizaremos o conhecido indicador ZigZag. Nos seus parâmetros de entrada, podem-se definir as propriedades necessárias para as linhas de suporte e resistência.
A escala das linhas pode ser alterada por meio dos parâmetros do indicador ZigZag. Os mesmos parâmetros podem ser utilizados em diferentes timeframes. Isto permitir-nos-á obter os extremos necessários, para, em seguida, construir com base neles os níveis de suporte e resistência.
As ilustrações que se seguem mostram como muda a natureza dos picos ao alterar o timeframe. A primeira imagem é um gráfico de 30 minutos, enquanto a segunda, um de 4 horas.
Seleção dos extremos adequados para a construção de níveis
Nós vamos construir apenas as linhas de suporte e resistência que passam perto do preço atual, isto é, as que serão relevantes em termos de análise técnica, naquele momento em particular. Adicionalmente, para as linhas terem uma inclinação convergindo no preço, se a tendência for de baixa, usamos todos os extremos superiores ou iguais ao extremo anterior, se ela for de alta, empregamos todos os extremos inferiores ou iguais ao extremo anterior. Na primeira figura, eles podem ser os pontos 1-2-3-4-5-7, enquanto, na segunda, 1-2-3-6-7-8.
Já temos estabelecido os critérios de seleção dos extremos. Agora, examinemos sua realização como código. Nós o apresentaremos aqui apenas parcialmente para esclarecer pontos chave.
//+------------------------------------------------------------------+ struct trade_points // Definimos a estrutura dos extremos { double price; // Preço int pos; // Localização, número da barra bool hpoint; // Se sim, trata-se do máximo bool lpoint; // Se sim, trata-se do mínimo };
Na função OnInit(), criamos o indicador do indicador ZigZag:
int OnInit() { ZZ_handle=iCustom(_Symbol,_Period,"ZigZag",ExtDepth,ExtDeviation,ExtBackstep); return(INIT_SUCCEEDED); }
Em seguida, encontrando alternadamente todos os extremos do Zigzag, na matriz, introduzimos as informações sobre eles:
double max=close[1]; double min=close[1]; int z=0; for(shift=0;shift<rates_total && !IsStopped();shift++) { CopyBuffer(ZZ_handle,0,shift,1,ZigzagBuffer); if(ZigzagBuffer[0]>0) { if(ZigzagBuffer[0]>=max && ZigzagBuffer[0]==high[shift]) { ArrayResize(mass,z+1); max=ZigzagBuffer[0]; mass[z].price=ZigzagBuffer[0]; mass[z].pos=shift; mass[z].hpoint=true; mass[z].lpoint=false; z++; } if(ZigzagBuffer[0]<=min && ZigzagBuffer[0]==low[shift]) { ArrayResize(mass,z+1); min=ZigzagBuffer[0]; mass[z].price=ZigzagBuffer[0]; mass[z].pos=shift; mass[z].lpoint=true; mass[z].hpoint=false; z++; } } }
Definição de critérios para a construção de linhas de tendência
Agora, como a matriz com picos está formada, podemos construir as linhas de suporte e resistência que necessitamos. A definição dos principais critérios para a construção das linhas é explicada abaixo.
A partir do ponto 1, podemos construir linhas que atravessam qualquer um dos seguintes pontos. Mas nem todas essas linhas podem ser consideradas linhas de suporte e resistência. Talvez sejam irrelevantes nesse momento e, portanto, não precisaremos delas no gráfico. Nós preferimos que o gráfico esteja livre de construções desnecessárias, por isso, pesquisamos e filtramos as linhas de mais.
Assumimos que A é o ponto de partida da linha, B - o segundo pico, e, S - o ponto perto da última barra.
Os critérios podem ser muitos, em situações diferentes eles variam. Aqui, consideramos apenas os principais. No futuro, quem estiver interessado pode melhorar esse indicador a seu exclusivo critério. Assim, os principais critérios são:
- Correlação entre as distâncias de AB e BC
- O número de vezes que o preço cruza o segmento AB
- O número de vezes que o preço cruza o segmento BC
- Distância entre C e o preço atual
- Comprimento máximo e mínimo da linha
- Inclinação da linha
- Permanência do preço acima ou abaixo da linha de resistência
Consideramos estes critérios em mais detalhes, a fim de entender melhor a configuração dos parâmetros de entrada.
- Para cumprir com as proporções aceitáveis, podem-se utilizar os coeficientes de Fibonacci e tomar uma correlação mínima admissível de não menos do que 0,25 ou 0,382. De acordo com este critério, a correlação entre os comprimentos deve corresponder à condição AB/AC>=02.25 (0,382) e a BC/AC>=02.25 (0,382). Por conveniência, este valor pode ser definido nas configurações de entrada.
- Dependendo do número de vezes que o preço cruza a linha AB, também é necessário filtrar cuidadosamente todas as linhas existentes. Há muitas opções sobre como realizar essa verificação. Podem-se considerar apenas as barras que se fecharam após o rompimento de dada linha, ou, pode-se considerar o rompimento segundo os preços High ou Low. O segundo critério desta verificação é o número de barras que atravessa este segmento da linha. Estes parâmetros também estão nas configurações de entrada.
- A importância da linha se pode julgar pelo número de rompimentos (e sua natureza) e pela posição do preço atual em relação ao segmento BC. Todos esses critérios podem ser utilizados para tanto formar uma linha quanto criar estratégias de negociação, ao desenvolver EAs. Neste indicador, nós vamos mostrar apenas as linhas que ainda não tenham atravessado dado segmento.
- Em primeiro lugar, a distância entre o preço atual e a linha pode ser filtrada dependendo de se esta linha é relevante ou não, atualmente. Por exemplo, podem-se traçar só linhas cuja distância é inferior a 50 - 100 pontos.
- Neste caso, o comprimento mínimo da linha é determinado pelo parâmetro de entrada do ZigZag, mas este parâmetro também pode ser controlado, se necessário. No indicador, serão verificados os comprimentos mínimos dos segmentos AB e BC.
- Como as linhas de suporte são mais significativa, pelo fato de abrirem posições, o indicador construirá, para a linha de tendência ascendente, linhas com uma inclinação zero ou positiva, enquanto, para a descendente - com uma inclinação zero ou negativa.
- Podemos usar as linhas de duas maneiras. A primeira seria considerando apenas as linhas de que não foram quebradas e operar com a tendência. A segunda consistiria em utilizar apenas o rompimento das linhas de tendência para abrir trades na direção oposta. Ambos os tipos de linhas são importantes, por isso eles refletidos no indicador.
Abaixo é mostrada uma parte do código em que são formadas as linhas de resistência das tendências de baixo.
// Definição de linhas satisfaz nossos critérios, a seguir, preenchimento da matriz para a tendência de baixa. for(j=z-1; j>=0; j--) { if(mass[j].hpoint) for(i=j-1; i>=0; i--) { if(mass[i].hpoint) if(i<j) { a=mass[j].pos; b=mass[i].pos; double ratio=double((a-b)*100/a); // Determinamos a correlação entre o comprimento do segmento AB e comprimento total AC if(ratio>fibo && ratio<(100-fibo)) // Determinamos se é satisfeito o critério №1, relação entre as áreas AB e BC if(b>Min_dist &&(a-b)>Min_dist) // Determinamos se é satisfeito o critério №5, comprimento mínimo dos trechos AB e BC { ax=mass[j].price; bx=mass[i].price; coef=(ax-bx)/(a-b); price=close[1]; deviation=(ax+coef*bx)-price; cross_bc=0; cross_ab=0; if(MathAbs(deviation)<tolerance*_Point) // Determinamos se é satisfeito o critério №4 (distância entre C e o preço de fechamento da barra anterior) { // Número de cruzamentos entre os pontos a e b for(int n=a; n>b; n--) if((close[n]-(ax+coef*(b-n)))>0) cross_ab++; // Número de cruzamentos de b até ao ponto final for(int n=b-1; n>=0; n--) if(close[n]>(bx+coef*(b-n)) && close[n+1]<(bx+coef*(b-n+1))) cross_bc++; if(cross_bc<=Intersection_bc && cross_bc<=Intersection_ab)// Determinamos se são satisfeitos os critérios №2 e №3 { // Preenchimento de matrizes para a tendência de baixa ArrayResize(DownTrend,y+1); DownTrend[y].a=a; DownTrend[y].b=b; DownTrend[y].ax=ax; DownTrend[y].bx=bx; DownTrend[y].dst=MathAbs(deviation); DownTrend[y].coef=coef; y++; } } } } } } // No gráfico, exibimos as linhas descendentes de acordo com a matriz obtida for(j=0; j<ArraySize(DownTrend); j++) { a=DownTrend[j].a; b=DownTrend[j].b; ax=DownTrend[j].ax; bx=DownTrend[j].bx; coef=DownTrend[j].coef; if(a>0 && b>0 && MathAbs(a-b)>0) { if(a>0 && b>0 && MathAbs(a-b)>0) { //--- criamos as linhas de tendência TrendCreate(0,"DownTrend "+string(j),0,time[a],ax,time[b],bx,DColor,DStyle,DWidth,DBack,DSelection,DRayLeft,DRayRight,DHidden,DZOrder); ChartRedraw(); } }
Exemplos de construção do indicador:
Uso de linhas de suporte e resistência na negociação
Relativamente aos níveis de suporte e resistência, o princípio básico do tranding consiste em comprar perto da linha de suporte, na tendência ascendente (e vender na descendente) ou durante a fase de correção. Usam-se alguns modelos gráficos (padrões).
Este tipo de estratégia de negociação permite tirar partido do movimento da tendência, mesmo quando o instrumento está numa fase de correção, ou quando o preço faz com que se forme certa figura. A tendência ajuda a determinar a direção em que você deseja abrir o trade. Por exemplo, se a tendência atual for descendente e, em seguida, mudar para uma fase de correção, é preferível abrir o trade de venda perto da linha de resistência, em vez de comprar no nível de suporte. O fato de a tendência ser descendente significa que os trades de venda são mais propensos a ter sucesso do que uma transação de compra. Se a tendência for ascendente e, em seguida, for formado um triângulo, será melhor abrir o trade de compra perto da linha de suporte desse triângulo.
Pode ser rentável abrir trades perto das linhas de suporte e resistência de acordo com a tendência, mas, muitas vezes, o preço rompe esses níveis. Por isso, é necessário esperar a confirmação da relevância do nível do instrumento financeiro em questão. Antes de comprar ou vender na linha, deve-se esperar a consolidação do preço ao lado dela. Alternativamente, pode-se esperar uma recuperação do nível de preços, e abrir o trade só depois disso.
Após abrir um trade de compra a partir da linha de suporte, é recomendável esperar a consolidação do preço ao lado dela, e, só depois, abrir uma ordem de compra, após o preço quebrar para acima o High desta zona de consolidação. Isso não só torna possível garantir que o nível realmente influencia o preço, mas também que este último se moverá na direção certa (para cima) a partir deste nível. Isso é exatamente o que precisamos para comprar. Algo semelhante acontece quado se abrem trades de venda a partir da linha de resistência, por isso, é necessário esperar uma consolidação perto da zona de resistência, e, só então, abrir o trade quando o preço cai abaixo do Low desta zona de consolidação.
Ao abrir um trade, é necessário prever com antecedência as condições para seu encerramento. Ao abrir um trade de compra a partir da linha de suporte, convém fechá-lo antes de o preço atingir a linha de resistência, com força. Algo semelhante acontece na abertura da trades de venda. Também é possível fechar trades nos níveis de suporte e resistência secundários. Ao comprar na linha de suporte, é preciso vender no nível de resistência dentro do canal de tendência ascendente. Mas também é possível tentar obter um maior lucro permitindo o preço quebrar o nível. Por exemplo, ao comprar a partir do nível de suporte no triângulo (com uma tendência de alta geral), pode-se manter a posição até o preço romper o triângulo e não continuar a subir. Depois disso, pode-se sair do trade, na próxima linha de resistência.
EA baseado no indicador
Abaixo está um EA com as seguintes função:
- StopLoss e TakeProfit
- Número máximo de ordens Buy/Sell
- Trailing Stop
- Função de break-even
- Fechamento de trades opostos de acordo com os sinais do indicador
- 4 filtros HTF (MACD, RSI, WPR, MA) com capacidade de seleção
O Advisor trabalha diretamente com as linhas de tendência criadas pelo indicador, por isso, para ele funcionar em tempo real, é preciso adicionar um indicador no gráfico com o EA estabelecido. Configurações que tenham a ver com o indicador devem ser definidas nele. No EA também existem configurações de indicador, mas elas são usadas apenas durante o teste. Para se poder testar o EA, no código é criado um identificador para o indicador, identificador esse que é definido na inicialização do advisor.
Há 3 modos de trabalho com o EA:
- from level - negociação com os preços refletidos sobre a linha de tendência. O trade é aberto quando: o preço mínimo ou máximo da barra atravessa o nível, o preço de fechamento não rompe a linha de tendência atual, bem como o preço da próxima barra está fechada sem ter quebrado a linha. Verifica-se se o preço rompeu a linha após tê-la tocado.
- level breakdown - negociação quando o preço quebra a linha de tendência. O trade é aberto quando: o preço mínimo ou máximo da barra atravessa o nível, o preço de fechamento não rompe a linha de tendência atual, bem como o candle da próxima barra está fechado após quebrar a linha de tendência.
- all - usam-se ambos os modos mencionados acima.
Abaixo é apresentada a função no código onde são formados os sinais de compra e venda:
//+------------------------------------------------------------------+ int signal() { int res=0; int macd=0; int rsi=0; int wpr=0; int ma=0; if(Use_macd==true)macd=macdS(); if(Use_rsi==true)rsi=rsiS(); if(Use_wpr==true)wpr=wprS(); if(Use_ma==true)ma=maS(); CopyOpen(NULL,0,1,3,O); CopyHigh(NULL,0,1,3,H); CopyLow(NULL,0,1,3,L); CopyClose(NULL,0,1,3,C); Signals=0; for(int i=0;i<ObjectsTotal(0,0,OBJ_TREND);i++) { string sName=ObjectName(0,i,0,OBJ_TREND); if(StringFind(sName,"UpTrend")==0 || StringFind(sName,"DownTrend")==0) { ax=ObjectGetDouble(0,sName,OBJPROP_PRICE,0); bx=ObjectGetDouble(0,sName,OBJPROP_PRICE,1); p1=(int)ObjectGetInteger(0,sName,OBJPROP_TIME,0); p2=(int)ObjectGetInteger(0,sName,OBJPROP_TIME,1); a=iBarShift(p1); b=iBarShift(p2); kkk=(bx-ax)/(a-b); lvl=bx+kkk*b; plvl=bx+kkk*(b-1); if(mode==0 || mode==2) { if(StringFind(sName,"UpTrend")==0 && L[1]<=plvl && C[1]>plvl && C[0]>lvl)Signals=1; if(StringFind(sName,"DownTrend")==0 && H[1]>=plvl && C[1]<plvl && C[0]<lvl)Signals=2; } if(mode==1 || mode==2) { if(StringFind(sName,"UpTrend")==0 && L[1]<=plvl && C[1]>plvl && C[0]<lvl)Signals=2; if(StringFind(sName,"DownTrend")==0 && H[1]>=plvl && C[1]<plvl && C[0]>lvl)Signals=1; } } } if(Signals==1 &&(macd==1 || Use_macd==false) && (rsi==1 || Use_rsi==false) && (wpr==1 || Use_wpr==false) && (ma==1 || Use_ma==false))res=1; if(Signals==2 &&(macd==2 || Use_macd==false) && (rsi==2 || Use_rsi==false) && (wpr==2 || Use_wpr==false) && (ma==2 || Use_ma==false))res=2; return(res); } //+------------------------------------------------------------------+
Durante o teste, foi possível determinar que é menos rentável operar com a recuperação a partir da linha do que negociar com o rompimento de níveis.
Abaixo estão os gráficos de teste de três modos com os seguintes parâmetros de entrada:
input string s="-------------------------------------------"; // Main settings input int Magic=12345; input double LotSize=0.1; input int Slippage=30; //Slippage, points input int StopLoss=0; //StopLoss, points input int TakeProfit=0; //TakeProfit, points input int TrailingStart=0; //Trailing Start, points input int TrailingStop= 0; //Trailing Stop, points input int TrailingStep= 0; //Trailing Step, points input int SL_prof=0; //Start BE, points input int SL_lev=0; //BE level, points input int Buy_max=1; //Max Buy orders input int Sell_max=1; //Max Sell orders input bool Sig_close=true; //Close counter transactions input tip mode=0; input string s0="-------------------------------------------"; // Indicators settings input int _ExtDepth=12; input int _ExtDeviation=5; input int _ExtBackstep=3; input int _Min_dist=0; // Minimum distance input int _fibo=30; // Fibo ratio input int _tolerance=200; // Tolerance input int _Intersection_ab=1; // The allowed number of intersections from point a to point b input int _Intersection_bc=1; // The allowed number of intersections from point b to point c input string s1="-------------------------------------------"; // MACD settings input ENUM_TIMEFRAMES macd_tf=PERIOD_CURRENT; // period input int fast_ema_period=12; // period of fast ma input int slow_ema_period=26; // period of slow ma input int signal_period=9; // period of averaging of difference input ENUM_APPLIED_PRICE applied_price=PRICE_CLOSE; // type of price input string s2="-------------------------------------------"; // RSI settings input ENUM_TIMEFRAMES rsi_tf=PERIOD_CURRENT; // period input int rsi_period=14; // period input ENUM_APPLIED_PRICE rsi_applied_price=PRICE_CLOSE; // type of price input double rsi_max_s=100; // max price for Sell input double rsi_min_s=70; // min price for Sell input double rsi_max_b=30; // max price for Buy input double rsi_min_b=0; // min price for Buy input string s3="-------------------------------------------"; // WPR settings input ENUM_TIMEFRAMES wpr_tf=PERIOD_CURRENT; // period input int calc_period=14; // period input double wpr_max_s=0; // max price for Sell input double wpr_min_s=-20; // min price for Sell input double wpr_max_b=-80; // max price for Buy input double wpr_min_b=-100; // min price for Buy input string s4="-------------------------------------------"; // MA settings input ENUM_TIMEFRAMES ma_tf=PERIOD_CURRENT; // period input int ma_period=10; // period of MA input int ma_shift=0; // shift input ENUM_MA_METHOD ma_method=MODE_SMA; // type of smoothing input ENUM_APPLIED_PRICE ma_applied_price=PRICE_CLOSE; // type of price input bool Use_macd=true; // Use MACD as a filter input bool Use_rsi=false; // Use RSI as a filter input bool Use_wpr=false; // Use WPR as a filter input bool Use_ma=false; // Use MA as a filter input int sbar=1; // Signal bar 0-current, 1-close
Durante o teste, foi aberto apenas um trade de 0,1 lotes, numa só direção. Com o sinal contrário, foi fechado o trade atual e aberto seu oposto. Foi usado o filtro do indicador MACD, neste caso, trades de compra foram abertos quando os valores do indicador eram inferiores a zero, enquanto, de venda - superiores a zero. O teste foi realizado num intervalo de tempo de 1 hora no EURUSD para 2015-2017.
Modo from level:
Modo level breakdown:
Abaixo estão os resultados do teste com as configurações padrão em vários pares de moedas.
Aqui, vê-se que os bons resultados só são mostrados no pares EURUSD e USDCHF. Isto é principalmente devido ao fato de que nem todas as linhas devem ser consideradas na negociação. Adicionalmente, é preciso levar em conta outros fatores listados anteriormente neste artigo.
Além disso, é necessário se lembrar sobre o impacto da análise fundamental, bem como o fato de as linhas de suporte/resistência, muitas vezes, ocorrerem após a publicação de notícias importantes.
Por isso, pode-se adiciona um filtro de notícias ao EA e, em seguida, testar o funcionamento apenas quando publicadas notícias ou proibido o trabalho após liberadas notícias. Como alternativa, este Advisor pode ser usado nos gráficos Renko.
Otimização
Na minha opinião, originalmente, os primeiros sete parâmetros foram estabelecidos de forma ideal, no EA, portanto, eu não fiz sua posterior otimização. Mas os parâmetros do indicador de ZigZag, por sua vez, são definidos por padrão, e não nos serviam como estavam. Após a otimização, foi possível confirmar que, para todas as moedas previamente testadas, os seguintes parâmetros são os mais adequados:
- _ExtDepth=24;
- _ExtDeviation=55;
- _ExtBackstep=9;
Durante a otimização, para abertura de trades, foi definido qual o modo de trabalho era mais adequado para um instrumento financeiro específico, bem como quanto afeta o resultado ao usar filtro. Só o indicador MACD foi usado como filtro. Mas, pode-se tentar trabalhar com quaisquer outros indicadores em diferentes intervalos de tempo.
A função de fechamento usando o sinal oposto foi utilizada para fechar tanto trades lucrativos como desfavoráveis. As funções de break-even e take-profit foram utilizadas para fixar o lucro e obter os melhores resultados. Foi durante o teste que se definiram os parâmetros ótimos, para cada moeda segundo estas funções.
Não foi usado stop-loss para fixar perdas, mas os trades desfavoráveis foram fechados apenas pelo sinal oposto.
O processo de otimização é exibido na tabela. Os testes foram realizados com um lote de 0,1, para 2017. Além disso, o número de trades de compra e venda abertos aumento até 10, todos os outros parâmetros foram definidos por padrão.
| Símbolo | Modo |
Filtro MACD | TakeProfit |
Start BE |
Lucro |
Profit Factor: | Recovery Factor: |
Max DD,% |
Total Trades: | Profit Trades,% |
|---|---|---|---|---|---|---|---|---|---|---|
| EURUSD |
level breakdown |
false |
0 |
25 |
117.20 |
1.88 |
1.65 |
0.69 |
79 |
73.42 |
| USDCHF |
level breakdown | false | 20 |
10 |
135.24 |
1.31 |
1.12 |
1.03 |
482 |
72.41 |
| GBPCHF |
from level |
true |
20 |
10 |
91.56 |
1.39 |
0.51 |
1.58 |
246 |
91.06 |
| AUDUSD |
level breakdown | false | 20 |
10 |
139.20 |
1.39 |
1.66 |
0.79 |
485 |
71.96 |
| AUDCAD |
level breakdown | true | 25 |
5 |
117.51 |
1.94 |
1.06 |
0.57 |
246 |
84.96 |
| EURJPY |
level breakdown | false | 20 |
5 |
128.90 |
1.60 |
0.98 |
1.26 |
341 |
78.89 |
| GBPUSD |
from level | false | 100 |
0 |
102.1 |
1.20 |
1.32 |
0.58 |
274 |
52.92 |
| USDJPY |
from level | false | 30 |
0 |
147.75 |
1.56 |
0.79 |
1.73 |
348 |
79.89 |
| EURGBP |
from level | true | 20 |
5 |
124.45 |
1.39 |
1.14 |
1.03 |
341 |
78.01 |
| EURCHF |
from level | true | 20 |
5 |
141.08 |
2.07 |
1.88 |
0.68 |
367 |
63.22 |
| USDCAD |
level breakdown | false |
100 |
25 |
142.57 |
1.46 |
0.45 |
1.22 |
248 |
78.87 |
| NZDUSD |
from level | false | 0 |
25 |
270.50 |
1.37 |
1.04 |
2.37 |
616 |
62.11 |
| GBPJPY |
level breakdown | true | 150 |
20 |
163.62 |
2.56 |
1.10 |
1.41 |
103 |
68.25 |
Fim do artigo
O artigo mostrou o princípio básico de construção automática de linhas de suporte e resistência. Com base nele, foi criado um EA e feita a otimização de parâmetros de entrada em 13 instrumentos financeiros. É necessário selecionar individualmente os parâmetros ideais do instrumento financeiro, a fim de obter os melhores resultados. Foi criado um EA com várias funções básicas e 4 filtros HTF, para encontrar os parâmetros ideais, automatizar a negociação e verificar o funcionamento das linas de suporte e resistência. No futuro, o indicador e o EA podem ser expandidos e atualizados, dependendo das necessidades específicas de cada trader.
Graças aos resultados do trabalho, foi possível determinar que é menos rentável operar com a recuperação do que com o rompimento de níveis. Isto sugere que a natureza do movimento de cada instrumento financeiro é diferente e, portanto, eles precisam de uma abordagem individual.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/3215
LifeHack para traders: preparemos "fast-food" de indicadores
Testador de estratégia personalizada com base em cálculos matemáticos rápido
O padrão Rompimento de Canal
Como reduzir os riscos trader
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso