Discussion :

[mouloudia125]

voila j'essaie de faire une opération de soustraction sur un index pour le compressé (i+1 - i) ... donc je crée un autre index qui va joué le role de i

donc un index va se modifié en avançant dans la boucle car je vais écrire sur lui

mais le probléme c'est que les 2 index se modifie en méme temp et ca donne un résultat erroné

donc ma question est comment avoir un index ou il ne se modifie pas avec la modification de l'autre

voila le fragment concerné de mon code

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
public static void compression(){
 
    for(int i=0;i<index_Opt.size();i++){
        for (int j = 0; j < index_Opt.get(i).Posting_list.size(); j++) {
            int m=1;
 
            for (int k = 1; k < index_Opt.get(i).Posting_list.get(j).list.size(); k++) {
 
 
 
 
                 index_Opt.get(i).Posting_list.get(j).list.get(k).DocId=index_Opt.get(i).Posting_list.get(j).list.get(k).DocId  - index_Opt2.get(i).Posting_list.get(j).list.get(k-1).DocId ;
            }
        }
    }
    Chargé_Index.sauver_indexOptimisé(index_Opt, "index_compress.txt");
 
}
 
    public static void main(String[] args) throws IOException {
 
      //  new Optimiser_Index();
optimisation_index();
        index_cur.clear();
 
        optimiserIndex_listeDoc();
          index_Opt2= index_Opt;
 
        compression();
 
    }

[joel.drigo]

Salut,

Je ne suis pas sûr de comprendre ce que tu cherches à faire, mais ça m'a l'air assez compliqué. Déjà, les notations pointées à rallonge dénotent d'un problème de conception objet : on ne devrait pas avoir à gérer des expressions aussi longues, surtout qu'on dirait qu'il s'agit de listes de listes de listes.

Ensuite, s'il s'agit de renuméroter des id, normalement il suffit de faire :

Code :

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

1
2
3
4
5
6
7
int nouvelId = 0;
for(MonObject object : objects) {
     int ancienId=object.getId();
     object.setId(nouvelId);
     // éventuellement modifier les pointeurs sur ancienId (en remplaçant leur valeur par ancienId
     nouvelId = nouvelId + 1;
}

Pas besoin de faire de différence, surtout que id+1-id vaut toujours 1, en encore moins de double boucle.

[mouloudia125]

oui j'avoue que c'est un peu compliqué ... je travail sur 'lindex inversé si vous le connaissais et la c'est le résultat de index optimisé *pour les modélisé j'ai eu recours a 3 objet

