Original_NNB/MQL5/Include/NeuroNetworksBook/realization/bufferdouble.mqh

<EFBFBD><EFBFBD>//+------------------------------------------------------------------+
//|                                                 BufferDouble.mqh |
//|                                  Copyright 2021, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| >4:;NG05< 181;8>B5:8                                            |
//+------------------------------------------------------------------+
#include <Arrays\ArrayDouble.mqh>
#include "opencl.mqh"
#include "defines.mqh"
//+------------------------------------------------------------------+
//| Class CBufferDouble                                              |
//| 07=0G5=85: ;0AA 48=0<8G5A:>3> 1CD5@0 40==KE                    |
//+------------------------------------------------------------------+
class CBufferDouble     :  public CArrayDouble
  {
protected:
   CMyOpenCL         *m_cOpenCL;    // 1J5:B :>=B5:AB0 OpenCL
   int               m_myIndex;     // =45:A 1CD5@0 40==KE 2 :>=B5:AB5
public:
                     CBufferDouble(void);
                    ~CBufferDouble(void);
//--- 5B>4 8=8F80;870F88 1CD5@0 =0G0;L=K<8 7=0G5=8O<8
   virtual bool      BufferInit(uint count, double value);
//--- !;>65=85 25:B>@>2 
   virtual bool      SumArray(const CArrayDouble *src);
//--- !>740=885 =>2>3> 1CD5@0 2 :>=B5:AB5 OpenCL
   virtual bool      BufferCreate(CMyOpenCL *opencl);
//--- #40;5=85 1CD5@0 2 :>=B5:AB5 OpenCL   
   virtual bool      BufferFree(void);                      
//--- 'B5=85 40==KE 1CD5@0 87 :>=B5:AB0 OpenCL
   virtual bool      BufferRead(void);
//--- 0?8AL 40==KE 1CD5@0 2 :>=B5:AB OpenCL            
   virtual bool      BufferWrite(void);                     
//--- >;CG5=85 8=45:A0 1CD5@0
   virtual int       GetIndex(void);
//--- 7<5=5=85 8=45:A0 1CD5@0                      
   virtual bool      SetIndex(int index) 
                        {
                         if(!m_cOpenCL.BufferFree(m_myIndex)) return false;
                         m_myIndex = index; return true;
                        }
//--- >?8@>20=85 40==KE 1CD5@0 2 <0AA82
   virtual int       GetData(double &values[], bool load = true);
   virtual int       GetData(CArrayDouble *values, bool load = true);
//---  0AAGQB A@54=53> 7=0G5=8O 1CD5@0 40==KE
   virtual double    MathMean(void);                        
//--- 0AHB018@>20=85 7=0G5=89 1CD5@0
   virtual int       Scaling(double value);                 
//--- 1=>245=85 40==KE 2 1CD5@5 87 <0AA820
   virtual bool      UpdateArray(const int start_pos,
                                 const CArrayDouble *src,
                                 const int start_src, int count);
   virtual bool      UpdateArray(const int start_pos, 
                                 const double &src[],
                                 const int start_src, int count);
//--- 45=B8D8:0B>@ :;0AA0
   virtual int       Type(void)  const { return defBufferDouble;      }
  };
//+------------------------------------------------------------------+
//| >=AB@C:B>@ :;0AA0                                               |
//+------------------------------------------------------------------+
CBufferDouble::CBufferDouble(void)  : m_myIndex(-1)
  {
   m_cOpenCL = NULL;
  }
//+------------------------------------------------------------------+
//| 5AB@C:B>@ :;0AA0                                                |
//+------------------------------------------------------------------+
CBufferDouble::~CBufferDouble(void)
  {
   if(CheckPointer(m_cOpenCL) != POINTER_INVALID && m_myIndex >= 0)
     {
      if(m_cOpenCL.BufferFree(m_myIndex))
        {
         m_myIndex = -1;
         m_cOpenCL = NULL;
        }
     }
   Shutdown();
  }
//+------------------------------------------------------------------+
//| !>740=885 =>2>3> 1CD5@0 2 :>=B5:AB5 OpenCL                       |
//+------------------------------------------------------------------+
bool CBufferDouble::BufferCreate(CMyOpenCL *opencl)
  {
//--- ;>: ?@>25@:8 8AE>4=KE 40==KE
   if(CheckPointer(opencl) == POINTER_INVALID)
     {
      BufferFree();
      return false;
     }
//--- A;8 ?>;CG5==K9 C:070B5;L A>2?0405B A @0=55 A>E@0=Q==K< ?@>AB> :>?8@C5< A>45@68<>5 1CD5@0 2 ?0<OBL :>=B5:AB0
   if(opencl == m_cOpenCL && m_myIndex >= 0)
     {
      if(BufferWrite())
         return true;
     }
//--- @>25@O5< =0;8G85 @0=55 A>E@0=Q==>3> C:070B5;O =0 :>=B5:AB OpenCL
//--- @8 =0;8G88, C40;O5< 1CD5@ 87 =58A?>;L7C5<>3> :>=B5:AB0
   if(CheckPointer(m_cOpenCL) != POINTER_INVALID && m_myIndex >= 0)
     {
      if(m_cOpenCL.BufferFree(m_myIndex))
        {
         m_myIndex = -1;
         m_cOpenCL = NULL;
        }
      else
         return false;
     }
//--- !>740Q< =>2K9 1CD5@ 2 C:07==>< :>=B5:AB5 OpenCL
   if((m_myIndex = opencl.AddBufferFromArray(m_data, 0, m_data_total, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR)) < 0)
      return false;
   m_cOpenCL = opencl;
//---
   return true;
  }
//+------------------------------------------------------------------+
//| 5B>4 C40;5=8O 1CD5@0 87 ?0<OB8 :>=B5:AB0 OpenCL                 |
//+------------------------------------------------------------------+
bool CBufferDouble::BufferFree(void)
  {
//--- @>25@O5< =0;8G85 @0=55 A>E@0=Q==>3> C:070B5;O =0 :>=B5:AB OpenCL
//--- @8 =0;8G88, C40;O5< 1CD5@ 87 =58A?>;L7C5<>3> :>=B5:AB0
   if(CheckPointer(m_cOpenCL) != POINTER_INVALID && m_myIndex >= 0)
      if(m_cOpenCL.BufferFree(m_myIndex))
        {
         m_myIndex = -1;
         m_cOpenCL = NULL;
         return true;
        }
   if(m_myIndex >= 0)
      m_myIndex = -1;
//---
   return false;
  }
//+------------------------------------------------------------------+
//| 5B>4 GB5=8O 40==KE 87 1CD5@0 :>=B5:AB0 OpenCL                   |
//+------------------------------------------------------------------+
bool CBufferDouble::BufferRead(void)
  {
   if(CheckPointer(m_cOpenCL) == POINTER_INVALID || m_myIndex < 0)
      return false;
//---
   return m_cOpenCL.BufferRead(m_myIndex, m_data, 0, 0, m_data_total);
  }
//+------------------------------------------------------------------+
//| 5B>4 70?8A8 40==KE 2 1CD5@0 :>=B5:AB0 OpenCL                    |
//+------------------------------------------------------------------+
bool CBufferDouble::BufferWrite(void)
  {
   if(CheckPointer(m_cOpenCL) == POINTER_INVALID || m_myIndex < 0)
      return false;
//---
   return m_cOpenCL.BufferWrite(m_myIndex, m_data, 0, 0, m_data_total);
  }
//+------------------------------------------------------------------+
//| 5B>4 8=8F80;870F88 1CD5@0 =0G0;L=K<8 7=0G5=8O<8                 |
//+------------------------------------------------------------------+
bool CBufferDouble::BufferInit(uint count, double value)
  {
   if(!Reserve(count))
      return false;
   m_data_total = (int)fmin(ArrayInitialize(m_data, value), count);
//---
   return m_data_total == count;
  }
//+------------------------------------------------------------------+
//| 5B>4 ?>;CG5=8O 7=0G5=89 1CD5@0                                  |
//+------------------------------------------------------------------+
int CBufferDouble::GetData(double &values[], bool load = true)
  {
   if(load && !BufferRead())
      return -1;
   return ArrayCopy(values, m_data, 0, 0, m_data_total);
  }
//+------------------------------------------------------------------+
//| 5B>4 ?>;CG5=8O 7=0G5=89 1CD5@0                                  |
//+------------------------------------------------------------------+
int CBufferDouble::GetData(CArrayDouble *values, bool load = true)
  {
   if(CheckPointer(values) == POINTER_INVALID)
      return -1;
   if(load && !BufferRead())
      return -1;
   if(!values.AssignArray(GetPointer(this)))
      return -1;
   return values.m_data_total;
  }
//+------------------------------------------------------------------+
//| 5B>4 AC<<8@>20=8O M;5<5=B>2 42CE 1CD5@>2 40==KE                 |
//+------------------------------------------------------------------+
bool CBufferDouble::SumArray(const CArrayDouble *src)
  {
   int num;
//--- @>25@:0 <0AA820 8AE>4=KE 60==KE
   if(!CheckPointer(src))
      return(false);
//---  575@28@>20=85 <5AB0 2 48=0<8G5A:>< <0AA825 4;O 70?8A8 @57C;LB0B>2
   num = src.m_data_total;
   if(m_data_max < num)
     {
      if(!Reserve(num))
         return(false);
     }
//--- &8:; A;>65=8O M;5<5=B>2 <0AA82>2
   for(int i = 0; i < num; i++)
     {
      if(m_data_total <= i)
         m_data[i] = src.m_data[i];
      else
         m_data[i] += src.m_data[i];
     }
   m_sort_mode = src.SortMode();
   m_data_total = (int)fmax(m_data_total, num);
//---
   return(true);
  }
//+------------------------------------------------------------------+
//| 5B>4 2KG8A;5=8O A@54=53> 7=0G5=88O <0AA820                      |
//+------------------------------------------------------------------+
double CBufferDouble::MathMean(void)
  {
   if(m_data_total <= 0)
      return 0;
//---
   double mean = 0;
   for(int i = 0; i < m_data_total; i++)
      mean += m_data[i];
//---
   return mean / m_data_total;
  }
//+------------------------------------------------------------------+
//| >;CG5=8 8=45:A0 1CD5@0 2 :>=B5:AB5 OpenCL                       |
//+------------------------------------------------------------------+
int CBufferDouble::GetIndex(void)
  {
   if(CheckPointer(m_cOpenCL) == POINTER_INVALID || m_myIndex < 0)
     {
      m_myIndex = -1;
      return m_myIndex;
     }
//---
   if(!m_cOpenCL.CheckBuffer(m_myIndex))
      m_myIndex = BufferCreate(m_cOpenCL);
//---
   return m_myIndex;
  }
//+------------------------------------------------------------------+
//| 5B>4 <0AHB018@>20=8O 40==KE (C<=>65=85 =0 :>=AB0=BC)            |
//+------------------------------------------------------------------+
int CBufferDouble::Scaling(double value)
  {
   for(int i = 0; i < m_data_total; i++)
      m_data[i] *= value;
//---
   return m_data_total;
  }
//+------------------------------------------------------------------+
//| 5B>4 70?>;=5=8O 1CD5@0 87 <0AA820 40==KE                        |
//+------------------------------------------------------------------+
bool CBufferDouble::UpdateArray(const int start_pos, const CArrayDouble *src, const int start_src, int count)
  {
   if(start_pos < 0 || start_src < 0)
      return false;
   if(CheckPointer(src) == POINTER_INVALID)
      return false;
   if(count < 0)
      count = src.Total() - start_src;
   if(count < 0 || src.Total() < (start_src + count))
      return false;
   if((start_pos + count) > m_data_max && !Reserve(start_pos + count))
      return false;
//---
   for(int i = 0; i < count; i++)
      m_data[start_pos + i] = src[start_src + i];
//---
   return true;
  }
//+------------------------------------------------------------------+
//| 5B>4 70?>;=5=8O 1CD5@0 87 <0AA820 40==KE                        |
//+------------------------------------------------------------------+
bool CBufferDouble::UpdateArray(const int start_pos, const double &src[], const int start_src, int count)
  {
   if(start_pos < 0 || start_src < 0)
      return false;
   int src_total = ArraySize(src);
   if(src_total <= 0)
      return false;
   if(count < 0)
      count = src_total - start_src;
   if(count < 0 || src_total < (start_src + count))
      return false;
   if((start_pos + count) > m_data_max && !Reserve(start_pos + count))
      return false;
//---
   for(int i = 0; i < count; i++)
      m_data[start_pos + i] = src[start_src + i];
//---
   return true;
  }
//+------------------------------------------------------------------+