Carteira de Investimentos no MetaTrader 4

31 outubro 2016, 11:50
transcendreamer
0
1 440

Magnus ab integro saeclorum nascitur ordo
Publius Vergilius Maro, Eclogues

Introdução

O princípio da Carteira de Investimentos é conhecido há muito tempo. Ao diversificar os fundos em várias direções, os investidores criam suas carteiras reduzindo o risco global de perda, tornando o crescimento da renda mais suave. A teoria da Carteira de Investimentos ganhou impulso em 1950, quando o primeiro modelo matemático foi proposto por Harry Markowitz. Em 1980, uma equipe de pesquisa da Morgan Stanley desenvolveu a primeira extensão da estratégia de negociação e abriu o caminho para um grupo de estratégias neutras de mercado. A presente teoria é complexa e variada a ponto de tornar quase impossível descrever todas as estratégias de carteira num único artigo. Portanto, abordaremos apenas uma pequena variação de estratégias especulativas, juntamente com a sua eventual aplicação na plataforma MetaTrader 4.

Neste artigo, serão aplicadas algumas definições, sendo elas:

  • Carteira de Investimentos (cesta, instrumento sintético) — é o conjunto de posições em multiplos instrumentos de negociação com ótimos volumes calculados. As posições que permanecem abertas por algum tempo, são rastreadas como se fossem uma e são finalizadas com um resultado financeiro comum.
  • Carteira de Investimentos de ajuste (cesta, instrumento sintético) — altera o conjunto de instrumentos da carteira e/ou seus volumes para minimizar as perdas ou corrigir resultados intermediários.
  • Volume sintético — é o número de posições sintéticas (número de vezes que a carteira foi comprada ou vendida).
  • Lucro/perda virtual — é o resultado financeiro que pode ser obtido ao segurar uma posição dentro de um determinado intervalo de tempo.

Carteiras de investimentos clássicas são, geralmente, aplicadas em bolsas de valores. No entanto, essa abordagem não combina muito com o Forex, já que a maioria das carteiras são especulativos. Elas são criadas e negociados um pouco diferente. No que diz respeito ao Forex, a negociação da Carteira de Investimentos é atualmente uma negociação de multi-moedas, entretanto, nem todas as estratégias de multi-moedas possuem uma carteira. Se os ativos forem negociados de forma independente e nenhuma dinâmica de resultados totais são rastreados, então, isto é uma negociação multi-moedas. Se vários sistemas independentes negociarem numa única conta de negociação, então isto será uma estratégia de Carteira de Investimentos. Aqui vamos considerar uma negociação da Carteira de Investimentos no sentido restrito — ou seja, quando uma posição sintética é formada a partir de diversos ativos, sendo gerenciada depois.


Princípios

O desenvolvimento da carteira consiste em três etapas: a seleção dos ativos, o cálculo dos lotes e as suas direções. Aqui discutiremos apenas alguns métodos simples de desenvolvimento da carteira, juntamente com o modelo do algoritmo. Em particular, propomos basicamente os métodos de Mínimos Quadrados Ordinários (MQO) e a Análise de Componentes Principais (ACP ou PCA). Mais informações podem ser encontradas aqui:

Ao desenvolver uma carteira, geralmente é necessário definir o comportamento gráfico desejado da mesma. O gráfico da carteira representa as mudanças do lucro total de todas as posições incluídas na carteira, dentro de um determinado intervalo de tempo. A otimização da carteira é uma busca por uma combinação de lotes e direções, para o melhor ajuste do comportamento desejado da mesma. Por exemplo, dependendo da nossa tarefa, pode ser que seja necessário que a carteira tenha um retorno de valor médio ou os atributos de uma tendência assimilada, ou talvez, o seu gráfico deva ser semelhante ao gráfico da função.

Três tipos de carteiras (tendência, lateralidade e função):


A carteira pode ser representado pela seguinte equação:

A*k1 + B*k2 + C*k3 + ... = F,

Onde

A, B, C ... são séries de tempo correspondente ao ativos da carteira

k1, k2, k3 ... são os lotes dos ativos(positivos — compra, negativo — venda)

F — função alvo (definida por valores em pontos de séries de tempo)

Esta é uma equação de regressão linear multivariada, com um zero como termo constante. Suas raízes podem ser facilmente encontradas ao usar o MQO. Inicialmente, as séries de tempo devem ser produzidas para serem compatíveis, deste modo, os pontos de preço serão conduzidos a um depósito de moedas. Neste caso, cada elemento de cada série de tempo representará um valor de lucro virtual de um único lote do ativo apropriado, num momento particular. O preço preliminar da logaritimação ou as diferenças de preços são usualmente recomendadas nas tarefas de aplicações das estatísticas. No entanto, neste caso, isso pode ser desnecessário e até mesmo prejudicial, desde que os dados críticos dos ativos dinâmicos gerais seriam, ao longo do caminho, destruídos.

A função alvo define o tipo do gráfico da carteira. Os valores da função alvo devem ser, preliminarmente, calculados em cada ponto adequadamente. Por exemplo, quando se desenvolve uma simples carteira crescente (carteira de tendência), a carteira de destino terá os valores 0, 1*S, 2*S, 3*S, etc., onde S é um incremento — ou seja, o valor em dinheiro, para o qual a carteira deve aumentar em cada barra, num intervalo pré-determinado. O algorítmo MQO adiciona as séries de tempo A, B, C, ... para que a sua soma total busque repetir a função alvo no gráfico. Para alcançar este objetivo, o algoritmo MQO minimiza a soma dos quadrados dos desvios entre a soma da série e a função alvo, esta é uma tarefa de estatística padrão. Nenhuma explicação detalhada do algoritmo da operação é requerida desde que você use uma biblioteca já pronta.

Também pode acontecer da função alvo conter somente valores nulos (carteira de lateralidade). Neste caso, uma taxa adicional do limite de soma suplementar deve ser acrescentada (por exemplo: k1 + k2 + k3 + ... = 1) para ignorar a resolução de uma equação de regressão com raízes zero. A alternativa é mover um termo da equação para a direita, tornando-a uma função alvo, no qual recebe a taxa -1, enquanto são otimizados os termos restantes, como de costume. Neste caso, nós igualamos a cesta de instrumentos a um instrumento selecionado, consequentemente criamos uma carteira crescente. Finalmente, o algoritmo PCA mais avançado pode ser usado para desenvolver essas carteiras. Aplica-se o instrumento da matriz covariante para calcular o vetor coeficiente, correspondendo ao ponto de nuvem cruzando o hiperplano da seção com a variância residual mínima da carteira. Novamente, não é necessario entender o algoritmo em detalhes aqui, pois pode-se usar uma biblioteca já pronta.


Algoritmos

Agora, é hora de implementar todas as ideias descritas acima utilizando a linguagem MQL. Usaremos uma biblioteca matemática bem conhecida (ALGLIB), adaptada para MT4. Às vezes, problemas podem ocorrer durante a sua instalação, por isso o assunto será melhor desenvolvido. Se vários terminais estão instalados no PC, é muito importante encontrar a pasta correta de dados, uma vez que o compilador não vê a biblioteca, caso ela esteja localizada em outra pasta de dados do terminal.

Instalando a biblioteca ALGLIB:

  1. Baixar a biblioteca e descompactar o arquivo zip;
  2. Abrir a pasta 'include' e procurar pelo diretório Math;
  3. Abrir a plataforma МetaТrader 4, ao qual a biblioteca deve ser adicionada;
  4. Selecionar o comando de menu: Arquivo — Abrir Pasta de Dados;
  5. Abrir o MQL4 e a subpasta Include;
  6. Copiar a pasta Math para a pasta Include do terminal;
  7. Verificar os resultados: os arquivos *.mhq devem estar dentro da pasta MQL4\Include\Math\Alglib.
O primeiro estágio da chave: é a conversão das séries de tempo a partir dos pontos de preço dentro do depósito da moeda. Para conseguir isso, é necessário escrever uma função especial para calcular o preço do contrato a qualquer momento. A função convencional MarketInfo não é muito adequada para isso, pois fornece um ponto de preço correto somente para a última barra do gráfico. O problema é que os desvios, inevitavelmente, aparecem no histórico como pontos de preços de alguns ativos, o quais mudam constantemente. Portanto, é fundamental converter com precisão a série de dados para evitar desequilíbrios significativos na sua carteira.

A função modelo, calcula o preço do contrato tal como é apresentado abaixo:

double ContractValue(string symbol,datetime time,int period)
  {
   double value=MarketInfo(symbol,MODE_LOTSIZE);                     // recebe o tamanho do lote
   string quote=SymbolInfoString(symbol,SYMBOL_CURRENCY_PROFIT);     // recebe a moeda de cálculo

   if(quote!="USD")                                                  // se a moeda de cálculo não for USD, executar a conversão
     {
      string direct=FX_prefix+quote+"USD"+FX_postfix;                // formar uma cotação direta para a moeda de cálculo
      if(MarketInfo(direct,MODE_POINT)!=0)                           // verificar a existência
        {
         int shift=iBarShift(direct,period,time);                    // encontrar a barra pelo tempo
         double price=iClose(direct,period,shift);                   // receber a cotação da barra
         if(price>0) value*=price;                                   // calcular o preço
        }
      else
        {
         string indirect=FX_prefix+"USD"+quote+FX_postfix;           // formar uma cotação de reversão para a moeda de cálculo
         int shift=iBarShift(indirect,period,time);                  // encontrar a barra pelo tempo
         double price=iClose(indirect,period,shift);                 // receber a cotação da barra
         if(price>0) value/=price;                                   // calcular o preço
        }
     }

   if(Chart_Currency!="USD")                                         // se a moeda destino não for utilizada, realizar uma conversão
     {
      string direct=FX_prefix+Chart_Currency+"USD"+FX_postfix;       // formar uma cotação direta para a moeda destino
      if(MarketInfo(direct,MODE_POINT)!=0)                           // verificar a existência
        {
         int shift=iBarShift(direct,period,time);                    // encontrar a barra pelo tempo
         double price=iClose(direct,period,shift);                   // receber a cotação da barra
         if(price>0) value/=price;                                   // calcular o preço
       }
      else
        {
         string indirect=FX_prefix+"USD"+Chart_Currency+FX_postfix;  // formar uma cotação reversão para a moeda destino
         int shift=iBarShift(indirect,period,time);                  // encontrar a barra pelo tempo
         double price=iClose(indirect,period,shift);                 // receber a cotação da barra
         if(price>0) value*=price;                                   // calcular o preço
        }
     }

   return(value);
  }

Esta função sempre será utilizada no futuro. Ela trabalha com pares de moedas, índices, futuros e CFDs. Além disso, também considera prefixos e sufixos dos ativos (FX_prefix, FX_postfix) aplicados por algumas corretoras. O resultado é convertido numa moeda de destino (Chart_Currency). Se multiplicarmos o valor de retorno da função pelo preço do ativo corrente, obtemos de preço de um lote do ativo. Após somar o preço de todos os contratos de lotes usados na carteira, nós obtemos o seu preço total. Se multiplicarmos a função de valor por uma diferença de preço no tempo, receberemos o lucro ou prejuízo gerado durante a alteração de preços.

O próximo passo é calcular o lucro virtual para todos os contratos de lotes individuais. O cálculo é implementado como um array bidimensional, aonde a primeira dimensão é um índice de ponto no intervalo calculado, enquanto a segunda dimensão é um índice de ativo (a segunda dimensão pode ser limitada por um determinado número, sabendo que a quantidade de ativos na carteira , obviamente, não irá ultrapassá-lo):

double EQUITY[][100];     // primeira dimensão é para as barras, enquanto a segunda é para os ativos

Primeiramente, não deveremos armazenar os preços iniciais para todos os ativos (no limite esquerdo do intervalo calculado). Então, a diferença entre os preços iniciais e finais é calculado em cada ponto do intervalo que também é calculado e multiplica pelo preço do contrato. A cada turno, deslocamos para a direita apenas um único intervalo no loop:

   for(int i=0; i<variables+constants; i++)                              //loop de ativos da carteira (variável e modelos constantes)
     {
      int shift=iBarShift(SYMBOLS[i],Timeframe,zero_time);               // recebe o índice de barra pelo tempo para um ponto zero
      opening[i]=iClose(SYMBOLS[i],Timeframe,shift);                     // recebe o preço da barra e salva no array
     }

   points=0;                                                             // calcula os pontos na variável
   datetime current_time=zero_time;                                      // inicia um loop a partir do ponto zero
   while(current_time<=limit_time)                                       // repassar a etiqueta de tempo no intervalo da otimização
     {
      bool skip_bar=false;
      afor(int i=0; i<variables+constants; i++)                           // loop de ativos de carteira (variaveis e modelos constantes)
         if(iBarShift(SYMBOLS[i],Timeframe,current_time,true)==-1)       // verifica a existência de barra para o ativo
            skip_bar=true;                                               // se a barra não existe, pular para outros ativos
      if(!skip_bar)                                                      // continua a operação se a barra estiver sincronizada entre todos os ativos
        {
         points++;                                                       // aumentar o número de pontos por um
         TIMES[points-1]=current_time;                                   // etiqueta de tempo armazenado na memória
         for(int i=0; i<variables+constants; i++)                        // loop principal do cálculo de lucro para todos os ativos no ponto
           {
            int shift=iBarShift(SYMBOLS[i],Timeframe,current_time);      // recebe o índice de barra pelo tempo
            closing[i]=iClose(SYMBOLS[i],Timeframe,shift);               // recebe o valor das barras
            double CV=ContractValue(SYMBOLS[i],current_time,Timeframe);  // calcula o preço do contrato
            profit[i]=(closing[i]-opening[i])*CV;                        // calcula o lucro por diferença de preço e custo
            EQUITY[points-1,i]=profit[i];                                // salva o valor do lucro
           }
        }
      current_time+=Timeframe*60;                                        // trocar para o próximo intervalo de tempo
     }

No trecho de código acima, zero_time — é o tempo do intervalo calculado da margem esquerda, limit_time — é o tempo do intervalo calculado da margem à direita, Timeframe — é o número de minutos na barra de acordo com o período de tempo utilizado, points — é o número total de pontos detectados no intervalo calculado. A regra da etiqueta de tempo de estrita conformidade é usada no exemplo acima, se numa barra está faltando apenas um ativo na etiqueta de tempo, uma posição é ignorada e um deslocamento é feita na próxima. O gerenciamento das etiquetas de tempo é muito importante na preparação dos dados preliminares, uma vez que o desalinhamento dos dados relativos aos diferentes ativos podem causar graves distorções na carteira.

Os dados do modelo de carteira para três ativos e uma função independente (parábola de raiz quadrada):

DATE/TIME AUDJPY GBPUSD EURCAD MODEL
03.08.16 14:00 0 0 0 0
03.08.16 15:00 -61,34 -155 -230,06 10,21
03.08.16 16:00 -82,04 -433 -219,12 14,43
03.08.16 17:00 -39,5 -335 -356,68 17,68
03.08.16 18:00 147,05 -230 -516,15 20,41
03.08.16 19:00 169,73 -278 -567,1 22,82
03.08.16 20:00 -14,81 -400 -703,02 25
03.08.16 21:00 -109,76 -405 -753,15 27
03.08.16 22:00 -21,74 -409 -796,49 28,87
03.08.16 23:00 51,37 -323 -812,04 30,62
04.08.16 00:00 45,43 -367 -753,36 32,27
04.08.16 01:00 86,88 -274 -807,34 33,85
04.08.16 02:00 130,26 -288 -761,16 35,36
04.08.16 03:00 321,92 -194 -1018,51 36,8
04.08.16 04:00 148,58 -205 -927,15 38,19
04.08.16 05:00 187 -133 -824,26 39,53
04.08.16 06:00 243,08 -249 -918,82 40,82
04.08.16 07:00 325,85 -270 -910,46 42,08
04.08.16 08:00 460,02 -476 -907,67 43,3
04.08.16 09:00 341,7 -671 -840,46 44,49


Agora que temos os dados dispostos, nós o enviaremos ao modelo de otimização. A otimização deve ser realizada utilizando as funções LRBuildZ, LSFitLinearC e PCABuildBasis da biblioteca ALGLIB. Estas funções estão descritas, resumidamente, no interior da própria biblioteca, assim como no site do projeto oficial: http://www.alglib.net/dataanalysis/linearregression.php e aqui: http://www.alglib.net/dataanalysis/principalcomponentsanalysis.php.

Primeiro, certifique-se de incluir a biblioteca:

#include <Math\Alglib\alglib.mqh>

Em seguida, o trecho de código, considerando o modelo, deve ser definido para cada modelo de otimização. Primeiro, examinaremos o exemplo do modelo de tendência:

   if(Model_Type==trend)
     {
      int info,i,j;                                                                                  // definir variáveis de trabalho
      CLinearModelShell LM;                                                                          // definir um modelo de objeto especial
      CLRReportShell AR;                                                                             // definir um relatório especial do objeto
      CLSFitReportShell report;                                                                      // definir ainda um outro objeto
      CMatrixDouble MATRIX(points,variables+1);                                                      // definir uma matriz para armazenar todos os dados
      if(Model_Growth==0) { Alert("Zero model growth!"); error=true; return; }                       // verificar os parâmetros do modelo
      for(j=0; j<points; j++)                                                                        // calcular a função de destino para otimizar os pontos de intervalo
        {
         double x=(double)j/(points-1)-Model_Phase;                                                  // calcular a coordenada X
         if(Model_Absolute) x=MathAbs(x);                                                            // se necessário, tornar o modelo simétrico
         MODEL[j]=Model_Growth*x;                                                                    // calcular a coordenada Y
        }
      double zero_shift=-MODEL[0]; if(zero_shift!=0) for(j=0; j<points; j++) MODEL[j]+=zero_shift;   // deslocar o modelo verticalmente para o ponto zero
      for(i=0; i<variables; i++) for(j=0; j<points; j++) MATRIX[j].Set(i,EQUITY[j,i]);               // baixar os dados de símbolo para a matriz
      for(j=0; j<points; j++) MATRIX[j].Set(variables,MODEL[j]);                                     //baixar os dados do modelo para a matriz
      CAlglib::LRBuildZ(MATRIX,points,variables,info,LM,AR);                                         // iniciar o cálculo de regressão
      if(info<0) { Alert("Error in regression model!"); error=true; return; }                        // verificar o resultado
      CAlglib::LRUnpack(LM,ROOTS,variables);                                                         // receber as raízes da equação
     }

A princípio, isso pode parecer complicado, no entanto é tudo muito simples. No início, a função de tendência linear é calculada e os seus valores são colocados no array MODEL. O parametro Model_Growth define o valor de crescimento para todo o cálculo de intervalo (o valor, pelo qual a carteira deve crescer na moeda de depósito). O Model_Absolute e o Model_Phase são parâmetros opcionais e não têm importância no atual estágio. A matriz é criada para realizar os cálculos (MATRIX). Os dados sobre o lucro virtual de todos os contratos do array EQUITY , tal como os valores da função alvo do array MODEL são baixados para a última linha da matriz. O número de variáveis independentes da equação de regressão é armazenada nas 'variáveis'. A função LRBuildZ é chamada posteriormente, para executar o cálculo. Depois disso, as raízes da equação de regressão são gravadas em série no array ROOTS usando a função LRUnpack. Toda a complexidade matemática está localizada dentro da biblioteca, enquanto você pode usar as funções já prontas. A principal dificuldade aqui é de natureza técnica e está relacionada com a criação correta de todas as chamadas, tal como a preservação de dados durante os preparativos.

O mesmo trecho de código pode ser utilizado para qualquer função. Simplesmente, troque o conteúdo do array MODEL com o da sua função alvo. O cálculo da função raiz quadrada parabólica é demonstrado a seguir:

      for(j=0; j<points; j++)                               // calcular a função alvo através da otimização dos pontos de intervalo
        {
         double x=(double)j/(points-1)-Model_Phase;         // calcular o valor do eixo X
         int sign=(int)MathSign(x);                         // definir o valor do sinal
         if(Model_Absolute) sign=1;                         // se necessário, tornar o modelo simétrico
         MODEL[j]=sign*Model_Growth*MathSqrt(MathAbs(x));   // calcular o valor do eixo Y
        }

A seguir, temos um exemplo de uma função mais complexa, no qual representa a soma de uma tendência linear e de uma oscilação harmônica:

      for(j=0; j<points; j++)                                     // calcular a função alvo para a otimização dos pontos de intervalo
        {
         double x=(double)j/(points-1)*Model_Cycles-Model_Phase;  // calcular o valor do eixo X
         if(Model_Absolute) x=MathAbs(x);                         // se necessário, tornar o modelo simétrico
         MODEL[j]=Model_Amplitude*MathSin(2*M_PI*x);              // calcular o valor da ordenada Y
        }

No exemplo acima, é possível administrar o tamanho da tendencia (usando o parâmetro Model_Growth) e a amplitude de oscilação (usando o parâmetro Model_Amplitude). O número de ciclos de oscilações é definido pelo Model_Cycles, enquanto o deslocamento da fase de oscilação é realizada utilizando o Model_Phase.

Além disso, um deslocamento vertical deve ser realizado para permitir que a função seja igual a zero no ponto para garantir que os cálculos estão corretos:

   double zero_shift=-MODEL[0];   // leia o valor de modelo no ponto zero
   if(zero_shift!=0)              //certifique-se de que não é zero
      for(j=0; j<points; j++)     // repassar todos os pontos de intervalo
         MODEL[j]+=zero_shift;    // deslocar todos os pontos do modelo

Estes exemplos tornam fácil o desenvolvimento de uma função personalizada. Você pode criar qualquer tipo de função, dependendo da sua tarefa e configuração da negociação. Quanto mais complexo for o tipo de função, mais difícil será selecionar a melhor solução, uma vez que o mercado não é obrigado a seguir a função. Aqui, a função é apenas uma aproximação.

Você não precisa de uma função alvo para criar spread e retornar uma carteira de lateralidade. Por exemplo, se você deseja criar um spread entre duas cestas de ativos, a cesta otimizada é baixada para a principal parte da matriz, enquanto a cesta de referência é usada como uma função alvo e transferida para a última coluna da matriz como um valor total:

   for(i=0; i<variables; i++)                    // ciclo pela cesta de ativos otimizados
      for(j=0; j<points; j++)                    // ciclo pelos pontos do intervalo calculado
         MATRIX[j].Set(i,EQUITY[j,i]);           // atualização de valores dos ativos da cesta otimizada para as colunas da matriz
   for(i=variables; i<variables+constants; i++)  // ciclo pelas cestas dos ativos de referência
      for(j=0; j<points; j++)                    // ciclo pelos pontos do intervalo calculado
         MODEL[j]+=EQUITY[j,i]*LOTS[i];          // atualização dos valores dos ativos da cesta de referência para a última coluna da matriz

A seguir o exemplo de cálculo da carteira de lateralidade, onde a função LSFitLinearC torna a carteira a mais simétrica possível, em torno de zero, dentro do intervalo calculado:

   if(Model_Type==fitting)
     {
      int info,i,j;                                                                        // definir variáveis de trabalho
      CLSFitReportShell report;                                                            // definir o modelo especial do objeto
      CMatrixDouble CONSTRAIN(1,variables+1);                                              // definir a matriz de limitações lineares
      CMatrixDouble MATRIX(points,variables);                                              // definir a matriz para armazenar todos os dados
      ArrayInitialize(MODEL,0);                                                            // preencher o modelo com zeros
      CONSTRAIN[0].Set(variables,1);                                                       // definir a única limitação
      for(i=0; i<variables; i++) CONSTRAIN[0].Set(i,1);                                    // a soma das raízes deve ser igual a um
      for(i=0; i<variables; i++) for(j=0; j<points; j++) MATRIX[j].Set(i,EQUITY[j,i]);     // baixar dados do símbolo para a matriz
      CAlglib::LSFitLinearC(MODEL,MATRIX,CONSTRAIN,points,variables,1,info,ROOTS,report);  // calcular o modelo de otimização utilizando o MQO
      if(info<0) { Alert("Error in linear fitting model!"); error=true; return; }          // verificar o resultado
     }

Abaixo, temos mais um exemplo importante de como calcular uma carteira de lateralidade com a variável mínima, utilizando o método PCA. Aqui, a função PCABuildBasis calcula as taxas, de modo que o gráfico da carteira mantém-se comprimido o máximo possível dentro do intervalo do cálculo:

   if(Model_Type==principal)
     {
      int info,i,j;                                                                        // definir variáveis de trabalho
      double VAR[];                                                                        // definir a variavel do array
      ArrayResize(VAR,variables);                                                          // converter o array com a dimensão necessária
      CMatrixDouble VECTOR(variables,variables);                                           // definir o vetor coeficiente da matriz
      CMatrixDouble MATRIX(points,variables);                                              // definir a matriz para armazenar todos os dados
      for(i=0; i<variables; i++) for(j=0; j<points; j++) MATRIX[j].Set(i,EQUITY[j,i]);     // atualizar dados do ativo para a matriz
      CAlglib::PCABuildBasis(MATRIX,points,variables,info,VAR,VECTOR);                     // calcular a base ortogonal utilizando o PCA
      if(info<0) { Alert("Error in principal component model!"); error=true; return; }     // verificar o resultado
      for(i=0; i<variables; i++) ROOTS[i]=VECTOR[i][variables-1];                          // atualizar  as melhores taxas
     }

Se você se sentir sobrecarregado por todos esses conceitos, não se preocupe. Como já foi dito, você não precisa conhecer todos os detalhes matemáticos para desenvolver uma carteira. Em geral, a sequência de estágios tem o seguinte formato:

1 Cálculo do lucro virtual para ativos da carteira com lotes individuais
2 Calculando os valores da função alvo
3 O algoritmo de otimização do lote
4 Normalização de volume da carteira
5 Cálculo de gráfico e de negociação utilizando a carteira

Agora que obtivemos o array ROOTS das taxas ideais usando uma série de procedimentos, é hora de transformar as taxas em lotes. Para fazer isso, precisamos da normalização: escalas e arredondamento. A configuração de uma escala requerida faz lotes apropriados à negociação. O arrendodamento é necessário para ajustar os lotes em função dos requesitos da corretora. Às vezes, é recomendável realizar a normalização pela margem total da carteira, entretanto, este método tem sérias desvantagens (uma vez que a margem individuais dos ativos variam e podem alterar). Portanto é muito mais sensato efetuar a normalização pelo preço de uma carteira ou a sua volatilidade.

Abaixo está um exemplo simples do algoritmo de normalização da carteira pelo preço:

      double total_value=0;                                                                         // definir a variável para o preço da carteira
      for(int i=0; i<variables+constants; i++)                                                      // repassar todos os ativos da carteira 
         total_value+=closing[i]*ContractValue(SYMBOLS[i],limit_time,Timeframe)*MathAbs(LOTS[i]);   // calcular e somar os componentes dos preços

      if(total_value==0) { Alert("Zero portfolio value!"); error=true; return; }                    // certifique-se de que o resultado não é zero
      scale_volume=Portfolio_Value/total_value;                                                     // encontrar uma taxa de escala

      for(int i=0; i<variables+constants; i++)                                                      // repassar todos os símbolos da carteira novamente
          LOTS[i]=NormalizeDouble(LOTS[i]*scale_volume,Lots_Digits);                                 // converter os lotes para o preço total necessário

Aqui, o valor da carteira é equiparado ao necessário através das proporções. Portfolio_Value — é o preço necessário da carteira; total_value — é o preço total da carteira com os índices de inadimplência; scale_volume — é a taxa da escala; Lots_Digits — é a capacidade do lote; LOTS — array do lote e os valores adequados para negociação.

Valores do lote formam a estrutura final da carteira. Os lotes positivos correspondem a uma posição comprada; já os lotes negativos, a uma posição vendida. Conhecendo a estrutura da carteira, pode-se desenhar o gráfico e realizar as operações de negociação com o carteira. A seguir, uma demonstração da estrutura da carteira após a normalização:

Symbol AUDJPY GBPUSD EURCAD
Lot -0,07 -0,11 -0,11

O gráfico da carteira é plotado apenas no Fechamento dos preços e exibidos numa subjanela separada do indicador. Com o intuito de construir o gráfico, precisamos calcular cada barra de gráfico correspondente ao lucro virtual, assim os ativos separados são previamente calculados. No entanto, agora eles estão resumidos, considerando os lotes atribuídos:

   for(int j=draw_begin; j>=draw_end; j--)                                                   // ciclo por barras do gráfico dentro do intervalo desenhado
     {
      double profit=0;                                                                       // começar com o valor
      for(int i=0; i<variables; i++)                                                         // repassar todos os ativos
        {
         if(Fast_Period>0 && Slow_Period>0 && number!=N_TOTAL)                               // executar verificações auxiliares
           {
            int shift=iBarShift(SYMBOLS[i],Period(),Time[j]);                                // obter índice da barra por tempo
            double CV=ContractValue(SYMBOLS[i],Time[j],Period());                            // calcular o preço do contrato
            double fast=iMA(SYMBOLS[i],Period(),Fast_Period,0,MODE_SMA,PRICE_CLOSE,shift);   // calcular a média lenta
            double slow=iMA(SYMBOLS[i],Period(),Slow_Period,0,MODE_SMA,PRICE_CLOSE,shift);   // calcular a média rápida
            profit+=(fast-slow)*CV*LOTS[i];                                                  // calcular o modelo de oscilação
           }
         else
           {
            int shift=iBarShift(SYMBOLS[i],Period(),Time[j]);                                // recebe o índice da barra pelo tempo
            double closing=iClose(SYMBOLS[i],Period(),shift);                                // recebe o preço do ativo no ponto
            double CV=ContractValue(SYMBOLS[i],Time[j],Period());                            // calcular o preço do contrato
            profit+=(closing-OPENINGS[i])*CV*LOTS[i];                                        // calcular o lucro pela diferença de preço e custo
           }
        }
      BUFFERS[number].buffer[j]=NormalizeDouble(profit,2);                                   // salvar o valor do lucro no array indicador
     }

Neste trecho de código, podemos ver que o gráfico é traçado entre as barras iniciais e finais: draw_begin e draw_end. O valor da carteira é igual soma dos lucros/perdas em todos os símbolos calculados, como uma diferença de preço multiplicado por um preço de contrato e lote calculado anteriormente. Tenho ignorado os aspectos técnicos relacionados com buffers de indicadores, formatação e afins. Um exemplo banal do indicador de carteira, é descrito na seção abaixo.

Aqui você pode examinar a construção do exemplo do gráfico da carteira (subjanela inferior do indicador) com o gráfico da função alvo em anexo:

 

Aqui, a parábola de raiz quadrada feita simétricamente em relação ao ponto de referência (Model_Absolute=true) é utilizado como a função alvo. Os limites de intervalos calculados são apresentados como linhas pontilhadas vermelhas, enquanto o gráfico da carteira tende a mover-se ao longo da linha de função, tanto dentro, quanto fora do intervalo calculado.

É possível realizar a análise técnica dos gráficos da carteira, semelhantes aos gráficos de preços e símbolos comuns, incluindo médias de aplicação móveis, linhas de tendência e níveis. Isso amplia as capacidades analíticas e de negociação, nos quais permitem que você selecione a estrutura da carteira para a formação de uma determinada configuração de negociação num gráfico do mesmo, por exemplo, a correção após um impulso de tendência, assim como o enfraquecimento da tendência, um lateral saíndo, a sobrecompra-sobrevenda, a convergência-divergência, desobstruções, o nível de consolidação e outras configurações. A qualidade de instalação da negociação é afetada pela composição da carteira, do método de otimização, da função alvo e do segmento histórico selecionado.

É necessário conhecer a volatilidade da carteira para selecionar um volume de negociação adequado. Uma vez que o gráfico da carteira é inicialmente baseado numa moeda de depósito, você pode estimar uma variação de flutuação do mesmo, assim como, a profundidade do rebaixamento de potencial diretamente nessa moeda utilizando o modo de cursor "mirar" e "puxar".

Um sistema de negociação deve ser baseado em propriedades comportamentais da carteira e assim, instalar estatísticas. Até o momento, ainda não mencionamos o fato de que o comportamento da carteira pode mudar, dramaticamente, fora do intervalo de otimização. Um lateral pode se transformar numa tendência, enquanto, uma tendência pode se transformar numa reversão. Um sistema de negociação também deve considerar que as propriedades da carteira são propensas a alterar-se ao longo do tempo. Esta questão será discutida a seguir.

As operações de negociação com uma carteira abrange, de uma só vez, a compra/venda de todos os símbolos do mesmo com volumes calculados. Para maior conveniência, seria razoável ter um Expert Advisor especial para realizar todo o trabalho de rotina, incluindo a obtenção de dados sobre a estrutura da carteira, a preparação das posições sintéticas, o monitoramento dos níveis de entrada, a fixação de lucros e o limite de perdas. Aplicaremos os seguintes termos relativos ao funcionamento do EA: carteira de posição sintética comprada e carteira de posição sintética vendida (onde as posições compradas são substituídas por outras posições vendidas e vice-versa). O EA deve ser capaz de acumular posições, rastrear volumes sintéticos, assim como executar carteira de compensação e transformação. O EA é considerado e exemplificado na próxima seção, através da sua estrutura, cujo não é explicado devido às restrições do volume de artigo.

Abaixo temos um exemplo da interface minimalista de uma carteira de posição sintética para um EA:


 

Às vezes, é necessário construir várias carteiras. No caso mais simples, vamos comparar duas carteiras. Algumas tarefas exigem uma série completa da carteira para construir um único segmento do histórico, resultando num conjunto de pastas contendo determinados padrões. A fim de implementar essas tarefas, é necessário um algoritmo para geração da carteira de acordo com um determinado modelo. O exemplo de implementação de tal indicador pode ser encontrado na próxima seção. Aqui, vamos apenas descrever suas características operacionais mais críticas.

Precisamos organizar um array de estrutura para armazenar os dados de múltiplas carteiras, por exemplo:

struct MASSIVE                     // definir a estrutura que contém vários tipos de dados
  {
   string symbol[MAX_SYMBOLS];     // texto do array para os ativos da carteira 
   double lot[MAX_SYMBOLS];        // array numérico para lotes
   string formula;                 // string com a equação da carteira 
   double direction;               // atributir a direção da carteira
   double filter;                  // atributo de filtro
  };

MASSIVE PORTFOLIOS[DIM_SIZE];      // criar o array de estrutura para o grupo de carteiras

Neste trecho do código, o DIM_SIZE define o tamanho máximo para o armazenamento de carteiras. A estrutura está organizada da seguinte forma: símbolo — array de ativo da carteira, lote — lote do array para ativos da carteira, fórmula — sequência de texto com a equação da carteira, direção — direção da carteira(comprado ou vendido), filtro — atribuir filtro (incluído/excluído). Aplicar o array de estrutura é mais conveniente e sensato, do que usar arrays separados.

O array de estrutura pode também ser criado, para armazenar arrays buffer da carteira no gráfico:

struct STREAM{double buffer[];};     // definir a estrutura que contém um array numérico
STREAM BUFFERS[DIM_SIZE];            // criar o array de estrutura

Carteiras dentro do conjunto variam de acordo com as suas combinações de símbolos. Estas combinações podem ser definidas com antecedência, ou geradas de acordo com certas regras. Ao trabalhar com um conjunto de carteiras, pode-se incluir várias etapas, dependendo da tarefa. Consideraremos a seguinte sequência de etapas aqui:

1 Gráficos de cálculos de carteiras separadas
2 Combinação de um conjunto de carteiras num ponto zero
3 Invertendo carteiras relativas a um nível zero
4 Aplicar o filtro a um conjunto de carteiras
5 Recapitulação — formando um supercarteira
Em primeiro lugar, carteiras separadas dentro de um conjunto são calculados de acordo com os princípios descritos anteriormente. A combinação de carteiras a um ponto zero é necessário para facilitar a análise. Para fazer isso, é selecionado um ponto para que todos as carteiras sejam iguais a zero. Inverter-se as carteiras em relação a um nível zero, também pode ser útil para simplificar a análise. Carteiras com direção descrescente após lotes serem invertidos mudam para direção crescente. As carteiras de filtragem, selecionam dentre um conjunto, as melhores carteiras através de alguns critérios, tal como, a velocidade de crescimento, a divergência de zero e a posição dentro de um conjunto em relação a outras carteiras. Assim, são selecionadas as melhores carteiras e afinadas para uma cesta das mesmas, ou de uma supercarteira (superposição de carteiras). 

A imagem abaixo ilustra estes passos:


 

Um deslocamento vertical é usado para combinar carteiras. A carteira é revertida quando multiplicado por -1. Finalmente, um filtro é aplicado para triagem e demonstração dos valores. Não haverá descrição detalhada destes algoritmos para evitar um volume enorme de código de rotina.

A seguir exemplos de carteiras construídas de acordo com os princípios mencionados:

 

O gráfico mostra carteiras calculadas pelo modelo de PCA. Os limites de intervalos calculados são mostrados como linhas tracejadas vermelhas. Aqui é possível analisar a expansão das carteiras definidas em ambos os lados do intervalo de otimização. O ponto zero é selecionado na margem esquerda, otimizando o intervalo, enquanto os momentos de inversão em relação a zero e a aplicação de filtro são marcados pelas linhas pontilhadas na cor roxa. A linha grossa descreve a supercarteira, composto através de outros ativos e sendo executada de forma decente, a partir do ponto zero.

A combinação das carteiras proporciona possibilidades adicionais para analisar e desenvolver estratégias de negociação, tais como: a diversificação de carteiras, os spreads entre as carteiras, a convergência-divergência da configuraçao das carteiras, a espera do entrelaçamento do conjunto das carteiras, movimento de uma carteira para a outra e mais abordagens.


Exemplos de implementação

Os métodos descritos no atual artigo foram implementados como um indicador de carteira, e um EA semi-automatizado. Aqui você pode encontrar as instruções, baixar o código fonte e adaptá-lo às suas necessidades:

  • Carteira Modeller — desenvolvedor e otimizador de carteira. Possui vários tipos de modelo de otimização com parâmetros configuráveis. Além disso, você pode adicionar os seus próprios modelos e funções alvo. Há também ferramentas básicas para a análise técnica, assim como, as opções de formatação de vários gráficos.

  • Carteira Multigraph — gerador de carteira, configurando os mesmos modelos, parâmetros, opções adicionais para a transformação e filtragem, como também produz uma supercarteira.

  • Carteira Manager — EA para trabalhar com carteiras e supercarteiras. Ele opera em conjunto com o indicador de carteira e permite abrir e gerir posições sintéticas, assim como tem funcionalidade de correção da carteira e também possui um modo automático de negociação baseado em linhas gráficas de ordens virtuais.

Link para download: https://www.mql5.com/ru/code/11859 (em Russo)


Estratégias de negociação

Há muitas estratégias de negociação com base na aplicação de instrumentos sintéticos. Serão consideradas algumas ideias básicas, nas quais podem ser úteis na criação de uma estratégia negociação de carteira de investimentos. Ao mesmo tempo, não vamos negligenciar sobre os riscos e limitações.

A abordagem clássica para a geração de uma carteira é identificar ativos subvalorizados que tem um potencial de crescimento e incluí-los na carteira com a expectativa de sua ascensão. A volatilidade da carteira é sempre menor do que a soma das volatilidades dos instrumentos incluídos. Esta abordagem é boa para o mercado de ações, no entanto é de uso limitado em Forex, pois as moedas normalmente não demonstram um crescimento sustentado, ao contrário das ações.

Abaixo está uma carteira a longo prazo de Warren Buffett:

 

Ao trabalhar com carteiras de investimento padrão, é necessário avaliar cuidadosamente o status de ativo circulante para posições compradas durante o movimento descendente de preços.

A primeira e mais fácil opção para formar a carteira de investimentovo é a negociaçao de um par — a criação de um spread de dois ativos correlacionados. No Forex, esta abordagem é significativamente limitada, pois pares de moedas altamente correlacionados não têm co-integração e, portanto, podem divergir consideravelmente ao longo do tempo. Neste caso, lida-se com um "spread interrompido". Além disso, esse par negociado transforma a negociação numa taxa de cruzamento sintético, pois normalmente são pares com uma moeda em comum incluídos no spread. Este tipo de par negociável é uma má ideia. Após abrir posições opostas por spread, às vezes temos que esperar muito tempo antes das curvas convergirem novamente.

Abaixo está um exemplo de pares altamente correlacionados e sua divergência gradual e inevitável:

 

O desenvolvimento desta abordagem é uma negociação multilateral distribuída quando três e mais pares de moedas estão incluídos no spread. Isso já é melhor do que o par sendo negociado, uma vez que é mais fácil criar um spread com grande número de opções de combinação. No entanto, permanecem os mesmos riscos: um spread pode divergir e não convergir novamente. É muito mais fácil alcançar um bom retorno distribuído num mercado calmo, porem notícias fundamentais causam uma divergência rápida e irreversível após determinado tempo. Curiosamente, se aumentarmos o número de instrumentos dentro do spread, a probabilidade de divergência aumenta, pois uma vez que mais moedas estão envolvidas, maior é a probabilidade de que algo aconteça durante algum comunicado da imprensa. Espera-se uma convergência do spread novamente, esta uma estratégia extremamente prejudicial, pois somente funciona num mercado lateral e tranquilo.

A seguir há um comportamento de spread multilateral apresentado durante um comunicado à imprensa:

 

A negociação de spread tem mais oportunidades na bolsa de valores no caso de haver uma ligação fundamental entre ativos. No entanto, ainda não existem garantias contra lacunas do spread na data dos dividendos, ou durante a expiração de contratos futuros. Spreads também pode ser composto de índices de mercado e futuros, mas isso requer a consideração de características comerciais da bolsa.

Um ramo sem saída da negociação de spread é representada por um multi-bloqueio quando pares de moedas, ciclicamente relacionados (por exemplo, EURUSD-GBPUSD-EURGBP), são selecionados e utilizados para formar um spread equilibrado. Neste caso, temos um spread perfeito que é impossível de negociar, pois os spreads totais e as comissões são demasiadamente elevadas. Se tentarmos desbalancear os lotes um pouco, o gráfico torna-se mais favorável a tendência, no qual contradiz a negociação do spread, enquanto os custos permanecem suficientemente altos, fazendo esta abordagem sem sentido.

Abaixo contém um exemplo de um multi-bloqueio equilibrado. O spread total é apresentado como duas linhas vermelhas:

 

As inconveniências da negociação de spread fazem-nos mudar a tendência dos modelos. À primeira vista, tudo parece ser harmonioso suficiente aqui: identificada a tendência, entrando durante uma correção e saindo com um lucro em níveis mais elevados.

A seguir um exemplo de um bom modelo de tendência:

 

No entanto, em alguns momentos, os modelos de tendências podem não vir a ser tão simples e úteis Às vezes, uma carteira se recusa a crescer mais e às vezes decresce bruscamente. Neste caso, lidamos com uma "tendência interrompida". Isso ocorre com bastante frequência nos modelos a curto e médio prazo. A eficiência da negociação depende muito da fase do mercado aqui. Quando o mercado está em tendência, o sistema funciona bem. Se o mercado está lateral ou especialmente volátil, podem ocorrer perdas numerosas.

A seguir, pode-se observar a conlusão de uma tendência acentuada:

 

Estas desvantagens nos fazem repensar as abordagens tradicionais. Agora, vamos dar uma olhada no rompimento do spread e métodos de negociação com reversão de tendência. A suposição comum é que, embora não se pode evitar a instabilidade da carteira, devemos aprender como usá-la.

A fim de desenvolver uma configuração de rompimento do spread, precisamos criar um spread de curto prazo, bastante compacto e com a volatilidade mínima em antecipação a um movimento forte. Quanto mais comprimir a volatilidade da carteira, mais forte ela "explode". Para acelerar o rompimento do spread é possível formar uma configuração, antes de iniciar as sessões de negociação e antes que a notícia selecione determinados intervalos de um mercado parado. O método de otimização PCA é o mais adequado para a compressão de volatilidade. Nesta configuração, não sabemos com antecedência a direção em que o rompimento ocorrerá, portanto, a entrada já é definida no movimento aos limites do spread.

Abaixo, uma exemplo de saída a partir do canal spread de curto prazo, com os limites destacados do canal spread:

 

As vantagens do método: os spreads de curto prazo são frequentes nos gráficos e a volatilidade após rompimento muitas vezes ultrapassa a largura do corredor do spread. As desvantagens: os spreads são expandidos durante os comunicados de imprensa e uma "via" pode se formar em alguns momentos quando o preço se move, tanto para cima, como para baixo . Se possível, a entrada conservadora pode ser proposta como alternativa, após sair de um corredor de spread durante a correção no limite do corredor.

A fim de criar uma configuração de inversão de tendência, é criado um modelo de tendência, bem como os movimentos de conversão e os níveis de preços da carteira são rastreados. A direção do movimento é claramente definida, mas não sabemos com antecedência quando a tendência inverte. Um cruzamento de linha de tendência interna, correção da reversão e reversão são rastreados para uma entrada conservadora. Tocando uma linha de tendência externa e uma reversão são rastreados para uma entrada agressiva.

A seguir há um exemplo de uma carteira de tendência com as linhas externas e internas apresentadas:

 

As vantagens do método: bom preço de entrada, conveniência, a instabilidade extrema de preços funciona em favor da configuração. Desvantagens: Preço da carteira pode subir a tendência devido a razões fundamentais, a fim de melhorar a situação, podemos entrar no volume fracionado, a partir de múltiplos níveis.

Uma configuração similar pode ser implementada usando uma função modelo de raiz quadrada parabólica. A configuração é baseada numa propriedade bem conhecida: quando o preço atinge um limite teórico do intervalo de distribuição do mercado, o seu maior movimento é dificultado. Como em outros casos, a otimização da função alvo é ajustada para a distribuição atual do mercado. Se os mercados caracterizam a distribuição de Gaussian normal, então a lei da raiz quadrada com base no tempo funcionaria sempre perfeitamente, mas a distribuição do mercado é fractal e não-estacionária em sua natureza, logo é necessário o ajuste situacional.

Você pode encontrar mais sobre distribuições de mercado nos seguintes livros de Edgar Peters:

  • Chaos and Order in the Capital Markets
  • Fractal Market Analysis

Abaixo está um exemplo de uma carteira movimentando a partir da função parabólica:

 

Esta configuração é perfeita para se adaptar ao meio termo da volatilidade. No entanto, assim como no caso de uma configuração de tendência, um preço de carteira pode se mover para cima devido a fatores fundamentais. O mercado não é obrigado a seguir qualquer comportamento de função alvo, bem como é obrigado a desviar-se da mesma. Algum nível de liberdade e dualidade permanecem em todos os momentos. Todas as configurações de negociação não são absolutamente neutras no mercado, mas baseiam-se em alguma forma de análise técnica.

As duas naturezas, tanto da tendência como a da lateralidade, podem ser vistas abaixo. Um modelo de tendência é semelhante a um plano irregular numa escala maior:

 

Além da combinação de ativo e tipo de modelo, a localização dos limites do intervalo estimado é de grande importância no desenvolvimento de uma carteira. Quando se configura a carteira, ela pode ser útil para mover os limites e comparar os resultados. Boa escolha de limites permitem encontrar carteiras que são mais adequados em termos de configuração da negociação. Se uma posição de carteira entra num rebaixamento, é possível corrigi-la sem fechar as posições existentes. Deslocar os limites muda a curva da carteira, adaptando-o a uma situação de mudança. Posições deve ser corrigidas em conformidade, após a reorganização da carteira. Isso não significa que o rebaixamento vai diminuir de uma vez, mas a carteira corrigida pode se tornar mais eficiente.

Em seguida, vamos considerar algumas propriedades de conjuntos da carteira e suas possíveis aplicações em sistemas de negociação.

A primeira propriedade definida da carteira para chamar a atenção é uma ampliação do conjunto, ou divergência com a distância a partir do ponto zero. Seria apenas natural e razoável usar essa propriedade para negociação: comprar carteiras em ascenção e vender quando caem.

Abaixo está uma amostra expandido do conjunto de carteiras:

 

A segunda propriedade — compressão da carteira (convergência) — é o oposto da anterior. Isso acontece depois da expansão. Os ciclos de expansão e compressão sugerem que este comportamento pode ser utilizado para abrir posições em antecipação de retorno ao centro do conjunto, depois de atingir um suposto grau maior de expansão. No entanto, o grau maior de expansão sempre pode variar, sendo impossível prever os limites finais de expansão do conjunto de curvas.

A seguir, um exemplo de conjunto da compressão de carteiras:

 

