Método de Descomposición LU

La descomposición de LU es una técnica que consta de dos pasos, la descomposición de LU y la sustitución; Al igual que la técnica de gauss requiere de la aplicación de técnicas de pivoteo para evitar la división por cero y evitar errores en los resultados.

Paso 1: descomposición de L y U, es posible utilizar gauss para descomponer nuestro sistema de ecuaciones en una matriz L y otra U.

 

Matriz L         
 

F21 = a21 / a11
F31 = a31 / a11
F32 = a’32 / a’22

Matriz U obtenida mediante eliminación de gauss

d1, d2, y d3 permanecen intactos.

 

Algoritmo escrito en C# que realiza la descomposición de LU, en este algoritmo que se realiza técnica de pivoteo por lo que se pueden producir errores al dividir por cero.

 

        /// <summary>
        /// Algoritmo que realiza descomposicion LU
        /// </summary>
        /// <param name="matrixU">matriz que contiene el sistema de ecuaciones a resolver (completo)</param>
        /// <param name="matrixL">matriz vacia que contendra (L) del mismo tamaño que matrixU</param>
        /// <param name="filas">cantidad de filas de ambas matrices</param>
        /// <param name="columnas">cantidad de columnas de ambas matrices</param>
        private void MetodoLU(ref double[,] matrixU, ref double[,] matrixL, int filas, int columnas)
        {
            for (int fpivot = 0; fpivot < filas - 1; fpivot++)
            {
                matrixL[fpivot, fpivot] = 1;

                for (int f = fpivot + 1; f < filas; f++)
                {
                    double k = matrixU[f, fpivot] / matrixU[fpivot, fpivot];

                    matrixL[f, fpivot] = matrixU[f, fpivot] / matrixU[fpivot, fpivot];

                    for (int c = fpivot; c < columnas - 1; c++)
                    {
                        matrixU[f, c] = matrixU[f, c] - (k * matrixU[fpivot, c]);
                    }
                }
            }
        }

Paso 2: realizar sustitución adelante y atrás para obtener nuestra solución
Igualar la matriz L a D y hacer sustitución adelante para obtener los valores de D

=  

Igualar la matriz U a nuestros nuevos valores D y hacer sustitución hacia atrás para obtener los valores de D que representan la solución del sistema.

Algoritmo escrito en C# para la sustitución hacia adelante, este método hace uso del algoritmo de sustitución hacia atrás empleado en el método de gauss:
        /// <summary>
        /// Algoritmo que realiza descomposicion LU
        /// </summary>
        /// <param name="matrixU">matriz que contiene el sistema de ecuaciones a resolver (completo)</param>
        /// <param name="matrixL">matriz vacia que contendra (L) del mismo tamaño que matrixU</param>
        /// <param name="filas">cantidad de filas de ambas matrices</param>
        /// <param name="columnas">cantidad de columnas de ambas matrices</param>
        /// <returns>devuelve un string que contiene la solucion</returns>
        private string SustitucionAdelante(ref double[,] matrixU,ref double[,] matrixL, int filas, int columnas)
        {
            StringBuilder sb = new StringBuilder();
            matrixL[0, columnas - 1] = matrixU[0, columnas - 1];
            sb.AppendLine("D1 = " + matrixL[0, columnas - 1].ToString());

            for (int i = 1; i < filas; i++)
            {
                double suma = 0;

                for (int j = 0; j < i; j++)
                {
                    suma += matrixL[i, j] * matrixL[j, columnas - 1];
                }

                matrixL[i, columnas - 1] = matrixU[i, columnas - 1] - suma;
                sb.AppendLine("D" + (i + 1) + "= " + matrixL[i, columnas - 1].ToString());
            }

            for (int i = 0; i < filas; i++)
            {
                matrixU[i, columnas - 1] = matrixL[i, columnas - 1];
            }

            //aplicar el algoritmo de sustitucion hacia atras empleado en el metodo de gauss a la matriz U
            sb.AppendLine(SustitucionAtras(matrixU));

            return sb.ToString();
        }

Programa que realiza Descomposición de LU en C#

 

Descarga solución para VS 2010