Paramétriser la lecture d'un fichier texte

Version imprimable

Bonjour,
J'ai un fichier texte qui ressemble à quelque chose comme ceci. Le nombre de colonnes est fixe mais le nombre de lignes (1000+) varie d'un fichier à un autre.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 1 80,9015579200 58,7787246700 100,0000000000 2 30,9003887200 95,1060791000 100,0000000000 3 -30,9015693700 95,1056900000 100,0000000000 4 -80,9029464700 58,7768058800 100,0000000000 5 -100,0000000000 -0,0000180993 100,0000000000 6 -80,9003143300 -58,7804298400 100,0000000000 7 -30,9010887100 -95,1058502200 100,0000000000 8 30,9034862500 -95,1050720200 100,0000000000 9 80,9029388400 -58,7768211400 100,0000000000 10 100,0000000000 0,0000000000 66,6666641200 11 80,9015579200 58,7787246700 66,6666641200 12 30,9003887200 95,1060791000 66,6666641200 13 -30,9015693700 95,1056900000 66,6666641200
J'aimerais lire ce fichier et le stocker dans un tableau. J'utilise Compaq Visual Fortran et j'ai essayé de comprendre le help pour faire une lecture mais sans succès. J'ai chercher pour trouver des exemples sur le net mais en vain. Si quelqu'un pouvait me diriger vers un exemple concret et complet ou bien me donner la syntaxe pour effetuer la lecture, j'apprécierais beaucoup.
Merci!

p.s. J'utilise Fotran90. Je dois traduire un programme Matlab en Fortran, je viens tout juste de commencer à travailler avec Fortran.

edit: Après plusieurs heures de tentatives, j'ai trouvé comment lire mon fichier. Par contre, je n'ai pas réussi à paramétriser l'algorithme aussi bien que je l'aurais voulu.

Tout d'abord, je veux stocker le nom du fichier dans une variable (filename). Pour que la commande OPEN puisse fonctionner, je dois indiquer le nombre de caractère lors de l'instanciation de la variable de type CHARACTER. Est-ce qu'il y aurait moyen d'utiliser l'instanciation CHARACTER(LEN=*) (ou autre chose permettant quelque chose de similaire) et ensuite de redimensionner la variable. Ainsi, il serait possible de changer facilement le nom du fichier.

Ensuite, pour le tableau contenant les données, je veux le dimensionner selon le nombre de lignes contenus dans le fichier. Je n'ai pas trouvé de commande pour obtenir directement le nombre de lignes contenues dans le fichier. Donc, j'ouvre une première fois le fichier et je compte le nombre de lignes. Ensuite, je dimensionne mon tableau et par la suite, je réouvre le fichier et je le relis une deuxième fois, mais cette fois, j'enregistre les données dans mon tableau. Est-ce qu'il y aurait moyen d'effectuer cela sans avoir à ouvrir le fichier deux fois? Ou tout autre méthode qui serait plus optimale? (J'ai l'impression que ma méthode utilisée n'est pas très bonne côté temps d'exécution...)

Voici ce que j'ai fait jusqu'à maintenant:
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 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 program Test1 implicit none character(len=15) :: filename integer :: i,j,nbNode,nbCol integer :: unitFile, iError,line double precision, allocatable :: fileContent(:,:) double precision, allocatable :: temp(:) nbNode = 0 nbCol = 4 allocate (temp(nbCol)) unitFile = 1 filename = "nodeMeshBig.txt" ! Ouvrir le fichier open(UNIT=unitFile, FILE=filename, FORM="FORMATTED", STATUS="OLD", ACTION="READ") ! Déterminer le nombre de lignes dans le fichier countLines: do read(UNIT=unitFile, FMT=*, IOSTAT=iError) temp if (iError == -1 .OR. iError > 0) then exit else nbNode = nbNode + 1 end if end do countLines close(UNIT=unitFile) ! Définir la dimension du tableau selon le nombre de lignes dans le fichier allocate (fileContent(nbNode,nbCol)) ! Réouvrir le fichier open(UNIT=unitFile, FILE=filename, FORM="FORMATTED", STATUS="OLD", ACTION="READ") ! Stocker les données du fichier dans un tableau saveNodes: do line = 1,nbNode read(UNIT=unitFile, FMT=*) fileContent(line,1:nbCol) end do saveNodes close(UNIT=unitFile) ! Vérification write(*,*) size(fileContent(:,1)) do i = 1,nbNode do j = 1,nbCol write(*,*) fileContent(i,j) end do end do end program Test1

28/07/2006, 13h21
yogitetradim

Bonjour,
je n'ai pas réellement de solutions à tes problèmes...tout au plus des "bidouilles" que j'ai moi même utilisé face à ce genre de question .
Pour la longeur de ta variable fichier....euh, est-ce vraiment limitant à ce point de déclarer une longeur "large" leng=100 qui permettrait de stocker la plupart des noms de fichiers ?
Pour la double lecture du fichier...c'est vrai que ça peut faire pas propre comme code...moi, je m'en contente à l'exception près que j'utilise la commande rewind en fin de première lecture, comme celà tu n'as pas à faire un close(unit) puis open(unit)
Mais là, je ne sais même pas si on a un gain de temps et si il n'y a pas de risques :roll:
Autrement, sous unix pour éviter une lecture ne servant qu'au compte des lignes, j'utilise assez souvent un WC -l sur mon fichier que je redirige vers le programme

