Questions des débutants MQL5 MT5 MetaTrader 5 - page 1322

Nouveau commentaire
 
Bonjour, il y a beaucoup de tampons indicateurs du même type, qui peuvent être calculés dans la boucle, mais comment faire un tableau de tampons indicateurs ? J'ai essayé à travers la structure, et tout allait bien, SetIndexBuffer() a fonctionné sans erreurs, mais quand OnCalculate() arrive, les tailles des tableaux ne changent pas et restent 0. Veuillez me conseiller sur la façon d'organiser le calcul des tampons d'indicateurs dans la boucle, peut-être par des noms, tels que : "buff_0", "buff_1", etc., mais comment faire, je ne sais pas(( Sinon, c'est une feuille très longue qui sort(
 
SanAlex:

Je suppose que c'est ce que vous aviez en tête - ça semble avoir marché.

Merci !

Tout est correct, mais cen'est pas exactement ce que j'avais en tête ! !! L'ordre est placé le long de la tendance (selon l'indicateur) et fermé à la prise et dès qu'il se ferme - un nouvel ordre est ouvert dans la même direction (le long de la tendance), mais ce n'est qu'une partie de mon idée.

La deuxième partie est qu'un ordre qui n'a pas été fermé par Takei lorsque la tendance s'inverse (lorsque l'indicateur donne un signal de changement de direction du prix) ne devrait pas être fermé (ce que vous avez fait).

En bref, les deux parties doivent fonctionner comme une paire.

 
Alexey Viktorov:

Hier, j'ai téléchargé ce miracle pour le regarder... Soudain, je n'avais plus d'internet. Après un orage, j'ai eu des travaux techniques pour le reste de la journée. J'ai donc décidé de le réécrire en MQL5 par désœuvrement et je l'ai publié ici.

Donc, chaque nuage a une lueur d'espoir.........

Merci beaucoup !

Cela pourrait s'avérer utile, si mon idée se réalise !

 
VANDER:
J'ai essayé sur la page et cela semble fonctionner correctement.

Ce n'est pas comme ça que ça marche ?

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:

et maintenant vous devez lui appliquer la méthode Martingale, c'est-à-dire ouvrir des ordres hors tendance avec un certain pas, un certain multiplicateur et prendre la moyenne.

En bref, les deux parties doivent fonctionner en binôme.

Vous voulez dire que la prochaine position doit être ouverte avec un lot double le 2-4-8-16 à l'achat et le 2-4-8-16 opposé à la vente ?

J'ai une telle fonction - je l'ai construite moi-même en quelque sorte.

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

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

Vous devez remplacer dans l'ouverture de la position - ici au lieu de InpLots par OptimizedBuy() et 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:

Vous voulez dire que la prochaine position sera ouverte avec un lot double le 2-4-8-16 en ACHETE et le 2-4-8-16 opposé en VENTE ?

J'ai une telle fonction - je l'ai construite moi-même en quelque sorte.

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

Vous devez le remplacer dans l'ouverture de la position - ici au lieu de InpLots avec OptimizedBuy() et OptimizedSell()

mais pour cette fonction, il serait préférable d'avoir cette fonction - elle fermerait au profit (en devise)

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:

Mais pour cette fonction il serait souhaitable d'avoir cette fonction, qui fermerait sur le profit (en devise)

Je vais essayer d'expliquer plus clairement le sens de mon idée et le fonctionnement de l'EA que je suis en train de créer.

Vous avez besoin d'un Martin simple - par exemple AutoProfit 3, dans lequel il suffit d'ajouter que l'ouverture des ordres est basée sur les signaux des indicateurs (selon la tendance), mais pas comme dans AutoProfit - car les cartes tombent sur ......... et c'est tout.

Avec à peu près les mêmes paramètres de sortie que dans le fichier joint.
Dossiers :
pbx0dcw.jpg  201 kb
 
Sprut 185:

Je vais essayer d'expliquer plus clairement le sens de mon idée et le travail de l'EA créée.

Vous avez besoin d'un Martin simple - par exemple AutoProfit 3, dans lequel il suffit d'ajouter que l'ouverture des ordres se fait sur le signal de l'indicateur (la tendance), plutôt que comme dans AutoProfit - comme la carte se trouve ......... et c'est tout.

Ainsi, il s'ouvre sur un signal de l'indicateur - mais si un signal opposé apparaît, il s'ouvrira dans l'autre sens. Si le signal bascule de l'autre côté et ferme cette position ouverte, cela ne fonctionne pas pour vous.

 
SanAlex:

Si le signal va dans l'autre sens, la position s'ouvrira dans l'autre direction et, si elle n'a pas clôturé sur un bénéfice, elle restera en place jusqu'à ce qu'elle clôture sur un bénéfice. Si un signal de l'autre côté se retourne et ferme cette position ouverte, cela ne vous conviendra pas.

Droit .......... et si cette position n'a pas clôturé sur un profit, elle restera là jusqu'à ce qu'elle clôture sur un profit.

Mais la position qui n'a pas été fermée sur le bénéfice(par exemple, à l'achat) doit rester et descendre jusqu'à une certaine étape où un autre ordre (à l'achat) est ouvert avec le volume multiplié et la perte de temps moyenne, etc., jusqu'à ce que la tendance s'inverse, mais l'ouverture de positions dans la voie ne s'arrêtera pas.

C'est pourquoi j'ai écrit que 2 blocs devraient fonctionner simultanément - Martin et par indicateur.

Si je n'ai pas bien expliqué quelque chose, je suis prêt à faire une démonstration sur Skype et à vous montrer à quoi cela doit ressembler.

 
Sprut 185:

Tout est correct .......... et si cette position n'a pas clôturé sur un bénéfice, elle y restera jusqu'à ce qu'elle clôture sur un bénéfice.

Mais la position qui n'a pas été clôturée sur un bénéfice(par exemple, en achat) devrait rester et descendre jusqu'à une certaine étape, où un autre ordre s'ouvrirait (en achat) avec le volume multiplié et le timing moyen descendrait, etc., jusqu'à ce que la tendance s'inverse, mais l'ouverture de positions dans le trade ne s'arrêterait pas.

C'est pourquoi j'ai écrit que 2 blocs devraient fonctionner simultanément - Martin et par indicateur.

Si quelque chose n'est pas bien expliqué, je suis prêt à faire une démonstration sur Skype et à vous montrer à quoi cela devrait ressembler.

Martin ne doit être activé que lorsque le signal de l'indicateur est opposé ou n'en dépend pas ?

Exemple : J'ai ouvert une position d'achat selon l'indicateur. Le prix a baissé de la distance fixée, et l'indicateur indique déjà Vendre. Faut-il ouvrir la position d'achat ?

1...131513161317131813191320132113221323132413251326132713281329...1503
Nouveau commentaire