Discussion :

[manaliac]

Bonjour,

je suis entrain de coder un programme qui lit un fichier ou se trouvent 5 tableaux.

Ces tableaux ont la dimension suivante : X(Nbi*Nbj*Nbk) et je voudrais passer à des tableaux tridimensionnel du genre X_nw(Nbi,Nbj,Nbk).

Est ce que vous sauriez l'algorithme nécessaire pour faire ce passage?

Merci bien

Manal

[aurelman]

Bonjour,

J'aurais tendance à dire que tout dépend de comment sont agencés les éléments dans le tableau unidimensionnel.

Si c'est :
[i1, j1, k1, i2, j2, k2, ...]
ou bien :
[i1, i2, i3, .... , j1, j2, j3, .... , k1, k2, k3,.... ]
ou bien encore autre chose...

De même pour ton tableau 3 dimensions, il faut savoir comment doivent être agencés les élements dedans.

Une fois cette problématique surmontée... trouver un algo qui fait la correspondance devrait être plus simple.

[manaliac]

Bonjour,
Mes éléments sont écrits de la manière suivante :

[i1 j1 k1 l1 m1
i2 j2 k2 l2 m2
...................... ]

donc mon programme lit chaque colonne et la place dans un tableau C1 --> C5,
ensuite je veux transformer ces tableaux unidimensionnels en des tableaux tridimentionnels.
Genre passe de C1(a*b*c) --> C1(a,b,c)

j'ai fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
for (k=0 , k < c , k++){
for (j=0 , j< b, j++){
for (i=0 , i<a,i++){
 
C_final[i][j][k]=C1(i*j*k)
           }
       }
 }

est ce que ça a l'air correct d'un point de vue correspondance d'indices?

Merci

[poukill]

Le mieux a faire à mon avis c'est d'utiliser la surcharge d'opérateur pour une classe de ton cru, en particulier operator()(int, int, int).
Sinon, à vue de nez, les indices c'est pas bon !
Avec ton écriture, C_final[1][2][1] = C_final[2][1][1] = C_final[1][1][2]

[icer]

Comme l'a dit Aurelpitiless, tout dépend comment les éléments de ton tableau sont agencés.

Pour visualiser un peu (en 3d ça reste encore possible), les données sont organisées comme dans un gros cube, subdivisé en petits cubes représentant chacun un élément du tableau. On peut découper ce cube en tranches, les tranches en lignes et les lignes en cellules.

Supposons que i, j et k sont les indices respectives de la cellule, de la ligne et de la tranche.

L'indice de l'élément dans le tableau unidimensionnel serait calculés ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

idx = k*T + j*L + k

Où T est la taile d'une tranche et L celle d'une ligne, toutes les deux exprimées en nombre d'éléments (les petits cubes).

Cette exemple suppose que les éléments dans ton tableau sont organisés dans l'ordre cellule-ligne-tranche. C'est à dire que lorsque que tu balayes linéairement les éléments de ton tableau unidimensionnel, tu passe d'abord de cellule en cellule, puis de ligne en ligne, finalement de tranche en tranche.

[Joel F]

l'acces par calcul d'un polynome est bof bof. Knuth a une variante interessante dans les NRC ou il construit une table d'indexage à l'allcoation. Cette méthode ets en géénral au moins aussi rapide mais facilite l'extebsion à un nombre de dimension arbritraire.

Un exemple en 2D:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
template<class T> static inline T** alloc( size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];
  m[0] = new T[h*w];
  for(size_t i=1;i<h;i++) m[i]=m[i-1]+w;
  return m;
}
 
template<class T> static inline T** share( T* data, size_t h, size_t w )
{
  typedef T* ptr_type;
  ptr_type* m;
  m    = new ptr_type[h];
  m[0] = data;
  for(size_t i=1;i<h;i++) m[i]=m[i-1]+w;
  return m;
}
 
template<class T> static inline void release( T** ptr, bool is_shared = false )
{
  if(ptr && !is_shared) delete[] ptr[0];
  if(ptr) delete[] ptr;
}
 
int main()
{
  float** tab;
  int width  = 5;
  int height = 3;
  tab = alloc<float>(height, width); // column first
 
  for(int r = 0;r<height;++r)
   for(int c = 0;c<width;++c)
    tab[r][c] = 1./(1+r+c);
 
  release(tab);
}

[Invité]

Bonsoir manaliac,

Tu peux t'inspirer de cet exemple 1D -> 2D

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
for (int k=0;k<siz_v;k++)
{
    i = floor(k/taille)%taille);
    j = k%taille;
    matrice[i][j]=v[k];
}

[Joel F]

Calculer floor et modulo à chaque itération me parait bien peu efficace ...

[Invité]

Bonjour,
J'ai une approche de réponse à Manaliac : le langage C et C++ ne prévoit pas de tableau multidimensionnels.
L'écrire Tab[][][] est en fait un tableau de tableaux de tableaux.
Naturellement c'est exactement la même chose que ce qui a été dit, mais c'est dit autrement.

[poukill]

Bonjour,
J'ai une approche de réponse à Manaliac : le langage C et C++ ne prévoit pas de tableau multidimensionnels.
L'écrire Tab[][][] est en fait un tableau de tableaux de tableaux.
Naturellement c'est exactement la même chose que ce qui a été dit, mais c'est dit autrement.

A éviter.
http://cpp.developpez.com/faq/cpp/in...E_matrix_array