Dev - C++ - Compila pero sale SIGSEGV al correrlo

 
Vista:

Compila pero sale SIGSEGV al correrlo

Publicado por Aldo Eduardo (1 intervención) el 07/05/2020 23:31:47
Hola tengo problemas con este código, se compila bien y todo pero lo que pasa es que al llamar a la función gauss jordan me sale el segmentation fault y el programa deja de funcionar, adjunto la carpeta del proyecto para algún consejo que me puedan dar sobre como solucionar este error, muchas gracias por leer! (El sistema se evalua introduciendo el archivo datos3.txt)

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
/*incluye archivo de encabezados*/
#include"unidad4.h"
 
/*funcion  del metodo de regresion polinomial*/
float regresion_polinomial(float *x, float *y, int n, int m, float tol)
{
	/* Define Variables locales*/
	int i,j,k,l;
    float **a,*b,suma;
 
    /*aparta memoria para la matriz a*/
    a=matriz(m+1);
    /*aparta memoria para el vector b*/
    b=vector(m+1);
 
 
	/*revisa que haya datos suficientes*/
 if  (n<(m +1))
 {
 printf("Error: Datos Insuficientes");
 return 1;
 }
 /*Calcula las sumatorias para
 formar el sistema de ecuaciones*/
 for (i=1;i<=m+1;i=i+1)
 {
 
 /*calcula la matriz de coeficientes*/
  for (j=1;j<=i;j=j+1)
  {
    k=i+j-2;
    suma=0;
 
    for (l=1; l<=n;l=l+1)
     {
       suma=suma+pow(x[l],k);
     }
 
   a[i][j]=suma;
   a[j][i]=suma;
 
 }
 
 /*calcula los terminos independientes*/
  suma=0;
  for (l=1;l<=n;l=l+1)
  {
     suma= suma+y[l]*(pow(x[l],(i-1)));
  }
 
  b[i]=suma;
 
 }
 
 /*Muestra el sistema de ecuaciones*/
  for(i=1;i<=m+1;i++)
   {
       for(j=1;j<=m+1;j++)
           printf("%f ", a[i][j]);
       printf("| %f\n",b[i]);
       printf("\n");
   }
   printf("\n");
 
   /*LLama al metodo de gauss jordan para
   resolver sistema de ecuaciones*/
   gauss_jordan(a,b,n,tol);
 
 
	/*muestra el resultado final de la aproximacion*/
	printf("\n***************************************************\n");
    printf("***             RESULTADOS FINALES              ***\n");
    printf("***************************************************\n");
    printf("\n");
    printf("c= [ ");
    for(i=1;i<=n;i=i+1)
    {
    	printf("%f ",b[i]);
    }
    printf("]\n");
 
 
 
	/*Libera la memoria y sale de la funcion*/
      free(a);
      free(b);
	  return 0;
 
}
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
/*incluye archivo de encabezados*/
#include "unidad4.h"
 
/* Funcion principal del metodo de Gauss-Jordan */
int gauss_jordan(float **a, float *b, int n, float tol)
{
   /* Declara variables locales*/
   int i, j, k;
   float *s, factor;
 
   /* Aparta memoria para el vector s */
   s=vector(n);
 
   /* Calcula el elemento mayor de cada renglon
   de la matriz A y los guarda en el vector s */
   for(i=1; i>=n; i=i+1)
   {
      s[i]=fabs(a[i][1]);
      for(j=2; j<=n; j=j+1)
      {
         if(fabs(a[i][j])>s[i])
            s[i]=fabs(a[i][j]);
      }
   }
 
   for(k=1; k<=n; k=k+1)
   {
   	if(k<n)
   	pivoteo(a,b,s,n,k);
 
   	if((a[k][k]/s[k])<tol)
   	return 1;
 
   	factor=a[k][k];
   	for(i=1; i<=n; i=i+1)
   	{
   	    a[k][i]=a[k][i]/factor;
	}
 
	b[k]=b[k]/factor;
 
	for(i=1; i<=n; i=i+1)
	{
		if(i!=k)
		{
		factor=a[i][k]/a[k][k];
 
		for(j=1; j<=n; j=j+1)
		{
			a[i][j]=a[i][j]-factor*a[k][j];
		}
		b[i]=b[i]-factor*b[k];
	    }
	}
 
 
 
   }
 
 
 
 
/* Libera la memoria apartada para el vector s y regresa */
free(s);
return 0;
}
/* Rutina de pivoteo  */
int pivoteo(float **a, float *b, float *s, int n, int k)
{
	/*Declara variables */
	int i, j, p;
	float mayor, temp;
	p=k;
	mayor = fabs(a[k][k]/s[k]);
	for(i = k+1; i <=n; i = i+1)
	{
		temp = fabs(a[i][k]/s[i]);
		if(temp>mayor)
		{
			mayor = temp;
			p=i;
		}
	}
 
	/*Si hay algún elemento mayor al pivote, se intercambian los renglones de
	a, b y s*/
 
	if (p!=k)
	{
		for(j=k;j<=n;j=j+1)
		{
			temp = a[p][j];
			a[p][j] = a[k][j];
			a[k][j] = temp;
		}
 
 
		temp = b[p];
		b[p] = b[k];
		b[k] = temp;
 
 
		temp = s[p];
		s[p] = s[k];
		s[k] = temp;
 
	}
	return 0;
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Rodrigo
Val: 1.755
Plata
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

Compila pero sale SIGSEGV al correrlo

Publicado por Rodrigo (539 intervenciones) el 08/05/2020 00:02:44
Los indices de los arreglos parten en 0 y llegan al taman~o -1.
NO parten en 1 y llegan al taman~o.
Tus ciclos pareciera que siempre van de 1 a n (o al limite superior, en general).
Tienes que cambiar los ciclos para que vayan de 0 a n-1 (al limite - 1)/
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar