Questions d'un "mannequin - page 126

Nouveau commentaire
 
Renat:

Depuis quand tous les tableaux sont-ils statiques, et toutes les tailles et indices statiques aussi ?

Comme les tableaux sont presque toujours dynamiques et que les index sont des variables, aucune vérification statique sérieuse ne peut être effectuée au moment d'un appel. Les seules vérifications qui restent à faire sont les vérifications méta/rtti et c'est pourquoi il est si important d'avoir accès à l'ensemble de l'objet/description et de ne pas travailler au hasard avec un morceau de mémoire.

Pour les tableaux statiques, tout est facile à vérifier au moment de la compilation, n'est-ce pas ?

Pour les dynamiques (qui ont des objets cachés !), il y a des méta-informations dans le runtime, non ? Il y en a ! Bien sûr qu'il y en a.

Il ne reste plus qu'à spécifier les contrôles d'exécution dans le code exécutable de la fonction en cours de compilation. Et c'est tout !

Et je ne dis pas que c'est un jeu d'enfant. Slava (Stringo) s'y connaît aussi. Qui a la vie facile de nos jours ? :)

// Après tout : tout se fait à quatre.

// S'ils disposent déjà de tableaux dynamiques, utilisez les méta-informations qu'ils transportent partout avec eux !

// En l'ayant, vous pouvez faire des choses encore plus merveilleuses (comme laisser l'utilisateur passer des tableaux de dimension inconnue).

// Mais dans mql5( !), vous ne pouvez même pas passer un tableau à deux dimensions avec les deux inconnues dans une fonction.

// Même en crapaud antique, tu peux le faire. :))

 
Renat:

Ne vous inquiétez pas, tout a été pensé depuis longtemps.

Nous connaissons très bien les conséquences de la violation des principes de protection - c'est la manière "en avril, nous avons corrigé 12 autres bogues critiques permettant de s'échapper de la machine virtuelle et de prendre le contrôle du système".

Les conséquences de cette solution particulière n'ont rien à voir avec le "contrôle du système". Je ne vous ai pas demandé de tels pointeurs de fonction. Le plus qu'il puisse faire est de planter la mémoire de "quelqu'un d'autre" si elle est hors de la plage du tableau incorrectement contrôlée.
 
MetaDriver:

1) C'était ma suggestion d'introduire le nommage et donc le typage rigide, d'autant plus que c'est le seul endroit qui n'est pas couvert par le typage du nommage, ce qui correspond bien à l'idéologie de l'universalisation des entités linguistiques.

2. Tout de même : premièrement, il est tordu, et deuxièmement, il n'est pas du tout universel. Suggérez un moyen(1) de copier un tableau mql bidimensionnel dans un tampon OpenCL sans réécriture et enveloppement inutile dans des structures, ou(2) en utilisant (pour une utilisation rapide) votre propre fonction ArrayCopy(...) pour les tableaux non-dimensionnels.

// Désolé pour le caractère abrupt du message précédent. Vraiment inutile. Je me suis excité à "ne compliquons pas les choses". car cela ne fait qu'entraîner des complications.

2a. je pense que votre "contrainte d'unidimensionnalité" pour des fonctions comme ArrayCopy() peut être adoucie sans douleur dans de nombreux cas avec une clause élémentaire dans les commentaires : " La fonction fonctionne également avec les tableaux multidimensionnels, à condition que le tableau multidimensionnel soit copié dans son intégralité. "

Cela éliminerait beaucoup de problèmes. // Mais pas tous, bien sûr.

Il y a deux façons de procéder. La première consiste à copier séparément les tableaux unidimensionnels, mais cela n'est pas bon, car l'interface OCL sera encombrée de tableaux,

La deuxième façon est de représenter un tableau unidimensionnel comme un tableau bidimensionnel, car il sera de toute façon transmis à OCL par bande. Donc ça se passe comme ça. À propos, les déplacements de données lors du changement de dimension pourraient être effectués en OCL en copiant une partie du tableau ; tout dépend de la taille et de la rentabilité.

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:

Il y a deux façons de procéder. La première consiste à copier séparément les tableaux unidimensionnels, mais cela ne sert à rien, car l'interface OCL sera encombrée de tableaux,

La deuxième méthode consiste à représenter un tableau unidimensionnel comme un tableau bidimensionnel, car il sera de toute façon transmis à OCL par bande. Donc ça se passe comme ça. À propos, les déplacements de données mêmes lorsque la dimensionnalité est modifiée peuvent être effectués en OCL en copiant une partie du tableau ; tout dépend de la taille et de la mesure dans laquelle cela est rentable.

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

J'en ai assez de tout ça. :) Occam est hystérique...

;)

Ici, j'ai un tableau à deux dimensions. J'ai son sizeof(My2DArray). De quoi d'autre ai-je besoin pour le copier dans le tampon ? De toute façon, personne ne m'a même fourni un décalage dans mon tableau pour en faire une variable. Donc, non. Je dois d'abord le réécrire (ce qui entraîne des décalages), ou écrire mon propre tableau à deux dimensions. ( !!) Oh, mon Dieu. Et c'est pour quoi faire ? Pour me garder en sécurité. ( !) Ça y est, je rigole. :)))

 
MetaDriver:

C'est tout ce dont j'ai eu assez. :) Occam est hystérique...

;)

:))

Pour parler franchement, les frais de redimensionnement sont énormes, mais vous pouvez les réduire en utilisant OCL pour ces choses.

Mais la copie directe d'un tableau bidimensionnel dans un tampon OCL.

Et je ne vous conseillerais pas de repartitionner le tableau à chaque éternuement.

Comme c'est le cas, c'est tout à fait applicable.

 
MetaDriver:

C'est tout ce dont j'ai eu assez. Occam est hystérique...

;)

Allez, trois fonctions d'obtention et de redimensionnement.

Je l'ai écrit pour toi sur mes genoux pendant que tu te morfondais.

 
Urain:
Allez, ça fait beaucoup de mots, trois fonctions set get et Resize.
C'est cool, je parie. Quand ils nous permettront de surcharger les opérateurs (et n'oubliez pas de rendre les opérateurs "[ ]" et "=" surchargeables, alors nous nous amuserons. Nous serons en mesure de vendre nos tableaux dynamiques sur le marché. Et ils le prendront ! Et qui ne les prendra pas - désactivons la transmission de gaz des tableaux multidimensionnels en fonctions. :)
 
MetaDriver:
Cool, aucun doute là-dessus. Quand ils nous permettront de surcharger les opérateurs (et n'oubliez pas de rendre l'opérateur "[ ]" préchargeable, alors vous serez heureux. Nous allons vendre nos propres matrices dynamiques sur le marché. Et ils le prendront ! Et qui ne le prendra pas - désactivons la transmission de gaz des tableaux multidimensionnels dans les fonctions. :)
Nous n'oublierons pas ;)
 
mql5:
Nous n'oublierons pas ;)
:))
 
MetaDriver:

J'ai un tableau à deux dimensions. J'ai son sizeof(My2DArray). De quoi d'autre ai-je besoin pour le copier dans le tampon ? De toute façon, personne ne m'a même fourni un décalage dans mon tableau pour en faire une variable. Donc, non. Je dois d'abord le réécrire (ce qui entraîne des décalages), ou écrire mon propre tableau à deux dimensions. ( !!) Eh bien, c'est le bazar. Et c'est pour quoi faire ? Pour me garder en sécurité. ( !) Ça y est, je rigole. :)))

Cher Monsieur, regardez le contexte.

1) Lorsque vous passez d'un environnement contrôlé et sûr à un tampon brut totalement incontrôlé, c'est vous qui êtes responsable de la compatibilité avec cet environnement binaire.

2) Lorsque vous écrivez du code, vous êtes responsable de l'architecture de ce code. Et ne vous plaignez pas qu'"il est difficile de mettre un cheval et une biche dans la même charrette" lorsque vous utilisez des structures différentes.

3) Je vous recommande de lire la description de CLBufferRead et CLBufferWrite - grâce à la référence universelle void*, vous pouvez passer tout type de référence à OpenCL. Et il y a aussi des décalages et des tailles. 

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

Je peux voir que le sujet est juste gratté à partir de rien.

1...119120121122123124125126127128129130131132133...277
Nouveau commentaire