Обновление правил использования констант в перечислениях и примеры правильного применения

[Удален] 2021.06.29 09:22 #13191

Sprut 185:

Короче не прокатило? А жаль !!!!

Ну не верю я, что не может быть ни какого решения - буду дальше бороздить просторы инета.

вообще-то можно добавить от объекта открывать закрывать - тогда может получится, но это муторная задача. если будет у меня настроение я попробую слепить.

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

вместо обычного ТР смастерить от Горизонтальной линии закрывать и открывать

Как я собираю себе Любые вопросы новичков по Как начать работу с

Kira27 2021.06.29 10:56 #13192

Artyom Trishkin:

Вывод очевиден - создавайте объекты нужных вам классов в своём.

Так и сделал, наследовав свой класс от CTrade, чтоб хоть торговые функции без объектов юзать))) Спасибо!

#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//--------------------------------------------------------------------

// Mas_Ord_New_[150][9];   // Массив ордеров последний известный
// Mas_Ord_Old_[150][9];   // Массив ордеров предыдущий (старый)
// Mas_Tip_[6];              // Массив коллич. ордеров всех типов

//+------------------------------------------------------------------+
#include <Trade\Trade.mqh> //Класс CTrade обеспечивает упрощенный доступ к торговым функциям.

#include <Trade\SymbolInfo.mqh>    //Класс CTrade 
CSymbolInfo SymbolInfo;            // Объект класса Для получения параметров по инструменту

#include <Trade\PositionInfo.mqh>;
CPositionInfo PositionInfo;        //объект PositionInfo класса СPositionInfo Для получения параметров открытых позиций

#include <Trade\OrderInfo.mqh>;
COrderInfo OrderInfo;          //Объект OrderInfo класса COrderInfo Для получения параметров отложеных ордеров

#include <Fibo_Level.mqh>
Fibo_Levell Level_Fibo2;
//+------------------------------------------------------------------+


class Terminal : public CTrade

  {
private:

public:
                     Terminal();
                    ~Terminal();

   void              Order_and_Pozition_Info
   (
      int &up_F_,          //Глобальный счётчик  типов TrendLineUp
      int &down_F_,        //Глобальный счётчик  типов TrendLineDown
      int &ID_Fibo_Up_,    //Счётчик-идентификатор фибо для сделок 
      int &ID_Fibo_Down_,
      int OrderFibo_78_,
      int STP_,
      int &Mas_Tip_[],              // Массив колич. ордеров всех типов
      double &FiboUp_New_[][],
      double &FiboDown_New_[][],
      string Sparam,
      double &Mas_Ord_New_[][],
      double &Mas_Ord_Old_[][],
      bool Alert_sig_Terminal_,
      bool &flag_interation_
   );
  };

[Удален] 2021.06.29 20:55 #13193

Sprut 185: Короче не прокатило? А жаль !!!!

Ну не верю я, что не может быть ни какого решения - буду дальше бороздить просторы инета.

наверное так как Вы задумали - вроде получилось.

//+------------------------------------------------------------------+
//|                                                  5 Sprut 185.mq5 |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
//---
#define MACD_MAGIC 1234502
//---
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
//---
double            m_adjusted_point;             // point value adjusted for 3 or 5 points
CTrade            m_trade;                      // trading object
CSymbolInfo       m_symbol;                     // symbol info object
CPositionInfo     m_position;                   // trade position object
CAccountInfo      m_account;                    // account info wrapper
//---
input double InpLots          =0.1;    // Lots
input int    InpTakeProfit    =50;     // Take Profit (in pips)
input bool   InpClOp          =false;  // Close opposite
//---
string InpObjDownName ="Sprutbuy";     // : Obj: Follows the price up (Horizontal Line)
string InpObjUpName   ="Sprutsell";    // : Obj: Follows the price down (Horizontal Line)
//---
double   m_take_profit;
int      m_price_uno;
datetime m_ExtPrevBars          = D'1970.01.01 00:00';
datetime m_ExtLastSignals       = D'1970.01.01 00:00';
datetime m_ExtPrevBars_x        = D'1970.01.01 00:00';
datetime m_ExtLastSignals_x     = D'1970.01.01 00:00';
int      m_handle_macd; // MACD indicator handle
int      ExtTimeOut=10; // time out in seconds between trade operations
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- initialize common information
   m_symbol.Name(Symbol());                  // symbol
   m_trade.SetExpertMagicNumber(MACD_MAGIC); // magic
   m_trade.SetMarginMode();
   m_trade.SetTypeFillingBySymbol(Symbol());
