Na MQL5 há sempre espaço para uma exploração! ;) - página 3

[---]

mql5:
Brevemente.
As funções das bibliotecas de sistemas para processos x86 (32 bits) têm um invólucro especial através do qual são passados para x64, executados e devolvidos a x86.

64 bit Windows tem uma pasta chamada SysWOW64. Esta pasta destina-se a aplicações de 32-bit lançadas no sistema operativo de 64-bit, enquanto que as bibliotecas e controladores regulares de 64-bit são armazenadas na pasta System32. Se o programa for lançado como 32-bit, as referências à pasta System32 são redireccionadas para SysWOW64.

Para ser breve, a questão dos 32/64 bits tornou-se aguda em MT5.

esta é uma questão muito importante e já é tempo de ser abordada.

ou adicionar uma pasta library64 para que o terminal saiba onde obter as bibliotecas
ou adicionar alguma forma de dispersar DLLs no sistema32/SysWow64 pastas
ou usar #ifdef

https://www.mql5.com/ru/forum/6729#comment_199764

ZS.
candidatura a SD #381730

[Yury Kulikov]

MetaDriver:

Matriz de qualquer dimensionalidade (para clareza, digamos, limitá-la a ^16).

A dimensionalidade é definida na criação pelo número de parâmetros, como para as matrizes normais.

XXArray  xx2(5,7),  xx5(12,12,16,16,8);

Os indexadores devem funcionar para todas as dimensões ( A[i][j][k][n][m]....)

Como a comunidade está em silêncio, vou continuar...

Um esboço de uma classe de matriz N-dimensional (dupla) e um teste para a testar.

A dimensionalidade é descrita pela matriz (int) no construtor.

//+------------------------------------------------------------------+
class CNXdouble
{
        double                 value[];
        int                    size[];
        int                    index;
        int                    ivalue;
public:
                               CNXdouble(const int &n[]);
                              ~CNXdouble()   { ArrayFree(value); ArrayFree(size);}
        double      operator[]   (long x_);
        CNXdouble  *operator[]  (int x_)      { ivalue+=x_*size[index++]; return(GetPointer(this));}
        void         operator=    (double d)    { value[ivalue]=d; index=0; ivalue=0;}
};
//+------------------------------------------------------------------+
CNXdouble::CNXdouble(const int &n[])
{
        int m=1, k=ArraySize(n);
        ArrayResize(size,k);
        size[k-1]=1;
        for(int i=k-2; i>=0; i--) size[i]=n[i+1]*size[i+1];
        for(int i=0; i<k; i++) m*=n[i];
        ArrayResize(value,m);
        index=0;
        ivalue=0;
}
//+------------------------------------------------------------------+
double CNXdouble::operator[] (long x_) 
{
        index=0;
        int i=ivalue;
        ivalue=0;
        return(value[i+(int)x_]);
}
//+------------------------------------------------------------------+
void OnStart()
{
   int n[]={2,3,4,2};      //описание 4-х мерного массива
   int a1=n[0], a2=n[1], a3=n[2], a4=n[3];
   CNXdouble d2(n);
   //запись в массив
   int c=0;
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++) 
               for(int y=0; y<a4; y++)
                   d2[i][j][x][y]=(double)c++;
   //чтение из массива
   string s="";
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++)
               for(long y=0; y<a4; y++)
                   s+=(string)d2[i][j][x][y]+" ";
   Print(s);
}
//+------------------------------------------------------------------+

[Yury Kulikov]

A segunda variante é uma matriz N-dimensional (dupla). A estrutura da matriz é também especificada no construtor por outra matriz (int).

Esta variante é um pouco mais rápida do que a anterior. E, nesta variante, é mais fácil criar operações com subarrays.

class CNArray
{
        CNArray                    *array[];
        double                      value[];
        bool                        last;
        int                         ivalue;
public:
                                   CNArray(const int &n[]);
                                  ~CNArray();
        double      operator[]      (long x);
        CNArray*   operator[]      (int x);
        void        operator=       (double d) { if(last)value[ivalue]=d;}
};
//+------------------------------------------------------------------+
CNArray::CNArray(const int &n[])
{
        int k=ArraySize(n);
        if(k>1)
        {
                ArrayResize(array,n[0]);
                int n1[];
                ArrayResize(n1,k-1);
                for(int i=0; i<k-1; i++) n1[i]=n[i+1];
                for(int i=0; i<n[0]; i++) array[i]=new CNArray(n1);
                ArrayFree(n1);
                last=false;
        }else if(k==1)
        {
                ArrayResize(value,n[0]);
                last=true;
        }
}
//+------------------------------------------------------------------+
CNArray::~CNArray()
{ 
        if(!last)
        {
                int n=ArraySize(array);
                for(int i=0; i<n; i++) delete array[i];
                ArrayFree(array);
        }else ArrayFree(value);
}
//+------------------------------------------------------------------+
double CNArray::operator[](long x) 
{
        if(last) return(value[(int)x]); else return(0);
}
//+------------------------------------------------------------------+
CNArray* CNArray::operator[](int x)
{ 
        if(last)
        {
                ivalue=x; 
                return(GetPointer(this));
        }else return(array[x]);
}

[Vladimir Gomonov]

Yurich:

A segunda variante é uma matriz N-dimensional (dupla). A estrutura da matriz é também especificada no construtor por outra matriz (int).

Esta variante é um pouco mais rápida do que a anterior. E, nesta variante, é mais fácil criar operações com subarrays.

Yurich, é um tipo porreiro. Distraí-me do fórum durante alguns dias, e já fez um par de variantes.

Primeira impressão - a primeira variante está repleta de falhas na chamada incorrecta com menor número de índices: por exemplo, duplo x=A[i][j][k]; "chamada tridimensional" para matriz tetradimensional retornará o dobro, mas a partir de qualquer outra posição de matriz que o utilizador quisesse.E não é óbvio como detectar e lidar com tais erros. Mas a vantagem indiscutível da primeira implementação é a economia de memória. A segunda forma é muito mais desperdiçadora. Mas, como notou correctamente, pode tentar passar para as subarrays e todas as dificuldades são bastante controláveis neste caso.

Tenho algumas ideias, mas só chegarei ao tempo livre na noite anterior, se lá chegar de todo. Mas vamos lá chegar, prometo. :)

--

Ideia básica: usar mais uma classe, algo como "controlador de índices esquerdo", e o índice mais à direita para processar por classe principal (se não funcionar, então mais uma classe para o índice direito). Ao fazê-lo, a matriz de base dupla (unidimensional e única) deve ser tornada um membro da principal classe CNArray. Algo parecido com isto.

[Igor Makanu]

MetaDriver

Tx. Primeira impressão - a primeira variante está repleta de falhas na chamada incorrecta com menor número de índices: isto é, por exemplo, duplo x=A[i][j][k]; "chamada tridimensional" para matriz tetradimensional retornará o dobro como se nada tivesse acontecido, mas ao mesmo tempo a partir da posição da matriz que o utilizador pretendia. Além disso, localizar e lidar com tais erros não é visível de que forma.

Tenho andado a brincar com o primeiro método de Yurich, e parece ser possível controlar a classificação da matriz desta forma:

class DinArr_Double{
        double                 value[];
        int                    size[];
        int                    index;
        int                    ivalue;
        int                    range;
        bool                   checkerror;
public:
                               DinArr_Double(const int &n[]);
                              ~DinArr_Double()   { ArrayFree(value); ArrayFree(size);}
        double          operator[](long x_);
        DinArr_Double*  operator[](int x_);
        void            operator= (double d)    { value[ivalue]=d; index=0; ivalue=0;}
};
//+------------------------------------------------------------------+
DinArr_Double::DinArr_Double(const int &n[]){
        int m=1, k=ArraySize(n);
        range = ArraySize(n);
        ArrayResize(size,k);
        size[k-1]=1;
        for(int i=k-2; i>=0; i--) size[i]=n[i+1]*size[i+1];
        for(int i=0; i<k; i++) m*=n[i];
        ArrayResize(value,m);
        index=0;
        ivalue=0;
        checkerror = false;
}
//+------------------------------------------------------------------+
double DinArr_Double::operator[](long x_){
        index=0;
        int i=ivalue;
        ivalue=0;
        return(value[i+(int)x_]);
}
//+------------------------------------------------------------------+
DinArr_Double*  DinArr_Double::operator[](int x_){
      ivalue+=x_*size[index++];

      if(index!=range)checkerror = true; else checkerror = false;
 
      return(GetPointer(this));
}
//+------------------------------------------------------------------+
void OnStart(){
   int n[]={2,3,4,2};      //описание 4-х мерного массива
   int a1=n[0], a2=n[1], a3=n[2], a4=n[3];
   DinArr_Double d2(n);
   //запись в массив
   int c=0;
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++) 
               for(int y=0; y<a4; y++)
                   d2[i][j][x][y]=(double)c++;
   //чтение из массива
   string s="";
   for(int i=0; i<a1; i++)
       for(int j=0; j<a2; j++) 
           for(int x=0; x<a3; x++)
               for(long y=0; y<a4; y++)
                   s+=(string)d2[i][j][x][y]+" ";
   Print(s);
}
//+------------------------------------------------------------------+

[---]

Tarefa:

- Passar uma série de números do Conselheiro Especialista para o indicador.

Requisitos.

Não utilizar
- eventos do gráfico,
- ficheiros,
- variáveis globais (também conhecidas como ficheiros),
- dll

[Alexander Bereznyak]

sergeev:

Tarefa:

- Passar uma série de números do Conselheiro Especialista para o indicador.

Requisitos.

- Não utilizar eventos gráficos, ficheiros, dll para transferência de dados

Será que asvariáveis globais do terminal funcionarão?

[Alexander Bereznyak]

Depois, os canais nomeados permanecem.

[---]

sandex:
Depois, os canais nomeados permanecem.

quem é o servidor?

[Yury Kulikov]

sergeev:

Tarefa:

- Passar uma série de números do Conselheiro Especialista para o indicador.

Condições.

Não utilizar
- eventos do gráfico,
- ficheiros,
- variáveis globais (ficheiros também conhecidos por aka),
- dll

Não há ninguém para o fazer :)

Depois proponho outra variante - usar as funções subchart eChartSetString()eChartGetString().