public Proyeccion()
{
mMatriz = new Matriz(3, 4);
mMatriz.EstablecerValoresPorFila(0, 1, 0, 0, 0);
mMatriz.EstablecerValoresPorFila(1, 0, 1, 0, 0);
mMatriz.EstablecerValoresPorFila(2, 0, 0, 0, 1);
}
public Transformacion3D(Matriz Matriz)
{
if (Matriz.EsCuadrada && Matriz.Filas == 4) {
mMatriz = Matriz;
} else {
throw new ExcepcionGeometrica3D("TRANSFORMACION3D (NEW): Las matrices de transformación tridimensional solo se pueden implementar con matrices cuadradas de 4x4" + Constants.vbNewLine + "Dimensiones de la matriz: " + Matriz.Filas + "x" + Matriz.Columnas);
}
}
public Proyeccion(Matriz Matriz)
{
if (Matriz.Filas == 3 && Matriz.Columnas == 4) {
mMatriz = Matriz;
} else {
throw new ExcepcionEscena("PROYECCION (NEW): Una proyección solo se puede definir mediante una matriz de dimensiones 3x4." + Constants.vbNewLine + "Dimensiones=" + Matriz.Filas + "x" + Matriz.Columnas);
}
}
public Punto2D(Matriz Matriz)
{
if (Matriz.Filas == 3 && Matriz.Columnas == 1) {
mX = Matriz.Valores[0, 0];
mY = Matriz.Valores[1, 0];
} else {
throw new ExcepcionGeometrica2D("PUNTO2D (NEW): La representación matricial de un punto bidimensional" + " corresponde a una matriz columna de tres elementos. " + Constants.vbNewLine + "Dimensiones de la matriz: " + Matriz.Filas + "x" + Matriz.Columnas);
}
}
public Punto3D(double ValX, double ValY, double ValZ)
{
mArray = new double[4, 1];
mMatriz = new Matriz(mArray);
mArray[0, 0] = ValX;
mArray[1, 0] = ValY;
mArray[2, 0] = ValZ;
mArray[3, 0] = 1;
}
public Punto3D()
{
mArray = new double[4, 1];
mMatriz = new Matriz(mArray);
mArray[0, 0] = 0;
mArray[1, 0] = 0;
mArray[2, 0] = 0;
mArray[3, 0] = 1;
}
public static Proyeccion ProyeccionIsometrica()
{
Matriz Matriz = new Matriz(3, 4);
Matriz.EstablecerValoresPorFila(0, Math.Cos(Math.PI / 6), -Math.Cos(Math.PI / 6), 0, 0);
Matriz.EstablecerValoresPorFila(1, -Math.Sin(Math.PI / 6), -Math.Sin(Math.PI / 6), 1, 0);
Matriz.EstablecerValoresPorFila(2, 0, 0, 0, 1);
return new Proyeccion(Matriz);
}
public static Proyeccion ProyeccionParalela()
{
Matriz Matriz = new Matriz(3, 4);
Matriz.EstablecerValoresPorFila(0, 1, 0, 0, 0);
Matriz.EstablecerValoresPorFila(1, 0, 1, 0, 0);
Matriz.EstablecerValoresPorFila(2, 0, 0, 0, 1);
return new Proyeccion(Matriz);
}
public SistemaEcuaciones(params Ecuacion[] ValEcuaciones)
{
double[] Sols = null;
double DetA = 0;
int[] Columnas = null;
Matriz Mat = null;
Matriz MatOr = null;
mEcuaciones = ValEcuaciones;
mNumeroIncognitas = 0;
mEsHomogeneo = TestHomogeneidad();
for (int i = 0; i <= mEcuaciones.GetUpperBound(0); i++) {
if (mNumeroIncognitas < mEcuaciones[i].NumeroVariables)
mNumeroIncognitas = mEcuaciones[i].NumeroVariables;
}
if (mEsHomogeneo) {
mMatrizPrincipal = Matriz.MatrizUnitaria(mNumeroIncognitas + 1);
mMatrizAmpliada = Matriz.MatrizUnitaria(mNumeroIncognitas + 1);
mRangoMatrizPrincipal = 0;
mRangoMatrizAmpliada = 0;
Sols = new double[mNumeroIncognitas];
mSolucion = new SolucionSistema(Sols);
} else {
mMatrizAmpliada = new Matriz(mEcuaciones.GetUpperBound(0) + 1, mNumeroIncognitas + 1);
for (int i = 0; i <= mEcuaciones.GetUpperBound(0); i++) {
mMatrizAmpliada.EstablecerValoresPorFila(i, mEcuaciones[i].Variables);
}
mMatrizPrincipal = Matriz.SubMatrizPorColumna(mMatrizAmpliada, mNumeroIncognitas);
mRangoMatrizAmpliada = Matriz.Rango(mMatrizAmpliada);
mRangoMatrizPrincipal = Matriz.Rango(mMatrizPrincipal);
if ((mRangoMatrizPrincipal == mRangoMatrizAmpliada)) {
if (mRangoMatrizAmpliada == mNumeroIncognitas) {
//RESOLUCION POR REGLA DE CRAMER:
Sols = new double[mNumeroIncognitas];
Columnas = new int[mMatrizPrincipal.Columnas];
if (mMatrizPrincipal.EsCuadrada) {
DetA = Matriz.CalculoDeterminante(mMatrizPrincipal);
MatOr = mMatrizPrincipal.Copia();
} else {
MatOr = Matriz.SubMatrizPorTamaño(mMatrizPrincipal, mNumeroIncognitas, mNumeroIncognitas);
DetA = Matriz.CalculoDeterminante(MatOr);
}
for (int i = 0; i <= mNumeroIncognitas - 1; i++) {
Mat = MatOr.Copia();
Mat.EstablecerValoresPorColumna(i, mMatrizAmpliada.ObtenerColumna(mNumeroIncognitas));
Sols[i] = Matriz.CalculoDeterminante(Mat) / DetA;
}
mSolucion = new SolucionSistema(Sols);
} else {
mSolucion = new SolucionSistema(TipoSolucionSistema.SistemaCompatibleIndeterminado);
}
} else {
mSolucion = new SolucionSistema(TipoSolucionSistema.SistemaIncompatible);
}
}
}
public static object MatrizPorFilas(Matriz Matriz, params int[] Filas)
{
Matriz Retorno = new Matriz(Filas.GetUpperBound(0) + 1, Matriz.Columnas);
for (int i = 0; i <= Filas.GetUpperBound(0); i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
Retorno.EstablecerValor(i, j, Matriz.ObtenerValor(Filas[i], j));
}
}
return Retorno;
}
public static object MatrizPorColumnas(Matriz Matriz, params int[] Columnas)
{
Matriz Retorno = new Matriz(Matriz.Filas, Columnas.GetUpperBound(0) + 1);
for (int i = 0; i <= Columnas.GetUpperBound(0); i++) {
for (int j = 0; j <= Matriz.Filas - 1; j++) {
Retorno.EstablecerValor(j, i, Matriz.ObtenerValor(j, Columnas[i]));
}
}
return Retorno;
}
public static object MatrizUnitaria(int Dimensiones)
{
if (Dimensiones <= 0)
Dimensiones = 1;
Matriz Retorno = new Matriz(Dimensiones, Dimensiones);
for (int i = 0; i <= Dimensiones - 1; i++) {
for (int j = 0; j <= Dimensiones - 1; j++) {
Retorno.EstablecerValor(i, j, (i == j ? 1 : 0));
}
}
return Retorno;
}
public static Matriz Copia(Matriz Matriz)
{
Matriz Retorno = new Matriz(Matriz.Filas, Matriz.Columnas);
for (int i = 0; i <= Matriz.Filas - 1; i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
Retorno.EstablecerValor(i, j, Matriz.Matriz[i, j]);
}
}
return Retorno;
}
public static Matriz Transpuesta(Matriz Matriz)
{
var Retorno = new Matriz(Matriz.Columnas, Matriz.Filas);
for (int i = 0; i <= Matriz.Filas - 1; i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
Retorno.EstablecerValor(j, i, Matriz.ObtenerValor(i, j));
}
}
return Retorno;
}
public static Matriz Producto(Matriz M1, Matriz M2)
{
if ((M1.Columnas == M2.Filas)) {
double ValorElemento = 0;
Matriz Retorno = new Matriz(M1.Filas, M2.Columnas);
for (int i = 0; i <= M1.Filas - 1; i++) {
for (int j = 0; j <= M2.Columnas - 1; j++) {
ValorElemento = 0;
for (int k = 0; k <= M1.Columnas - 1; k++) {
ValorElemento += M1.ObtenerValor(i, k) * M2.ObtenerValor(k, j);
}
Retorno.EstablecerValor(i, j, ValorElemento);
}
}
return Retorno;
} else {
throw new ExcepcionOperacionMatricial("MATRIZ (PRODUCTO): El número de columnas del primer factor debe ser igual al número de filas del segundo" + Constants.vbNewLine + "Primer factor: " + M1.Filas + "x" + M1.Columnas + Constants.vbNewLine + "Segundo factor: " + M2.Filas + "x" + M2.Columnas);
}
}
public static double CalculoDeterminante(Matriz Matriz)
{
if (Matriz.Filas == Matriz.Columnas) {
double Positivos = 0;
double Negativos = 0;
switch (Matriz.Filas) {
case 1:
return Matriz.ObtenerValor(0, 0);
case 2:
Positivos = Matriz.ObtenerValor(0, 0) * Matriz.ObtenerValor(1, 1);
Negativos = Matriz.ObtenerValor(0, 1) * Matriz.ObtenerValor(1, 0);
return Positivos - Negativos;
case 3:
Positivos = (Matriz.ObtenerValor(0, 0) * Matriz.ObtenerValor(1, 1) * Matriz.ObtenerValor(2, 2)) + (Matriz.ObtenerValor(0, 1) * Matriz.ObtenerValor(1, 2) * Matriz.ObtenerValor(2, 0)) + (Matriz.ObtenerValor(1, 0) * Matriz.ObtenerValor(2, 1) * Matriz.ObtenerValor(0, 2));
Negativos = (Matriz.ObtenerValor(0, 2) * Matriz.ObtenerValor(1, 1) * Matriz.ObtenerValor(2, 0)) + (Matriz.ObtenerValor(0, 1) * Matriz.ObtenerValor(1, 0) * Matriz.ObtenerValor(2, 2)) + (Matriz.ObtenerValor(1, 2) * Matriz.ObtenerValor(2, 1) * Matriz.ObtenerValor(0, 0));
return Positivos - Negativos;
default:
double Retorno = 0;
for (int i = 0; i <= Matriz.Filas - 1; i++) {
Retorno += (Adjunto(Matriz, i, 0) * Matriz.ObtenerValor(i, 0));
}
return Retorno;
}
} else {
throw new ExcepcionMatrizNoCuadrada("MATRIZ (DETERMINANTE): Solo se puede obtener el determinante de matrices cuadradas." + Constants.vbNewLine + "Dimensiones de la matriz: " + Matriz.Filas + "x" + Matriz.Columnas);
}
}
public static Matriz[] RepresentacionMatricial(Recta2D Recta)
{
Matriz[] Retorno = new Matriz[2];
Retorno[0] = Recta.PuntoDiretor.Matriz;
Retorno[1] = Recta.PuntoDeMira.Matriz;
return Retorno;
}
public static object SubMatrizCuadrada(Matriz Matriz, int Fila, int Columna, int Dimensiones)
{
object functionReturnValue = null;
if (!((Fila + Dimensiones <= Matriz.Filas) && (Columna + Dimensiones <= Matriz.Columnas))) {
throw new ExcepcionMatriz("MATRIZ (SUBMATRIZ CUADRADA): No se puede obtener una submatriz de las dimensiones especificadas desde el elemento especificado.");
return functionReturnValue;
}
Matriz Retorno = new Matriz(Dimensiones, Dimensiones);
for (int i = 0; i <= Retorno.Filas - 1; i++) {
for (int j = 0; j <= Retorno.Columnas - 1; j++) {
Retorno.EstablecerValor(i, j, Matriz.ObtenerValor(i + Fila, j + Columna));
}
}
return Retorno;
return functionReturnValue;
}
public static Matriz SubMatrizPorColumna(Matriz Matriz, int Columna)
{
if (Matriz.Columnas >= 2) {
Matriz Retorno = new Matriz(Matriz.Filas, Matriz.Columnas - 1);
int y = 0;
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
switch (j) {
case // ERROR: Case labels with binary operators are unsupported : LessThan
Columna:
y = j;
break;
case // ERROR: Case labels with binary operators are unsupported : Equality
Columna:
continue;
case // ERROR: Case labels with binary operators are unsupported : GreaterThan
Columna:
y = j - 1;
break;
}
for (int i = 0; i <= Matriz.Filas - 1; i++) {
Retorno.EstablecerValor(i, y, Matriz.ObtenerValor(i, j));
}
}
return Retorno;
} else {
throw new ExcepcionSubMatriz("MATRIZ (SUBMATRIZ): No se puede obtener una submatriz de una matriz columna, una matriz fila, o una matriz de un solo elemento." + Constants.vbNewLine + "Dimensiones de la matriz: " + Matriz.Filas + "x" + Matriz.Columnas);
}
}
public static Matriz SubMatrizPorTamaño(Matriz Matriz, int Filas, int Columnas)
{
Matriz Retorno = null;
if (Filas <= Matriz.Filas && Columnas <= Matriz.Columnas && Filas > 0 && Columnas > 0) {
Retorno = new Matriz(Filas, Columnas);
for (int i = 0; i <= Filas - 1; i++) {
for (int j = 0; j <= Columnas - 1; j++) {
Retorno.EstablecerValor(i, j, Matriz.ObtenerValor(i, j));
}
}
return Retorno;
} else {
throw new ExcepcionSubMatriz("MATRIZ (SUBMATRIZ): El número de filas y/o columnas es menor que uno o superior a los originales." + Constants.vbNewLine + "Dimensiones originales: " + Matriz.Filas.ToString() + "x" + Matriz.Columnas.ToString() + Constants.vbNewLine + "Dimensiones especificadas: " + Filas.ToString() + "x" + Columnas.ToString());
}
}
public static Matriz Suma(Matriz M1, Matriz M2)
{
Matriz Retorno = null;
if ((M1.Filas == M2.Filas && M1.Columnas == M2.Columnas)) {
Retorno = new Matriz(M1.Filas, M1.Columnas);
for (int i = 0; i <= M1.Filas - 1; i++) {
for (int j = 0; j <= M1.Columnas - 1; j++) {
Retorno.EstablecerValor(i, j, M1.ObtenerValor(i, j) + M2.ObtenerValor(i, j));
}
}
return Retorno;
} else {
throw new ExcepcionOperacionMatricial("MATRIZ (SUMA): Los sumandos deben tener las mismas dimensiones" + Constants.vbNewLine + "Primar sumando: " + M1.Filas + "x" + M1.Columnas + Constants.vbNewLine + "Segundo sumando: " + M2.Filas + "x" + M2.Columnas);
}
}
public static Matriz Resta(Matriz M1, Matriz M2)
{
Matriz Retorno = null;
if ((M1.Filas == M2.Filas && M1.Columnas == M2.Columnas)) {
Retorno = new Matriz(M1.Filas, M1.Columnas);
for (int i = 0; i <= M1.Filas - 1; i++) {
for (int j = 0; j <= M1.Columnas - 1; j++) {
Retorno.EstablecerValor(i, j, M1.ObtenerValor(i, j) - M2.ObtenerValor(i, j));
}
}
return Retorno;
} else {
throw new ExcepcionOperacionMatricial("MATRIZ (RESTA): Minuendo y sustraendo deben tener las mismas dimensiones" + Constants.vbNewLine + "Minuendo: " + M1.Filas + "x" + M1.Columnas + Constants.vbNewLine + "Sustraendo: " + M2.Filas + "x" + M2.Columnas);
}
}
public Transformacion3D()
{
mMatriz = Motor3D.Algebra.Matriz.MatrizUnitaria(4);
}
public static int Rango(Matriz Matriz)
{
Matriz SubMat = null;
bool NoCeros = true;
bool SinSubMat = false;
int Tamaño = (Matriz.Filas > Matriz.Columnas ? Matriz.Columnas : Matriz.Filas);
int Det = 0;
if (Matriz.EsCuadrada) {
if (CalculoDeterminante(Matriz) == 0) {
while (Tamaño > 1) {
SinSubMat = true;
for (int i = 0; i <= Matriz.Filas - 1; i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
try {
SubMat = SubMatrizCuadrada(Matriz, i, j, Tamaño);
Det = CalculoDeterminante(SubMat);
if (Det == 0) {
Tamaño -= 1;
continue;
}
SinSubMat = false;
} catch (ExcepcionMatriz ex) {
}
}
}
if (!SinSubMat) {
if (Tamaño > 1) {
return Tamaño;
}
}
Tamaño -= 1;
}
return 1;
} else {
return Matriz.Filas;
}
} else {
while (Tamaño > 1) {
SinSubMat = true;
for (int i = 0; i <= Matriz.Filas - 1; i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
try {
SubMat = SubMatrizCuadrada(Matriz, i, j, Tamaño);
Det = CalculoDeterminante(SubMat);
if (Det == 0) {
Tamaño -= 1;
continue;
}
SinSubMat = false;
} catch (ExcepcionMatriz ex) {
}
}
}
if (!SinSubMat) {
if (Tamaño > 1) {
return Tamaño;
}
}
Tamaño -= 1;
}
return 1;
}
}
public static double Adjunto(Matriz Matriz, int Fila, int Columna)
{
Matriz SubMatriz = Matriz.SubMatriz(Matriz, Fila, Columna);
if (SubMatriz.EsCuadrada) {
return (Math.Pow((-1), (Fila + Columna + 2))) * CalculoDeterminante(SubMatriz);
} else {
throw new ExcepcionMatrizNoCuadrada("MATRIZ (ADJUNTO): La submatriz obtenida no es cuadrada. No se puede calcular el determinante." + Constants.vbNewLine + "Dimensiones de la submatriz: " + SubMatriz.Filas + "x" + SubMatriz.Columnas);
}
}
public static Matriz Producto(Matriz Matriz, double Factor)
{
for (int i = 0; i <= Matriz.Filas - 1; i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
Matriz.EstablecerValor(i, j, Matriz.ObtenerValor(i, j) * Factor);
}
}
return Matriz;
}
public static Matriz Adjunta(Matriz Matriz)
{
Matriz functionReturnValue = null;
Matriz Retorno = new Matriz(Matriz.Filas, Matriz.Columnas);
for (int i = 0; i <= Matriz.Filas - 1; i++) {
for (int j = 0; j <= Matriz.Columnas - 1; j++) {
try {
Retorno.EstablecerValor(i, j, Adjunto(Matriz, i, j));
} catch (ExcepcionAlgebraica ex) {
throw new ExcepcionMatrizNoCuadrada("MATRIZ (ADJUNTA): La submatriz obtenida no es cuadrada. No se puede calcular el determinante.");
return functionReturnValue;
}
}
}
return Retorno;
return functionReturnValue;
}
public static Matriz CalculoInversa(Matriz Matriz)
{
if (Matriz.EsCuadrada) {
double Det = CalculoDeterminante(Matriz);
if (Det != 0) {
return Producto(Transpuesta(Adjunta(Matriz)), (1 / Det));
} else {
throw new ExcepcionOperacionMatricial("MATRIZ (CALCULOINVERSA): El determinante de la matriz es cero. No se puede calcular la inversa.");
}
} else {
throw new ExcepcionMatrizNoCuadrada("MATRIZ (CALCULOINVERSA): La matriz no es cuadrada. No se puede calcular el determinante.");
}
}
public Punto3D(Matriz Matriz)
{
mMatriz = Matriz;
mArray = Matriz.Array;
mArray[3, 0] = 1;
}
public static Matriz RepresentacionMatricial(Punto2D Punto)
{
Matriz Retorno = new Matriz(3, 1);
Retorno.EstablecerValoresPorColumna(0, Punto.X, Punto.Y, 1);
return Retorno;
}
