UNIVERSIDAD NACIONAL DE CAJAMARCA

FACULTAD DE EDUCACION
ESPECIALIDAD MATEMATICA E INFORMATICA

TITULO

DETERMINANTE DE UNA MATRIZ

ASIGNATURA:

ESTRUCTURA DE DATOS

ALGORITMOS II

ALUMNO:

SALAZAR BERNARDO, JHEINER

VASQUEZ AGUILAR, ZULY MALU

JARA MARIN OSMER

CICLO:

VI

2018 – Cajamarca
 INTRODUCCIÓN

El presente informe desarrollaremos el tema de determinante de una matriz a través de ejemplos

prácticos sabiendo que una matriz es una estructura de datos que contiene un número de
variables a las que se accede mediante índices calculados. Las variables contenidas en una
matriz, denominadas también elementos de la matriz, son todas del mismo tipo y este tipo se
conoce como tipo de elemento de la matriz.

Los tipos de matriz son tipos de referencia, y la declaración de una variable de matriz
simplemente establece un espacio reservado para una referencia a una instancia de matriz. Las
instancias de matriz reales se crean dinámicamente en tiempo de ejecución mediante el operador
new. La nueva operación especifica la longitud de la nueva instancia de matriz, que luego se
fija para la vigencia de la instancia. Los índices de los elementos de una matriz van de 0 a
Length.
 DETERMINANTE DE UNA MATRIZ

DEFINICIÓN DE UNA MATRIZ

Hay varias maneras de implementar una matriz en C#. El enfoque tradicional y el que se usa en
este artículo, es utilizar una matriz de matrices, a veces llamado una matriz escalonada. Por
ejemplo, este código define una matriz con tres filas y dos columnas:

A diferencia de la mayoría de los lenguajes programación, C# tiene un tipo de matriz

multidimensional integrado, que proporciona un enfoque alternativo. Por ejemplo:

Un tercer enfoque para implementar matrices en C# es utilizar una sola matriz combinada con
la manipulación del índice de matriz, como este:

Sin importar el esquema de almacenamiento utilizado, matrices pueden implementarse usando

un enfoque de método estático o una programación orientada a objetos. Por ejemplo, podría
parecerse un enfoque de programación orientada a objetos:
No hay sola mejor opción para el diseño de la matriz; el mejor diseño depende de la situación
particular de codificación en que está operando y sobre sus preferencias de codificación. Este
artículo utiliza un método estático porque es el más fácil de entender y refactorizar.

Cuando se utiliza un diseño de matriz de matrices de matrices, porque cada fila debe asignarse
por separado, a menudo es conveniente definir un método auxiliar para realizar la asignación
de memoria. Por ejemplo:

El método puede ser llamado como tal:

 DETERMINANTE DE UNA MATRIZ

Sea A una matriz cuadrada; asociada a esa matriz hay un número llamado determinante, que se
simboliza por |A| o det(A) y que se calcula de la siguiente forma:

El método determinantorder2():
Este método es muy sencillo lo cual no es necesario explicar nada. (Revisen arriba como se
calcula el determinante de orden 2).

Si el orden de A es 2 el determinante es el producto de los elementos de la diagonal principal

menos el producto de los elementos de la diagonal secundaria:

Código

static int DeterminantOrder2(int[,] matrix)

return (matrix[0, 0] * matrix[1, 1]) - (matrix[0, 1] * matrix[1, 0]);

El método determinatrec():

viene a ser "el más complicado", porque no es más que una representación en código de la
ecuación que les presenté antes para calcular el determinante de orden mayor que 2.

1. static int DeterminantRec(int[,] matrix)

2. {
3. //Caso de parada que sea de orden 2 y lo calculamos con el método para
4. //el determinante de orden 2
5. if (matrix.GetLength(0) == 2)
6. {
7. return DeterminantOrder2(matrix);
8. }
9. else
10. {
11. int det = 0; //Inicializamos una variable para almacenar el valor del determinante
12.
13. //En este ciclo recorremos una fila para para obtener el adjunto de cada elemento
14. //de esta fila así calcular el determinante de este fijando cada elemento de la fila
15. //0
16. for (int i = 0; i < matrix.GetLength(1); i++)
17. {
18. //Creamos una matriz para rellenarla con la matriz para luego calcular su
19. //determinante llamando recursivo. Esta matriz tiene un orden menor (en una
20. //unidad) que la matriz original
21. int[,] minor = new int[matrix.GetLength(0) - 1, matrix.GetLength(1) - 1];
22.
23. //Aquí llamamos al método auxiliar que se encarga de rellenar la matriz auxiliar
24. FillMatrix(matrix, minor, 0, i);
25.
26. //Aquí lo que vamos a definir si lo que se hace es sumar o restar. Esto es una
27. //manera de representar el cambio de signo que trae consigo el (-1) elevado a
28. //i+j. En este caso como utilizamos la fila 0 siempre, ese número va a ser
29. //positivo solo cuando estemos en una columna (j) que sea par, negativo en
30. //caso contrario
31. if (i % 2 == 0)
32. //Aquí lo que hacemos es multiplicar el valor del elemento en cuestión
33. //por el adjunto teniendo en cuenta el signo correspondiente y se lo
34. //sumamos a la variable det (en el else es lo mismo lo que con el signo
35. //negativo). Aquí es donde está la llamada recursiva pues hay que calcular el
36. //determinante de la matriz "minor"
37. det+= (matrix[0, i]) * (DeterminantRec(minor));
38. else
39. det+= (-matrix[0, i]) * (DeterminantRec(minor));
40. }
41.
42. //Una vez que ya recorrimos toda la fila, devolvemos el determinante
43. return det;
44. }
45. }
El método fillmatrix():

Este método recibe la matriz desde la cual se van a sacar los valores, la matriz donde se van a
copiar (de un orden menor en una unidad), la fila y la columna que se va a eliminar:

Código
static void FillMatrix(int[,] matrix, int[,] toFill, int row, int column)
{
//Ciclo anidado para recorrer la matriz desde la cual se van a sacar los valores
for (int i = 0; i < matrix.GetLength(0); i++)
{
for (int j = 0; j < matrix.GetLength(1); j++)
{//Si estamos en una fila menor a la que se va a eliminar
if (i < row)
{//Si estamos en una columna menor a la que se va a eliminar
if (j < column)
toFill[i, j] = matrix[i, j]; //Copiamos el valor normalmente
else
if (j > column) //En este momento estamos en una fila menor a la que se va a
//eliminar pero por encima de la columna a eliminar, por lo tanto
//se saca el valor de la matriz y se coloca en una columna con una
//unidad menos (j-1)
toFill[i, j - 1] = matrix[i, j];
else //Si estamos en una fila mayor a la que se va a eliminar
if (i > row)
{
//Si estamos en una columna mayor a la que se va a eliminar
if (j < column)
//En este momento estamos por encima de la fila a eliminar pero por debajo
//de la columna a eliminar, por lo tanto tenemos que quitarle una unidad a la fila//(i-1)
toFill[i - 1, j] = matrix[i, j];
else
if (j > column)
//Aquí estamos por encima tanto de la fila como de la columna a eliminar por lo
//tanto le quitamos una unidad tanto a las filas como a la columna (i-1, j-1)
toFill[i - 1, j - 1] = matrix[i, j];
}
}
}
}
Ejemplo práctico

Código en C# que dada una matriz de 3x3 encuentra el determinante de la misma utilizando el
método de Sarrus, aclaro que está hecho de la forma más simple posible y en modo de consola,
sin más rodeos aquí el código:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ejemplo
{
class Program
{
static void Main(string[] args)
{

//declaramos un arreglo de enteros en este caso de 3x3

int[,] matriz = new int[3, 3];
for (int i = 0; i < 3; i++) //para llenar el arreglo
{
for (int j = 0; j < 3; j++)
{
Console.WriteLine("Escribe el número correspondiente a la posición
{0},{1}", i + 1, j + 1);
matriz[i, j] = int.Parse(Console.ReadLine());
}
} //terminamos de llenar la matriz
//empezamos sarrus, super simple nada de complicaciones
//lo hacemos con la formula directamente
//diagonal principal - diagonal inversa
int sarrus = 7;
sarrus = ((matriz[0, 0] * matriz[1, 1] * matriz[2, 2]) + (matriz[1, 0] * matriz[2,
1] * matriz[0, 2]) + (matriz[0, 1] * matriz[1, 2] * matriz[2, 0])) - ((matriz[0, 2] *
matriz[1, 1] * matriz[2, 0]) + (matriz[0, 1] * matriz[1, 0] * matriz[2, 2]) + (matriz[1, 2]
* matriz[2, 1] * matriz[0, 0]));
//imprimimos el resultado
Console.WriteLine("EL determinante de la matriz es: {0}", sarrus);
Console.ReadKey(); //para que quede esperando y podamos ver el resultado

}
}
}
Conclusiones

 Para la solución de ejercicios en c Sharp es necesario saber la teoría y aplicación de

determinantes de una matriz.
 Este programa nos permite obtener el determinante de una matriz de la forma
(nxn, nxm,) empleando los diferentes algoritmos para cada una de ellas .
 Es necesario saber que el calculo de la matriz nxn nos permite saber si esta es invertible.
sí cero no tiene inversa y entonces podemos programar una excepción para ejecutar el
código para el cálculo de inversa.