Perguntas de Iniciantes MQL5 MT5 MetaTrader 5 - página 1322

Novo comentário
 
Boa tarde, existem muitos buffers indicadores do mesmo tipo, que podem ser calculados no laço, mas como fazer um conjunto de buffers indicadores? Experimentei através da estrutura, e tudo estava bem, SetIndexBuffer() funcionou sem erros, mas quando OnCalculate() vem, os tamanhos da matriz não mudam e permanecem 0. Por favor aconselhe como organizar o cálculo dos buffers indicadores no laço, talvez por nomes, tais como: "buff_0", "buff_1", etc., mas como fazer isto eu não sei(( Caso contrário, sai uma folha muito longa(
 
SanAlex:

Acho que era isso que tinha em mente - parece ter funcionado.

Obrigado!

Tudo está correcto, masnão exactamente o que eu tinha em mente!! A encomenda é colocada ao longo da tendência (de acordo com o indicador) e fechada no take e assim que fecha - uma nova encomenda é aberta na mesma direcção (ao longo da tendência), mas isto é apenas uma parte da minha ideia.

A segunda parte é que uma ordem que não foi fechada por Takei quando a tendência se inverte (quando o indicador dá um sinal de uma mudança na direcção do preço) não deve ser fechada (o que já fez).

Em suma, as duas partes devem funcionar como um par.

 
Alexey Viktorov:

Ontem descarreguei este milagre para ver... De repente não tinha internet. Após uma trovoada, tive trabalhos técnicos durante o resto do dia. Por isso decidi reescrevê-lo na MQL5 por inactividade e publiquei-o aqui.

Assim, cada nuvem tem um lado positivo.........

Muito obrigado!

Pode vir a ser útil, se a minha ideia se concretizar!

 
VANDER:
Experimentei-o através da página e parecia funcionar bem

Não é assim que funciona?

int size=100;

struct All
   {
   double buff[];
   } all[];

int OnInit()
   {
   IndicatorBuffers(size);
   ArrayResize(all,size);
   for(int i=0; i<size; i++)
      {
      SetIndexBuffer(i,all[i].buff);
      SetIndexStyle(i,DRAW_LINE);
      }
   return(INIT_SUCCEEDED);
   }

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
   {
   for(int i=0; i<size; i++)
      {
      all[i].buff[shift]=i;
      }
   return(rates_total);
   }
 

Sprut 185:

e agora tem de lhe aplicar Martingale, ou seja, ordens abertas sem tendência com um determinado passo, multiplicador e tomar a média.

Em suma, as duas partes devem funcionar em par.

Quer dizer que a próxima posição deve ser aberta com o lote duplo 2-4-8-16 em BUY e oposto 2-4-8-16 em SELL?

Tenho essa função - construí-a eu próprio de alguma forma.

//+------------------------------------------------------------------+
//| ENUM_LOT_RISK                                                    |
//+------------------------------------------------------------------+
enum LotMax
  {
   Lot=0,   // Lots
   Lotx2=1, // Lots*2
   Risk=2,  // Risk
  };
//+------------------------------------------------------------------+
input LotMax InpLotRisk              = Risk;         // : Lots,- Lots*2,- Risk
input double MaximumRisk             = 0.02;         // : Maximum Risk in percentage
input double DecreaseFactor          = 3;            // : Descrease factor
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double TradeSizeOptimized(void)
  {
   double price=0.0;
   double margin=0.0;
//--- select lot size
   if(!SymbolInfoDouble(_Symbol,SYMBOL_ASK,price))
      return(0.0);
   if(!OrderCalcMargin(ORDER_TYPE_BUY,_Symbol,1.0,price,margin))
      return(0.0);
   if(margin<=0.0)
      return(0.0);
   double lot=NormalizeDouble(AccountInfoDouble(ACCOUNT_MARGIN_FREE)*MaximumRisk/margin,2);
//--- calculate number of losses orders without a break
   if(DecreaseFactor>0)
     {
      //--- select history for access
      HistorySelect(0,TimeCurrent());
      //---
      int    orders=HistoryDealsTotal();  // total history deals
      int    losses=0;                    // number of losses orders without a break
      for(int i=orders-1; i>=0; i--)
        {
         ulong ticket=HistoryDealGetTicket(i);
         if(ticket==0)
           {
            Print("HistoryDealGetTicket failed, no trade history");
            break;
           }
         //--- check symbol
         if(HistoryDealGetString(ticket,DEAL_SYMBOL)!=_Symbol)
            continue;
         //--- check Expert Magic number
         if(HistoryDealGetInteger(ticket,DEAL_MAGIC)!=UNO_MAGIC)
            continue;
         //--- check profit
         double profit=HistoryDealGetDouble(ticket,DEAL_PROFIT);
         if(profit>0.0)
            break;
         if(profit<0.0)
            losses++;
        }
      //---
      if(losses>1)
         lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,1);
     }
//--- normalize and check limits
   double stepvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP);
   lot=stepvol*NormalizeDouble(lot/stepvol,0);
   double minvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MIN);
   if(lot<minvol)
      lot=minvol;
   double maxvol=SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_MAX);
   if(lot>maxvol)
      lot=maxvol;
//--- return trading volume
   return(lot);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedBuy(void)
  {
   double PROFIT_BUY=0.00;
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+m_position.Select(Symbol());
           }
        }
     }
   double Lots=MaximumRisk;
   double ab=PROFIT_BUY;
   switch(InpLotRisk)
     {
      case Lot:
         Lots=MaximumRisk;
         break;
      case Lotx2:
         if(ab>0 && ab<=1)
            Lots=MaximumRisk*2;
         if(ab>1 && ab<=2)
            Lots=MaximumRisk*4;
         if(ab>2 && ab<=3)
            Lots=MaximumRisk*8;
         if(ab>3)
            Lots=TradeSizeOptimized();
         break;
      case Risk:
         Lots=TradeSizeOptimized();
         break;
     }
   return(Lots);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+
double OptimizedSell(void)
  {
   double PROFIT_SELL=0.00;
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of open positions
     {
      string   position_GetSymbol=PositionGetSymbol(i); // GetSymbol позиции
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_SELL)
           {
            PROFIT_SELL=PROFIT_SELL+m_position.Select(Symbol());
           }
        }
     }
   double Lots=MaximumRisk;
   double ab=PROFIT_SELL;
   switch(InpLotRisk)
     {
      case Lot:
         Lots=MaximumRisk;
         break;
      case Lotx2:
         if(ab>0 && ab<=1)
            Lots=MaximumRisk*2;
         if(ab>1 && ab<=2)
            Lots=MaximumRisk*4;
         if(ab>2 && ab<=3)
            Lots=MaximumRisk*8;
         if(ab>3)
            Lots=TradeSizeOptimized();
         break;
      case Risk:
         Lots=TradeSizeOptimized();
         break;
     }
   return(Lots);
  }
//+------------------------------------------------------------------+

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

Precisa de substituir na abertura de posição - aqui em vez de InpLots por OptimizedBuy() e OptimizedSell()

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,OptimizedBuy(),price,0.0,0.0))

      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,OptimizedSell(),price,0.0,0.0))
 
SanAlex:

Quer dizer que a próxima posição será aberta com o lote duplo 2-4-8-16 em BUY e oposto 2-4-8-16 em SELL?

Tenho essa função - construí-a eu próprio de alguma forma.

\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

É necessário substituí-lo na abertura de posição por OptimizedBuy() e OptimizedSell() em vez de InpLots()

mas para esta função, seria melhor ter esta função - fecharia com lucro (em moeda)

