Esempio n. 1
0
 public Matriz(Matriz <T> copia)
 {
     this.X = copia.X;
     this.Y = copia.Y;
     Datos  = new T[this.X, this.Y];
     for (int i = 0; i < this.X; i++)
     {
         for (int j = 0; j < this.X; j++)
         {
             Datos[i, j] = copia.Datos[i, j];
         }
     }
 }
Esempio n. 2
0
        public Matriz(Matriz <T> copiap)
        {
            dynamic copia = copiap;

            X     = copia.X;
            Y     = copia.Y;
            Datos = new T[X, Y];
            for (int i = 0; i < X; i++)
            {
                for (int j = 0; j < Y; j++)
                {
                    Datos[i, j] = copia[i, j];
                } //for j
            }     //for i
        }
Esempio n. 3
0
        T GetDeterminante(Matriz <T> matrizX)
        {
            dynamic matriz   = matrizX;
            dynamic solución = new T();

            if (matriz.X == 2)
            {
                return(matriz.Datos[0, 0] * matriz.Datos[1, 1] - matriz.Datos[1, 0] * matriz.Datos[0, 1]);
            }

            for (int i = 0; i < matriz.X; i++)
            {
                solución += ((i % 2 == 0) ? 1 : -1) * matriz.CruceEn(i) * GetDeterminante(matriz.CortarEn(i));
            }

            return(solución);
        }
Esempio n. 4
0
        public static Matriz <T> operator -(Matriz <T> ax, Matriz <T> b)
        {
            dynamic a = ax;

            if (a.X != b.X || a.Y != b.Y)
            {
                throw new Exception();
            }
            Matriz <T> resultado = new Matriz <T>(a.X, a.Y);

            for (int i = 0; i < a.X; i++)
            {
                for (int j = 0; j < a.Y; j++)
                {
                    resultado.Datos[i, j] = a.Datos[i, j] - b.Datos[i, j];
                }
            }
            return(resultado);
        }
Esempio n. 5
0
        public Matriz <T> Invertir()
        {
            if (this.X != this.Y)
            {
                throw new Exception();
            }
            dynamic resultado = new Matriz <T>(this);
            dynamic identidad = new MatrizIdentidad <T>(this.X);
            dynamic auxiliar;

            for (int i = 0; i < this.X; i++)
            {
                auxiliar = 1 / resultado.Datos[i, i];
                for (int j = 0; j < this.X; j++)
                {
                    resultado.Datos[i, j] *= auxiliar;
                    identidad.Datos[i, j] *= auxiliar;
                }
                for (int j = 0; j < this.X; j++)
                {
                    auxiliar = new T();
                    auxiliar = resultado.Datos[j, i];
                    if (j == i)
                    {
                        continue;
                    }
                    for (int k = 0; k < this.X; k++)
                    {
                        resultado.Datos[j, k] -= resultado.Datos[i, k] * auxiliar;
                        identidad.Datos[j, k] -= identidad.Datos[i, k] * auxiliar;
                    } //for k
                }     //for j
            }         //for i

            return(identidad);
        }
Esempio n. 6
0
        public static Matriz <T> operator *(Matriz <T> ax, Matriz <T> b)
        {
            dynamic a = ax;

            if (a.Y != b.X)
            {
                throw new Exception();
            }
            Matriz <T> resultado = new Matriz <T>(a.X, b.Y);

            for (int i = 0; i < a.X; i++)
            {
                for (int j = 0; j < b.Y; j++)
                {
                    resultado.Datos[i, j] = new T();
                    for (int k = 0; k < a.Y; k++)
                    {
                        resultado.Datos[i, j] += a.Datos[i, k] * b.Datos[k, j];
                    } //k
                }     //j
            }         //i

            return(resultado);
        }