public void restarle(Matriz m)
{
for (int i = 0; i < this.matriz.GetLength(0); i++)
{
for (int j = 0; j < this.matriz.GetLength(1); j++)
{
this.matriz[i, j] -= m.matriz[i, j];
}
}
}
static void Main(string[] args)
{
Matriz ma = new Matriz();
ma.Cargar();
ma.CalcularSumaSueldos();
ma.ImprimirTotalPagado();
ma.EmpleadoMayorSueldo();
Console.ReadKey();
}
// Funcion para obtener una matriz identidad.
// Recibe como parametro el numero de filas y
// columnas de la matriz identidad deseada.
public static Matriz Identity(int n)
{
Matriz I = new Matriz(n);
for (int i = 0; i < I.rows; i++)
{
I.Append(i, i, 1);
}
return(I);
}
//fin del metodo mostrar
public static Matriz operator +(Matriz m1, Matriz m2)
{
Matriz o1 = new Matriz();
for (int i = 0; i < o1.n; i++)
{
for (int j = 0; j < o1.n; j++)
{
o1.v[i, j] = m1.v[i, j] + m2.v[i, j];
}
}
return(o1);
}
// Funcion que devuelve la transpuesta de una matriz
public Matriz Transpose()
{
Matriz T = new Matriz(columns, rows);
for (int i = 0; i < T.rows; i++)
{
for (int j = 0; j < T.columns; j++)
{
T.Append(i, j, Get(j, i));
}
}
return(T);
}
// Funcion para obtener una copia del
// objeto Matriz.
public Matriz Copy()
{
Matriz copy = new Matriz(rows, columns);
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
copy.Append(i, j, matriz[i, j]);
}
}
return(copy);
}
//Método que obtiene la matriz diagonal de otra matriz dada
public static Matriz DiagonalNormal(Matriz A)
{
Matriz Resultado = new Matriz(4, 4); //Instaciamos una matriz de 4x4
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (j == i)
{
Resultado.Append(i, j, A.Get(i, j)); //Obtenemos los valores de la diagonal
}
}
}
return(Resultado); //Retornamos la matriz diagonal
}
// Funcion que recibe como parametro un objeto
// de la clase Matriz y se suman los valores de
// ambas matrices.
public void Add(Matriz B)
{
if (rows == B.rows && columns == B.columns)
{
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
matriz[i, j] += B.Get(i, j);
}
}
}
else
{
Console.WriteLine("\nError: Las matrices no son cuadradas, no se pueden sumar ):");
}
}
// Funcion para calcular la matriz triangular superior.
public static Matriz Triangular(Matriz A)
{
// Matriz resultante
Matriz B = A.Copy();
for (int i = 0; i < B.rows; i++)
{
for (int j = 0; j < B.columns - 1; j++)
{
// Se realizan las operaciones de acuerdo
// a la diagonal de la matriz.
if (i == j && B.Get(i, j) != 0)
{
// Se colocan ceros abajo de cada valor de
// la diagonal.
for (int k = i + 1; k < B.rows; k++)
{
// Vector que guardará el resultado
// de la operacion entre reglones.
Vector result;
// Obtengo la fila de la matriz
Vector row = B.Get(i);
// Fila en donde se colocará un cero.
Vector nextRow = B.Get(k);
// Se realiza la operacion
row.Mult(-1 * B.Get(k, j) / B.Get(i, j));
result = Vector.Add(row, nextRow);
//Console.Write($"\n{-1*B.Get(k, j)}/{B.Get(i, j)} * R[{i}] + R[{k}] = ");
//result.Print();
// Se insertan los nuevos valores de la fila
// de la matriz.
B.Insert(result, k);
//Console.WriteLine("\n Resultado Matriz = \n");
//B.Print();
}
}
}
}
// Se devuelve la matriz triangular
return(B);
}
// Funcion que devuelve la matriz dominante
public static Matriz Dominante(Matriz A)
{
Matriz Resultado = A; //Instaciamos una matriz de resultados
double dd = 0, suma, aux = 0, may = 0; //Declaramos variables
int ind = 0;
for (int k = 0; k < 4; k++)
{
may = Math.Abs(Resultado.Get(k, k)); //Se declara el mayor en función de la diagonal
for (int l = k + 1; l < 4; l++)
{
if (may < Math.Abs(Resultado.Get(l, k))) //Busca el valor mayor de cada fila de la columna dada
{
may = Math.Abs(Resultado.Get(l, k));
ind = l; //Guardamos el indice del mayor
}
}
suma = 0;
for (int j = 0; j < 4; j++)
{
if (k == j)
{
dd = Math.Abs(Resultado.Get(k, j)); //Obtenemos el mayor de cada fila
}
else
{
suma = suma + Math.Abs(Resultado.Get(k, j)); //Sumatoria de los valores restantes de la fila
}
}
if (dd < suma) //Criterio de convergencia
{
for (int i = 0; i < 4; i++)
{
aux = Resultado.Get(k, i); //Canbiamos los valores entre las filas
Resultado.Append(k, i, Resultado.Get(ind, i));
Resultado.Append(ind, i, aux);
}
}
}
return(Resultado);
}//Fin método dominante
static void Main(string[] args)
{
Matriz A = new Matriz(2, 3);
for (int i = 0; i < 6; i++)
{
A.SetElemento(i / 3, i % 3, (i + 1) / 3.0);
}
Console.WriteLine("Impresión de la matriz A");
A.imprimir("0.000");
double[,] aux = new double[, ] {
{ 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 }
};
Matriz B = new Matriz(aux);
Console.WriteLine("\nImpresión de la matriz B");
B.imprimir();
Console.WriteLine("\nAcceso al elemento B[1,2]={0}", B.GetElemento(1, 2));
Console.Write("\nfila 1 de A: ");
foreach (double d in A.GetFila(1))
{
Console.Write("{0:0.0} ", d);
}
Console.Write("\n\nColumna 0 de B: ");
foreach (double d in B.GetColumna(0))
{
Console.Write("{0} ", d);
}
Console.Write("\n\nDiagonal principal de B: ");
foreach (double d in B.GetDiagonalPrincipal())
{
Console.Write("{0} ", d);
}
Console.Write("\n\nDiagonal secundaria de B: ");
foreach (double d in B.GetDiagonalSecundaria())
{
Console.Write("{0} ", d);
}
A.multiplicarPor(B);
Console.WriteLine("\n\nA multiplicado por B");
A.imprimir();
Console.WriteLine("Presione cualquier tecla para finalizar...");
Console.ReadKey();
}
public void multiplicarPor(Matriz m)
{
double total;
Matriz matriz_aux = new Matriz(this.matriz.GetLength(0), this.matriz.GetLength(1));
for (int i = 0; i < this.matriz.GetLength(0); i++)
{
for (int j = 0; j < this.matriz.GetLength(1); j++)
{
total = 0;
for (int k = 0; k < this.matriz.GetLength(1); k++)
{
total = total + (this.matriz[i, k] * m.matriz[k, j]);
}
matriz_aux.matriz[i, j] = total;
}
}
this.matriz = matriz_aux.matriz;
}
// Método que retorna la diagonal inversa de una matriz
public static Matriz Diagonal(Matriz A)
{
Matriz Resultado = new Matriz(A.rows, A.columns); //Instaciamos una matriz de n x n
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
if (j != i) //Busca que el valor de la fila sea el mismo que la columna
{
Resultado.Append(i, j, 0); //De ser así, asignamos el valor cero
}
else
{
Resultado.Append(i, j, 1 / A.Get(i, j)); //De no ser asi asignamos la inversa de la matriz, cumpliendo que (A^-1) * (A) = I
}
}
}
return(Resultado); //Retorna la matriz del resultado
}
//Método que devuelve una matriz triangular inferior
public static Matriz TriangularInferior(Matriz A)
{
Matriz Resultado = new Matriz(A.rows, A.columns); //Instaciamos una matriz de n x n
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++) //Busca que el valor de la columna sea mayor que el de la fila
{
if (j > i)
{
Resultado.Append(i, j, 0); //De ser así, asignamos el valor cero
}
else
{
Resultado.Append(i, j, A.Get(i, j)); //De no cumplirse, asignamos el valor que contiene en esa posición
}
}
}
return(Resultado); //Retornamos el valor de matriz resultado
}
// Funcion para obtener una matriz identidad.
// Recibe como parametro el numero de filas y
// columnas de la matriz identidad deseada.
public static Matriz Combine(Matriz A, Matriz B)
{
Matriz AB = new Matriz(A.rows, A.columns * 2);
for (int i = 0; i < AB.rows; i++)
{
for (int j = 0; j < AB.columns; j++)
{
if (j >= AB.columns / 2)
{
AB.Append(i, j, B.Get(i, j % A.columns));
}
else
{
AB.Append(i, j, A.Get(i, j));
}
}
}
return(AB);
}
public static void Main(string[] args)
{
Matriz m1 = new Matriz();
Console.WriteLine("Datos de la matriz m1");
m1.cargar();
Console.WriteLine("Matriz m1");
m1.mostrar();
Console.WriteLine("Datos de la matriz m1");
Matriz m2 = new Matriz();
m2.cargar();
Console.WriteLine("Matriz m2");
m2.mostrar();
Matriz m3;
m3 = m1 + m2;
Console.WriteLine("Resultado de la suma de m1 y m2");
m3.mostrar();
Console.ReadKey();
}
public static Matriz Inverse(Matriz A)
{
if (A.rows == A.columns)
{
if (Matriz.Determinant(A) != 0)
{
// Agrego a la matriz una matriz identidad
Matriz B = Combine(A, Matriz.Identity(A.rows));
// Creo la matriz que guardará la matriz inversa
Matriz inverse = new Matriz(A.rows, A.columns);
// Se realiza la eliminacion por Gauss-Jordan
B = Matriz.GaussJordan(B);
// Se extrae solo la matriz identidad que
// fue agregada a la matriz. Esta tendrá
// los valores de la matriz inversa.
for (int i = 0; i < B.rows; i++)
{
for (int j = B.columns / 2; j < B.columns; j++)
{
inverse.Append(i, j % A.columns, B.Get(i, j));
}
}
return(inverse);
}
else
{
Console.WriteLine("Error: el determinante de la matriz es 0 ):");
return(null);
}
}
else
{
Console.WriteLine("Error: la matriz no es cuadrada ):");
return(null);
}
}
// Funcion que recibe como parametros dos matrices
// A y B. Devuelve la suma de ambas.
public static Matriz Add(Matriz A, Matriz B)
{
if (A.rows == B.rows && A.columns == B.columns)
{
// Matriz que guardará el resultado de la suma
Matriz C = new Matriz(A.rows, B.columns);
for (int i = 0; i < A.rows; i++)
{
for (int j = 0; j < A.columns; j++)
{
C.matriz[i, j] = A.Get(i, j) + B.Get(i, j);
}
}
return(C);
}
else
{
Console.WriteLine("\nError: Las matrices no son cuadradas, no se pueden sumar ):");
return(null);
}
}
// Funcion que recibe como parametros dos matrices
// A y B. Devuelve la multiplicación de ambas. 3 x 3 - 3 x 1
public static Vector Mult(Matriz A, Vector B)
{
if (A.columns == B.len)
{
Vector C = new Vector(A.rows);
for (int i = 0; i < A.rows; i++)
{
double sum = 0;
for (int j = 0; j < A.columns; j++)
{
sum += A.Get(i, j) * B.vector[j];
}
C.vector[i] = sum;
}
return(C);
}
else
{
Console.WriteLine("\nError: La cantidad de columnas de la matriz debe ser igual a la cnatidad de elementos del vector.");
return(null);
}
}
// Metodo de eliminacion de Gauss-Jordan
public static Matriz GaussJordan(Matriz A)
{
// Matriz resultante
Matriz B = A.Copy();
for (int i = 0; i < B.rows; i++)
{
for (int j = 0; j < B.columns; j++)
{
// Se realizan las operaciones de acuerdo
// a la diagonal de la matriz.
if (i == j)
{
if (B.Get(i, j) != 1)
{
// Si el elemento en la diagonal es un 0
// se intercambia el renglon por otro.
if (B.Get(i, j) == 0)
{
for (int f = i; f < B.rows; f++)
{
if (B.Get(f, j) == 1 || B.Get(f, j) != 0)
{
//Console.WriteLine("\nSe intercambian renglones");
//Console.Write($"\nR[{i}] -> R[{f}]");
//Console.WriteLine("\nResultado: \n");
Vector aux = B.Get(i);
B.Insert(B.Get(f), i);
B.Insert(aux, f);
//B.Print();
break;
}
}
}
// Se obtiene la fila de la matriz
Vector row = B.Get(i);
//Console.Write($"\nR[{i}]/{B.Get(i, j)} = ");
// Se divide el valor de la diagonal
// entre si mismo para obtener un pivote.
row.Div(B.Get(i, j));
//row.Print();
// Se insertan los nuevos valore de
// la fila a la matriz.
B.Insert(row, i);
//B.Print();
}
// Se colocan ceros arriba y abajo de cada
//valor de la diagonal de la matriz
for (int k = 1; k < B.rows; k++)
{
// Si el valor que está debajo o arriba
// del valor de la diagonal es diferente
// de cero, se realizan las operaciones
// entre renglones para obtener un cero.
if (B.Get((i + k) % B.rows, j) != 0)
{
// Vector que guardará el resultado
// de la operacion entre reglones.
Vector result;
// Obtengo la fila de la matriz
Vector row = B.Get(i);
// Fila en donde se colocará un cero.
Vector nextRow = B.Get((i + k) % B.rows);
// Se realiza la operacion
row.Mult(-1 * B.Get((i + k) % B.rows, j));
result = Vector.Add(row, nextRow);
//Console.Write($"\n-{B.Get((i + k) % B.rows, j)} * R[{i}] + R[{(i + k) % B.rows}] = ");
//result.Print();
// Se insertan los nuevos valores de la fila
// de la matriz.
B.Insert(result, (i + k) % B.rows);
//Console.WriteLine("\n Resultado Matriz = \n");
//B.Print();
}
}
}
}
}
return(B);
}
private void btnCreate_Click(object sender, EventArgs e)
{
matriz = new Matriz(Convert.ToInt32(txtSize.Text));
}
public Form1()
{
InitializeComponent();
matriz = new Matriz(5, 5);
}
