passage d'un tableau unidimentionnel à tridimentionnel

Version imprimable

18/05/2010, 13h49
manaliac

passage d'un tableau unidimentionnel à tridimentionnel

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
18/05/2010, 14h22
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.
18/05/2010, 14h43
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:

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
18/05/2010, 14h59
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]
18/05/2010, 16h49
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:

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.

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:

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);
}

Bonsoir manaliac,

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

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]; }

21/05/2010, 21h54
Joel F

Calculer floor et modulo à chaque itération me parait bien peu efficace ...
22/05/2010, 16h23
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.
23/05/2010, 23h02
poukill

Citation:

Envoyé par Pierre Dolez

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