FórumSeções

Perguntas de um "boneco" - página 126

Novo comentário
Renat:

Desde quando é que todas as matrizes são estáticas, e todos os tamanhos e índices também estão estáticos?

Uma vez que as matrizes são quase sempre dinâmicas e os índices são variáveis, não podem ser feitas verificações estáticas sérias no momento de uma chamada. As únicas verificações que restam são as meta/rtti checks e é por isso que é tão importante ter acesso a todo o objecto/descrição e não trabalhar na casualidade com um pedaço de memória.

Então, vamos em ordem. Para as matrizes estáticas, tudo é fácil de verificar em tempo de compilação, certo?

Para os dinâmicos (que têm objectos escondidos!), há meta-informação em tempo de execução, certo? Há! Claro que há.

Tudo o que resta é especificar as verificações de tempo de execução no código executável da função que está a ser compilada. E é tudo!

E não estou a dizer que é canja. Bem, Slava (Stringo) também conhece as suas coisas. Quem tem hoje em dia facilidade, afinal? :)

// Afinal de contas: tudo é feito em quatro.

// Se já tiverem matrizes dinâmicas, utilizem a meta-informação que levam consigo para todo o lado!

// Tendo-o, pode-se fazer até coisas maravilhosas (como deixar o utilizador passar matrizes de dimensão desconhecida).

// E em mql5(!), não se pode sequer passar uma matriz bidimensional com ambas as incógnitas para uma função.

// Mesmo em sapo antigo, pode fazê-lo. :))

Renat:

Não se preocupe, tudo já foi pensado há muito tempo.

As consequências da quebra dos princípios de protecção que conhecemos muito bem - é a forma "em Abril corrigimos mais 12 bugs críticos permitindo sair da máquina virtual e obter controlo sobre o sistema".

As consequências desta solução particular, nem sequer cheiram a "controlo do sistema". Não lhe pedi tais indicações de função. O máximo que pode fazer é falhar a memória "de outra pessoa" se estiver fora do alcance da matriz incorrectamente controlada.
MetaDriver:

1. essa foi a minha sugestão de introduzir a dactilografia e, consequentemente, a dactilografia rígida, especialmente porque é o único lugar não abrangido pela dactilografia, encaixando-se assim bem na ideologia da universalização das entidades linguísticas.

2. Mesmo assim: primeiro, é torto, e segundo, não é de todo universal. Sugira uma forma(1) de copiar um mql-array bidimensional para um buffer OpenCL sem reescrever e envolver desnecessariamente em estruturas, ou(2) usando (para velocidade) a sua própria função ArrayCopy(...) para arrays não uniformes.

// Desculpem a brusquidão do posto anterior. Realmente desnecessário. Fiquei entusiasmado com "não vamos complicar as coisas". Uma vez que apenas conduz a complicações.

2a. Penso que a sua "restrição unidimensional" para funções como ArrayCopy() pode ser suavizada sem dor em muitos casos com uma cláusula elementar nos comentários: "A função funciona também com matrizes multidimensionais, desde que a matriz multidimensional seja copiada na sua totalidade. "

Isso eliminaria muitos problemas. // Mas nem todos, claro.

Há duas maneiras, uma é copiar separadamente as matrizes unidimensionais, mas isso não é bom, porque a interface OCL estará desordenada de matrizes,

A segunda forma é representar uma matriz unidimensional como bidimensional, porque de qualquer forma será transmitida à OCL por fita adesiva. Por isso, é assim. A propósito, os próprios dados movem-se quando a dimensão é alterada poderiam ser feitos em OCL, copiando uma parte da matriz; tudo depende do tamanho e se é rentável.

class CArrayTwo_merniy
  {
   float             a[];
   int               size_i;
   int               size_j;
public:
                     CArrayTwo_merniy(void){size_i=0;size_j=0;};
                    ~CArrayTwo_merniy(void){};
   void              Resize(int i,int j)
     {
      int size;
      if(j<size_j)// если уменьшаем j размер массива
        {
         for(int l=1;l<i;l++)
            for(int k=0;k<j;k++)
               a[l*i+k]=a[l*size_i+k];
         size=ArrayResize(a,i*j);
         if(size==i*j)
           {size_i=i; size_j=j;}
         return;
        }
      else // иначе, если увеличиваем j размер массива
        {
         size=ArrayResize(a,i*j);
         if(size==i*j)
           {
            for(int l=i-1;l>=0;l--)
               for(int k=j-1;k>=0;k--)
                  a[l*i+k]=a[l*size_i+k];
            size_i=i; size_j=j;
           }
        }
     };
   void set(int i,int j,float v)
     {
      if(i*size_i+j>=0 && i*size_i+j<size_i*size_j)a[i*size_i+j]=v;
      else Print("Ошибка set ["+i+":"+j+"]");
     };
   float get(int i,int j)
     {
      if(i*size_i+j>=0 && i*size_i+j<size_i*size_j)return(a[i*size_i+j]);
      else {Print("Ошибка get ["+i+":"+j+"]"); return(EMPTY_VALUE);}
     };
  };
