Discussion :

[dhoorens]

Bonjour,

j'ai un fichier de paramètres dépendant du temps pour un programme qui est sous format CSV.
Ce fichier se présente sous la forme suivante:

Colonnes:
la variable temporelle en colonne. Il ya 480 mois (40 ans) => 480 colonnes



Lignes:
PLus de 1000 lignes. Chacune de ces lignes correspond à une simulation bien précise. Ces lignes sont ordonnées (plus petite simul vers la plus grande)
La première colonne reprend le numéro de la simulation.


J'aimerais faire qqch du style:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int lastSimulation = 1000;
for (int i = 1; i<= lastSimulation; i++){
    std::ifstream fichier( "fichier.txt" );
 
    if ( fichier ) 
    {
        std::string ligne; 
        while ( std::getline( fichier, ligne ) ) {
               if( on est sur la ligne correspondant au compteur i)
                     doSomething();        
         }
     }
}

Le code (que j'ai retapé de mémoire ) fonctionne, mais le problème est que si le n° de simulation est dans le début du fichier, j'arrive à la fonction doSomething() (forcément) assez vite, par contre si la simulation est très loin dans le fichier, ca prend bcp de temps (une seconde contre qqs millisecondes).
Le temps étant très important pour moi, avez vous une idée pour acceder à une ligne particulière plus rapidement?

Merci bcp
David

[ram-0000]

Je ne sais pas si c'est possible mais si les lignes font toutes la même longueur, tu pourrais utiliser fseek (ou équivalent) afin de te positionner directement dans le fichier sur la ligne à lire. Par contre, attention si une seule ligne ne respecte pas le format !!!

Si le critère de temps de positionnement est vraiment important, tu pourrais même imposer une taille fixe pour tes lignes.

C'est le seul moyen que je voie pour optimiser le temps d'accès à une ligne particulière.

[dhoorens]

En fait toutes les colonnes contiennent des chiffres (hormis la première qui indique le n0 de la simulation (c'est aussi un chiffre :-) ).
Ces chiffres sont du style 0.0457568 mais avec parfois moins ou plus de décimales... Et il n'est pas possible de restreindre la taille pcq c'est un autre programme (un générateur de scénarios économiques) qui me fournit cet input sous format csv.

[anykeyh]

A) D'un coté:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
    std::ifstream fichier( "fichier.txt" );
 
    if ( fichier ) 
    {
 
        std::string ligne; 
        int i = 0;
        while (  std::getline( fichier, ligne ) && (i++<lastSimulation) ) {
               if( on est sur la ligne correspondant au compteur i) //Renverra toujours vrai
                     doSomething();        
         }
     }

ça ne sert à rien de double boucler!

B) Sinon tu peux pas tous passer en memoire?

Si A et B ne conviennents pas:

C) Algorithme recursif en complexité log2:

fonction chercher_log2(int commencerOu)

fseek(commencerOu)

lire jusqu'au prochain caractere "\n" (saut de ligne, ou fin de fichier)

if( on est sur une ligne inferieur au compteur i)
alors
-> chercher_log2(commencerOu + commencerOu/2)
sinon
if(on est sur une ligne egale au compteur i)
retourner ligne ou flux ou directement la structure etc...
sinon
-> chercher_log2(commencerOu - commencerOu/2)
fin if
fin if

Cela marche uniquement si toute tes structures sont dans un ordre triée

[koala01]

Salut,

Peut-être - étant donné que tu as un nombre de colonnes connues - serait-il intéressant d'envisager un simili fichier ISAM (le I étant pour "indexed" )

Dans un fichier à part, tu indiques les offsets de chaque début de ligne, et tu charges ces offset dans un tableau en début de programme.

Quand tu dois accéder à un élément X, tu calcule pos = X / nombre_colonnes à l'arrondi inférieur, et tu récupères l'offset en tab_offset[pos].

Cet offset te permet (à l'aide de fseek) de sauter directement au début de ligne qui t'intéresse, et tu n'a plus au maximum qu'à lire la totalité des colonnes de cette ligne

Nous ne sommes pas encore en O(log(n)), cela te permet de garder un temps "presque constant" (constant pour aller chercher la ligne, en O(N) pour aller chercher la colonne)

Pour obtenir l'index, l'idéal serait de modifier l'application qui crée ton fichier CSV de manière à ce qu'elle crée l'index, mais, sinon:

1. tu peux créer une petite application qui s'en charge (ca doit pas faire beaucoup plus de 5 lignes )
2. Tu peux lire une fois le fichier au lancement de ton application, et créer l'index "à la volée" (ici aussi, cela ne fait pas beaucoup plus de 5 lignes )

Cependant, ces deux dernières solutions seront plus lentes que la solution idéale

[EDIT]Il est aussi possible de prévoir un index d'offset toutes les X données (ou X peut varier à ton gré de 1 - qui n'est pas vraiment intéressant au vu de la taille du tableau qu'il implique - à autant que tu veux )

[dhoorens]

Mais il ya une sorte d'index, puisque la première colonne contient le n° de la simulation..

On a qqch du style:
Simul ; 0 ; 1 ; 2 ; 3 ;......
1; 0.045 ; 0.0645; 0.0368; 0.12 ;....
2; 0.0756; 0.0752; 0.0953; 0.564 ;....
3; 0.065 ; 0.0123; 0.0321; 0.8525;....
......

Est ce que je peux l'utiliser astucieusement?

[dhoorens]

Salut,

Peut-être - étant donné que tu as un nombre de colonnes connues - serait-il intéressant d'envisager un simili fichier ISAM (le I étant pour "indexed" )

Dans un fichier à part, tu indiques les offsets de chaque début de ligne, et tu charges ces offset dans un tableau en début de programme.

Quand tu dois accéder à un élément X, tu calcule pos = X / nombre_colonnes à l'arrondi inférieur, et tu récupères l'offset en tab_offset[pos].

Cet offset te permet (à l'aide de fseek) de sauter directement au début de ligne qui t'intéresse, et tu n'a plus au maximum qu'à lire la totalité des colonnes de cette ligne

Nous ne sommes pas encore en O(log(n)), cela te permet de garder un temps "presque constant" (constant pour aller chercher la ligne, en O(N) pour aller chercher la colonne)

Pour obtenir l'index, l'idéal serait de modifier l'application qui crée ton fichier CSV de manière à ce qu'elle crée l'index, mais, sinon:

1. tu peux créer une petite application qui s'en charge (ca doit pas faire beaucoup plus de 5 lignes )
2. Tu peux lire une fois le fichier au lancement de ton application, et créer l'index "à la volée" (ici aussi, cela ne fait pas beaucoup plus de 5 lignes )

Cependant, ces deux dernières solutions seront plus lentes que la solution idéale

[EDIT]Il est aussi possible de prévoir un index d'offset toutes les X données (ou X peut varier à ton gré de 1 - qui n'est pas vraiment intéressant au vu de la taille du tableau qu'il implique - à autant que tu veux )

Bonjour
J'ai essayé cette solution, càd que je crée un petit fichier txt qui indique à chaque ligne l'offset correspondant à la longueur de la ligne correspondante dans mon fichier de base.

Ensuite, lorsque j'ai besoin d'une ligne en particulier, j'ouvre mes deux fichiers (le gros et le petit) et je recupère dans le petit l'offset correspondant à ma simulation et je me déplace à l'aide de fseek dans le gros fichier jusque l'offset et je récupère ma ligne.
Tout fonctionne bien, sauf qu'au niveau du temps c'est pas top.

Lorsque je fais tourner mon programme sur les 100 premieres simulations , ça prend 1 minute (c'est le temps que dure mon programme => il faut prendre le temps relatif)
Lorsque je fais tourner mon programme sur les 100 premieres simulations , ca prend 5 minutes

=> j'ai (en gros) un rapport X5 entre le fait d'accèder aux premières lignes et les dernières lignes...

C'est un peu genant car je voudrais réduire le temps de calcul considérablement...:-/

Si vous avez une idée...
Merci