Domande dai principianti MQL5 MT5 MetaTrader 5 - pagina 1322

Nuovo commento
 
Buon pomeriggio, ci sono molti buffer di indicatori dello stesso tipo, che possono essere calcolati nel ciclo, ma come fare un array di buffer di indicatori? Ho provato attraverso la struttura, e tutto andava bene, SetIndexBuffer() funzionava senza errori, ma quando arriva OnCalculate(), le dimensioni dell'array non cambiano e rimangono 0. Per favore, consigliate come organizzare il calcolo dei buffer degli indicatori nel ciclo, forse per nomi, come: "buff_0", "buff_1", ecc., ma come fare questo non lo so(( Altrimenti, viene fuori un foglio molto lungo(
 
SanAlex:

Immagino che sia quello che avevi in mente - sembra che abbia funzionato.

Grazie!

Tutto è corretto, manon è esattamente quello che avevo in mente!!... L'ordine viene piazzato lungo la tendenza (secondo l'indicatore) e chiuso alla presa e non appena si chiude - un nuovo ordine viene aperto nella stessa direzione (lungo la tendenza), ma questa è solo una parte della mia idea.

La seconda parte è che un ordine che non è stato chiuso da Takei quando la tendenza si inverte (quando l'indicatore dà un segnale di cambiamento nella direzione del prezzo) non dovrebbe essere chiuso (cosa che tu hai fatto).

In breve, le due parti dovrebbero lavorare in coppia.

 
Alexey Viktorov:

Ieri ho scaricato questo miracolo da guardare... Improvvisamente non avevo internet. Dopo un temporale ho avuto lavori tecnici per il resto della giornata. Così ho deciso di riscriverlo in MQL5 per pigrizia e l'ho pubblicato qui.

Quindi ogni nuvola ha un rivestimento d'argento.........

Grazie mille!

Potrebbe essere utile, se la mia idea si realizza!

 
VANDER:
Provato attraverso la pagina e sembra funzionare bene

Non è così che funziona?

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 ora devi applicarci la Martingala, cioè aprire ordini non-trend con un certo passo, moltiplicatore e fare la media.

In breve, le due parti dovrebbero lavorare in coppia.

Vuoi dire che la prossima posizione dovrebbe essere aperta con doppio lotto 2-4-8-16 su BUY e opposto 2-4-8-16 su SELL?

Ho una tale funzione - l'ho costruita io stesso in qualche modo.

//+------------------------------------------------------------------+
//| 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);
  }
//+------------------------------------------------------------------+

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

Dovete sostituire nell'apertura della posizione - qui invece di InpLots con 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:

Vuoi dire che la prossima posizione sarà aperta con doppio lotto 2-4-8-16 in BUY e opposto 2-4-8-16 in SELL?

Ho una tale funzione - l'ho costruita io stesso in qualche modo.

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

Dovete sostituirlo nell'apertura della posizione - qui invece di InpLots con OptimizedBuy() e OptimizedSell()

ma per questa funzione, sarebbe meglio avere questa funzione - chiuderebbe a profitto (in valuta)

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:

Ma per questa funzione sarebbe auspicabile avere questa funzione, che chiuderebbe sul profitto (in valuta)

Cercherò di spiegare meglio il significato della mia idea e il funzionamento dell'EA che sto creando.

Hai bisogno di un semplice Martin - per esempio AutoProfit 3, in cui devi solo aggiungere che l'apertura degli ordini era basata sui segnali degli indicatori (secondo il trend), ma non come in AutoProfit - poiché le carte cadono su ......... e questo è tutto.

Con più o meno gli stessi parametri di output del file allegato.
File:
pbx0dcw.jpg  201 kb
 
Sprut 185:

Lasciatemi cercare di spiegare più chiaramente il significato della mia idea e il lavoro dell'EA creata.

Hai bisogno di un semplice Martin - per esempio AutoProfit 3, in cui devi solo aggiungere che l'apertura degli ordini era sul segnale dell'indicatore (il trend), piuttosto che come in AutoProfit - come la scheda si trova ......... e questo è tutto.

Quindi, si apre su un segnale dell'indicatore - ma se appare un segnale opposto, si aprirà nell'altra direzione. Se il segnale gira dall'altra parte e chiude quella posizione aperta, non funziona per voi.

 
SanAlex:

Se il segnale gira nella direzione opposta, si aprirà nell'altra direzione, e se quella posizione non ha chiuso in profitto, rimarrà lì finché non chiuderà in profitto. Se un segnale dall'altra parte si è girato e ha chiuso quella posizione aperta, non vi conviene.

Giusto .......... e se quella posizione non ha chiuso in profitto, rimarrà lì finché non chiuderà in profitto.

Ma la posizione che non è stata chiusa in profitto(per esempio, in acquisto) dovrebbe rimanere e scendere fino ad un certo passo dove un altro ordine (in acquisto) viene aperto con il volume moltiplicato e la perdita media di tempo, ecc, fino a quando la tendenza si inverte, ma l'apertura di posizioni in pista non si ferma.

Ecco perché ho scritto che 2 blocchi dovrebbero lavorare simultaneamente - Martin e per indicatore.

Se non ho spiegato bene qualcosa - sono pronto a fare una dimostrazione su Skype e mostrarvi come dovrebbe essere.

 
Sprut 185:

Tutto è corretto .......... e se quella posizione non ha chiuso in profitto, rimarrà lì finché non chiuderà in profitto.

Ma la posizione che non ha chiuso in profitto(per esempio, in acquisto) dovrebbe rimanere e scendere ad un certo passo, dove si aprirebbe un altro ordine (in acquisto) con il volume moltiplicato e il tempo medio scenderebbe, ecc, fino a quando la tendenza si inverte, ma l'apertura di posizioni nel commercio non si fermerebbe.

Ecco perché ho scritto che 2 blocchi dovrebbero lavorare simultaneamente - Martin e per indicatore.

Se qualcosa non è ben spiegato - sono pronto a fare una dimostrazione su Skype e mostrarvi come dovrebbe essere.

Martin deve essere attivato solo quando il segnale dell'indicatore è opposto o non dipende da esso?

Esempio: ho aperto una posizione Buy secondo l'indicatore. Il prezzo si è spostato verso il basso della distanza stabilita, e l'indicatore mostra già Sell. Si deve aprire la posizione Buy?

1...131513161317131813191320132113221323132413251326132713281329...1504
Nuovo commento
Motivazione: