C/Visual C - Determinantes de una matriz ¡El último lo juro!

   
Vista:

Determinantes de una matriz ¡El último lo juro!

Publicado por Yael (6 intervenciones) el 30/11/2013 03:56:04
¿Podrían ayudarme a comenzar un programa en C que calcule la determinante de una matriz?

Ya generé la matriz en memoria dinámica con dobles puntero, nada más que no sé como calcular su determinante. Con librerías stdio.h, stdlib.h y time.h únicamente.

Agradecería cualquier apoyo

¡GRACIAS!
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

Determinantes de una matriz ¡El último lo juro!

Publicado por Chema (187 intervenciones) el 30/11/2013 11:44:31
Muestra el código y si veo que te has esforzado te ayudo.
Despejar dudas SI, hacer los deberes NO.
Por cierto necesito que me expliques qué es el determinante de una matriz.
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

Determinantes de una matriz ¡El último lo juro!

Publicado por Yael (6 intervenciones) el 01/12/2013 03:58:34
Ok! :) entiendo perfectamente. Así debe de ser. Esto es lo que llevo:

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
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
int main(void)
{
	int i, j, ra, ca, rb, cb, rc, cc;
	float *A, **pA, *B, **pB, *C, **pC;
	printf("Ingrese el valor de los renglones A: ");
	scanf("%d", &ra);
	printf("Ingrese el valor de las columnas A: ");
	scanf("%d", &ca);
	printf("Ingrese el valor de los renglones B: ");
	scanf("%d", &rb);
	printf("Ingrese el valor de las columnas B: ");
	scanf("%d", &cb);
	A=(float*)malloc(ra*ca*sizeof(float));
	pA=(float**)malloc(ca*sizeof(float*));
	B=(float*)malloc(rb*cb*sizeof(float));
	pB=(float**)malloc(cb*sizeof(float*));
	C=(float*)malloc(ra*ca*sizeof(float));
	pC=(float**)malloc(ca*sizeof(float*));
//	Liberando memorias en caso de que los valores ingresados sean mayor a las posibilidades de la computadora------------->
	if(A==NULL||pA==NULL||B==NULL||pB==NULL||pC==NULL||C==NULL)
	{
		free(A);
		free(pA);
		free(B);
		free(pB);
		free(pC);
		free(C);
		printf("ERROR: Memoria insuficiente\n");
		return -1;
	}
	for(j=0; j<ca; j++)
		pA[j]=A+j*ra;
	for(j=0; j<cb; j++)
		pB[j]=B+j*rb;
//	Si filas y columnas no son iguales error-------------------------------------------------------->	
	if(ra!=rb||ca!=cb)
	{
		printf("ERROR: Las filas y columnas ingresadas deben ser identicas\n");
		free(A);
		free(pA);
		free(B);
		free(pB);
		return 01;
	}
//	for(j=0; j<cc; j++)
//		pC[j]=C+j*rc;
// 	Llenando matrices (Automático)--------------------------------------------------------------------------------->
/*	for(j=0; j<ca; j++)
		for(i=0; i<ra; i++)
			*(A+j*ra+i)=1.0*(rand)/RAND_MAX;
	for(j=0; j<cb; j++)
		for(i=0; i<rb; i++)
			*(B+j*rb+i)=1.0*(rand)/RAND_MAX;*/
// 	Llenando matrices (Manual)--------------------------------------------------------------------------------->			
	for(j=0; j<ca; j++)
		for(i=0; i<ra; i++)
		{
			printf("A[%d][%d] = ", j+1, i+1);
			scanf("%f", pA+ra*i+j);
		}
	for(j=0; j<cb; j++)
		for(i=0; i<rb; i++)
		{
			printf("B[%d][%d] = ", j+1, i+1);
			scanf("%f", pB+rb*i+j);
		}
//Realizando suma----------------------------------------------------------------------------------------------------->		
/*	for(j=0; j<ca; j++)
		for(i=0; i<ra; i++)
			pC[ra*j+i]=pA[ra*j+i]+pB[ra*j+i];*/
// Imprimiendo resultado---------------------------------------------------------------------------------------------->		
	for(j=0; j<ca; j++)
	{
		for(i=0; i<ra; i++)
			printf("%f\t", pC[ra*i+j]);
		printf("\n");
	}
		printf("%f\n");
	system("PAUSE");
	return 0;
}

