Créer un tableau à 2 dimensions dépendantes

Bonjour,

Je cherche un moyen de créer un tableau A(i,j) dont la dismension de j est fonction de i en fortran 90.

Un exemple pour être plus précis :
dimension (A(:,1)) = 10
dimension (A(:,2)) = 20

Merci

Salut!

Citation:

---

la dismension de j est fonction de i

---

Donc un tableau bidimensionnel dont les lignes n'ont pas toutes la même longueur.

Comme je ne connais pas très bien le Fortran 90, je ne peux pas te répondre. En Fortran 77, un tableau bidimensionnel doit être rectangulaire, mais il y a des astuces pour contourner la difficulté.

Jean-Marc Blanc

Bonjour,

Citation:

---

Envoyé par FR119492

Donc un tableau bidimensionnel dont les lignes n'ont pas toutes la même longueur.

---

Oui c'est exactement ça.

Bon je pense avoir trouvé une solution temporaire à mon problème en faisant un tableau de structures, comme ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

type TAB real(kind=8), dimension(:) , pointer :: T integer(kind=4) :: n end type TAB   program TEST implicit none   type(TAB) , dimension(:), allocatable :: MonTab   end TEST

---

Ainsi je peux allouer la dimension que je souhaite à MonTab, puis chaque élément de MonTab est une structure qui contient un tableau dynamique.

Néanmoins si quelqu'un a une solution plus simple, je suis preneur

Deux possibilités :

1. Soit tu créé ton tableau de la taille maximale possible (ie ton 'i' maximum), mais ce n'est pas du tout optimisé et cela peut te saturer ta mémoire

2. Soit tu utilises un type dérivé du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

TYPE TABLEAU_BISCORNU REAL(KIND=8), allocatable, dimension(:) :: TABLEAU_FILS END TYPE TABLEAU_BISCORNU   TYPE(TABLEAU_BISCORNU), allocatable, dimension(:) :: TABLEAU_PARENT   ALLOCATE(TABLEAU_PARENT(J))   DO K=1,J ALLOCATE(TABLEAU_PARENT(K)%TABLEAU_FILS(VALEUR(K))) END DO

---

Avec VALEUR un tableau comprenant la taille des sous-tableaux que tu veux affecter.

Ensuite, pour 'remplir' les cases d'une structure, il te faut faire :

Code:

---

1 2	TABLEAU_PARENT(IDX)%TABLEAU_FILS(:)=1d0

---

par exemple.

En espérant avoir répondu à ta question,

Marlan

À ma connaissance, la solution avec type dérivé est la seule possible parce que Fortran ne permet pas de déclarer un tableau de pointeurs.

Ton code sera malheureusement difficile à lire. TableauParent(i)%TableauFils(j) est nettement moins intuitif que Tableau(i,j). Tu pourrais utiliser des noms près de l'usage, comme Tableau_Lig(i)%Col(j) pour aider le lecteur.

À moins que tu aies un compilateur pure F95, favorise le membre allocatable plutôt que pointer (seul permis en F95 standard). Ton code sera plus robuste.

Salut!
Il y a une solution quand la matrice est triangulaire. Dans la bibliothèque LinPack, compare les routines SPPSL (stockage de la matrice dans un tableau dont la moitié n'est pas utilisée) et SPOSL (stockage bout à bout dans un tableau à une seule dimension). Je pense qu'il est possible de généraliser le stockage bout à bout en ajoutant un tableau indiquant où commence chaque ligne.
Jean-Marc Blanc

Citation:

---

Envoyé par FR119492

...Je pense qu'il est possible de généraliser le stockage bout à bout en ajoutant un tableau indiquant où commence chaque ligne.

---

Je n'y avais pas pensé, mais tu as raison. Il suffit d'avoir un tableau à un dimension de la longueur totale, et d'avoir une fonction qui calcule le déplacement. On a alors des expressions du genre Tableau(Idx(i,j)) où Idx() est la fonction de calcul du déplacement.

Citation:

---

Envoyé par Sylvain Bergeron

Je n'y avais pas pensé, mais tu as raison. Il suffit d'avoir un tableau à un dimension de la longueur totale, et d'avoir une fonction qui calcule le déplacement. On a alors des expressions du genre Tableau(Idx(i,j)) où Idx() est la fonction de calcul du déplacement.

---

Merci pour cette idée auquel je n'avais pas pensé non plus.
C'est très propre comme ça et beaucoup moins lourd qu'en passant par des structures.

Comme suggérait Jean-Marc, tu peux utiliser un tableau de déplacement cumulatif. Les expressions deviennent Tableau(i+Depl(j)). C'est un peu moins joli qu'avec une fonction de déplacement, mais c'est certainement plus efficace puisqu'il n'y a plus de call et que le calcul se fait une seule fois.