//--- tuning for 3 or 5 digits
   int digits_adjust=1;
   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)
      digits_adjust=10;
   m_adjusted_point=m_symbol.Point()*digits_adjust;
//--- set default deviation for trading in adjusted points
   m_take_profit     =InpTakeProfit*m_adjusted_point;
//--- set default deviation for trading in adjusted points
   m_trade.SetDeviationInPoints(3*digits_adjust);
//--- create MACD indicator
   m_handle_macd=iCustom(NULL,0,"StepMA_NRTR");
   if(m_handle_macd==INVALID_HANDLE)
     {
      printf("Error creating MACD indicator");
      return(false);
     }
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick(void)
  {
   static datetime limit_time=0; // last trade processing time + timeout
//---
   if(ProcessingUp() || ProcessingDown())
     {
      return;
     }
//--- don't process if timeout
   if(TimeCurrent()>=limit_time)
     {
      //--- check for data
      if(Bars(Symbol(),Period())>2)
        {
         //--- change limit time by timeout in seconds if processed
         if(Processing())
            limit_time=TimeCurrent()+ExtTimeOut;
        }
     }
  }
//+------------------------------------------------------------------+
//| main function returns true if any position processed             |
//+------------------------------------------------------------------+
bool Processing(void)
  {
//--- refresh rates
   if(!m_symbol.RefreshRates())
      return(false);
   double m_buff_MACD_main[],m_buff_MACD_signal[];
   bool StNRUp,StNRDn;
   ArraySetAsSeries(m_buff_MACD_main,true);
   ArraySetAsSeries(m_buff_MACD_signal,true);
   int start_pos=1,count=3;
   if(!iGetArray(m_handle_macd,0,start_pos,count,m_buff_MACD_main)||
      !iGetArray(m_handle_macd,1,start_pos,count,m_buff_MACD_signal))
     {
      return(false);
     }
//---
   StNRUp=m_buff_MACD_main[0]<m_buff_MACD_signal[0];
   StNRDn=m_buff_MACD_main[0]>m_buff_MACD_signal[0];
//--- BUY Signal
   if(StNRUp)
     {
      if(InpClOp)
         if(ShortClosed())
            Sleep(1000);
      if(m_price_uno<0)
         LongOpened();
      m_price_uno=+1;
      return(true);
     }
//--- SELL Signal
   if(StNRDn)
     {
      if(InpClOp)
         if(LongClosed())
            Sleep(1000);
      if(m_price_uno>0)
         ShortOpened();
      m_price_uno=-1;
      return(true);
     }
//--- exit without position processing
   return(false);
  }
//+------------------------------------------------------------------+
//| Check for long position closing                                  |
//+------------------------------------------------------------------+
bool LongClosed(void)
  {
   bool res=false;
//--- should it be closed?
   ClosePositions(POSITION_TYPE_BUY);
//--- processed and cannot be modified
   res=true;
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for short position closing                                 |
//+------------------------------------------------------------------+
bool ShortClosed(void)
  {
   bool res=false;
//--- should it be closed?
   ClosePositions(POSITION_TYPE_SELL);
//--- processed and cannot be modified
   res=true;
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for long position opening                                  |
//+------------------------------------------------------------------+
bool LongOpened(void)
  {
   bool res=false;
//--- check for long position (BUY) possibility
   double price=m_symbol.Ask();
   double tp   =m_symbol.Bid()+m_take_profit;
//--- check for free money
   if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_BUY,InpLots,price)<0.0)
      printf("We have no money. Free Margin = %f",m_account.FreeMargin());
   else
     {
      //--- open position
      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,InpLots,price,0.0,tp))
         printf("Position by %s to be opened",Symbol());
      else
        {
         printf("Error opening BUY position by %s : '%s'",Symbol(),m_trade.ResultComment());
         printf("Open parameters : price=%f,TP=%f",price,tp);
        }
      PlaySound("ok.wav");
      if(!InpClOp)
         CreateHline(0,0,InpObjDownName,tp,clrGreen,0,0,1,1,1,1,2);
     }
//--- in any case we must exit from expert
   res=true;
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Check for short position opening                                 |
//+------------------------------------------------------------------+
bool ShortOpened(void)
  {
   bool res=false;
//--- check for short position (SELL) possibility
   double price=m_symbol.Bid();
   double tp   =m_symbol.Ask()-m_take_profit;
//--- check for free money
   if(m_account.FreeMarginCheck(Symbol(),ORDER_TYPE_SELL,InpLots,price)<0.0)
      printf("We have no money. Free Margin = %f",m_account.FreeMargin());
   else
     {
      //--- open position
      if(m_trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,InpLots,price,0.0,tp))
         printf("Position by %s to be opened",Symbol());
      else
        {
         printf("Error opening SELL position by %s : '%s'",Symbol(),m_trade.ResultComment());
         printf("Open parameters : price=%f,TP=%f",price,tp);
        }
      PlaySound("ok.wav");
      if(!InpClOp)
         CreateHline(0,0,InpObjUpName,tp,clrGreen,0,0,1,1,1,1,2);
     }
//--- in any case we must exit from expert
   res=true;
//--- result
   return(res);
  }
//+------------------------------------------------------------------+
//| Refreshes the symbol quotes data                                 |
//+------------------------------------------------------------------+
bool RefreshRates()
  {
//--- refresh rates
   if(!m_symbol.RefreshRates())
     {
      return(false);
     }
//--- protection against the return value of "zero"
   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)
     {
      return(false);
     }
//---
   return(true);
  }
//+------------------------------------------------------------------+
//| Check Freeze and Stops levels                                    |
//+------------------------------------------------------------------+
void FreezeStopsLevels(double &freeze,double &stops)
  {
//--- check Freeze and Stops levels
   double coeff=(double)1;
   if(!RefreshRates() || !m_symbol.Refresh())
      return;
//--- FreezeLevel -> for pending order and modification
   double freeze_level=m_symbol.FreezeLevel()*m_symbol.Point();
   if(freeze_level==0.0)
      if(1>0)
         freeze_level=(m_symbol.Ask()-m_symbol.Bid())*coeff;
//--- StopsLevel -> for TakeProfit and StopLoss
   double stop_level=m_symbol.StopsLevel()*m_symbol.Point();
   if(stop_level==0.0)
      if(1>0)
         stop_level=(m_symbol.Ask()-m_symbol.Bid())*coeff;
//---
   freeze=freeze_level;
   stops=stop_level;
//---
   return;
  }
//+------------------------------------------------------------------+
//| Close positions                                                  |
//+------------------------------------------------------------------+
void ClosePositions(const ENUM_POSITION_TYPE pos_type)
  {
   double freeze=0.0,stops=0.0;
   FreezeStopsLevels(freeze,stops);
   for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties
         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==MACD_MAGIC)
            if(m_position.PositionType()==pos_type)
              {
               if(m_position.PositionType()==POSITION_TYPE_BUY)
                 {
                  bool take_profit_level=((m_position.TakeProfit()!=0.0 && m_position.TakeProfit()-m_position.PriceCurrent()>=freeze) || m_position.TakeProfit()==0.0);
                  bool stop_loss_level=((m_position.StopLoss()!=0.0 && m_position.PriceCurrent()-m_position.StopLoss()>=freeze) || m_position.StopLoss()==0.0);
                  if(take_profit_level && stop_loss_level)
                     if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol
                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","BUY PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());
                 }
               if(m_position.PositionType()==POSITION_TYPE_SELL)
                 {
                  bool take_profit_level=((m_position.TakeProfit()!=0.0 && m_position.PriceCurrent()-m_position.TakeProfit()>=freeze) || m_position.TakeProfit()==0.0);
                  bool stop_loss_level=((m_position.StopLoss()!=0.0 && m_position.StopLoss()-m_position.PriceCurrent()>=freeze) || m_position.StopLoss()==0.0);
                  if(take_profit_level && stop_loss_level)
                     if(!m_trade.PositionClose(m_position.Ticket())) // close a position by the specified m_symbol
                        Print(__FILE__," ",__FUNCTION__,", ERROR: ","SELL PositionClose ",m_position.Ticket(),", ",m_trade.ResultRetcodeDescription());
                 }
               PlaySound("ok.wav");
              }
  }
//+------------------------------------------------------------------+
//| Filling the indicator buffers from the indicator                 |
//+------------------------------------------------------------------+
bool iGetArray(const int handle,const int buffer,const int start_pos,
               const int count,double &arr_buffer[])
  {
   bool result=true;
   if(!ArrayIsDynamic(arr_buffer))
     {
      return(false);
     }
   ArrayFree(arr_buffer);
//--- reset error code
   ResetLastError();
//--- fill a part of the iBands array with values from the indicator buffer
   int copied=CopyBuffer(handle,buffer,start_pos,count,arr_buffer);
   if(copied!=count)
     {
      return(false);
     }
   return(result);
  }
//+------------------------------------------------------------------+
//| ProcessingClosSell                                               |
//+------------------------------------------------------------------+
bool ProcessingUp(void)
  {
   bool rv=false;
   datetime time_current=TimeCurrent();
   if(time_current-m_ExtLastSignals>10)
     {
      MqlRates rates[];
      int start_pos=0,count=1;
      if(CopyRates(m_symbol.Name(),Period(),start_pos,count,rates)!=count)
        {
         m_ExtPrevBars=0;
         return(true);
        }
      double price_line=0.0;
      if(ObjectFind(0,InpObjUpName)>=0)
        {
         long object_type=ObjectGetInteger(0,InpObjUpName,OBJPROP_TYPE);
         if(object_type==OBJ_HLINE)
            price_line=ObjectGetDouble(0,InpObjUpName,OBJPROP_PRICE);
         if(price_line>0.0)
           {
            if((rates[0].open>price_line && rates[0].close<price_line) ||
               (rates[0].open<price_line && rates[0].close>price_line))
              {
               //--- try to close or modify short position
               if(ShortOpened())
                  return(true);
              }
           }
        }
     }
   return(rv);
  }
//+------------------------------------------------------------------+
//| ProcessingClosBuy                                                |
//+------------------------------------------------------------------+
bool ProcessingDown(void)
  {
   bool rv=false;
   datetime time_current=TimeCurrent();
   if(time_current-m_ExtLastSignals_x>10)
     {
      MqlRates rates[];
      //ArraySetAsSeries(rates,true);
      int start_pos=0,count=1;
      if(CopyRates(m_symbol.Name(),Period(),start_pos,count,rates)!=count)
        {
         m_ExtPrevBars_x=0;
         return(true);
        }
      double price_line=0.0;
      if(ObjectFind(0,InpObjDownName)>=0)
        {
         long object_type=ObjectGetInteger(0,InpObjDownName,OBJPROP_TYPE);
         if(object_type==OBJ_HLINE)
            price_line=ObjectGetDouble(0,InpObjDownName,OBJPROP_PRICE);
         if(price_line>0.0)
           {
            if((rates[0].open>price_line && rates[0].close<price_line) ||
               (rates[0].open<price_line && rates[0].close>price_line))
              {
               //--- try to close or modify long position
               if(LongOpened())
                  return(true);
              }
           }
        }
     }
   return(rv);
  }
//+------------------------------------------------------------------+
//|  Creating a horizontal price level                               |
//+------------------------------------------------------------------+
bool CreateHline(long ch_id,int sub_window,
                 string name,double price,
                 color clr,ENUM_LINE_STYLE style,
                 int width,bool back,
                 bool selectable,bool selected,
                 bool hidden,long z_order)
  {
   int    err = GetLastError();
   string lnName = name;
   err = 0;
   if(ObjectFind(0,lnName)!=-1)
      ObjectDelete(0,lnName);
   if(!ObjectCreate(ch_id,lnName,OBJ_HLINE,sub_window,0,price))
     {
      err = GetLastError();
      Print("Can't create object #", lnName, "# Error(",err,"):", err);
      return(false);
     }
   ObjectSetInteger(ch_id,lnName,OBJPROP_COLOR,clr);
   ObjectSetInteger(ch_id,lnName,OBJPROP_STYLE,style);
   ObjectSetInteger(ch_id,lnName,OBJPROP_WIDTH,width);
   ObjectSetInteger(ch_id,lnName,OBJPROP_BACK,back);
   ObjectSetInteger(ch_id,lnName,OBJPROP_SELECTABLE,selectable);
   ObjectSetInteger(ch_id,lnName,OBJPROP_SELECTED,selected);
   ObjectSetInteger(ch_id,lnName,OBJPROP_HIDDEN,hidden);
   ObjectSetInteger(ch_id,lnName,OBJPROP_ZORDER,z_order);
   return(true);
  }
//+------------------------------------------------------------------+

Alexey Viktorov 2021.06.30 13:42 #13194

Sprut 185:

Привет!

Перерыл весь инет и решение на mql5 не нашел, а вот на mql4 нашел советника - как раз Мартина, который работает одновременно в две стороны и в бай и в селлл - одновременно. Может попробовать взять за основу его........., но вот только придется его переписывать с mql4, на MQL5.

Для ознакомления Вам с ним - прикрепляю его файл.

Вчера скачал это чудо для посмотреть… И вдруг лишили меня тырнета. После грозы технические работы до конца дня. Вот и решил я от безделья переписать это чудо на MQL5, опубликован тут.

Получается нет худа без добра………

Советники: DVA_Martin

2021.06.30
www.mql5.com

Статьи и техническая библиотека по автоматическому трейдингу: Советники: DVA_Martin

FOREX - Тенденции, прогнозы Чистая математика, физика, химия Что за дела?

Ivan Nagibin 2021.06.30 20:27 #13195

Добрый день, имеется множество однотипных индикаторных буферов, расчитать которые можно в цикле, но как сделать массив индикаторных буферов? Попробовал через стрктуру, и вроде бы все было хорошо, SetIndexBuffer() отработал без ошибок, но при наступлении OnCalculate() размеры массивов не меняются и остаются 0. Подскажите как организовать расчет индикаторных буферов в цикле, возможно по именам, типа: "buff_0", "buff_1" и т.д., но как это сделать я не знаю(( А то очень длинная простыня получается(

Любые вопросы новичков по Сделать буфер структурой.. ссылка на переменную

Sprut 185 2021.06.30 20:42 #13196

SanAlex:

наверное так как Вы задумали - вроде получилось.

Спасибо!

Все верно, но не совсем, что я задумал !!! ордер ставятся по тренду (по индикатору) и закрываются по тейку и как только закрывается - открываются новый ордер в ту же сторону (по тренду), но это только одна часть моей задумки.

Вторая заключается в том, что ордер - который не закрылся по тейку при развороте тренда (сигнала индикатора о изменении направления движения цены) должен не закрываться (что Вы и сделали), а к нему теперь - нужно применить Мартнгейл, т.е. открывать ордера не по тренду с определенным шагом, множителем и усреднением тейку.

Короче две части должны работать в паре.

Напишу советник бесплатно Перевыставление ордеров, помогите с скрипт на изменение тейк

Sprut 185 2021.06.30 20:45 #13197

Alexey Viktorov:

Вчера скачал это чудо для посмотреть… И вдруг лишили меня тырнета. После грозы технические работы до конца дня. Вот и решил я от безделья переписать это чудо на MQL5, опубликован тут.

Получается нет худа без добра………

Спасибо большое!

Может и пригодится, если получится реализовать мою идею!

[Удален] 2021.06.30 21:00 #13198

VANDER:
Попробовал через стрктуру, и вроде бы все было хорошо

Разве так не работает?

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

[Удален] 2021.06.30 21:02 #13199

Sprut 185:

а к нему теперь - нужно применить Мартнгейл, т.е. открывать ордера не по тренду с определенным шагом, множителем и усреднением тейку.

Короче две части должны работать в паре.

Вы имеете ввиду что бы следующая позиция открывалась с удвоенным лотом 2-4-8-16 по BUY и противоположно 2-4-8-16 в SELL ???

у меня такая функция есть - слепил себе как то.

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

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

надо заменить в открытии позиции - тут вместо InpLots на OptimizedBuy() и 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))

Прошу помощи в написании Почему могут существовать разнонаправленные Лавина

[Удален] 2021.06.30 21:21 #13200

SanAlex:

Вы имеете ввиду что бы следующая позиция открывалась с удвоенным лотом 2-4-8-16 по BUY и противоположно 2-4-8-16 в SELL ???

у меня такая функция есть - слепил себе как то.

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

надо заменить в открытии позиции - тут вместо InpLots на OptimizedBuy() и OptimizedSell()

но для этой функции желательно ещё эту функцию иметь - что бы закрывало по профиту (в валюте)

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

Вопросы от начинающих MQL5 MT5 MetaTrader 5 - страница 1320