Preguntas de un "tonto" - página 126

Nuevo comentario
 
Renat:

¿Desde cuándo todos los arrays son estáticos, y todos los tamaños e índices también son estáticos?

Como los arrays son casi siempre dinámicos y los índices son variables, no se pueden hacer comprobaciones estáticas serias en el momento de una llamada. Las únicas comprobaciones que quedan por hacer son las de meta/rtti y por eso es tan importante tener acceso a todo el objeto/descripción y no trabajar por casualidad con un trozo de memoria.

Así pues, vayamos por orden. Para las matrices estáticas, todo es fácil de comprobar en tiempo de compilación, ¿verdad?

Para los dinámicos (¡que tienen objetos ocultos!), hay metainformación en tiempo de ejecución, ¿no? Sí, claro que sí.

Lo único que queda es especificar las comprobaciones en tiempo de ejecución en el código ejecutable de la función que se compila. Y eso es todo.

Y no digo que sea pan comido. Bueno, Slava (Stringo) también sabe lo que hace. ¿Quién lo tiene fácil hoy en día? :)

// Al fin y al cabo: todo se hace de cuatro en cuatro.

// Si ya tienen arrays dinámicos, ¡utiliza la metainformación que llevan a todas partes!

// Al tenerlo, puedes hacer cosas aún más maravillosas (como dejar que el usuario pase arrays de dimensión desconocida).

// Pero en mql5(!), ni siquiera se puede pasar una matriz bidimensional con ambas incógnitas a una función.

// Incluso en el sapo antiguo se puede hacer. :))

 
Renat:

No te preocupes, todo está pensado desde hace tiempo.

Las consecuencias de romper los principios de protección las conocemos muy bien - es la forma de "en abril arreglamos 12 errores más críticos que permiten salir de la máquina virtual y obtener el control del sistema".

Las consecuencias de esta solución en particular, ni siquiera huelen a "control del sistema". Lo máximo que puede hacer es colapsar la memoria de "alguien más" si está fuera del rango del array controlado incorrectamente.
 
MetaDriver:

1. Esa fue mi sugerencia de introducir la nomenclatura y, por lo tanto, la tipificación rígida, especialmente porque es el único lugar que no está cubierto por la tipificación de la nomenclatura, por lo que encaja bien con la ideología de la universalización de las entidades del lenguaje.

2. De todos modos: en primer lugar, está torcido, y en segundo lugar, no es universal en absoluto. Sugiera una manera(1) de copiar un array bidimensional mql en un buffer OpenCL sin reescribir y envolver innecesariamente en estructuras, o(2) usando (para la velocidad) su propia función ArrayCopy(...) para arrays no uniformes.

// Perdón por la brusquedad del post anterior. Realmente innecesario. Me emocioné con el "no compliquemos las cosas". Ya que sólo conduce a complicaciones.

2a. Creo que tu "restricción de unidimensionalidad" para funciones como ArrayCopy() se puede suavizar sin problemas en muchos casos con una cláusula elemental en los comentarios: " La función funciona también con matrices multidimensionales, siempre que la matriz multidimensional se copie en su totalidad. "

Eso eliminaría muchos problemas. // Pero no todos, por supuesto.

Hay dos maneras, una es copiar arrays unidimensionales por separado, pero eso no es bueno, porque la interfaz OCL se verá abarrotada de arrays,

La segunda forma es representar un array unidimensional como uno bidimensional porque de todas formas se pasará a OCL por cinta. Así que es así. Por cierto, los propios movimientos de datos cuando se cambia la dimensión podrían hacerse en OCL copiando una parte del array; todo depende del tamaño y de si es rentable.

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:

Hay dos maneras, una es copiar arrays unidimensionales por separado, pero no es bueno, porque la interfaz OCL se verá abarrotada de arrays,

La segunda forma es representar un array unidimensional como uno bidimensional, ya que de todas formas será pasado a OCL por la cinta. Así que es así. Por cierto, los propios movimientos de datos cuando se cambia la dimensionalidad se pueden hacer en OCL copiando una parte del array; todo depende del tamaño y hasta qué punto es rentable.

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

Ya estoy harto de todo esto. :) Occam es un histérico...

;)

Aquí tengo un array bidimensional. Tengo su sizeof(My2DArray). ¿Qué más necesito para copiarlo en el buffer? De todos modos, nadie me ha proporcionado siquiera un desplazamiento en mi matriz para convertirla en una variable. Así que, no. Primero tengo que reescribirlo (lo que conlleva retrasos), o escribir mi propio array bidimensional. (!!) Bueno, eso es genial. ¿Y para qué sirve? Así puedo estar seguro. (!) Eso es, me estoy riendo. :)))

 
MetaDriver:

Eso es todo lo que he tenido suficiente. :) Occam es un histérico...

;)

:))

Francamente, la sobrecarga de redimensionamiento es enorme, pero se puede reducir utilizando OCL para estas cosas.

Pero la copia directa de un array bidimensional en un buffer OCL.

Y no te aconsejo que vuelvas a particionar el array a cada estornudo.

Tal como está, es bastante aplicable.

 
MetaDriver:

Eso es todo lo que he tenido suficiente. Occam está histérico...

;)

Vamos, que son tres funciones de obtención y redimensionamiento de conjuntos.

Lo escribí para ti de rodillas mientras estabas deprimido.

 
Urain:
Vamos, que son muchas palabras, tres funciones set get y Resize
Seguro que es genial. Cuando nos hagan sobrecargar los operadores (y no se olviden de hacer sobrecargables los operadores "[ ]" y "=", entonces nos divertiremos. Podremos vender nuestras matrices dinámicas en el mercado. ¡Y lo aceptarán! Y que no los tomará - vamos a apagar la transmisión de gas de matrices multidimensionales en las funciones. :)
 
MetaDriver:
Genial, sin duda. Cuando nos hagan la sobrecarga de operadores (y no se olviden de hacer precargable el operador "[ ]", entonces serás feliz. Venderemos nuestras propias matrices dinámicas en el mercado. ¡Y lo aceptarán! Y que no lo tomará - vamos a apagar la transmisión de gas de matrices multidimensionales en las funciones. :)
No lo olvidaremos ;)
 
mql5:
No lo olvidaremos ;)
:))
 
MetaDriver:

Tengo un array bidimensional. Tengo su sizeof(My2DArray). ¿Qué más necesito para copiarlo en el buffer? De todos modos, nadie me ha proporcionado siquiera un desplazamiento en mi matriz para convertirla en una variable. Así que, no. Primero tengo que reescribirlo (lo que conlleva retrasos), o escribir mi propia matriz bidimensional. (!!) Oh, Dios mío. ¿Y para qué sirve? Así puedo estar seguro. (!) Eso es, me estoy riendo. :)))

Estimado señor, observe el contexto.

1) Cuando saltas de un entorno controlado y seguro a un búfer sin control alguno, eres tú el responsable de la compatibilidad con ese entorno binario.

2) Cuando escribes código, eres responsable de la arquitectura de ese código. Y no te quejes de que "es difícil meter a un caballo y a una cierva en el mismo carro" cuando utilizas estructuras diferentes.

3) Te recomiendo que leas la descripción de CLBufferRead y CLBufferWrite - gracias a la referencia universal void*, puedes pasar cualquier tipo de referencia a OpenCL. Y también hay compensaciones y tamaños. 

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      // количество значений из массива для записи, по умолчанию весь массив
   );

Veo que el tema está arañado de la nada.

1...119120121122123124125126127128129130131132133...277
Nuevo comentario
Razón de la queja: