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.