Code:

wc -l fichier > programme_fortran

et je met comme première instruction dans mon programme un

Code:

read(*,*)nlignes

Personnellement je travaille sur des gros fichiers (plusieurs centaines de milliers de lignes) avec une grosse machine, donc....tant que le calcul se fait dans un temps raisonnable, je ne perds pas trop de temps à optimiser...mais si quelqu'un à une astuce pour faire le travail plus proprement, je suis preneur.
28/07/2006, 14h22
DaZumba

Citation:

Envoyé par yogitetradim

Personnellement je travaille sur des gros fichiers (plusieurs centaines de milliers de lignes) avec une grosse machine, donc....tant que le calcul se fait dans un temps raisonnable, je ne perds pas trop de temps à optimiser...mais si quelqu'un à une astuce pour faire le travail plus proprement, je suis preneur.

Il faut utiliser la valeur de iostat retournee par read(), comme presente dans ce post.

Pour le reste, c'est de la gestion de memoire dynamique, a coup de allocate() et en utilisant une fonction reallocate() telle que celle presentee ici, par exemple. Il est souvent utile de faire le module d'I/O en C (qui se prete mieux a ce genre de choses) et le coeur du programme en Fortran.

EDIT: iostat est retourne par read(), non par open() comme indique par erreur dans la premiere version du post. Merci a yogitetradim.

Merci beacoup pour les réponses, je peux maintenant faire exactement ce que je voulais :)

Citation:

Envoyé par yogitetradim

Pour la longeur de ta variable fichier....euh, est-ce vraiment limitant à ce point de déclarer une longeur "large" leng=100 qui permettrait de stocker la plupart des noms de fichiers ?

Puisque la déclaration character(len=*) ne fonctionnait pas j'ai cru qu'il fallait indiquer le nombre exacte de caractères pour que la commande READ fonctionne. Je n'avais donc même pas essayé de mettre une valeur supérieure... Grosse erreur de ma part. Merci!

Citation:

Envoyé par DaZumba

Il faut utiliser la valeur de iostat retournee par read(), comme presente dans ce post.

Pour le reste, c'est de la gestion de memoire dynamique, a coup de allocate() et en utilisant une fonction reallocate() telle que celle presentee ici, par exemple. Il est souvent utile de faire le module d'I/O en C (qui se prete mieux a ce genre de choses) et le coeur du programme en Fortran.

Super la fonction pour redimensionner les tableaux. Ce sera très pratique. Je ne connaissais pas la commande du pointeur ( => ), ce sera aussi très utile. Je vais donc redimensionner mon tableau au fur et à mesure que je lis le fichier. Ce sera beacoup plus propre selon moi. Merci!

Une dernière question. Pour un fichier contenant entre 1k et 10k lignes. Par combien de lignes à la fois serait-il préférable de redimensionner le tableau? Par exemple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 Je crée un tableau de 1000 lignes Je lis les 1000 premières lignes du fichier S'il y a une 1001e ligne, j'augmente la taille du tableau de nbLigne=100 Je lis les 100 autres lignes du fichier (ou arrêt avant et redimension du tableau selon le nombre exact de lignes lues) S'il y a une 1101e ligne, j'augmente la taille du tableau de nbLigne=100 Je lis les 100 autres lignes du fichier (ou arrêt avant et redimension du tableau selon le nombre exact de lignes lues) Continuer jusqu'à la fin du fichier...
Qu'elle valeur de nbLigne serait suggérée? Sans être la valeur optimale, qu'elle serait une valeur qui aurait du bon sens?
Après réflexion, serait-il préférable de définir un tableau plus grand (> 10k) et ensuite de le redimensionner selon le nombre exact de lignes?

Concernant ma dernière question, je me casse probablement la tête sur des détails qui sont totalement négligeable par rapport à l'ensemble de mon application. J'indique donc résolu et tant mieux si quelqu'un répond toutefois à ma question non triviale :aie:

Merci!

29/07/2006, 19h24
Jedai

C'est une question plutôt algorithmique que tu poses en fait à la fin de ton post.
Généralement la solution adoptée est de doubler à chaque fois qu'on atteint la limite, on aboutit ainsi à une complexité amortie d'ajout d'un élément en O(1) (temps constant).
D'un autre côté dans ton cas, une heuristique bien fondée sur la longueur attendue de tes fichiers peut-être plus efficace (par ailleurs peut-être (sans doute) serait-il plus efficace de lire ton fichier une première fois par gros blocs et de compter les caractères de fin de ligne pour en déduire la longueur nécessaire).

--
Jedaï
30/07/2006, 16h35
Vol

Ouin, c'est vrai, c'est de l'algo... je ne voulais pas créer un nouveau post seulement pour cette question. Merci d'avoir quand même répondu :P
Je vais utiliser ta suggestion de doubler à chaque fois que la limite est atteinte. Ça semble bien.