Clase Matriz

CLASE MATRIZ

class Matriz
{
private float[,] matriz;
private int filas, columnas;

public Matriz()
{

}

public Matriz(int f, int c)
{
filas = f;
columnas = c;
matriz = new float[filas, columnas];
}

//Método
public void leer()
{
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
Console.WriteLine("Ingrese el valor :[" + i + ", " + j + "]");
matriz[i - 1, j - 1] = Convert.ToInt32(Console.ReadLine());
}
}
}

public override string ToString()
{
return imprimir();
}

public static Matriz operator +(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] + m2.matriz[i - 1, j - 1];
}
}
}
return aux;
}
// Método para multiplicar las matrices
public static Matriz operator *(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
int cont, cont1;
Matriz aux = new Matriz(fm1, cm2);
if (cm1 == fm2)
{
int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
for (k = 0; k < cm1; k++)
{
aux.matriz[i, j] = aux.matriz[i, j] + (m1.matriz[i, k] * m2.matriz[k, j]);
}
}
}
}
return aux;
}

public static Matriz operator *(int n, Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;

int cont, cont1;
Matriz aux = new Matriz(fm1, cm1);

int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] * n;
}
}
return aux;
}
public static Matriz operator -(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] - m2.matriz[i - 1, j - 1];
}
}
}
return aux;
}

public float determinante(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
float aux=1;
float aux1 = 1,aux2=1,det=0;

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
if (i == j)
{
aux = m1.matriz[i,j];
aux1 = aux * aux1;
}
else {
aux = m1.matriz[i,j];
aux2 = aux * aux2;
}
}
}
det = aux1 - aux2;
return det;
}

public Matriz Inversa(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(fm1, cm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] / determinante(m1);
}
}
return aux;
}

public Matriz Transpuesta(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(cm1, fm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[j, i] = m1.matriz[i, j];
}
}
return aux;
}

public string imprime()
{
string cad = "", cad1 = "", cad2 = "";
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
cad = "" + matriz[i - 1, j - 1] + "\t";
cad1 = cad1 + cad;
}
cad1 = cad1 + "\n";
cad2 = cad2 + cad1;
}
return cad1;
}
}
}

Clase Matriz(C# con sobrecarga de operadores)

using System;
using System.Collections.Generic;
using System.Text;
namespace Operadores{

class Matriz {
private float[,] matriz;
private int filas, columnas;

public Matriz() {
}

public Matriz(int fila, int columna) {
filas = fila;
columnas = columna;
matriz = new float[filas, columnas];
}

public void leer()
{
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
Console.WriteLine("Ingrese el valor en la posicion [" + i + ", " + j + "]");
matriz[i - 1, j - 1] = Convert.ToInt32(Console.ReadLine());
}
}
}

public override string ToString()
{
return imprime_matriz();
}

public static Matriz operator +(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] + m2.matriz[i - 1, j- 1];
}
}
}
return aux;
}

public static Matriz operator *(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
int cont, cont1;
Matriz aux = new Matriz(fm1, cm2);
if (cm1 == fm2)
{
int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
for (k = 0; k < cm1; k++)
{
aux.matriz[i, j] = aux.matriz[i, j] + (m1.matriz[i, k] * m2.matriz[k, j]);
}
}
}
}
return aux;
}

public static Matriz operator *(int n, Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int cont, cont1;
Matriz aux = new Matriz(fm1, cm1);
int i, j, k;
for (i = 0; i < aux.filas; i++)
{
cont1 = 0;
for (j = 0; j < aux.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] * n;
}
}
return aux;
}

public static Matriz operator -(Matriz m1, Matriz m2)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
int fm2 = m2.filas;
int cm2 = m2.columnas;
Matriz aux = new Matriz(fm1, cm1);
if ((fm1 == fm2) && (cm1 == cm2))
{
for (int i = 1; i <= aux.filas; i++)
{
for (int j = 1; j <= aux.columnas; j++)
{
aux.matriz[i - 1, j - 1] = m1.matriz[i - 1, j - 1] - m2.matriz[i - 1, j - 1];
}
}
}
return aux;
}

public float determinante(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
float aux=1;
float aux1 = 1,aux2=1,det=0;
for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
if (i == j)
{
aux = m1.matriz[i,j];
aux1 = aux * aux1;
}
else {
aux = m1.matriz[i,j];
aux2 = aux * aux2;
}
}
}
det = aux1 - aux2;
return det;
}

public Matriz Inversa(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(fm1, cm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[i, j] = m1.matriz[i, j] / determinante(m1);
}
}
return aux;
}

public Matriz Transpuesta(Matriz m1)
{
int fm1 = m1.filas;
int cm1 = m1.columnas;
Matriz aux = new Matriz(cm1, fm1);

for (int i = 0; i < m1.filas; i++)
{
for (int j = 0; j < m1.columnas; j++)
{
aux.matriz[j, i] = m1.matriz[i, j];
}
}
return aux;
}

public string imprime_matriz()
{
string cad = "", cad1 = "", cad2 = "";
for (int i = 1; i <= filas; i++)
{
for (int j = 1; j <= columnas; j++)
{
cad = "" + matriz[i - 1, j - 1] + "\t";
cad1 = cad1 + cad;
}
cad1 = cad1 + "\n";
cad2 = cad2 + cad1;
}
return cad1;
}
}
}

Clase Matriz (C#)

using System;
using System.Collections.Generic;
using System.Text;
namespace Matriz
{
public class clsMatriz
{
public float[,] mat = new float[10, 10];
public int limf, limc;
public float deter;

public clsMatriz()
{
for (int i = 0; i < j =" 0;" deter =" 0;">
public void leer()
{
do
{
Console .WriteLine ("De cuantas filas desea la matriz? ingrese un valor max de 10\t");
limf = Convert.ToInt32(Console.ReadLine());
} while (limf <= 0 limf > 10);
do
{
Console.WriteLine("De cuantas columnas desea la matriz? ingrese un valor max de 10\t");
limc = Convert.ToInt32(Console.ReadLine());
} while (limc <= 0 limc > 10);

for (int i = 0; i < limf; i++)
for (int j = 0; j < limc; j++)
{
Console.WriteLine("Ingrese el elemento de la fila"+(i + 1)+"de la columna"+(j + 1) +"\t");
mat[i,j]=Convert .ToInt32(Console.ReadLine());
}
}

public void Escribe()
{
string aux="";
for (int i = 0; i < this.limf; i++)
{
for (int j = 0; j < this.limc; j++)
aux = aux + this.mat[i, j] + "\t";
aux = aux + "\n";
}
Console.Write(aux);
}


public static clsMatriz operator +(clsMatriz m1, clsMatriz m2)
{
clsMatriz m3 = new clsMatriz();
m3.limf = m1.limf;
m3.limc = m2.limc;
for (int i = 0; i < m1.limf; i++)
for (int j = 0; j < m1.limc; j++)
m3.mat[i,j] = m1.mat[i, j] + m2.mat [i, j];
return m3;
}


public static clsMatriz operator -(clsMatriz m1, clsMatriz m2)
{
clsMatriz m3 = new clsMatriz();
m3.limf = m1.limf;
m3.limc = m2.limc;
for (int i = 0; i < m1.limf; i++)
for (int j = 0; j < m1.limc; j++)
m3.mat[i, j] = m1.mat[i, j] - m2.mat[i, j];
return m3;
}


public static clsMatriz operator *(clsMatriz m1, clsMatriz m2)
{
clsMatriz m3 = new clsMatriz();
m3.limf = m1.limf;
m3.limc = m2.limc;
for (int i = 0; i < m3.limf; i++)
{
for (int j = 0; j < m3.limc; j++)
{
m3.mat[i,j] = 0;
for (int l = 0; l < m1.limc; l++)
{
m3.mat[i,j] = m3.mat[i,j] + (m1.mat[i,l] * m2.mat[l,j]);
}
}
}
return m3;
}


public bool ValidaMatCuadrada(clsMatriz m1, clsMatriz m2)
{
bool valida=false;
if (m1.limf == m2.limf && m1.limc == m2.limc)
valida=true;
return valida;
}

public bool ValidaMultiplicacion(clsMatriz m1, clsMatriz m2)
{
bool valida=false;
if (m1.limc == m2.limf)
valida=true;
return valida;
}

public void Deter()
{
deter = this.mat[0, 0] * this.mat[1, 1] - this.mat[0, 1] * this.mat[1, 0];
}


public void Inversa()
{
this.Deter();
if (this.deter != 0)
{
float aux;
aux = this.mat[0, 0] / this.deter;
this.mat[0, 0] = this.mat[1, 1] / this.deter;
this.mat[1, 1] = aux;
this.mat[1, 0] = (this.mat[1, 0] * (-1))/this.deter ;
this.mat[0, 1] = (this.mat[0, 1] * (-1))/ this.deter ;
}
}


public clsMatriz Transpuesta()
{
clsMatriz m3 = new clsMatriz();
m3.limf = this.limf;
m3.limc = this.limc;
for (int i = 0; i < this.limf; i++)
{
for (int j = 0; j < this.limc; j++)
m3.mat [j,i]=this.mat [i,j];
}
return m3;
}

}
}

Clase Matriz

using System;
using System.Collections.Generic;
using System.Text;
namespace Matrices
{
public class clsMatriz
{
private double[,] mat;
private int fila, colum;
public clsMatriz()
{
}
public clsMatriz(int f, int c)
{
fila = f;
colum = c;
mat = new double[fila, colum];
}
public void leerMatriz()
{
for (int i = 1; i <= fila; i++)
{
for (int j = 1; j <= colum; j++)
{
Console.WriteLine("Ingrese el valor en la posicion [" + i + ", " + j + "]");
mat[i - 1, j - 1] = Convert.ToInt32(Console.ReadLine());
}
}
}
public override string ToString()
{
return Matriz();
}
public static clsMatriz operator +(clsMatriz mat1, clsMatriz mat2)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int fmat2= mat2.fila;
int cmat2 = mat2.colum;
clsMatriz suma = new clsMatriz(fmat1, cmat2);
if ((fmat1 == fmat2) && (cmat1 == cmat2))
{
for (int i = 1; i <= suma.fila; i++)
{
for (int j = 1; j <= suma.colum; j++)
{
suma.mat[i - 1, j - 1] = mat1.mat[i - 1, j - 1] + mat2.mat[i - 1, j - 1];
}
}
}
return suma;
}
public static clsMatriz operator -(clsMatriz mat1, clsMatriz mat2)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int fmat2 = mat2.fila;
int cmat2 = mat2.colum;
clsMatriz resta = new clsMatriz(fmat1, cmat1);
if ((fmat1 == fmat2) && (cmat1 == cmat2))
{
for (int i = 1; i <= resta.fila; i++)
{
for (int j = 1; j <= resta.colum; j++)
{
resta.mat[i - 1, j - 1] = mat1.mat[i - 1, j - 1] - mat2.mat[i - 1, j - 1];
}
}
}
return resta;
}
public static clsMatriz operator *(clsMatriz mat1, clsMatriz mat2)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int fmat2 = mat2.fila;
int cmat2 = mat2.colum;
int aux;
clsMatriz multiplicacion = new clsMatriz(fmat1, cmat2);
if (cmat1 == fmat2)
{
for (int i = 0; i < multiplicacion.fila; i++)
{
aux = 0;
for (int j = 0; j < multiplicacion.colum; j++)
{
for (int k = 0; k < cmat1; k++)
{
multiplicacion.mat[i, j] = multiplicacion.mat[i, j] + (mat1.mat[i, k] * mat2.mat[k, j]);
}
}
}
}
return multiplicacion;
}
public static clsMatriz operator *(int num, clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int aux;
clsMatriz escalar = new clsMatriz(fmat1, cmat1);
for (int i = 0; i < escalar.fila; i++)
{
aux = 0;
for (int j = 0; j < escalar.colum; j++)
{
escalar.mat[i, j] = mat1.mat[i, j] * num;
}
}
return escalar;
}
public double CalculaDeterminante(clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
double temp = 1, temp1 = 1, temp2 = 1, det = 0;
for (int i = 0; i < mat1.fila; i++)
{
for (int j = 0; j < mat1.colum; j++)
{
if (i == j)
{
temp = mat1.mat[i, j];
temp1 = temp * temp1;
}
else
{
temp = mat1.mat[i, j];
temp2 = temp * temp2;
}
}
}
det = temp1 - temp2;
return det;
}
public clsMatriz MatrizInversa(clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
clsMatriz inversa = new clsMatriz(fmat1, cmat1);
for (int i = 0; i < mat1.fila; i++)
{
for (int j = 0; j < mat1.colum; j++)
{
try
{
inversa.mat[i, j] = mat1.mat[i, j] / CalculaDeterminante(mat1);
}
catch (DivideByZeroException)
{
Console.WriteLine("No se puede realizar la division por 0");
}
}
}
return inversa;
}
public clsMatriz MatrizTranspuesta(clsMatriz mat1)
{
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
clsMatriz transpuesta = new clsMatriz(cmat1, fmat1);
for (int i = 0; i < mat1.fila; i++)
{
for (int j = 0; j < mat1.colum; j++)
{
transpuesta.mat[j, i] = mat1.mat[i, j];
}
}
return transpuesta;
}
public clsMatriz MatrizIdentidad(clsMatriz mat1)
{
clsMatriz inv=new clsMatriz();
inv = MatrizInversa(mat1);
int fmatinv = inv.fila;
int cmatinv = inv.colum;
int fmat1 = mat1.fila;
int cmat1 = mat1.colum;
int aux;
clsMatriz identidad = new clsMatriz(fmat1, cmat1);
for (int i = 0; i < identidad.fila; i++)
{
for (int j = 0; j < identidad.colum; j++)
{
for (int k = 0; k < cmatinv; k++)
{
identidad.mat[i, j] = identidad.mat[i, j] + (mat1.mat[i, k] * inv.mat[k, j]);
}
}
}
return identidad;
}
public string Matriz()
{
string cad = "", cad1 = "", cad2 = "";
for (int i = 1; i <= fila; i++)
{
for (int j = 1; j <= colum; j++)
{
cad = "" + mat[i - 1, j - 1] + "\t";
cad1 = cad1 + cad;
}
cad1 = cad1 + "\n";
cad2 = cad2 + cad1;
}
return cad1;
}
}
}