Está en la página 1de 11

EJERCICIO N1

Programar la suma de dos matrices cuadradas de dimensin DIM.


/*Suma de dos matrices cuadradas*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define DIM 100
void leer_matriz(int,float[DIM][DIM]);
void escribir_matriz(int,float[][DIM]);
void suma_matrices (int,float[][DIM],float[][DIM],float[][DIM]);
int main()
{
int n; float x[DIM][DIM], y[DIM][DIM], z[DIM][DIM];
do
{
printf("Introduce la dimension de la matriz (<=100): ");
scanf("%d",&n);
}while ((0>n) || (n>DIM));
printf("\nIntroduce la primera matriz\n");
leer_matriz(n,x);
system("cls");
printf("\nIntroduce la segunda matriz\n");
leer_matriz(n,y);
system("cls");
suma_matrices(n,x,y,z);
printf("\nSuma de las dos matrices:\n");
escribir_matriz(n,z);
system("PAUSE");
return 0;
}
void leer_matriz(int n, float v[][DIM])
{
int i,j;
for(i=0;i<n;i++)
{
printf("\nVamos a introducir la fila %d.\n",i+1);
for(j=0;j<n;j++)
{
printf("Introduce la componente (%d,%d): ",i+1,j+1);
scanf("%f",&v[i][j]);
}

}
}
void escribir_matriz(int n, float v[][DIM])
{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("%12.2f",v[i][j]);
}
printf("\n");
}
}
void suma_matrices (int n,float v1[][DIM],float v2[][DIM],float v3[][DIM])
{
int i,j;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
v3[i][j]=v1[i][j]+v2[i][j];
}

EJERCICIO N2

Lo mismo para el producto de dos matrices cuadradas de dimensin DIM.


/*Producto de dos matrices cuadradas*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define DIM 100
void leer_matriz(int,float[DIM][DIM]);
void escribir_matriz(int,float[][DIM]);
void producto_matrices (int,float[][DIM],float[][DIM],float[][DIM]);
int main()
{
int n; float x[DIM][DIM], y[DIM][DIM], z[DIM][DIM];
do
{
printf("Introduce la dimension de la matriz (<=100): ");
scanf("%d",&n);
} while ((0>n) || (n>DIM));
printf("\nIntroduce la primera matriz\n");
leer_matriz(n,x);
system("cls");
printf("\nIntroduce la segunda matriz\n");
leer_matriz(n,y);
system("cls");
producto_matrices(n,x,y,z);
printf("\nProducto de las dos matrices:\n");
escribir_matriz(n,z);
system("PAUSE");
return 0;
}
void leer_matriz(int n, float v[][DIM])
{
int i,j;
for(i=0;i<n;i++)
{
printf("\nVamos a introducir la fila %d.\n",i+1);
for(j=0;j<n;j++)
{
printf("Introduce la componente (%d,%d): ",i+1,j+1);
scanf("%f",&v[i][j]);
}
}
}

void escribir_matriz(int n, float v[][DIM])


{
int i,j;
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
printf("%12.2f",v[i][j]);
}
printf("\n");
}
}
void producto_matrices (int n,float v1[][DIM],float v2[][DIM],float v3[][DIM])
{
int i,j,k;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
{
v3[i][j]=0;
for(k=1;k<n;k++)
v3[i][j]=v3[i][j]+v1[i][k]*v2[k][j];
}
}

EJERCICIO N3

Escribir un programa que obtenga el determinante de una matriz n*n empleando recursividad. Hay
que darle como entreada el tamao de la matriz (n) y los n*n elementos de la matriz (m[i][j]).
Devuelve el determinante de la matriz.
#include <iostream.h>
#include <alloc.h>
#include <math.h>

double det(double **m, int b){


double determinante = 0, aux = 0;
int c;
if(b==2)
return m[0][0]*m[1][1] - m[1][0]*m[0][1];
else{
for(int j=0; j<b; j++){
double **menor = (double **)malloc(sizeof(double)*(b-1));
for(int h=0; h<(b-1); h++) menor[h] = (double *)malloc(sizeof(double)*(b-1));
for(int k=1; k<b; k++){
c = 0;
for(int l=0; l<b; l++){
if(l!=j){
menor[k-1][c] = m[k][l];
c++;
}
}
}
aux = pow(-1, 2+j)*m[0][j]*det(menor, b-1);
determinante += aux;
for(int q = 0; q<(b-1); q++)

free(menor[q]);
free(menor);
}
return determinante;
}
}

int main(){
int n; // n = numero de renglones = numero de columnas
double **m=NULL;
cout<<"Elija el numero de renglones o columnas que tiene su matriz: ";
cin>>n;

// Se crea la matriz de forma dinamica


m = (double **)malloc(sizeof(double)*n);
for(int i=0; i<n; i++) m[i]=(double *)malloc(sizeof(double)*n);

// Pide el valor de cada elemento de la matriz


for(int y=0; y<n; y++)
for(int w=0; w<n; w++){
cout<<"Introduzca el valor de matriz["<<y<<"]["<<w<<"]: ";
cin>>m[y][w];
}

// Despliego el resultado de la funcion det


cout<<"nDeterminante: "<<det(m, n);

// Libero la memoria utilizada por la matriz


for(int r=0; r<n; r++) free(m[r]);
free(m);

return 0;
}

EJERCICIO N4

Escribir un programa que haga el producto de dos matrices 3x3. El programa debe incluir un
procedimiento que lea las matrices, una funcin que haga el producto y otro procedimiento que
escriba el resultado:
SOLUCIN
#include<cstdlib>
#include<iostream>
using namespace std;
void leermatriz (float m[3][3])
{
int i,j;
for (i=1;i<=3;i++)
{
for (j=1;j<=3;j++)
{
cout<<"introducir el elemento "<<i<<","<<j<<endl;
cin>>m[i][j];
}
}
}
void producto_matrices (float a [3][3],float b[3][3],float p[3][3])
{
int i,j,k;
for (i=1;i<=3;i++)
{
p[i][j]=0;
for (j=1;j<=3;j++)
{
p[i][j]=p[i][j]+a[i][k]*b[k][j];
}
}
}
void escribir_matriz (float m[3][3])
{

int i,j;
for (i=1;i<=3;i++)
{
for (j=1;j<=3;j++)
{
cout<<m[i][j]<<" ";
}
cout<<endl;
}
}
int main()
{
float a[3][3];
leermatriz (a);
leermatriz (b);
producto_matrices (a,b,p);
escribir_matriz (p);

system("PAUSE");
return EXIT_SUCCESS;
}

EJERCICIO N5

Escribir un programa que determine la determinante y inversa de una matriz cualquiera

#include <iostream>
#include <iomanip>
#include <gsl/gsl_linalg.h>
using namespace std;
int main (int argc, char **argv)
{
size_t i,j,m;
// i,j son variables contador, m es el tamao u orden de la matriz
int s; // s es la variable signum de las permutaciones
cout<<"\nIntroduce el orden de la matriz: ";
cin>>m;
// Declaramos las matrices A, p y invA de forma dinmica para as poder
destruirlas
// cuando acabemos con ellas y as; liberar memoria. invA es la inversa y p es
// la permutacin
gsl_matrix * A = gsl_matrix_alloc(m,m);
gsl_permutation * p = gsl_permutation_alloc(m);
gsl_matrix *invA = gsl_matrix_alloc(m,m);
cout<<"\nIntroduce los elementos de la matriz:"<<endl;
for(i=0; i<m*m; i++)
{
cout<<"A("<<i+1<<")"<<"=";
cin>>A->data[i];
}
gsl_linalg_LU_decomp (A, p, &s); //Calculo la descomposicin LU
gsl_linalg_LU_invert(A,p,invA);

// Calculo la inversa de A y la guardo en

invA
// Calculamos y visualizamos por terminal el determinante de A
cout<<"\ndet(A) = "<<gsl_linalg_LU_det(A, s)<<endl;
// Visualizamos por terminal la inversa de A
cout<<"\nLa inversa de A es:"<<endl;
for(i=0; i<m; i++)
{
for(j=0;j<m; j++)
{
cout<<gsl_matrix_get(invA,i,j)<<setw(10);
}
cout<<endl;
}
// Liberamos memoria destruyendo la que ocupan A, p e invA

gsl_matrix_free(A);
gsl_matrix_free(invA);
gsl_permutation_free(p);
return(0);
}