PROGRAMACIÓN VISUAL

REPORTE DE PRÁCTICA #1

Alumno: Marcus André Menegatti da Costa

Número de Control: 21130040
Carrera: Ing. Electrónica
Profesor: Alejandro Enrique Dzul Lopez

Torreón, Coahuila, 16/09/2022

Semestre: 04.2022
Índice
1. INTRODUCCIÓN ..................................................................................................................... 2
2. ANÁLISIS ................................................................................................................................ 2
 Función menu(): ................................................................................................................ 2
 Función llenar_matriz(): .................................................................................................... 4
 Función traspuesta(): ........................................................................................................ 5
 Función determinante(): ................................................................................................... 6
 Función cofactor(): ............................................................................................................ 7
 Función inversa: ................................................................................................................ 8
 Función escribir_matriz: .................................................................................................... 9
3. CÓDIGO EM C++ .................................................................................................................. 10
4. CONCLUSIÓN ....................................................................................................................... 18

Tabla de Ilustraciones
1. Menu Principal .......................................................................................................................... 3
2. Opción inválida .......................................................................................................................... 3
3. Llenar una matriz A ................................................................................................................... 4
4. Matriz inversa ............................................................................................................................ 4
5. Matriz A ..................................................................................................................................... 5
6. Matriz Traspuesta de A ............................................................................................................. 6
7. Determinante de la matriz A ..................................................................................................... 7
8. Matriz de cofactores de la matriz A .......................................................................................... 8
9. Matriz inversa ............................................................................................................................ 9
10. Presentación del programa ................................................................................................... 17
11. Opción 1 seleccionada........................................................................................................... 17
12. Opción 2 seleccionada........................................................................................................... 17
13. Opción 3 seleccionada........................................................................................................... 18
14. Opción 4 seleecionada .......................................................................................................... 18
15. Opción 5 seleccionada........................................................................................................... 18
 1. INTRODUCCIÓN

El objetivo de la actual práctica es desarrollar un programa en lenguaje C/C++,

en modo consola, con un menú repetitivo y que sea capaz de leer una matriz A,
así como calcular su traspuesta, determinante, cofactores e inversa, y que se
finalice al escoger la opción “salir”.

Para la resolución de este problema, fue utilizado el lenguaje C++, en el

programa Borland C++ Builder 6.

Algunas limitaciones se podrán notar en el algoritmo final del programa

desarrollado. Primeramente, solo se toma en consideración las matrices de
orden 3, es decir, matrices cuadradas que contienen tres renglones y tres
columnas. Se escogió esta particularidad por la complejidad de hacer un
algoritmo general (de orden n) y porque así lo pide el enunciado del problema.
Segundo, el algoritmo no trabaja con formas fraccionarias, por lo que solo
regresará números decimales, si es el caso.

La metodología empleada para la resolución de las matrices fue el uso de

funciones y ciclos for en su mayoría.

2. ANÁLISIS

Para el análisis del código, se tomará función por función para una mejor
organización y compreensión.

Las funciones utilizadas en el programa son: menu(), llenar_matriz(),

traspuesta(), determinante(), cofactor(), inversa() y escribir_matriz().

 Función menu():

Para el menú del programa principal, fue usada una función del tipo vacía
(void) que no regresa valores. Dentro de esta función están definidas las
variables utilizadas por las funciones siguientes y las variables de control.

2
Fue utilizado como ciclo principal del menú el do…while, porque el menú se
debe realizar al menos una vez. Como variable de control de este ciclo fue
usada la variable entera o (de opción), que almacena números enteros. Como
el programa ofrece seis opciones y la última es justamente para salir de él, el
ciclo termina cuando se teclea el número 6, como se puede apreciar en la
imagen abajo.

1. Menu Principal

Dentro del ciclo do…while fue usada la estructura selectiva switch para tener
acceso a las diferentes opciones del menú. La variable de control de switch
es la misma (o). Los valores válidos de o son de 1 a 6. Si el número es
diferente de estos, el programa regresa el siguiente mensaje:

2. Opción inválida

Para control del menú se utilizaron dos variables de control más, b1 y b2.
Estas dos variables son banderas que permiten que el programa siga
funcionando correctamente. Por ejemplo, si la matriz A no fue definida, no se
puede generar ni la traspuesta, ni el determinante, ni la matriz de cofactores,
ni la matriz inversa. Por eso, las variables b1 y b2 recibieron un valor falso (el
cero). Caso la matriz A no es definida, esas funciones permanecerán con el
valor b1 falso y regresarán el mensaje: “Llenar una matriz A!”.

3
 3. Llenar una matriz A

Al generar la matriz A, el valor de b1 cambia a verdadero (1) y permite generar

todas las demás opciones.

Las variable b2 tiene la misma función. La única diferencia es que b2 sirve

para permitir que se genere la matriz inversa de A, puesto que para calcular
la matriz inversa se necesita la matriz de cofactores de A. De este modo, caso
no sea generada la matriz de cofactores, la opción 5 regresará el mensaje:
“Llenar una matriz A o generar la Matriz de Cofactores!”.

4. Matriz inversa

Al final del código de la función menú, se utiliza la función getch(), para

esperar a que el usuario teclee algún carácter, y la función clrscr(), para
limpiar la pantalla, por cuestiones de limpieza y estética.

 Función llenar_matriz():

4
La función llenar_matriz() tiene como objetivo justamente llenar una matriz A.
Es formada por dos ciclos for: uno para los renglones y otro para las
columnas.

Es una función vacía (void) y que genera un arreglo de dos dimensiones tipo
double. Los arreglos, por default, trabajan con llamadas por referencia.

 Función traspuesta():

Para la función traspuesta() se utilizó el tipo void que recibe un arreglo y

genera otro arreglo, ambos tipo double. La función es compuesta por dos
ciclos for y lo que hace es intercambiar filas por columnas. Es decir, si la
matriz A tiene una fila i y una columna j, la traspuesta va a tener una fila j y
columna i.

5. Matriz A

5
 6. Matriz Traspuesta de A

Como apreciado en las imágenes, hubo un cambio de filas por columnas.

 Función determinante():

Para la función determinante() fue utilizada una función del tipo double que
recibe un arreglo del mismo tipo y una variable tipo entera que recibe el orden
de la matriz.

Para la generación del determinante fue usado la estructura selectiva if…else

para saber el orden de la matriz y efectuar el cálculo para su determinante.
Aquí, el orden puede ser tanto 3, como 2.

A pesar de la matriz principal ser de orden 3, se necesita calcular el

determinante de una matriz de orden 2 para la función cofactor(). En el
subtema de este función se explicará el porqué de esto.

Como dicho a principio, el cálculo de los determinantes fue una limitación del
programa, ya que calcula nada más los determinantes de orden 2 y 3. No fue
programado un algoritmo general, de orden n.

La fórmula usada para el cálculo del determinante de orden 2 fue:

𝑑𝑒𝑡 = 𝑎[0][0] ∗ 𝑎[1][1] − (𝑎[0][1] ∗ 𝑎[1][0]).

La fórmula para calcular el determinante de orden 3 fue:

6
 𝑑𝑒𝑡 = 𝑎[0][0] ∗ (𝑎[1][1] ∗ 𝑎[2][2] − 𝑎[1][2] ∗ 𝑎[2][1]) − (𝑎[0][1] ∗ (𝑎[1][0]
∗ 𝑎[2][2] − 𝑎[1][2] ∗ 𝑎[2][0])) + (𝑎[0][2] ∗ (𝑎[1][0] ∗ 𝑎[2][1]
− 𝑎[1][1] ∗ 𝑎[2][0]))
Esta fórmula toma en consideración los cofactores de la matriz 3x3.
Al final del cálculo, la función regresa el valor de det.

7. Determinante de la matriz A

En el ejemplo arriba, el determinante es de la matriz A, escrita en los

ejemplos anteriores.

 Función cofactor():

Para la función cofactor(), fue utilizada una función tipo double que recibe un
arreglo del mismo tipo, tres números enteros y regresa un valor tipo double.
Los enteros requeridos para esta función son el orden, la fila y la columna de
la matriz A.

Esta función genera una matriz menor (matriz de orden n-1). La matriz menor
elimina de la matriz grande un renglón y una columna, definidos por el índice
del elemento que sirve como pivote. Si elemento es de la primera fila y
primera columna, todos los elementos de la primera fila y primera columna
serán eliminados, quedando apenas los elementos de la segunda y tercera
filas y columnas.

Al generar esta matriz menor, la función calcula el determinante de dichas

matrices. Por este motivo, en la función determinante() fue establecido el
cálculo para matrices de orden 2. Como el orden de la matriz grande es 3,
por consiguiente el orden de la matriz menor será n-1=2.

7
Para generar esta matriz de cofactores, en el menú principal fue usado dos
ciclos for para moverse en las filas y columnas de la matriz A, generando, así,
una nueva matriz de cofactores.

Dentro de la función cofactor(), fueron usados dos ciclos for y dos estructuras
selectivas if.

Las estructuras for fueron usadas para recorrer todas las filas y columnas de
la matriz A, mientras que el primer if fue usado para eliminar las filas y
columnas correspondientes a los índices de los elementos. El segundo if es
usado como un ciclo for, que recorre las filas y columnas de la matriz menor.
Al final, es calculado el determinante de cada matriz menor, usando la función
determinante(), y el valor es regresado para un nuevo elemento en una nueva
matriz de cofactores.

8. Matriz de cofactores de la matriz A

Fórmula usada para calcular los determinantes para la matriz de cofactores:

𝑑𝑒𝑡 = (−1) 𝑓𝑖𝑙𝑎+𝑐𝑜𝑙𝑢𝑚𝑛𝑎 ∗ 𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑛𝑡𝑒(𝑚𝑒𝑛𝑜𝑟, 𝑛)
Donde n es el nuevo orden, de la matriz menor.

 Función inversa:

La inversa de una matriz puede ser calculada mediante la fórmula: 𝐴−1 =

1
(𝐴𝐶 )𝑇 , donde 𝐴𝐶 es la matriz de cofactores.
𝑑𝑒𝑡𝐴

8
Por tanto, si se calcula la traspuesta de la matriz de cofactores y se divide
cada uno de sus elementos por el determinante de la matriz A, se obtiene la
matriz inversa.

La función inversa() hace justamente esto. Como el determinante puede valer

cero en algunos casos, la división por cero ocasiona una indeterminación
matemática. Cuando una matriz tiene un determinante igual a cero, quiere
decir que no tiene matriz inversa.

Para estructurar este hecho en el código, se usó la estructura selectiva

if…else para averiguar que si el determinante es igual a cero, la matriz A no
tiene inversa. Caso contrario, se calcula la matriz inversa de la matriz A.

La función inversa es del tipo void, recibe dos arreglos del tipo double y envía
un arreglo tipo double.

De esta forma, la matriz calcula el determinante de la matriz A, traspone la

matriz de cofactores y calcula la nueva matriz inversa.

Como mencionado, la función está hecha por una estructura selectiva if…else
y, además, dos ciclos for para formar la nueva matriz inversa.

Del ejemplo anterior tenemos:

9. Matriz inversa

Como se puede ver, realmente la matriz A no puede tener inversa, ya que su

determinante es cero, como visto anteriormente.

 Función escribir_matriz:

9
 Por último, la función escribir_matriz() tiene como objetivo mostrar en pantalla
como quedó la matriz de orden 3 que se desea ver.

Esta función está formada por dos ciclos for que recorre todos los renglones
y columnas del arreglo y se trata de una función tipo vacía que recibe un
arreglo del tipo double. La función es usada cada vez que se solicite una
matriz. Para que se vea bien estéticamente, fue agregado un tabulador antes
de cada número escrito.

Por fin, se tiene la función principal main() que es donde corre el programa. Como
todas las opciones están en la función menu(), esta es la única que aparece en
la función main().

3. CÓDIGO EM C++

A continuación se mostrará el código de la solución presentada. Se presentarán,

también, algunas imágenes de cómo funciona el programa cuando el
determinante es diferente de cero.

#include <iostream.h>
#include <conio.h>
#include <math.h>
#define R 3
#define C 3

void menu(void);
void llenar_matriz(double [][C]);
void traspuesta(double [][C], double [][C]);
double determinante(double [][C], int);
double cofactor(double [][C], int, int, int);
void inversa (double [][C], double [][C], double [][C]);
void escribir_matriz(double[][C]);

10
void main (void)
{
menu();
}

//------------------------------------------------------
//MENU
//------------------------------------------------------

void menu(void)
{
int o, b1=0, b2=0, ban, b3;
double m[R][C];
double tras[R][C];
double cof[R][C];
double inv[R][C];
double det;
do
{
cout<<"MENU\n1. Llenar una matriz A;\n2. Obtener la
matriz traspuesta de A;\n3. Obtener el determinante de A;\n4. Obtener
la matriz de cofactores de A;\n5. Obtener la matriz inversa de A;\n6.
Salir;\nOpcion: ";
cin>>o;
switch (o)
{
case 1:
llenar_matriz(m);
escribir_matriz(m);
b1=1;
break;

case 2:
{
if (b1)
{
traspuesta(m,tras);

11
 escribir_matriz(tras);
}
else
{
cout<<"Llenar una matriz A!";
}
break;
}

case 3:
if (b1)
{
det = determinante(m, R);
cout<<"Determinante = "<<det;
}
else
{
cout<<"Llenar una matriz A!";
}
break;

case 4:
if (b1)
{
for(int i=0;i<R;i++)
{
for (int j=0;j<C;j++)
{
cof[i][j]=cofactor(m, R, i, j);
}
}
escribir_matriz(cof);
b2=1;
}
else
{

12
 cout<<"Llenar una matriz A!";
}
break;

case 5:
if (b1 && b2)
{
inversa(cof,inv,m);
}
else
{
cout<<"Llenar una matriz A o generar la
Matriz de Cofactores!";
}
break;

case 6:
break;

default:
cout<<"Elegir opcion valida!";
break;
}
getch();
clrscr();
}while(o!=6);
}

//------------------------------------------------------
//LLENAR LA MATRIZ A
//------------------------------------------------------

void llenar_matriz(double a[][C])

{
for (int i=0;i<R;i++)
{
for (int j=0;j<C;j++)

13
 {
cout<<"A["<<i+1<<"]["<<j+1<<"] = ";
cin>>a[i][j];
}
}
}
//------------------------------------------------------
//TRASPUESTA DE LA MATRIZ A
//------------------------------------------------------
void traspuesta(double a[][C], double b[][C])
{
for (int i=0;i<R;i++)
{
for(int j=0;j<C;j++)
{
b[j][i] = a[i][j];
}
}
}
//------------------------------------------------------
//DETERMINANTE DE LA MATRIZ A
//------------------------------------------------------
double determinante(double a[R][C], int orden)
{
double det=0.0;
if (orden==R-1)
{
det=a[0][0]*a[1][1]-(a[0][1]*a[1][0]);
}
else
{
det=a[0][0]*(a[1][1]*a[2][2]-a[1][2]*a[2][1])-
(a[0][1]*(a[1][0]*a[2][2]-a[1][2]*a[2][0]))+(a[0][2]*(a[1][0]*a[2][1]-
a[1][1]*a[2][0]));
}
return det;
}

14
//------------------------------------------------------
//COFACTOR DE LA MATRIZ A

double cofactor(double a[][C], int orden, int fila, int columna)

{
double menor[R][C];
double det;
int n=orden-1;
int x=0, y=0, i, j;
for (i=0;i<orden;i++)
{
for(j=0;j<orden;j++)
{
if(i!=fila && j!=columna)
{
menor[x][y]=a[i][j];
y++;
if(y>=n)
{
x++;
y=0;
}
}
}
}
det = pow((-1),(fila+columna))*determinante(menor,n);
return det;
}
//------------------------------------------------------
//COFACTOR DE LA MATRIZ A
//------------------------------------------------------
void inversa (double a[][C], double b[][C], double c[][C])
{
double det;
det = determinante(c,R);
traspuesta(a,b);

15
 if (det!=0)
{
for (int i=0;i<R;i++)
{
for (int j=0;j<C;j++)
b[i][j]=b[i][j]/det;
}
escribir_matriz(b);
}
else
{
cout<<"La matriz no tiene inversa!";
}
}
//------------------------------------------------------
//ESCRIBIR LA MATRIZ A
//------------------------------------------------------

void escribir_matriz(double a[][C])

{
cout<<"\nMATRIZ:\n";
for (int i=0;i<R;i++)
{
for (int j=0;j<C;j++)
{
cout<<"\t"<<a[i][j];
}
cout<<endl;
}
}

16
10. Presentación del programa

11. Opción 1 seleccionada

12. Opción 2 seleccionada

17
 13. Opción 3 seleccionada

14. Opción 4 seleecionada

15. Opción 5 seleccionada

4. CONCLUSIÓN

A pesar de la limitación cuanto al número de orden, el algoritmo está bien

diseñado para operar en las cuatro opciones que ofrece el programa. El uso de
funciones hace que el programa se vea más ordenado y de fácil manipulación.
El cálculo de matrices es una tarea muy laboriosa de hacer “a mano”. Por esta

18
razón es importante desarrollar maneras computacionales de resolver estos
tipos de problemas.

El uso de ciclos es esencial para que el programa funcione. El uso de estructuras

selectivas es esencial para que el programa esté “protegido” contra posibles
erros o indefiniciones matemáticas.

El conocimiento matemático, más allá del conocimiento en programación,

también es algo requerido. Sin esto, no es posible programar una calculadora de
matrices.

19