input double InpTProfit              = 40000;        // : Take Profit --> (In currency the amount)
input double InpSLoss                = 1000000;      // : Stop Loss --> (In currency the amount)
//+------------------------------------------------------------------+
//| ProfitOnTick closing                                             |
//+------------------------------------------------------------------+
void ProfitOnTick(void)
  {
//---
   double PROFIT_BUY=0.00;
   double PROFIT_SELL=0.00;
   int total=PositionsTotal();
   for(int i=total-1; i>=0; i--)
     {
      string   position_GetSymbol=PositionGetSymbol(i);
      if(position_GetSymbol==m_symbol.Name())
        {
         if(m_position.PositionType()==POSITION_TYPE_BUY)
           {
            PROFIT_BUY=PROFIT_BUY+PositionGetDouble(POSITION_PROFIT);
           }
         else
           {
            PROFIT_SELL=PROFIT_SELL+PositionGetDouble(POSITION_PROFIT);
           }
        }
      if(PROFIT_BUY<-InpSLoss || PROFIT_BUY>=InpTProfit)
        {
         CheckForCloseBuy();
        }
      if(PROFIT_SELL<-InpSLoss || PROFIT_SELL>=InpTProfit)
        {
         CheckForCloseSell();
        }
     }
  }
//+------------------------------------------------------------------+
 
SanAlex:

Mas para esta função seria desejável ter esta função, que fecharia com lucro (em moeda)

Deixem-me tentar explicar mais claramente o significado da minha ideia e do funcionamento da EA que estou a criar.

É necessário um simples Martin - por exemplo, AutoProfit 3, no qual basta acrescentar que a abertura das encomendas foi baseada em sinais indicadores (de acordo com a tendência), mas não como em AutoProfit - uma vez que os cartões caem em ......... e é tudo.

Com aproximadamente os mesmos parâmetros de saída que no ficheiro anexo.
Arquivos anexados:
pbx0dcw.jpg  201 kb
 
Sprut 185:

Deixem-me tentar explicar mais claramente o significado da minha ideia e o trabalho da EA criada.

É preciso um simples Martin - por exemplo, AutoProfit 3, no qual basta acrescentar que a abertura das encomendas estava no sinal do indicador (a tendência), e não como em AutoProfit - pois o cartão está em ......... e é tudo.

Assim, abre num sinal do indicador - mas se um sinal aparecer em sentido contrário, abrirá na outra direcção. Se o sinal vira para o outro lado e fecha aquela posição aberta, não lhe convém.

 
SanAlex:

Se o sinal virar no sentido contrário, abrirá no sentido contrário, e se essa posição não tiver fechado com lucro, ficará pendurado até fechar com lucro. Se um sinal para o outro lado virou e fechou essa posição aberta, não lhe servirá.

direita .......... e se essa posição não tiver fechado com lucro, ficará lá até fechar com lucro.

Mas a posição que não foi fechada com lucro(por exemplo, na compra) deve permanecer e descer a um determinado passo onde outra ordem (na compra) é aberta com o volume multiplicado e a perda de tempo média, etc., até que a tendência se inverta, mas a abertura de posições na pista não vai parar.

É por isso que escrevi que 2 blocos devem funcionar simultaneamente - Martin e por indicador.

Se eu não explicar bem uma coisa - estou pronto para demonstrar no Skype e mostrar-vos como deve ser.

 
Sprut 185:

Tudo está correcto .......... e se essa posição não tiver fechado com lucro, ficará lá até fechar com lucro.

Mas a posição que não fechava com lucro(por exemplo, na compra) deveria permanecer e descer a um certo passo, onde outra ordem abriria (na compra) com o volume multiplicado e o tempo médio desceria, etc., até que a tendência se invertesse, mas a abertura de posições no comércio não pararia.

É por isso que escrevi que 2 blocos devem funcionar simultaneamente - Martin e por indicador.

Se algo não estiver bem explicado - estou pronto para demonstrar no Skype e mostrar-vos como deve ser.

Martin só deve ser activado quando o sinal indicador é oposto ou não depende dele?

Exemplo: abri uma posição de compra de acordo com o indicador. O preço desceu pela distância definida, e o indicador já mostra um Sell. A posição Comprar deve ser aberta?

1...131513161317131813191320132113221323132413251326132713281329...1503
Novo comentário
Razão: