add new backup ...

2024-06-01 19:37:54 +03:30
parent 0998ffa2a5
commit 83c000fdd6
142 changed files with 60067 additions and 0 deletions
@@ -0,0 +1,45 @@
+//+------------------------------------------------------------------+
+//|                                                     Controls.mq5 |
+//|                             Copyright 2000-2024, MetaQuotes Ltd. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright "Copyright 2000-2024, MetaQuotes Ltd."
+#property link      "https://www.mql5.com"
+#property version   "1.00"
+#include "ControlsDialog.mqh"
+//+------------------------------------------------------------------+
+//| Global Variables                                                 |
+//+------------------------------------------------------------------+
+CControlsDialog ExtDialog;
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit()
+  {
+//--- create application dialog
+   if(!ExtDialog.Create(0,"Controls",0,20,20,360,324))
+     return(INIT_FAILED);
+//--- run application
+   ExtDialog.Run();
+//--- succeed
+   return(INIT_SUCCEEDED);
+  }
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+  {
+//--- destroy dialog
+   ExtDialog.Destroy(reason);
+  }
+//+------------------------------------------------------------------+
+//| Expert chart event function                                      |
+//+------------------------------------------------------------------+
+void OnChartEvent(const int id,         // event ID  
+                  const long& lparam,   // event parameter of the long type
+                  const double& dparam, // event parameter of the double type
+                  const string& sparam) // event parameter of the string type
+  {
+   ExtDialog.ChartEvent(id,lparam,dparam,sparam);
+  }
+//+------------------------------------------------------------------+
@@ -0,0 +1,427 @@
+//+------------------------------------------------------------------+
+//|                                               ControlsDialog.mqh |
+//|                             Copyright 2000-2024, MetaQuotes Ltd. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#include <Controls\Dialog.mqh>
+#include <Controls\Button.mqh>
+#include <Controls\Edit.mqh>
+#include <Controls\DatePicker.mqh>
+#include <Controls\ListView.mqh>
+#include <Controls\ComboBox.mqh>
+#include <Controls\SpinEdit.mqh>
+#include <Controls\RadioGroup.mqh>
+#include <Controls\CheckGroup.mqh>
+//+------------------------------------------------------------------+
+//| defines                                                          |
+//+------------------------------------------------------------------+
+//--- indents and gaps
+#define INDENT_LEFT                         (11)      // indent from left (with allowance for border width)
+#define INDENT_TOP                          (11)      // indent from top (with allowance for border width)
+#define INDENT_RIGHT                        (11)      // indent from right (with allowance for border width)
+#define INDENT_BOTTOM                       (11)      // indent from bottom (with allowance for border width)
+#define CONTROLS_GAP_X                      (5)       // gap by X coordinate
+#define CONTROLS_GAP_Y                      (5)       // gap by Y coordinate
+//--- for buttons
+#define BUTTON_WIDTH                        (100)     // size by X coordinate
+#define BUTTON_HEIGHT                       (20)      // size by Y coordinate
+//--- for the indication area
+#define EDIT_HEIGHT                         (20)      // size by Y coordinate
+//--- for group controls
+#define GROUP_WIDTH                         (150)     // size by X coordinate
+#define LIST_HEIGHT                         (179)     // size by Y coordinate
+#define RADIO_HEIGHT                        (56)      // size by Y coordinate
+#define CHECK_HEIGHT                        (93)      // size by Y coordinate
+//+------------------------------------------------------------------+
+//| Class CControlsDialog                                            |
+//| Usage: main dialog of the Controls application                   |
+//+------------------------------------------------------------------+
+class CControlsDialog : public CAppDialog
+  {
+private:
+   CEdit             m_edit;                          // the display field object
+   CButton           m_button1;                       // the button object
+   CButton           m_button2;                       // the button object
+   CButton           m_button3;                       // the fixed button object
+   CSpinEdit         m_spin_edit;                     // the up-down object
+   CDatePicker       m_date;                          // the datepicker object
+   CListView         m_list_view;                     // the list object
+   CComboBox         m_combo_box;                     // the dropdown list object
+   CRadioGroup       m_radio_group;                   // the radio buttons group object
+   CCheckGroup       m_check_group;                   // the check box group object
+
+public:
+                     CControlsDialog(void);
+                    ~CControlsDialog(void);
+   //--- create
+   virtual bool      Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2);
+   //--- chart event handler
+   virtual bool      OnEvent(const int id,const long &lparam,const double &dparam,const string &sparam);
+
+protected:
+   //--- create dependent controls
+   bool              CreateEdit(void);
+   bool              CreateButton1(void);
+   bool              CreateButton2(void);
+   bool              CreateButton3(void);
+   bool              CreateSpinEdit(void);
+   bool              CreateDate(void);
+   bool              CreateListView(void);
+   bool              CreateComboBox(void);
+   bool              CreateRadioGroup(void);
+   bool              CreateCheckGroup(void);
+   //--- handlers of the dependent controls events
+   void              OnClickButton1(void);
+   void              OnClickButton2(void);
+   void              OnClickButton3(void);
+   void              OnChangeSpinEdit(void);
+   void              OnChangeDate(void);
+   void              OnChangeListView(void);
+   void              OnChangeComboBox(void);
+   void              OnChangeRadioGroup(void);
+   void              OnChangeCheckGroup(void);
+  };
+//+------------------------------------------------------------------+
+//| Event Handling                                                   |
+//+------------------------------------------------------------------+
+EVENT_MAP_BEGIN(CControlsDialog)
+   ON_EVENT(ON_CLICK,m_button1,OnClickButton1)
+   ON_EVENT(ON_CLICK,m_button2,OnClickButton2)
+   ON_EVENT(ON_CLICK,m_button3,OnClickButton3)
+   ON_EVENT(ON_CHANGE,m_spin_edit,OnChangeSpinEdit)
+   ON_EVENT(ON_CHANGE,m_date,OnChangeDate)
+   ON_EVENT(ON_CHANGE,m_list_view,OnChangeListView)
+   ON_EVENT(ON_CHANGE,m_combo_box,OnChangeComboBox)
+   ON_EVENT(ON_CHANGE,m_radio_group,OnChangeRadioGroup)
+   ON_EVENT(ON_CHANGE,m_check_group,OnChangeCheckGroup)
+EVENT_MAP_END(CAppDialog)
+//+------------------------------------------------------------------+
+//| Constructor                                                      |
+//+------------------------------------------------------------------+
+CControlsDialog::CControlsDialog(void)
+  {
+  }
+//+------------------------------------------------------------------+
+//| Destructor                                                       |
+//+------------------------------------------------------------------+
+CControlsDialog::~CControlsDialog(void)
+  {
+  }
+//+------------------------------------------------------------------+
+//| Create                                                           |
+//+------------------------------------------------------------------+
+bool CControlsDialog::Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2)
+  {
+   if(!CAppDialog::Create(chart,name,subwin,x1,y1,x2,y2))
+      return(false);
+//--- create dependent controls
+   if(!CreateEdit())
+      return(false);
+   if(!CreateButton1())
+      return(false);
+   if(!CreateButton2())
+      return(false);
+   if(!CreateButton3())
+      return(false);
+   if(!CreateSpinEdit())
+      return(false);
+   if(!CreateListView())
+      return(false);
+   if(!CreateDate())
+      return(false);
+   if(!CreateRadioGroup())
+      return(false);
+   if(!CreateCheckGroup())
+      return(false);
+   if(!CreateComboBox())
+      return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the display field                                         |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateEdit(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT;
+   int y1=INDENT_TOP;
+   int x2=ClientAreaWidth()-INDENT_RIGHT;
+   int y2=y1+EDIT_HEIGHT;
+//--- create
+   if(!m_edit.Create(m_chart_id,m_name+"Edit",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!m_edit.ReadOnly(true))
+      return(false);
+   if(!Add(m_edit))
+      return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "Button1" button                                      |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateButton1(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+BUTTON_WIDTH;
+   int y2=y1+BUTTON_HEIGHT;
+//--- create
+   if(!m_button1.Create(m_chart_id,m_name+"Button1",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!m_button1.Text("Button1"))
+      return(false);
+   if(!Add(m_button1))
+      return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "Button2" button                                      |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateButton2(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT+(BUTTON_WIDTH+CONTROLS_GAP_X);
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+BUTTON_WIDTH;
+   int y2=y1+BUTTON_HEIGHT;
+//--- create
+   if(!m_button2.Create(m_chart_id,m_name+"Button2",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!m_button2.Text("Button2"))
+      return(false);
+   if(!Add(m_button2))
+      return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "Button3" fixed button                                |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateButton3(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT+2*(BUTTON_WIDTH+CONTROLS_GAP_X);
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+BUTTON_WIDTH;
+   int y2=y1+BUTTON_HEIGHT;
+//--- create
+   if(!m_button3.Create(m_chart_id,m_name+"Button3",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!m_button3.Text("Locked"))
+      return(false);
+   if(!Add(m_button3))
+      return(false);
+   m_button3.Locking(true);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "SpinEdit" element                                    |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateSpinEdit(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y)+(BUTTON_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+GROUP_WIDTH;
+   int y2=y1+EDIT_HEIGHT;
+//--- create
+   if(!m_spin_edit.Create(m_chart_id,m_name+"SpinEdit",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!Add(m_spin_edit))
+      return(false);
+   m_spin_edit.MinValue(10);
+   m_spin_edit.MaxValue(1000);
+   m_spin_edit.Value(100);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "DatePicker" element                                  |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateDate(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT+GROUP_WIDTH+2*CONTROLS_GAP_X;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y)+(BUTTON_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+GROUP_WIDTH;
+   int y2=y1+EDIT_HEIGHT;
+//--- create
+   if(!m_date.Create(m_chart_id,m_name+"Date",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!Add(m_date))
+      return(false);
+   m_date.Value(TimeCurrent());
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "ListView" element                                    |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateListView(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT+GROUP_WIDTH+2*CONTROLS_GAP_X;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (BUTTON_HEIGHT+CONTROLS_GAP_Y)+
+          (EDIT_HEIGHT+2*CONTROLS_GAP_Y);
+   int x2=x1+GROUP_WIDTH;
+   int y2=y1+LIST_HEIGHT-CONTROLS_GAP_Y;
+//--- create
+   if(!m_list_view.Create(m_chart_id,m_name+"ListView",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!Add(m_list_view))
+      return(false);
+//--- fill out with strings
+   for(int i=0;i<16;i++)
+      if(!m_list_view.AddItem("Item "+IntegerToString(i)))
+         return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "ComboBox" element                                    |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateComboBox(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (BUTTON_HEIGHT+CONTROLS_GAP_Y)+
+          (EDIT_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+GROUP_WIDTH;
+   int y2=y1+EDIT_HEIGHT;
+//--- create
+   if(!m_combo_box.Create(m_chart_id,m_name+"ComboBox",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!Add(m_combo_box))
+      return(false);
+//--- fill out with strings
+   for(int i=0;i<16;i++)
+      if(!m_combo_box.ItemAdd("Item "+IntegerToString(i)))
+         return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "RadioGroup" element                                  |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateRadioGroup(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (BUTTON_HEIGHT+CONTROLS_GAP_Y)+
+          (EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (EDIT_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+GROUP_WIDTH;
+   int y2=y1+RADIO_HEIGHT;
+//--- create
+   if(!m_radio_group.Create(m_chart_id,m_name+"RadioGroup",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!Add(m_radio_group))
+      return(false);
+//--- fill out with strings
+   for(int i=0;i<3;i++)
+      if(!m_radio_group.AddItem("Item "+IntegerToString(i),1<<i))
+         return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Create the "CheckGroup" element                                  |
+//+------------------------------------------------------------------+
+bool CControlsDialog::CreateCheckGroup(void)
+  {
+//--- coordinates
+   int x1=INDENT_LEFT;
+   int y1=INDENT_TOP+(EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (BUTTON_HEIGHT+CONTROLS_GAP_Y)+
+          (EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (EDIT_HEIGHT+CONTROLS_GAP_Y)+
+          (RADIO_HEIGHT+CONTROLS_GAP_Y);
+   int x2=x1+GROUP_WIDTH;
+   int y2=y1+CHECK_HEIGHT;
+//--- create
+   if(!m_check_group.Create(m_chart_id,m_name+"CheckGroup",m_subwin,x1,y1,x2,y2))
+      return(false);
+   if(!Add(m_check_group))
+      return(false);
+//--- fill out with strings
+   for(int i=0;i<5;i++)
+      if(!m_check_group.AddItem("Item "+IntegerToString(i),1<<i))
+         return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnClickButton1(void)
+  {
+   m_edit.Text(__FUNCTION__);
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnClickButton2(void)
+  {
+   m_edit.Text(__FUNCTION__);
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnClickButton3(void)
+  {
+   if(m_button3.Pressed())
+      m_edit.Text(__FUNCTION__+"On");
+   else
+      m_edit.Text(__FUNCTION__+"Off");
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnChangeSpinEdit()
+  {
+   m_edit.Text(__FUNCTION__+" : Value="+IntegerToString(m_spin_edit.Value()));
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnChangeDate(void)
+  {
+   m_edit.Text(__FUNCTION__+" \""+TimeToString(m_date.Value(),TIME_DATE)+"\"");
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnChangeListView(void)
+  {
+   m_edit.Text(__FUNCTION__+" \""+m_list_view.Select()+"\"");
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnChangeComboBox(void)
+  {
+   m_edit.Text(__FUNCTION__+" \""+m_combo_box.Select()+"\"");
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnChangeRadioGroup(void)
+  {
+   m_edit.Text(__FUNCTION__+" : Value="+IntegerToString(m_radio_group.Value()));
+  }
+//+------------------------------------------------------------------+
+//| Event handler                                                    |
+//+------------------------------------------------------------------+
+void CControlsDialog::OnChangeCheckGroup(void)
+  {
+   m_edit.Text(__FUNCTION__+" : Value="+IntegerToString(m_check_group.Value()));
+  }
+//+------------------------------------------------------------------+
@@ -0,0 +1,451 @@
+//+------------------------------------------------------------------+
+//|                                                  MACD Sample.mq5 |
+//|                             Copyright 2000-2024, MetaQuotes Ltd. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright   "Copyright 2000-2024, MetaQuotes Ltd."
+#property link        "https://www.mql5.com"
+#property version     "5.50"
+#property description "It is important to make sure that the expert works with a normal"
+#property description "chart and the user did not make any mistakes setting input"
+#property description "variables (Lots, TakeProfit, TrailingStop) in our case,"
+#property description "we check TakeProfit on a chart of more than 2*trend_period bars"
+
+#define MACD_MAGIC 1234502
+//---
+#include <Trade\Trade.mqh>
+#include <Trade\SymbolInfo.mqh>
+#include <Trade\PositionInfo.mqh>
+#include <Trade\AccountInfo.mqh>
+//---
+input double InpLots          =0.1; // Lots
+input int    InpTakeProfit    =50;  // Take Profit (in pips)
+input int    InpTrailingStop  =30;  // Trailing Stop Level (in pips)
+input int    InpMACDOpenLevel =3;   // MACD open level (in pips)
+input int    InpMACDCloseLevel=2;   // MACD close level (in pips)
+input int    InpMATrendPeriod =26;  // MA trend period
+//---
+int ExtTimeOut=10; // time out in seconds between trade operations
+//+------------------------------------------------------------------+
+//| MACD Sample expert class                                         |
+//+------------------------------------------------------------------+
+class CSampleExpert
+  {
+protected:
+   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
+   //--- indicators
+   int               m_handle_macd;                // MACD indicator handle
+   int               m_handle_ema;                 // moving average indicator handle
+   //--- indicator buffers
+   double            m_buff_MACD_main[];           // MACD indicator main buffer
+   double            m_buff_MACD_signal[];         // MACD indicator signal buffer
+   double            m_buff_EMA[];                 // EMA indicator buffer
+   //--- indicator data for processing
+   double            m_macd_current;
+   double            m_macd_previous;
+   double            m_signal_current;
+   double            m_signal_previous;
+   double            m_ema_current;
+   double            m_ema_previous;
+   //---
+   double            m_macd_open_level;
+   double            m_macd_close_level;
+   double            m_traling_stop;
+   double            m_take_profit;
+
+public:
+                     CSampleExpert(void);
+                    ~CSampleExpert(void);
+   bool              Init(void);
+   void              Deinit(void);
+   bool              Processing(void);
+
+protected:
+   bool              InitCheckParameters(const int digits_adjust);
+   bool              InitIndicators(void);
+   bool              LongClosed(void);
+   bool              ShortClosed(void);
+   bool              LongModified(void);
+   bool              ShortModified(void);
+   bool              LongOpened(void);
+   bool              ShortOpened(void);
+  };
+//--- global expert
+CSampleExpert ExtExpert;
+//+------------------------------------------------------------------+
+//| Constructor                                                      |
+//+------------------------------------------------------------------+
+CSampleExpert::CSampleExpert(void) : m_adjusted_point(0),
+                                     m_handle_macd(INVALID_HANDLE),
+                                     m_handle_ema(INVALID_HANDLE),
+                                     m_macd_current(0),
+                                     m_macd_previous(0),
+                                     m_signal_current(0),
+                                     m_signal_previous(0),
+                                     m_ema_current(0),
+                                     m_ema_previous(0),
+                                     m_macd_open_level(0),
+                                     m_macd_close_level(0),
+                                     m_traling_stop(0),
+                                     m_take_profit(0)
+  {
+   ArraySetAsSeries(m_buff_MACD_main,true);
+   ArraySetAsSeries(m_buff_MACD_signal,true);
+   ArraySetAsSeries(m_buff_EMA,true);
+  }
+//+------------------------------------------------------------------+
+//| Destructor                                                       |
+//+------------------------------------------------------------------+
+CSampleExpert::~CSampleExpert(void)
+  {
+  }
+//+------------------------------------------------------------------+
+//| Initialization and checking for input parameters                 |
+//+------------------------------------------------------------------+
+bool CSampleExpert::Init(void)
+  {
+//--- 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_macd_open_level =InpMACDOpenLevel*m_adjusted_point;
+   m_macd_close_level=InpMACDCloseLevel*m_adjusted_point;
+   m_traling_stop    =InpTrailingStop*m_adjusted_point;
+   m_take_profit     =InpTakeProfit*m_adjusted_point;
+//--- set default deviation for trading in adjusted points
+   m_trade.SetDeviationInPoints(3*digits_adjust);
+//---
+   if(!InitCheckParameters(digits_adjust))
+      return(false);
+   if(!InitIndicators())
+      return(false);
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Checking for input parameters                                    |
+//+------------------------------------------------------------------+
+bool CSampleExpert::InitCheckParameters(const int digits_adjust)
+  {
+//--- initial data checks
+   if(InpTakeProfit*digits_adjust<m_symbol.StopsLevel())
+     {
+      printf("Take Profit must be greater than %d",m_symbol.StopsLevel());
+      return(false);
+     }
+   if(InpTrailingStop*digits_adjust<m_symbol.StopsLevel())
+     {
+      printf("Trailing Stop must be greater than %d",m_symbol.StopsLevel());
+      return(false);
+     }
+//--- check for right lots amount
+   if(InpLots<m_symbol.LotsMin() || InpLots>m_symbol.LotsMax())
+     {
+      printf("Lots amount must be in the range from %f to %f",m_symbol.LotsMin(),m_symbol.LotsMax());
+      return(false);
+     }
+   if(MathAbs(InpLots/m_symbol.LotsStep()-MathRound(InpLots/m_symbol.LotsStep()))>1.0E-10)
+     {
+      printf("Lots amount is not corresponding with lot step %f",m_symbol.LotsStep());
+      return(false);
+     }
+//--- warning
+   if(InpTakeProfit<=InpTrailingStop)
+      printf("Warning: Trailing Stop must be less than Take Profit");
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Initialization of the indicators                                 |
+//+------------------------------------------------------------------+
+bool CSampleExpert::InitIndicators(void)
+  {
+//--- create MACD indicator
+   if(m_handle_macd==INVALID_HANDLE)
+      if((m_handle_macd=iMACD(NULL,0,12,26,9,PRICE_CLOSE))==INVALID_HANDLE)
+        {
+         printf("Error creating MACD indicator");
+         return(false);
+        }
+//--- create EMA indicator and add it to collection
+   if(m_handle_ema==INVALID_HANDLE)
+      if((m_handle_ema=iMA(NULL,0,InpMATrendPeriod,0,MODE_EMA,PRICE_CLOSE))==INVALID_HANDLE)
+        {
+         printf("Error creating EMA indicator");
+         return(false);
+        }
+//--- succeed
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| Check for long position closing                                  |
+//+------------------------------------------------------------------+
+bool CSampleExpert::LongClosed(void)
+  {
+   bool res=false;
+//--- should it be closed?
+   if(m_macd_current>0)
+      if(m_macd_current<m_signal_current && m_macd_previous>m_signal_previous)
+         if(m_macd_current>m_macd_close_level)
+           {
+            //--- close position
+            if(m_trade.PositionClose(Symbol()))
+               printf("Long position by %s to be closed",Symbol());
+            else
+               printf("Error closing position by %s : '%s'",Symbol(),m_trade.ResultComment());
+            //--- processed and cannot be modified
+            res=true;
+           }
+//--- result
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Check for short position closing                                 |
+//+------------------------------------------------------------------+
+bool CSampleExpert::ShortClosed(void)
+  {
+   bool res=false;
+//--- should it be closed?
+   if(m_macd_current<0)
+      if(m_macd_current>m_signal_current && m_macd_previous<m_signal_previous)
+         if(MathAbs(m_macd_current)>m_macd_close_level)
+           {
+            //--- close position
+            if(m_trade.PositionClose(Symbol()))
+               printf("Short position by %s to be closed",Symbol());
+            else
+               printf("Error closing position by %s : '%s'",Symbol(),m_trade.ResultComment());
+            //--- processed and cannot be modified
+            res=true;
+           }
+//--- result
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Check for long position modifying                                |
+//+------------------------------------------------------------------+
+bool CSampleExpert::LongModified(void)
+  {
+   bool res=false;
+//--- check for trailing stop
+   if(InpTrailingStop>0)
+     {
+      if(m_symbol.Bid()-m_position.PriceOpen()>m_adjusted_point*InpTrailingStop)
+        {
+         double sl=NormalizeDouble(m_symbol.Bid()-m_traling_stop,m_symbol.Digits());
+         double tp=m_position.TakeProfit();
+         if(m_position.StopLoss()<sl || m_position.StopLoss()==0.0)
+           {
+            //--- modify position
+            if(m_trade.PositionModify(Symbol(),sl,tp))
+               printf("Long position by %s to be modified",Symbol());
+            else
+              {
+               printf("Error modifying position by %s : '%s'",Symbol(),m_trade.ResultComment());
+               printf("Modify parameters : SL=%f,TP=%f",sl,tp);
+              }
+            //--- modified and must exit from expert
+            res=true;
+           }
+        }
+     }
+//--- result
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Check for short position modifying                               |
+//+------------------------------------------------------------------+
+bool CSampleExpert::ShortModified(void)
+  {
+   bool   res=false;
+//--- check for trailing stop
+   if(InpTrailingStop>0)
+     {
+      if((m_position.PriceOpen()-m_symbol.Ask())>(m_adjusted_point*InpTrailingStop))
+        {
+         double sl=NormalizeDouble(m_symbol.Ask()+m_traling_stop,m_symbol.Digits());
+         double tp=m_position.TakeProfit();
+         if(m_position.StopLoss()>sl || m_position.StopLoss()==0.0)
+           {
+            //--- modify position
+            if(m_trade.PositionModify(Symbol(),sl,tp))
+               printf("Short position by %s to be modified",Symbol());
+            else
+              {
+               printf("Error modifying position by %s : '%s'",Symbol(),m_trade.ResultComment());
+               printf("Modify parameters : SL=%f,TP=%f",sl,tp);
+              }
+            //--- modified and must exit from expert
+            res=true;
+           }
+        }
+     }
+//--- result
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Check for long position opening                                  |
+//+------------------------------------------------------------------+
+bool CSampleExpert::LongOpened(void)
+  {
+   bool res=false;
+//--- check for long position (BUY) possibility
+   if(m_macd_current<0)
+      if(m_macd_current>m_signal_current && m_macd_previous<m_signal_previous)
+         if(MathAbs(m_macd_current)>(m_macd_open_level) && m_ema_current>m_ema_previous)
+           {
+            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);
+                 }
+              }
+            //--- in any case we must exit from expert
+            res=true;
+           }
+//--- result
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Check for short position opening                                 |
+//+------------------------------------------------------------------+
+bool CSampleExpert::ShortOpened(void)
+  {
+   bool res=false;
+//--- check for short position (SELL) possibility
+   if(m_macd_current>0)
+      if(m_macd_current<m_signal_current && m_macd_previous>m_signal_previous)
+         if(m_macd_current>(m_macd_open_level) && m_ema_current<m_ema_previous)
+           {
+            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);
+                 }
+              }
+            //--- in any case we must exit from expert
+            res=true;
+           }
+//--- result
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| main function returns true if any position processed             |
+//+------------------------------------------------------------------+
+bool CSampleExpert::Processing(void)
+  {
+//--- refresh rates
+   if(!m_symbol.RefreshRates())
+      return(false);
+//--- refresh indicators
+   if(BarsCalculated(m_handle_macd)<2 || BarsCalculated(m_handle_ema)<2)
+      return(false);
+   if(CopyBuffer(m_handle_macd,0,0,2,m_buff_MACD_main)  !=2 ||
+      CopyBuffer(m_handle_macd,1,0,2,m_buff_MACD_signal)!=2 ||
+      CopyBuffer(m_handle_ema,0,0,2,m_buff_EMA)         !=2)
+      return(false);
+//   m_indicators.Refresh();
+//--- to simplify the coding and speed up access
+//--- data are put into internal variables
+   m_macd_current   =m_buff_MACD_main[0];
+   m_macd_previous  =m_buff_MACD_main[1];
+   m_signal_current =m_buff_MACD_signal[0];
+   m_signal_previous=m_buff_MACD_signal[1];
+   m_ema_current    =m_buff_EMA[0];
+   m_ema_previous   =m_buff_EMA[1];
+//--- it is important to enter the market correctly, 
+//--- but it is more important to exit it correctly...   
+//--- first check if position exists - try to select it
+   if(m_position.Select(Symbol()))
+     {
+      if(m_position.PositionType()==POSITION_TYPE_BUY)
+        {
+         //--- try to close or modify long position
+         if(LongClosed())
+            return(true);
+         if(LongModified())
+            return(true);
+        }
+      else
+        {
+         //--- try to close or modify short position
+         if(ShortClosed())
+            return(true);
+         if(ShortModified())
+            return(true);
+        }
+     }
+//--- no opened position identified
+   else
+     {
+      //--- check for long position (BUY) possibility
+      if(LongOpened())
+         return(true);
+      //--- check for short position (SELL) possibility
+      if(ShortOpened())
+         return(true);
+     }
+//--- exit without position processing
+   return(false);
+  }
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit(void)
+  {
+//--- create all necessary objects
+   if(!ExtExpert.Init())
+      return(INIT_FAILED);
+//--- secceed
+   return(INIT_SUCCEEDED);
+  }
+//+------------------------------------------------------------------+
+//| Expert new tick handling function                                |
+//+------------------------------------------------------------------+
+void OnTick(void)
+  {
+   static datetime limit_time=0; // last trade processing time + timeout
+//--- don't process if timeout
+   if(TimeCurrent()>=limit_time)
+     {
+      //--- check for data
+      if(Bars(Symbol(),Period())>2*InpMATrendPeriod)
+        {
+         //--- change limit time by timeout in seconds if processed
+         if(ExtExpert.Processing())
+            limit_time=TimeCurrent()+ExtTimeOut;
+        }
+     }
+  }
+//+------------------------------------------------------------------+
@@ -0,0 +1,372 @@
+//+------------------------------------------------------------------+
+//|                                                    Functions.mqh |
+//|                             Copyright 2000-2024, MetaQuotes Ltd. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+
+//--- custom function y=f(x,y)
+typedef double(*MathFunction)(double,double);
+
+//+------------------------------------------------------------------+
+//| math functions                                                   |
+//+------------------------------------------------------------------+
+enum EnMathFunction
+  {
+   Peaks=0,
+   Chomolungma=1,
+   ClimberDream=2,
+   Granite=3,
+   Hedgehog=4,
+   Hill=5,
+   Josephine=6,
+   Screw=7,
+   DoubleScrew=8,
+   MultiExtremalScrew=9,
+   Sink=10,
+   Skin=11,
+   Trapfall=12,
+  };
+//+------------------------------------------------------------------+
+//| Names of the math functions                                      |
+//+------------------------------------------------------------------+
+const string ExtFunctionsNames[]=
+  {
+   "Peaks",
+   "Chomolungma",
+   "Climber Dream",
+   "Granite",
+   "Hedgehog",
+   "Hill",
+   "Josephine",
+   "Screw",
+   "Double Screw",
+   "Multi Extremal Screw",
+   "Sinc",
+   "Skin",
+   "Trapfall"
+  };
+//+------------------------------------------------------------------+
+//| Function Peaks                                                   |
+//+------------------------------------------------------------------+
+double PeaksFunction(double x,double y)
+  {
+   double res = 3*MathPow((1-x),2)*MathExp(-x*x-(y+1)*(y+1))-10*(0.2*x-MathPow(x,3)-MathPow(y,5))*MathExp(-x*x-y*y)-1/3*MathExp(-(x+1)*(x+1)-y*y);
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Chomolungma                                             |
+//+------------------------------------------------------------------+
+double ChomolungmaFunction(double x,double y)
+  {
+   double a= MathCos(x*x)+MathCos(y*y);
+   double b= MathPow(MathCos(5*x*y),5);
+   double c=1.0/MathPow(2,b);
+//--- calculate result
+   double res=a-c;
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function ClimberDream                                            |
+//+------------------------------------------------------------------+
+double ClimberDreamFunction(double x,double y)
+  {
+   double a= MathSin(MathSqrt(MathAbs(x - 1.3) + MathAbs(y)));
+   double b= MathCos(MathSqrt(MathAbs(MathSin(x))) + MathSqrt(MathAbs(MathSin(y))));
+   double f=a+b;
+//--- calculate result
+   double res=MathPow(f,4);
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Granite                                                 |
+//+------------------------------------------------------------------+
+double GraniteFunction(double x,double y)
+  {
+   double a= MathPow(MathSin(MathSqrt(MathAbs(x)+MathAbs(y))),2);
+   double b= MathPow(MathCos(MathSqrt(MathAbs(x)+MathAbs(y))),2);
+//--- calculate result
+   double res=a*b;
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Hedgehog                                                |
+//+------------------------------------------------------------------+
+double HedgehogFunction(double x,double y)
+  {
+   double a1=MathSin(MathSqrt(MathAbs(x-2)+MathAbs(y)));
+   double a2=MathCos(MathSqrt(MathAbs(MathSin(x)))+MathSqrt(MathAbs(MathSin(y))));
+//--- calculate result
+   double res=a1+a2;
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Hill                                                    |
+//+------------------------------------------------------------------+
+double HillFunction(double x,double y)
+  {
+//--- calculate result
+   double res=MathExp(-x*x-y*y);
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Josephine                                               |
+//+------------------------------------------------------------------+
+double JosephineFunction(double x,double y)
+  {
+   double a= MathSin(MathPow(MathAbs(x)+MathAbs(y),0.5));
+   double b= MathCos(MathPow(MathAbs(x),0.5)+MathPow(MathAbs(y),0.5));
+//--- calculate function
+   double res=a+b;
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Screw                                                   |
+//+------------------------------------------------------------------+
+double ScrewFunction(double x,double y)
+  {
+   double a=(y==0)?0:((x*y<0)?MathArctan(x/y):MathArctan(x/y)+M_PI);
+   double b=x*x+y*y;
+   double f=MathSin(b+a);
+//--- calculate result
+   double  res=(f*f);
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function DoubleScrew                                             |
+//+------------------------------------------------------------------+
+double DoubleScrewFunction(double x,double y)
+  {
+   double a=(y==0)?0:((x*y<0)?MathArctan(x/y):MathArctan(x/y)+M_PI);
+   double b=x*x+y*y;
+   double res1=MathCos(b/2+a*3);
+   res1=((res1*res1)/sqrt(b+1)-0.2);
+   double res2=MathCos(b/2-a*3);
+   res2=((res2*res2)/sqrt(b+1)-0.2);
+   double f=fmax(res1,res2);
+//--- calculate result
+   double    res=(f>0)?f:0;
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function MultiExtremalScrew                                      |
+//+------------------------------------------------------------------+
+double MultiExtremalScrewFunction(double x,double y)
+  {
+   double a=(y==0)?0:((x*y<0)?MathArctan(x/y):MathArctan(x/y)+M_PI);
+   double b=x*x+y*y;
+   double res1=MathCos(b/2+a*3);
+   res1=((res1*res1)/sqrt(b+1)-0.2);
+   double res2=MathCos(b/2-a*3);
+   res2=((res2*res2)/sqrt(b+1)-0.2);
+//--- calculate function
+   double res=fmin(res1,res2);
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Sink                                                    |
+//+------------------------------------------------------------------+
+double SinkFunction(double x,double y)
+  {
+   static double   k=5.0;
+   static double   p=6.0;
+//--- calculate result
+   double     res=MathSin(x*x+y*y)+k*MathExp(-p*x*x-p*y*y);
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Skin                                                    |
+//+------------------------------------------------------------------+
+double SkinFunction(double x,double y)
+  {
+   double a1=2*x*x;
+   double a2=2*y*y;
+   double b1=MathCos(a1)-1.1;
+   b1=b1*b1;
+   double c1=MathSin(0.5*x)-1.2;
+   c1=c1*c1;
+   double d1=MathCos(a2)-1.1;
+   d1=d1*d1;
+   double e1=MathSin(0.5*y)-1.2;
+   e1=e1*e1;
+//--- calculate result
+   double res=b1+c1-d1+e1;
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Function Trapfall                                                |
+//+------------------------------------------------------------------+
+double TrapfallFunction(double x,double y)
+  {
+   double a1=MathSqrt(MathAbs(MathSin(x-1.0)));
+   double b1=MathSqrt(MathAbs(MathSin(y+2.0)));
+//--- calculate result
+   double     res=-MathSqrt(MathAbs(MathSin(MathSin(a1+b1))));
+//---
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| GenerateFunctionData                                             |
+//+------------------------------------------------------------------+
+void GenerateFunctionData(double &data[],int &x_size,int &y_size,double x_min,double x_max,double y_min,double y_max,MathFunction function)
+  {
+   double dx = 0.1;
+   double dy = 0.1;
+//---
+   x_size = (int)((x_max - x_min)/dx) + 1;
+   y_size = (int)((y_max - y_min)/dy) + 1;
+   ArrayResize(data,x_size*y_size);
+//---
+   for(int j = 0; j < y_size; j++)
+     {
+      for(int i = 0; i < x_size; i++)
+        {
+         double x = x_min + i*dx;
+         double y = y_min + j*dy;
+         data[j*x_size + i] = function(x,y);
+        }
+     }
+  }
+//+------------------------------------------------------------------+
+//| GenerateData                                                     |
+//+------------------------------------------------------------------+
+void GenerateData(EnMathFunction function_id,double &data[],int &x_size,int &y_size)
+  {
+//---
+   switch(function_id)
+     {
+      case Peaks:
+         GenerateFunctionData(data,x_size,y_size,-3.0,+3.0,-3.0,+3.0,PeaksFunction);
+         break;
+      case Chomolungma:
+         GenerateFunctionData(data,x_size,y_size,-2.0,+2.0,-2.0,+2.0,ChomolungmaFunction);
+         break;
+      case ClimberDream:
+         GenerateFunctionData(data,x_size,y_size,-10.0,+10.0,-10.0,+10.0,ClimberDreamFunction);
+         break;
+      case Granite:
+         GenerateFunctionData(data,x_size,y_size,-4.0,+4.0,-4.0,+4.0,GraniteFunction);
+         break;
+      case Hedgehog:
+         GenerateFunctionData(data,x_size,y_size,-10.0,+10.0,-10.0,+10.0,HedgehogFunction);
+         break;
+      case Hill:
+         GenerateFunctionData(data,x_size,y_size,-1.5,+1.5,-1.5,+1.5,HillFunction);
+         break;
+      case Josephine:
+         GenerateFunctionData(data,x_size,y_size,-200.0,+200.0,-200.0,+200.0,JosephineFunction);
+         break;
+      case Screw:
+         GenerateFunctionData(data,x_size,y_size,-3.0,+3.0,-3.0,+3.0,ScrewFunction);
+         break;
+      case DoubleScrew:
+         GenerateFunctionData(data,x_size,y_size,-3.0,+3.0,-3.0,+3.0,DoubleScrewFunction);
+         break;
+      case MultiExtremalScrew:
+         GenerateFunctionData(data,x_size,y_size,-3.0,+3.0,-3.0,+3.0,MultiExtremalScrewFunction);
+         break;
+      case Sink:
+         GenerateFunctionData(data,x_size,y_size,-3.0,+3.0,-3.0,+3.0,SinkFunction);
+         break;
+      case Skin:
+         GenerateFunctionData(data,x_size,y_size,-5.0,+5.0,-5.0,+5.0,SkinFunction);
+         break;
+      case Trapfall:
+         GenerateFunctionData(data,x_size,y_size,-5.0,+5.0,-5.0,+5.0,TrapfallFunction);
+         break;
+     }
+  }
+//+------------------------------------------------------------------+
+//| GenerateFunctionDataFixedSize                                    |
+//+------------------------------------------------------------------+
+bool GenerateFunctionDataFixedSize(int x_size,int y_size,double &data[],double x_min,double x_max,double y_min,double y_max,MathFunction function)
+  {
+   if(x_size<2 || y_size<2)
+     {
+      PrintFormat("Error in data sizes: x_size=%d,y_size=%d",x_size,y_size);
+      return(false);
+     }
+   double dx = (x_max - x_min)/(x_size-1);
+   double dy = (y_max - y_min)/(y_size-1);
+   ArrayResize(data,x_size*y_size);
+//---
+   for(int j = 0; j < y_size; j++)
+     {
+      for(int i = 0; i < x_size; i++)
+        {
+         double x = x_min + i*dx;
+         double y = y_min + j*dy;
+         data[j*x_size + i] = function(x,y);
+        }
+     }
+   return(true);
+  }
+//+------------------------------------------------------------------+
+//| GenerateDataFixedSize                                            |
+//+------------------------------------------------------------------+
+bool GenerateDataFixedSize(int x_size,int y_size,EnMathFunction function_id,double &data[])
+  {
+   if(x_size<2 || y_size<2)
+     {
+      PrintFormat("Error in data sizes: x_size=%d,y_size=%d",x_size,y_size);
+      return(false);
+     }
+   bool result=false;
+//---
+   switch(function_id)
+     {
+      case Peaks:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-3.0,+3.0,-3.0,+3.0,PeaksFunction);
+         break;
+      case Chomolungma:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-2.0,+2.0,-2.0,+2.0,ChomolungmaFunction);
+         break;
+      case ClimberDream:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-10.0,+10.0,-10.0,+10.0,ClimberDreamFunction);
+         break;
+      case Granite:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-4.0,+4.0,-4.0,+4.0,GraniteFunction);
+         break;
+      case Hedgehog:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-10.0,+10.0,-10.0,+10.0,HedgehogFunction);
+         break;
+      case Hill:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-1.5,+1.5,-1.5,+1.5,HillFunction);
+         break;
+      case Josephine:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-200.0,+200.0,-200.0,+200.0,JosephineFunction);
+         break;
+      case Screw:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-3.0,+3.0,-3.0,+3.0,ScrewFunction);
+         break;
+      case DoubleScrew:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-3.0,+3.0,-3.0,+3.0,DoubleScrewFunction);
+         break;
+      case MultiExtremalScrew:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-3.0,+3.0,-3.0,+3.0,MultiExtremalScrewFunction);
+         break;
+      case Sink:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-3.0,+3.0,-3.0,+3.0,SinkFunction);
+         break;
+      case Skin:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-5.0,+5.0,-5.0,+5.0,SkinFunction);
+         break;
+      case Trapfall:
+         result=GenerateFunctionDataFixedSize(x_size,y_size,data,-5.0,+5.0,-5.0,+5.0,TrapfallFunction);
+         break;
+     }
+//---
+   return(result);
+  }
+//+------------------------------------------------------------------+
@@ -0,0 +1,233 @@
+//+------------------------------------------------------------------+
+//|                                              Moving Averages.mq5 |
+//|                             Copyright 2000-2024, MetaQuotes Ltd. |
+//|                                             https://www.mql5.com |
+//+------------------------------------------------------------------+
+#property copyright "Copyright 2000-2024, MetaQuotes Ltd."
+#property link      "https://www.mql5.com"
+#property version   "1.00"
+
+#include <Trade\Trade.mqh>
+
+input double MaximumRisk        = 0.02;    // Maximum Risk in percentage
+input double DecreaseFactor     = 3;       // Descrease factor
+input int    MovingPeriod       = 12;      // Moving Average period
+input int    MovingShift        = 6;       // Moving Average shift
+//---
+int    ExtHandle=0;
+bool   ExtHedging=false;
+CTrade ExtTrade;
+
+#define MA_MAGIC 1234501
+//+------------------------------------------------------------------+
+//| 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)!=MA_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);
+  }
+//+------------------------------------------------------------------+
+//| Check for open position conditions                               |
+//+------------------------------------------------------------------+
+void CheckForOpen(void)
+  {
+   MqlRates rt[2];
+//--- go trading only for first ticks of new bar
+   if(CopyRates(_Symbol,_Period,0,2,rt)!=2)
+     {
+      Print("CopyRates of ",_Symbol," failed, no history");
+      return;
+     }
+   if(rt[1].tick_volume>1)
+      return;
+//--- get current Moving Average 
+   double   ma[1];
+   if(CopyBuffer(ExtHandle,0,0,1,ma)!=1)
+     {
+      Print("CopyBuffer from iMA failed, no data");
+      return;
+     }
+//--- check signals
+   ENUM_ORDER_TYPE signal=WRONG_VALUE;
+
+   if(rt[0].open>ma[0] && rt[0].close<ma[0])
+      signal=ORDER_TYPE_SELL;    // sell conditions
+   else
+     {
+      if(rt[0].open<ma[0] && rt[0].close>ma[0])
+         signal=ORDER_TYPE_BUY;  // buy conditions
+     }
+//--- additional checking
+   if(signal!=WRONG_VALUE)
+     {
+      if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) && Bars(_Symbol,_Period)>100)
+         ExtTrade.PositionOpen(_Symbol,signal,TradeSizeOptimized(),
+                               SymbolInfoDouble(_Symbol,signal==ORDER_TYPE_SELL ? SYMBOL_BID:SYMBOL_ASK),
+                               0,0);
+     }
+//---
+  }
+//+------------------------------------------------------------------+
+//| Check for close position conditions                              |
+//+------------------------------------------------------------------+
+void CheckForClose(void)
+  {
+   MqlRates rt[2];
+//--- go trading only for first ticks of new bar
+   if(CopyRates(_Symbol,_Period,0,2,rt)!=2)
+     {
+      Print("CopyRates of ",_Symbol," failed, no history");
+      return;
+     }
+   if(rt[1].tick_volume>1)
+      return;
+//--- get current Moving Average 
+   double   ma[1];
+   if(CopyBuffer(ExtHandle,0,0,1,ma)!=1)
+     {
+      Print("CopyBuffer from iMA failed, no data");
+      return;
+     }
+//--- positions already selected before
+   bool signal=false;
+   long type=PositionGetInteger(POSITION_TYPE);
+
+   if(type==(long)POSITION_TYPE_BUY && rt[0].open>ma[0] && rt[0].close<ma[0])
+      signal=true;
+   if(type==(long)POSITION_TYPE_SELL && rt[0].open<ma[0] && rt[0].close>ma[0])
+      signal=true;
+//--- additional checking
+   if(signal)
+     {
+      if(TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) && Bars(_Symbol,_Period)>100)
+         ExtTrade.PositionClose(_Symbol,3);
+     }
+//---
+  }
+//+------------------------------------------------------------------+
+//| Position select depending on netting or hedging                  |
+//+------------------------------------------------------------------+
+bool SelectPosition()
+  {
+   bool res=false;
+//--- check position in Hedging mode
+   if(ExtHedging)
+     {
+      uint total=PositionsTotal();
+      for(uint i=0; i<total; i++)
+        {
+         string position_symbol=PositionGetSymbol(i);
+         if(_Symbol==position_symbol && MA_MAGIC==PositionGetInteger(POSITION_MAGIC))
+           {
+            res=true;
+            break;
+           }
+        }
+     }
+//--- check position in Netting mode
+   else
+     {
+      if(!PositionSelect(_Symbol))
+         return(false);
+      else
+         return(PositionGetInteger(POSITION_MAGIC)==MA_MAGIC); //---check Magic number
+     }
+//--- result for Hedging mode
+   return(res);
+  }
+//+------------------------------------------------------------------+
+//| Expert initialization function                                   |
+//+------------------------------------------------------------------+
+int OnInit(void)
+  {
+//--- prepare trade class to control positions if hedging mode is active
+   ExtHedging=((ENUM_ACCOUNT_MARGIN_MODE)AccountInfoInteger(ACCOUNT_MARGIN_MODE)==ACCOUNT_MARGIN_MODE_RETAIL_HEDGING);
+   ExtTrade.SetExpertMagicNumber(MA_MAGIC);
+   ExtTrade.SetMarginMode();
+   ExtTrade.SetTypeFillingBySymbol(Symbol());
+//--- Moving Average indicator
+   ExtHandle=iMA(_Symbol,_Period,MovingPeriod,MovingShift,MODE_SMA,PRICE_CLOSE);
+   if(ExtHandle==INVALID_HANDLE)
+     {
+      printf("Error creating MA indicator");
+      return(INIT_FAILED);
+     }
+//--- ok
+   return(INIT_SUCCEEDED);
+  }
+//+------------------------------------------------------------------+
+//| Expert tick function                                             |
+//+------------------------------------------------------------------+
+void OnTick(void)
+  {
+//---
+   if(SelectPosition())
+      CheckForClose();
+   else
+      CheckForOpen();
+//---
+  }
+//+------------------------------------------------------------------+
+//| Expert deinitialization function                                 |
+//+------------------------------------------------------------------+
+void OnDeinit(const int reason)
+  {
+  }
+//+------------------------------------------------------------------+