El determinante de una matriz es la resolución de la misma a través de reducirla a el determinante básico 2*2, así una determinante de 3*3 tiene puede reducirse a su vez en 3 de 2*2. Una de 4*4 en 12 de 2*2, etc.

Aunque hay quienes también usan otros métodos como: Gauss-Jordan o Sarrus, para resolver estas matrices.
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

Determinantes de una matriz ¡El último lo juro!

Publicado por Chema (187 intervenciones) el 01/12/2013 19:45:48
El código que veo ...... mejor no lo comento


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
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
typedef struct Matrix {
	int column;
	int tuple;
	float **mtx;
}Matrix;
 
Matrix *GetMatrix(int column, int tuple){
	Matrix *matrix;
	int i;
 
	matrix = malloc(sizeof(Matrix));
	matrix->mtx = malloc(column*sizeof(float*));
 
	for(i=0; i <column;i++){
		matrix->mtx[i]=malloc(tuple*sizeof(float));
	}
 
	matrix->column =column;
	matrix->tuple =tuple;
	return matrix;
}
 
void InitRandonMatrix(Matrix *matrix){
	int col, tuple;
	for(col=0; col <matrix->column;col++){
		for(tuple=0; tuple <matrix->tuple;tuple++){
			matrix->mtx[col][tuple] =  (rand() % 10+1);
		}
	}
}
void PrintMatrix(Matrix *matrix){
	int col, tuple;
	for(col=0; col <matrix->column;col++){
		for(tuple=0; tuple <matrix->tuple;tuple++){
			 if(tuple==0)
				printf("\ntupla:=%d    ",col);
			printf("%.0f-",matrix->mtx[col][tuple]);
		}
	}
}
 
void FreeMatrix(Matrix *matrix){
	int tuple;
	for(tuple=0; tuple <matrix->tuple;tuple++){
			free(matrix->mtx[tuple]);
	}
		free(matrix);
}
 
/*
*Aqui el amigo Yel deberá calcular sus determinantes y
*sacar buena nota a mi salud jejejejejejejeje.
*/
 
enum{M_PA=0,M_PB,M_PC};
void SumMatrix(Matrix **matrix) {
	int col, tuple;
	float **pA,  **pB,  **pC;
	pA = matrix[M_PA]->mtx;
	pB = matrix[M_PB]->mtx;
	pC = matrix[M_PC]->mtx;
 
	for(col=0; col <matrix[M_PA]->column;col++){
		for(tuple=0; tuple <matrix[M_PA]->tuple;tuple++){
			printf("%.0f-",pA[col][tuple]);
		}
	}
}
 
 
int main(void){
	int i;
	Matrix **matrix;
	srand (time(NULL));
	matrix =malloc(3*sizeof(Matrix*));
 
	for(i =0; i<3; i++){
		matrix[i] =GetMatrix(12,5);
		InitRandonMatrix(matrix[i]);
	}
 
	SumMatrix(matrix);
	PrintMatrix(matrix[0]);
	PrintMatrix(matrix[1]);
	PrintMatrix(matrix[2]);
 
	for(i =0; i<3; i++){
		FreeMatrix(matrix[i]);
		free(matrix);
	}
 
	return 0;
}
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

Determinantes de una matriz ¡El último lo juro!

Publicado por Chema (187 intervenciones) el 01/12/2013 23:03:19
Un pequeño despiste.... las prisas.
Para liberar totalmente la memoria sustituir

1
2
3
4
5
6
7
8
9
void FreeMatrix(Matrix *matrix){
	int column;
 
	for(column=0; column <matrix->column;column++){
			free(matrix->mtx[column]);
	}
	free(matrix->mtx);
	free(matrix);
}

En Main debe quedar asi.
1
2
3
4
for(i =0; i<3; i++){
		FreeMatrix(matrix[i]);
	}
	free(matrix);

Y ahora si es correcto si usamos Valgrin y comprobamos la memoria:
==2980== HEAP SUMMARY:
==2980== in use at exit: 0 bytes in 0 blocks
==2980== total heap usage: 43 allocs, 43 frees, 1,080 bytes allocated
==2980==
==2980== All heap blocks were freed -- no leaks are possible
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