//+------------------------------------------------------------------+
void OnStart()
  {
   CArrayTwo_merniy ar; string t;
   ar.Resize(3,3); int cnt=0;
   for(int i=0;i<3;i++)for(int j=0;j<3;j++){ar.set(i,j,(float)cnt); cnt++;}
   t="исх ";for(int i=0;i<3;i++){for(int j=0;j<3;j++)t+="["+ar.get(i,j)+"]";t+=".";} Print(t);
   ar.Resize(5,5);
   t="5х5 "; for(int i=0;i<5;i++){for(int j=0;j<5;j++)t+="["+ar.get(i,j)+"]";t+=".";} Print(t);
   ar.Resize(3,3);
   t="3х3 ";for(int i=0;i<3;i++){for(int j=0;j<3;j++)t+="["+ar.get(i,j)+"]";t+=".";} Print(t);
  }
Urain:

Há duas maneiras, uma é copiar separadamente as matrizes unidimensionais, mas não é bom, porque a interface OCL estará desordenada de matrizes,

A segunda forma é representar uma matriz unidimensional como bidimensional, porque de qualquer forma será passada para a OCL pela fita adesiva. Por isso, é assim. A propósito, os próprios dados movem-se quando a dimensionalidade é alterada pode ser feita em OCL copiando uma parte da matriz; tudo depende do tamanho e até que ponto é rentável.

многа многа букаф

Já estou farto de tudo isto. :) Occam é histérico...

;)

Aqui tenho uma matriz bidimensional. Eu tenho o seu tamanho de(My2DArray). De que mais preciso para o copiar para o buffer? De qualquer modo, ninguém me proporcionou sequer uma compensação na minha matriz para fazer dela uma variável. Portanto, não. Primeiro tenho de reescrevê-lo (o que leva a desfasamentos), ou escrever a minha própria matriz bidimensional (!!!) Bem, isso é óptimo. E para que serve? Para que eu possa estar seguro. (!) É isso mesmo, estou a rir. :)))

MetaDriver:

É tudo o que já tive o suficiente. :) Occam é histérico...

;)

:))

Francamente falando, o redimensionamento das despesas gerais é enorme, mas é possível reduzi-lo usando a OCL para estas coisas.

Mas a cópia directa de uma matriz bidimensional para um buffer OCL.

E não vos aconselharia a re-particionarem a matriz a cada espirro.

Tal como está, é bastante aplicável.

MetaDriver:

É tudo o que já tive o suficiente. Occam é histérico...

;)

Vá lá, são três conjuntos de funções get and resize.

Escrevi-o para si de joelhos enquanto andava por aí a chorar.

Urain:
Vá lá, isso é um monte de palavras, três funções definidas get e Resize
É fixe, aposto. Quando nos fizerem sobrecarregar operadores (e não se esqueçam de tornar os operadores "[ ]" e "=" sobrecarregáveis, então divertir-nos-emos. Seremos capazes de vender as nossas matrizes dinâmicas no mercado. E eles vão aceitá-lo! E quem não os aceitará - vamos desligar a transmissão de gás das matrizes multidimensionais em funções. :)
MetaDriver:
Fixe, sem dúvida. Quando nos fizerem sobrecarregar o operador (e não se esqueça de tornar o operador "[ ]" pré-carregável, então ficará feliz. Venderemos as nossas próprias matrizes dinâmicas no mercado. E eles vão aceitá-lo! E quem não o aceitar - vamos desligar a transmissão de gás de matrizes multidimensionais em funções. :)
Não esqueceremos ;)
mql5:
Não esqueceremos ;)
:))
MetaDriver:

Tenho uma matriz bidimensional. Eu tenho o seu tamanho de(My2DArray). De que mais preciso para copiar para o buffer? De qualquer modo, ninguém me proporcionou sequer uma compensação na minha matriz para fazer dela uma variável. Portanto, não. Primeiro tenho de reescrevê-lo (o que leva a desfasamentos), ou escrever a minha própria matriz bidimensional (!!!) Meu Deus. E para que serve? Para que eu possa estar seguro. (!) É isso mesmo, estou a rir. :)))

Caro Senhor, observe o contexto.

1) Quando se salta de um ambiente controlado e seguro para um tampão em bruto completamente descontrolado, é você que é responsável pela compatibilidade com esse ambiente binário.

2) Quando escreve o código, é responsável pela arquitectura desse código. E não lamente que "é difícil colocar um cavalo e uma corça na mesma carroça" quando se utilizam estruturas diferentes.

3) Recomendo que leia a descrição de CLBufferRead e CLBufferWrite - graças ao vazio universal* referência, pode passar qualquer tipo de referência ao OpenCL. E também há compensações e tamanhos. 

uint  CLBufferRead(
   int          buffer,                    // хендл на буфер OpenCL
   const void&  data[],                     // массив значений
   uint         buffer_offset=0,           // смещение в OpenCL буфере в байтах, по умолчанию 0
   uint         data_offset=0,             // смещение в массиве в элементах, по умолчанию 0
   uint         data_count=WHOLE_ARRAY      // количество значений из буфера для чтения, по умолчанию весь буфер
   );

uint  CLBufferWrite(
   int          buffer,                    // хендл на буфер OpenCL
   const void&  data[],                     // массив значений
   uint         buffer_offset=0,           // смещение в OpenCL буфере в байтах, по умолчанию 0
   uint         data_offset=0,             // смещение в массиве в элементах, по умолчанию 0
   uint         data_count=WHOLE_ARRAY      // количество значений из массива для записи, по умолчанию весь массив
   );

Vejo que o assunto é apenas riscado do nada.

1...119120121122123124125126127128129130131132133...277
Novo comentário