a-com[ 7527,1,1]
a-minus[ 1097,1,1|1281,1,1|1669,1,1|2275,1,1|2451,2,2|2623,2,2|2655,1,1|3410,1,1|3673,3,3|6097,1,1|6218,1,1|6587,1,1|7103,1,1|8798,1,1|8808,2,2|9277,1,1]
a-plus[ 587,1,1|1620,1,1|2699,1,1|2749,1,1|3557,1,1|4090,1,1|4193,1,1|6118,1,1|6817,2,2|7669,1,1|7813,2,2|8075,2,2|8589,1,1|8799,1,1|8808,7,7|9078,1,1]
a-rated[ 1257,1,1|2275,1,1|3114,1,1|4002,1,1]
a-rating[ 2749,1,1]
aa[ 146,1,1|1626,2,2|1709,2,2|1969,1,1|2181,2,2|2211,1,1|2549,2,2|2556,1,1|2894,1,1|3304,1,1|3615,2,2|4162,1,1|4198,1,1|4423,2,2|5154,2,2|5389,1,1|5953,3,3|6241,2,2|6580,1,1|6616,1,1|7123,3,3|7135,4,4|7141,1,1|7665,1,1|8307,1,1|8309,1,1|9078,1,1]
[-minus 587,1,1|1328,1,1|1991,1,2|2285,1,3|2699,2,2|3557,1,1|3980,1,2|3986,1,2|4090,3,5|6706,1,1|6817,1,2|7770,1,1|7915,1,1|8043,2,2|8075,2,3|8808,8,14|9126,1,1]
[-plus 1667,1,2|3401,2,2|4980,1,3|5100,1,3|5448,1,2|8808,2,8]
[a 126,1,1|361,1,1|767,1,1|1314,1,1|1377,2,3|1648,1,1|1998,1,1|2022,1,1|2212,1,2|2465,1,1|2749,2,2|2761,1,1|3335,1,1|3369,1,2|3533,1,1|3907,1,1|5100,2,4|5280,1,1|5372,3,3|6800,1,1|6947,3,5|7577,1,1|8581,1,1]
[a-rated 361,1,1|2404,1,1|6308,1,2|7098,1,1]
[c 1116,1,1|5954,1,1|7565,1,1]
[chener 5867,1,1]
[giy 2096,1,1]
[ix 9278,1,1]
[ncor 1968,1,1]
[p 6430,2,2]
[pi 2306,1,1]
[pl 346,1,1|363,1,1|452,1,1|620,1,1|763,1,1|1034,1,1|2918,1,1]
[r 398,2,2|7544,1,1]
[re 5456,1,1]
[rn 6724,1,1]
[ron 4972,1,1|6724,1,1]
[ti 2664,1,1|7776,1,1]
ab[ 281,7,7|439,1,1|840,1,1|939,1,1|968,1,1|971,2,2|995,3,3|1863,1,1|1910,1,1|1934,1,1|1947,2,2|1949,1,1|2348,1,1|2367,1,1|2413,1,1|2435,2,2|2733,1,1|2781,1,1|2817,2,2|2825,2,2|2834,1,1|3322,2,2|3749,2,2|3759,3,3|3770,1,1|3803,4,4|3847,2,2|3992,1,1|4076,4,4|4286,1,1|4385,1,1|4786,1,1|5023,1,1|5930,1,1|5973,1,1|6083,1,1|6422,1,1|6441,1,1|7503,2,2|8021,4,4|8412,1,1|8413,1,1|9168,1,1|9177,1,1]
[a 2789,3,3]

donc maintenant je dois le compressé et pour le faire je dois faire une opération de soustraction pour les 'docid' le premier de l'objet lié au terme
et pour le faire j'ai décalrer un autre index similaire a celui ci pour sauvgarder l'ancien en lui ou il jouera le role de i-1 .... mais le probléme c'est qu'il se modifie avec l'autre ...

[joel.drigo]

Je parlais de simplifier en faisant des classes avec des accesseurs, pour éviter d'avoir des trucs du genre list.get(i).list.get(j).list.get(k)....

Pour le reste, je comprends rien à ce que tu dis. Je ne vois pas ce que change le fait d'être en index inversé pour l'id d'un objet.

Si on a (clef -> liste des docs):

mot1 -> [R3, R5, R8]
mot2 ->  [R5, R8]
mot3 -> [R3]

Et qu'on renumérote simplement, on obtient

mot1 -> [R1, R2, R3]
mot2 ->  [R2, R3]
mot3 -> [R1]

Ou ce n'est pas ça que tu cherches à faire ?

[mouloudia125]

moi je modifie que l'id (le premier champ) car chaque mot a une liste de champs (doc_id, term_freq,post)
donc je modifie la valuer du doc_id de chaque mot pour que la valeur de doc_id(i) = doc_id(i) - doc_id(i-1)

donc pour simplifié la question .... j'ai un index A et je creé un index B
B recoit A
dans mon programe quand je modifie A .. B se modifie aussi ... alors que je veu qu'il garde l'ancien valeur de A

A.doc_id(i) = A.doci_id(i) - B.doc_id(i)

j’espère que j'ai bien simplifié

[mouloudia125]

c'est bon je l'ai trouvé il faut que j'ajoute la methode clone pour que le nouveaux index ne change pas
mais j'avoue je suis un perdu