Discussion :

[panda31]

Bonjour à tous,

j'expose mon problème. Mon travail a pour cible les molécules et j'ai par conséquent besoin de manipuler des matrices de grandes tailles (3*Natomes )². Je manipule des double dans ces matrices.
Comme j'ai de nombreux 0 (en fait des double 0.) dans ces matrices, j'ai pensé à une matrice creuse. Alors je me suis lancé à l'aveugle dans sa construction.
J'ai pensé de suite à UNE liste simplment chaînée mais la manipulation est difficile.
J'avais en fait des éléments de la forme :
______________
| value |
______________

| ligne |
______________
| colonne |
______________
| suiv |
______________

Bref un cas d'école (normal vu que je suis simplement étudiant ).

Mais après avoir fait des tests, j'ai vite compris que je m'exposais à des SEGMENTATION FAULT en manipulant ceci...
En effet, ma liste est d'abord à NULL, puis j'obtiens NULL<-E1...<-En
Donc ensuite j'ai pensé à une liste doublement chaînée pour une manipulation de E1 à En... Mais bon là j'ai pensé au NET pour mes recherches. Et voilà ti pas que les schémas que je trouve n'ont strictement rien à voir avec ma construction !!!

Il ma faut en fait faire DEUX tableaux de pointeurs vers mes éléments modifiés ainsi :

______________
| value (i,j) |
______________

| i |
______________
| j |
______________
| i_suiv |
______________
| j_suiv |
______________


Ainsi les éléments de même j sont sur la même colonne et les éléments de même i sur la même ligne...

PAS COMPLIQUE DU TOUT COMME TRUC !!!!
Comment on fait déjà pour faire des tableaux pareils ? Pensez-vous qu'il y a bcp de malloc ? (AAAAAAAAAAH) Parce que c'est un truc à se casser les dents !

Je peux vous mettre déjà mon travail initial...

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
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
#include "MatCreuse.h"
 
struct ElemMat * MatCreuse_creer()
{/*Cree une matrice creuse*/
    struct ElemMat * MatCreuse;
    MatCreuse = NULL ;
    return(MatCreuse) ;
}
struct ElemMat * MatCreuse_ajouter(struct ElemMat * MatCreuse , int line , int column , double value )
{/*Ajoute un element la matrice creuse*/
    struct ElemMat * nouvMat;
    nouvMat = (struct ElemMat *)malloc(sizeof(struct ElemMat)) ;
    if (nouvMat == NULL)
    {
        printf("Pas assez de memoire pour MatCreuse\n") ;
        exit(1) ;
    }
    nouvMat->line = line ;
    nouvMat->column = column ;
    nouvMat->value = value ;
    nouvMat->suiv = MatCreuse ;
}
void MatCreuse_liberer(struct ElemMat * MatCreuse)
{/*Libere l'espace memoire occupe par MatCreuse*/
    /*Variables locales*/
    struct ElemMat  * aux1, * aux2 ;
    /*Corps de la procedure*/
    aux1 = MatCreuse ;
    while (aux1 != NULL)
    {
        aux2=aux1;
        aux1 = aux1->suiv ;
        free(aux2) ;
    }
}
 
 
double Energie1(int Natomes, double *dx, struct ElemMat *D_MatCreuse, int tailleMatCreuse)
{
    struct ElemMat * aux_MatCreuse = D_MatCreuse ;
    int ind_D=0, it;
    double E;
    puts("Energie\n");
    it = 3 * Natomes - 6;
    E = 0.;
    while(aux_MatCreuse != NULL ){
        E += dx[aux_MatCreuse->line] * dx[aux_MatCreuse->column] * aux_MatCreuse->value;
        ind_D++;
        aux_MatCreuse = aux_MatCreuse->suiv ;
    }
    if (aux_MatCreuse->line == aux_MatCreuse->column && aux_MatCreuse->value != 0){
    E += dx[aux_MatCreuse->line] * dx[aux_MatCreuse->line] * aux_MatCreuse->value;
    }
 
    return (E);
}

Ma structure était de la forme :

Code :

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

1
2
3
4
5
6
7
struct ElemMat{/*Element de base de la liste doublement chainee MatCreuse*/
    int line ;
    int column ;
    double value ;
    struct ElemMat * suiv ;
    struct ElemMat * prec ;
};

Merci d'avance pour tous vos beaux conseils sachant que je n'ai trouvé aucun algo des matrices creuses !

Ciao

PJ : Le fichier Flexible.c qui est le coeur de calcul de mon programme en phase de développement.

[Gruik]

Pourquoi se prendre le chou avec des listes chainees?
Si tu connais le nombre d'elements à la creation de la matrice, bat suffit d'allouer un tableau suffisament grand.

[Pragmateek]

Pourquoi se prendre le chou avec des listes chainees?
Si tu connais le nombre d'elements à la creation de la matrice, bat suffit d'allouer un tableau suffisament grand.

Mais pour une matrice creuse c'est du gaspillage.
La liste chaînée coûte moins en mémoire.

[panda31]

Mais pour une matrice creuse c'est du gaspillage.
La liste chaînée coûte moins en mémoire.

Merci ! Ca me rassure sur ma pseudo-intelligence !!!

Bref, je ne me décide toujours pas avec ces structures. Cependant, la simplicité d'implémentation de ma première idée semble un très bon argument pour la choisir. Qu'en pensez-vous ?

[panda31]

Bon alors j'ai tout repris pour ma liste chainee simple...
Sur le papier, schema a l'appui cela devrait etre OK.
Pour eviter de faire une pile et de m'embeter a remonter a l'envers la liste, j'ai fait un remplissage en partant de la fin.
Merci a tous

TAG RESOLU => YEEEEEEES

[fearyourself]

TAG RESOLU => YEEEEEEES

En haut à droite, il y a un bouton "Outils de la discussion", dedans tu trouveras le bouton résolu.

Jc

[FidoDido®]

Code :

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

1
2
3
4
5
6
struct ElemMat * MatCreuse_creer()
{/*Cree une matrice creuse*/
    struct ElemMat * MatCreuse;
    MatCreuse = NULL ;
    return(MatCreuse) ;
}

je crois que tu peux aller plus vite en mettant directement :

Code :

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

1
2
3
4
5
 
struct ElemMat * MatCreuse_creer()
{/*Cree une matrice creuse*/
return NULL;
}

Sur MatCreuse_ajouter tu n'aurais pas oublié de retourner newMat ?

Enfin je dis ca je dis rien, pcq c'est sûr que ce ne sont que des détails

[panda31]

ben en fait j'avais en effet oublié mais c'est réparé ! Merci pour les remarques constructives !