Discussion :

[rAyyy]

Bonjour,

j'ai reçu 2 .c que j'aimerais décortiquer et comprendre la structure (je n'ai pas d’énorme connaissance en programmation)
Pour cela j'ai d’abord essayai de compiler et de tester le programme en lui même(ce qui est logique)

J'arrive à compiler sans problème. Lorsque je veut lancer le programme j'ai un message d'erreur "segmentation error (core dumped)"

J'ai tenter de chercher le problème avec gdb.

Mais étant donner que je ne mit connait pas énormément je n'arrive pas à voir ce que je doit faire.
Un petit coup de pouce serait fort sympathique

Voila ce que me retourne gdb:



Voila les 2 .c :

main.c

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/time.h>
#include <stdbool.h>
static int nbDl ;
 
/*! \brief Computes coordinates of point number 'i'
 
  The points are computed on a cylinder defined by 'radius' and 'height'. The number of points is given by nbDl.
  \a i should be in [0, nbDl[.
  \param i the number of the point (input)
  \param coord the coordinates x y z of this point (output)
*/
void computeCoord(int i, double *coord) {
  const double radius=0.5 ;
  const double height=1. ;
  static double angleStep=0. ;
  static double zStep=0. ;
  double theta ;
 
  if (i<0 || i>=nbDl) {
    printf("Incorrect unknown number %d, should be in [0, %d[\n", i, nbDl) ;
    exit (-1);
  }
 
  if (angleStep==0.) {
    zStep=height/(double)nbDl ;
    angleStep=sqrt(zStep*2.*M_PI/radius) ;
  }
 
  theta=(double)i * angleStep ;
  coord[0]=radius * sin(theta) ;
  coord[1]=radius * cos(theta) ;
  coord[2]=(double)i*zStep ;
 
  return ;
}
 
void computeKernel(double r, double *kernel) {
  *kernel=exp(-r*r)/(r+0.1) ;
}
 
void computeDistance(double *coord1, double *coord2, double *r) {
  double v[3] ;
 
  v[0]=coord1[0]-coord2[0] ;
  v[1]=coord1[1]-coord2[1] ;
  v[2]=coord1[2]-coord2[2] ;
  *r=sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]) ;
 
  return ;
}
 
/*! \brief Computes a block of matrix
 
  We compute the block defined by [rowMin, rowMax] x [colMin, colMax] where index should be in [0, nbDl[.
  The output is written in block, an allocated array of sufficient size. The output is a fortran-style, column wise block.
  \param rowMin beginning row index
  \param rowMax ending row index
  \param colMin beginning col index
  \param colMax ending col index
  \param block 
*/
void computeMatrixBlock(int rowMin, int rowMax, int colMin, int colMax, double *block) {
  double coord1[3], coord2[3], r, kernel ;
  int i, j, pos ;
 
  pos=0 ;
  for (j=colMin ; j<=colMax ; j++) {
    computeCoord(j, &(coord2[0])) ;
    for (i=rowMin ; i<=rowMax ; i++) {
      computeCoord(i, &(coord1[0])) ;
 
      computeDistance(&(coord1[0]), &(coord2[0]), &r) ;
      computeKernel(r, &(block[pos])) ;
      pos++ ;
    }
  }
  return ;
}
 
void computeRhs(double *rhs) {
  double coord[3] ;
  int i ;
 
  for (i=0 ; i<nbDl ; i++) {
    computeCoord(i, &(coord[0])) ;
    rhs[i]=cos(coord[0]+coord[1]+coord[2]) ;
  }
 
  return ;
}
 
void loadFile(char *name, void **p) {
  int fd, ierr, header[5] ;
  ssize_t res ;
  size_t s ;
 
  *p=NULL ;
  fd=open(name, O_RDONLY) ;
  if(fd==-1) {
    printf("   %s not found\n", name) ;
    return ;
  }
  res=read(fd, header, sizeof(int)*5) ;
  s=(size_t)header[1]*header[2]*header[3] ;
  *p=(void*)malloc(s) ;
  res=read(fd, *p, s) ;
  if(res!=sizeof(double)*nbDl) exit(-1) ;
  ierr=close(fd) ;
  if(ierr==-1) exit(errno) ;
 
  return ;
}
 
 
void computeRelativeError(double *sol, double *ref, double *eps) {
  int i ;
  double normRef, normDelta ;
 
  normDelta=0. ;
  normRef=0. ;
  for (i=0 ; i<nbDl ; i++) {
    normDelta += (sol[i]-ref[i])*(sol[i]-ref[i]) ;
    normRef += ref[i]*ref[i] ;
  }
  *eps = sqrt(normDelta/normRef) ;
  return ;
}
 
bool compareSolutions(double *rhs,double threshold) {
  char fileName[100] ;
  double *rhsRef, eps ;
 
 
  /* Comparing with MPF solution if available */
  sprintf(fileName, "ref_MPF_%d", nbDl) ;
  /* Allocates and loads the right hand side */
  loadFile(fileName, (void**)&rhsRef) ;
  /* Compute relative error */
  if (rhsRef) {
    computeRelativeError(rhs, rhsRef, &eps) ;
    free(rhsRef) ;
    if (eps<=threshold) {
        return true;
      }
    else {
        return false;
       }
  }  
  return false ;
}
 
extern void solver(int, char**, int, double**, void (*)(int, int, int, int, double*) ) ;
 
int main(int argc, char **argv) {
  int ierr ;
  double *rhs ;
  struct itimerval tv ;
  double t1, t2 ;
  double threshold=1e-14;
  bool status;
  /* Set the number of unknowns */
  if (argc > 1)   
    nbDl=atoi(argv[1]) ;
  else 
    nbDl=60000 ;
 
 
 
  /* Allocates and computes the right hand side */
  rhs=(double*)calloc(nbDl, sizeof(double)) ;
  computeRhs(rhs) ;
 
  /* Init timers */
  tv.it_interval.tv_sec = 86400000 ;
  tv.it_interval.tv_usec = 0;
  tv.it_value.tv_sec = 86400000 ;
  tv.it_value.tv_usec = 0;
  ierr=setitimer(ITIMER_REAL, &tv, NULL) ; 
 
  /* Solves the system by calling the participant's routine */
  ierr=getitimer( ITIMER_REAL, &tv ) ; 
  t1 = -( (double )(tv.it_value.tv_sec)+((double )(tv.it_value.tv_usec))*1.e-6 ) ;
  solver(argc, argv, nbDl, &rhs, computeMatrixBlock) ;
  ierr=getitimer( ITIMER_REAL, &tv ) ; 
  t2 = -( (double )(tv.it_value.tv_sec)+((double )(tv.it_value.tv_usec))*1.e-6 ) ;
 
 
 
  /* Compare the result to a reference result (if available) */
  status=compareSolutions(rhs,threshold);
  if(status)
    printf("OK  %.4f\n", t2-t1);
  else 
    printf("KO\n");
 
 
  free(rhs) ;
 
  return 0 ;
}

solver.c:

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
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
 
/* simple version of the solver */
void solver(int argc, char**argv,
	     int nbDl,
	     double **rhs,
	     void (*computeBlock)(int, int, int, int, double*)) {
  double *mat ;
  int info, *pivot, ione=1, fd, ierr, header[5] ;
  char fileName[100] ;
  ssize_t res ;
 
 
  /* allocate the matrix and the pivot */
  mat=(double*)calloc(nbDl*nbDl, sizeof(double)) ;
  pivot=(int*)calloc(nbDl, sizeof(int)) ;
 
  /* fills the matrix */
  computeBlock(0, nbDl-1, 0, nbDl-1, mat) ;
 
  /* Factorize the matrix */
  dgetrf_(&nbDl, &nbDl, mat, &nbDl, pivot, &info) ;
  if (info) exit(info) ;
 
  /* Solve the system */
  dgetrs_("N", &nbDl, &ione, mat, &nbDl, pivot, *rhs, &nbDl, &info) ;
  if (info) exit(info) ;
 
  /* Freeing */
  free(mat) ;
  free(pivot) ;
 
  return ;
}

[Neckara]

Bonjour,

Si tu débutes, je te conseillerais de vite oublier ce code.
La personne qui l'a produite a mis des return; à la fin de ses fonctions void, ce qui est totalement inutile.

Dans la fonction du dernier fichier, il fait des calloc au début de la fonction et libère la mémoire à la fin de celle-ci.
L'allocation dynamique n'a aucun intérêt ici.

De plus, dans le main, on voit bien que le programmeur ne sait pas faire d'header, il met une fonction en "extern" au lieu de faire un .h

Il met

Code :

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

1
2
3
4
5
6
    if (eps<=threshold) {
        return true;
      }
    else {
        return false;
       }

au lieu de

Code :

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

return eps<=threshold

C'est vraiment pas un bon exemple pour une personne qui débute.

[rAyyy]

Ça dépend ce que tu entend par débuter.
Je sait programmer mais de façon "simple".

Par exemple il y a plusieurs choses que je ne comprend pas dans ces .c:
exemple les arguments pour un main, j’avais jamais vu ça.

Mais j'ai de bonne raison de vouloir le comprendre. Le but de ce code est de résoudre des systèmes linéaires rapidement ce que je veut apprendre. Je suis très intéressé dans le calcul scientifique d'où mon envie de comprendre.

[Neckara]

Ce code est vraiment mal fait, donc si tu arrives à trouver une autre code ça sera toujours un peu mieux.

Mais pose tes questions et on essayera d'y répondre.

exemple les arguments pour un main, j’avais jamais vu ça.

Code :

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

int main(int argc, char **argv)

Quand on lance un programme en ligne de commande on peut le lancer avec des arguments :

Code :

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

./exe arg1 arg2 "arg       3"

int argc correspond au nombre d'arguments.
char **argv correspond aux arguments avec :
- argv[0] : nom de l'executable ;
- argv[1] = "arg1"
- argv[2] = "arg2"
- argv[3] = "arg 3"
- argv[4] = NULL

[kwariz]

...
Dans la fonction du dernier fichier, il fait des calloc au début de la fonction et libère la mémoire à la fin de celle-ci.
L'allocation dynamique n'a aucun intérêt ici.

Bonjour,

en fait il peut y avoir un intérêt quand ce qui est alloué est très grand, ça évite un stack overflow ...

[rAyyy]

Merci Neckara, donc si j'ai bien compris si il n'y a pas d'argument nbdl est directement mit à 60000 et si il y a un argument c'est la 1ere partie numérique de l'argument que nbdl prend.

Cependant j'ai mit 1 ou 3 ou 4 en argument et ça ma écrit:
REF_MPF_1 not found ( ou _3 ou_4)
j'ai essayer avec 60000 ça ma mit le même message d'erreur qu'avant, c.a.d :
Segmentation error (core dumped)

j'ai essayer avec 10500 et je n'ai rien après, je ne peut même pas entrer de commande
Ça écrit juste les caractères que je tape dans la konsole sans rien faire
Est ce que ça veut dire que le programme est en cour d’exécution?

[Neckara]

Bonjour,

en fait il peut y avoir un intérêt quand ce qui est alloué est très grand, ça évite un stack overflow ...

Oui mais dans ce cas là, on justifie l'allocation par un commentaire et on ne met pas de calloc quand on remplit entièrement le tableau juste après

Cependant j'ai mit 1 ou 3 ou 4 en argument et ça ma écrit:
REF_MPF_1 not found ( ou _3 ou_4)
j'ai essayer avec 60000 ça ma mit le même message d'erreur qu'avant, c.a.d :
Segmentation error (core dumped)

j'ai essayer avec 10500 et je n'ai rien après, je ne peut même pas entrer de commande
Ça écrit juste les caractères que je tape dans la konsole sans rien faire
Est ce que ça veut dire que le programme est en cour d’exécution?

Le programmeur a mis un atoi pour récupérer le nombre, fonction très déconseillée, il vaut mieux utiliser un sscanf ou un strtol.
Ici le cas d'erreur n'est pas gérer, je te conseille donc de rajouter un printf pour voir quelle est le nombre lu.

Sinon, essaye de lancer ton programme avec un debuggeur ou de mettre des printf un peu de partout pour identifier la ligne qui plante.

[ternel]

le code contient des abérations...

des fonctions void f(double a, double *b) au lieu de double f(double)computeKernel serait fausse (-r²/r n'est pas -r²/(r+0.1) ) (si ma mémoire est bonne)

les returns en fin de void

l'absence de documentation/controle sur les types des arguments fonctions: pointeurs pour retour?, tableaux?, absence de const....

Comme j'ai un peu de temps, et de curiosité, je refais une version nettoyée.

Code main.c :

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
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
 
#include "support.h"
#include "solver.h"
 
int nbDl;
 
int main(int argc, char **argv) {
  int ierr ;
  double *rhs ;
  struct itimerval tv ;
  double t1, t2 ;
  double threshold=1e-14;
 
  /* Set the number of unknowns */
  nbDl = (argc > 1) ? atoi(argv[1]) : 60000;
 
  /* Allocates and computes the right hand side */
  rhs = (double*)calloc(nbDl, sizeof(double)) ;
  computeRhs(rhs) ;
 
  /* Init timers */
  tv.it_interval.tv_sec = 86400000 ;
  tv.it_interval.tv_usec = 0;
  tv.it_value.tv_sec = 86400000 ;
  tv.it_value.tv_usec = 0;
  ierr=setitimer(ITIMER_REAL, &tv, NULL) ; 
 
  /* Solves the system by calling the participant's routine */
  ierr=getitimer( ITIMER_REAL, &tv ) ; 
 
  t1 = -( (double )(tv.it_value.tv_sec)+((double )(tv.it_value.tv_usec))*1.e-6 ) ;
 
  solver(argc, argv, nbDl, &rhs, computeMatrixBlock) ;
  ierr=getitimer( ITIMER_REAL, &tv ) ; 
 
  t2 = -( (double )(tv.it_value.tv_sec)+((double )(tv.it_value.tv_usec))*1.e-6 ) ;
 
 
 
  /* Compare the result to a reference result (if available) */
  if( compareSolutions(rhs,threshold) )
    printf("OK  %.4f\n", t2-t1);
  else 
    printf("KO\n");
 
 
  free(rhs) ;
 
  return 0 ;
}

Code support.c :

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
 
#include "support.h"
#include "solver.h"
 
 
/*! \brief Computes coordinates of point number 'i'
 
  The points are computed on a cylinder defined by 'radius' and 'height'. The number of points is given by nbDl.
  \a i should be in [0, nbDl[.
  \param i the number of the point (input)
  \param coord the coordinates x y z of this point (output)
*/
void computeCoord(int i, /*output*/ double coord[3]) {
  const double radius=0.5 ;
  const double height=1. ;
  static double angleStep=0. ;
  static double zStep=0. ;
  double theta ;
 
  if (i<0 || i>=nbDl) {
    printf("Incorrect unknown number %d, should be in [0, %d[\n", i, nbDl) ;
    exit (-1);
  }
 
  if (angleStep==0.) {
    zStep = height/(double)nbDl ;
    angleStep = sqrt(zStep*2.*M_PI/radius) ;
  }
 
  theta=(double)i * angleStep ;
  coord[0]=radius * sin(theta) ;
  coord[1]=radius * cos(theta) ;
  coord[2]=(double)i*zStep ;
 
  return ;
}
 
 
double computeKernel(double r) {
  return exp(-r*r)/(r+0.1) ;
}
 
double computeDistance(const double coord1[3], const double coord2[3]) {
  double x=coord1[0]-coord2[0];
  double y=coord1[1]-coord2[1];
  double z=coord1[2]-coord2[2];
  return sqrt(x*x + y*y + z*z);
}
 
/*! \brief Computes a block of matrix
 
  We compute the block defined by [rowMin, rowMax] x [colMin, colMax] where index should be in [0, nbDl[.
  The output is written in block, an allocated array of sufficient size. The output is a fortran-style, column wise block.
  \param rowMin beginning row index
  \param rowMax ending row index
  \param colMin beginning col index
  \param colMax ending col index
  \param block 
*/
void computeMatrixBlock(int rowMin, int rowMax, int colMin, int colMax, double *block) {
  double coord1[3], coord2[3], r ;
  int i, j, pos=0;
 
  for (j=colMin ; j<=colMax ; j++) {
    computeCoord(j, coord2) ;
    for (i=rowMin ; i<=rowMax ; i++) {
      computeCoord(i, coord1) ;
 
      r = computeDistance(coord1, coord2) ;
      block[pos++] = computeKernel(r) ;
    }
  }
  return ;
}
 
void computeRhs(double *rhs) {
  double coord[3] ;
  int i ;
 
  for (i=0 ; i<nbDl ; i++) {
    computeCoord(i, coord) ;
    rhs[i]=cos(coord[0]+coord[1]+coord[2]) ;
  }
}
 
void* loadFile(char *name) {
  int fd, ierr, header[5] ;
  ssize_t res ;
  size_t s ;
 
  void *returned=NULL ;
 
  fd=open(name, O_RDONLY) ;
  if(fd==-1) {
    printf("   %s not found\n", name) ;
    return returned;
  }
  res = read(fd, header, sizeof(int)*5) ;
  s = (size_t)header[1]*header[2]*header[3];
 
  returned = malloc(s);
 
  res = read(fd, returned, s);
 
  ierr = close(fd) ;
  if(ierr==-1) exit(errno) ;
 
  if(res!=sizeof(double)*nbDl) exit(-1) ;
 
  return returned;
}
 
 
double computeRelativeError(const double sol[], const double ref[]) {
  int i ;
  double normRef, normDelta ;
 
  normDelta=0. ;
  normRef=0. ;
  for (i=0 ; i<nbDl ; i++) {
    normDelta += (sol[i]-ref[i])*(sol[i]-ref[i]) ;
    normRef += ref[i]*ref[i] ;
  }
  return sqrt(normDelta/normRef) ;
}
 
bool compareSolutions(double *rhs, double threshold) {
  char fileName[100] ;
  double *rhsRef, eps ;
 
  /* Comparing with MPF solution if available */
  sprintf(fileName, "ref_MPF_%d", nbDl) ;
 
  /* Allocates and loads the right hand side */
  rhsRef = (double*) loadFile(fileName) ;
 
  /* Compute relative error */
  if (!rhsRef) return false;
 
  eps = computeRelativeError(rhs, rhsRef) ;
  free(rhsRef) ;
  return eps<=threshold;
}

Code support.h :

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
 
#include <stdbool.h>
 
extern int nbDl ;
 
/*! \brief Computes coordinates of point number 'i'
 
  The points are computed on a cylinder defined by 'radius' and 'height'. The number of points is given by nbDl.
  \a i should be in [0, nbDl[.
  \param i the number of the point (input)
  \param coord the coordinates x y z of this point (output)
*/
void computeCoord(int i, double coord[3]) ;
 
double computeKernel(double r) ;
double computeDistance(const double coord1[3], const double coord2[3]) ;
 
/*! \brief Computes a block of matrix
 
  We compute the block defined by [rowMin, rowMax] x [colMin, colMax] where index should be in [0, nbDl[.
  The output is written in block, an allocated array of sufficient size. The output is a fortran-style, column wise block.
  \param rowMin beginning row index
  \param rowMax ending row index
  \param colMin beginning col index
  \param colMax ending col index
  \param block 
*/
void computeMatrixBlock(int rowMin, int rowMax, int colMin, int colMax, double *block) ;
 
void computeRhs(double *rhs) ;
 
void* loadFile(char *name);
 
 
double computeRelativeError(const double sol[], const double ref[]) ;
 
bool compareSolutions(double *rhs,double threshold) ;

Code solver.h :

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

1
2
3
4
5
#ifndef SOLVER_H
#define SOLVER_H 1
 
void solver(int argc, char** argv, int nbDL, double** rhs, void (*computeBlock)(int rowMin, int rowMax, int colMin, int colMax, double *block) ) ;
#endif

voila, c'est toujours codé avec les pieds, mais au moins, c'est un minimum valable

[rAyyy]

Merci leternel.
Est ce qu'il y a un moyen simple de compiler avec les headers?
j'ai entrer comme commande sur linux :gcc main.c support.c solver.c -lm -llapack -o truc
mais j'imagine qu'il doit y avoir un moyen plus simple non?
( les sources et headers sont dans le même fichier)

Donc j'ai regarder un peut les messages d'erreur que j'ai eu
REF_MPF_1 not found (pour un argument de 1) , ça signifie que la fonction loadfile ne trouve pas le un fichier de référence. Bon j'ai aucune idée du type de fichier et de ce qu'il renferme :/.
Peu être le temps prit pour un nombre de point de 1.

Cependant, j'ai un peu plus comprit la démarche du programme. Il étudie le temps que prend la résolution prit par le solver du système linéaire.

Le message était bloqué quand il ne détecte pas le fichier dont j'ai parler.
J'ai donc ressorti le printf("OK %.4f\n", t2-t1); du if.


J'ai un autre problème le programme marche pour des valeurs (arguments qui est le nombre de point du système) que pour un certain nombre: de 1 à 5000 ça marche mais dans les alentours de 60000 le programme bug dans computekernel. (j'ai mit le message du deboger dans mon 1er post)
Quelqu'un aurait une idée de ce qui pose ce problème?
(d’ailleurs je ne comprend pas non plus l'utilité de la fonction compute kernel)


Bon je pense que ça doit avoir une relation avec la taille du système: pour 100 point il prend 1 second pour traiter mais pour 1000 point et bien il n'a toujours pas fini après 10min.

[ternel]

Merci leternel.
Est ce qu'il y a un moyen simple de compiler avec les headers?
j'ai entrer comme commande sur linux :gcc main.c support.c solver.c -lm -llapack -o truc
mais j'imagine qu'il doit y avoir un moyen plus simple non?
( les sources et headers sont dans le même fichier)

Dossier, veux tu dire?
moi, j'utilise souvent gcc *.c <-lce_qu'il_faut> -o truc
les headers sont automatiquements trouvés, parce que le texte entre les "" est un chemin relatif du fichier à injecté à la place de la commande #include (tandis que <> cherche dans les includes systemes).
l'option -I permet de rajouter un dossier dans la recherche des headers.

Pour le reste, j'ai pas pigé grand chose au programme, faute de pouvoir linker.

[kwariz]

Bonjour,

je dirai qu'il est toujours bon d'inclure les headers qui vont avec les bibliothèques qu'on utilise, en l'occurence si on utilise la bibliothèque lapack il est bon d'inclure les headers fournis avec, certainement lapack.h (après un très brève recherche de "dgetrf_" avec google ...)
Il ne me semble pas que tu l'inclues ...

Quant à créer ton exécutable, je pense qu'un petit makefile fera certainement l'affaire ; au pire ton IDE doit pouvoir gérer ça sinon.

[rAyyy]

C'est que j'ai installer linux en virtuel juste pour pouvoir tester ce programme, je ne l'ai jamais utiliser avant (impossible de le lancer sur windows). Donc j'ai juste appris les base pour pouvoir compiler et donc je manie pas à la perfection.
D’ailleurs je n'ai même pas encore d'IDE.

Mais bon mon problème principale n'est pas le jonglage des commande et des header mais de comprendre le programme

Et leternel pourquoi tu ne peut pas linker? Tu n'a pas la librairie LAPACK?
Si j'ai réussi à l’installer en débutant sur LINUX c'est que ça doit être simple à faire non?
Bon après peut être que tu n'a pas envie de te prendre la tête dessus ^^

[ternel]

Et leternel pourquoi tu ne peut pas linker? Tu n'a pas la librairie LAPACK?
Si j'ai réussi à l’installer en débutant sur LINUX c'est que ça doit être simple à faire non?
Bon après peut être que tu n'a pas envie de te prendre la tête dessus ^^

Parce que j'ai fais ca au boulot, alors que je n'ai pas les droits d'installer ce que je veux, et que je n'ai acces qu'au dépot de ma boite, un miroir réduit du dépot ubuntu (encore en version 9.10…)
J'ai déjà galéré pour compiler un g++ 4.7.

Et je n'avais pas identifié LAPACK