Aplicando-se várias funções-alvo, parâmetros de filtragem, inversões e combinações proporcionam boas oportunidades para a experimentação, buscando configurações eficientes de negociação. Geralmente, todas as configurações podem ser divididas em duas classes: negociação de rompimentos e negociação de reversão (roll-backs).

Abaixo está um exemplo de configuração de negociação com uma reversão e deslocamento de um conjunto de carteiras:

 

Um exemplo da configuração de negociação de reversão com base no modelo multi-tendência é mostrado abaixo:

 

Outra propriedade recorrente da carteira é uma reviravolta na configuração (auto-cruzamento). Tipicamente, isto corresponde a uma mudança de tendência do mercado. Se negociarmos em antecipação uma expansão de carteiras, uma reviravolta será um efeito negativo exigindo um configuração de re-arranjo. Para outras estratégias, cruzamento de algumas curvas de carteiras pode ser usado para identificar carteiras promissoras. Além disso, é necessário considerar uma distância percorrida, os níveis, a posição num conjunto e a posição em relação a função alvo.

Segue um exemplo de um conjunto alterado várias vezes:

 

Nós não focamos a nossa atenção sobre a questão do gerenciamento de volume até agora, ainda que seja uma parte crítica de qualquer sistema de negociação. Em geral, podemos descrever as seguintes abordagens:

  • Negociar uma única posição sintética (o caso mais simples)
  • Dividir os volumes (entrada estendida por níveis)
  • Adicionar a uma carteira em ascenção (tendência pela pirâmide)
  • Adicionar a uma carteira num rebaixamento (posição média)
  • Adicionar a uma carteira depois de uma correção (método de finalização)
  • Adicionar a uma carteira após uma reversão (estratégia expansiva)
  • adicionar a novas carteiras (carteira consolidada)
  • abordagem combinada (combinando várias abordagens)

O método de gerenciamento de volume específico deve ser selecionado considerando os recursos do sistema de negociação. Ao planejar um lucro e um levantamento de crédito, os cálculos devem basear-se na volatilidade da carteira. No caso mais simples, a volatilidade da carteira pode ser avaliada como a amplitude do movimento do seu gráfico dentro de um determinado segmento. É muito melhor avaliar a volatilidade, não só dentro do intervalo de otimização bem como avaliar o histórico anterior. Sabendo da volatilidade da carteira, é possível calcular um valor teórico do rebaixamento máximo total numa série de posições. Tradicionalmente, alertamos contra a adição de volumes agressivo muito frequentes. O total de fundos alocados à cobertura da carteira numa conta de negociação devem ser capazes de suportar o movimento desfavorável, considerando todas as posições adicionais.

Multi carteiras de negociação significam a seleção e consolidação de uma carteira sistemática. Se uma carteira é comprada e outra é adicionada a ela, isso pode ter um efeito de diversificação positiva se as carteiras têm diferenças perceptíveis. Mas se as carterias são correlacionadas, isso pode ter um efeito negativo, uma vez que pode haver rebaixamento no caso de um movimento desfavorável. Normalmente, você deve evitar a adição de carteiras correlacionadas. À primeira vista, a negociação de um spread entre duas carteiras correlacionandas pode parecer ser muito promissor, mas um exame mais atento mostra que não são diferentes dos spreads usuais, uma vez que não são estacionários.

Várias estratégias de saída podem ser aplicadas na negociação multi carteira, incluindo:

  • fechamento por um resultado total de todas as carteiras
  • fechamento de um grupo de carteiras por um resultado total dos grupos
  • fechamento pelas metas e limites configurados nas carteiras.

Para algumas estratégias, o ponto de entrada é de importância crítica. Por exemplo, se uma estratégia aplica preços de extremidades antes de uma inversão de tendência ou correção, o período adequado para a entrada é muito curto. Outras estratégias são mais dependentes do cálculo ideal de uma posição adicionando o princípio de seleção de sistema e carteiras. Neste caso, as carteiras individuais podem entrar num rebaixamento, mas outras carteiras (mais eficientes) dentro da série consolidada regulam o resultado global.


Conclusão

Vantagens da negociação de carteira: a otimização permite que você crie uma curva de carteira conforme as suas preferências, bem como formar uma configuração de negociação desejada e operar igualmente aos pares de negociação no gráfico de preços. No entanto, ao contrário das carteiras de negociação, a compra e venda de ativos convencionais deixam os traders em posição passiva. Os traders, com as carteiras de investimentos, podem se ajustar as novas condições do mercado.

Desvantagens da negociação de carteira: ordens pendentes padrão não são aplicáveis, requisitos de volume mínimos mais rigorosos, maiores spreads no timeframe М30 e prazos menores afeta o escalpelamento intraday, não existem dados OHLC, nem todos os indicadores podem ser aplicados as carteiras.

Geralmente, esta é uma abordagem bastante específica na negociação. Aqui fizemos apenas uma visão geral introdutória das propriedades da carteira de investimentos em forex e métodos de trabalho. Se você deseja realizar estudos mais profundos de sistemas de negociação de carteiras, eu recomendo usar a plataforma MetaTrader 5, pois as propriedades de distribuição do mercado são estudadas em pacotes estatísticos especializados.




Traduzido do russo pela MetaQuotes Software Corp.
Artigo original: https://www.mql5.com/ru/articles/2646

Rede neural profunda com Máquina de Boltzmann Restrita Empilhada. Auto-aprendizagem, auto-controle Rede neural profunda com Máquina de Boltzmann Restrita Empilhada. Auto-aprendizagem, auto-controle

Este artigo é uma continuação dos artigos anteriores sobre redes neurais profundas e seleção de preditores. Aqui, consideraremos as características de uma rede neural iniciada com a Stacked RBM (Máquina de Boltzmann Restrita Empilhada), bem como sua implementação no pacote "darch".

Trabalhando com cesta de moedas no mercado Forex Trabalhando com cesta de moedas no mercado Forex

O artigo descreve como os pares de moedas podem ser divididos em grupos (cestas), bem como a forma de obter dados sobre o seu status (por exemplo, compradas e vendidas) usando certos indicadores e como aplicar esses dados na negociação.

Como desenvolver e testar uma estratégia para Opções Binárias com o Testador de Estratégia do MetaTrader 4 Como desenvolver e testar uma estratégia para Opções Binárias com o Testador de Estratégia do MetaTrader 4

Tutorial para desenvolver uma estratégia para Opções Binárias e testa-la no Testador de Estratégia do MetaTrader 4 com o utilitário do Mercado Binary-Options-Strategy-Tester.

Três Aspectos Sobre Automação da Negociação Manual. Parte 1: Negociação Três Aspectos Sobre Automação da Negociação Manual. Parte 1: Negociação

Este artigo é o primeiro de uma série de artigos sobre automação da negociação manual na plataforma МetaТrader 4. Cada artigo será dedicado a um dos seguintes aspectos: automação da negociação manual, atual estado da exibição da automação da negociação e automação dos relatórios sobre os resultados da negociação. Neste artigo, vou apresentar uma abordagem interessante para a criação de EAs controlados manualmente por um trader.