{ "cells": [ { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": true }, "outputs": [], "source": [ "%plot --format svg" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": true }, "outputs": [], "source": [ "setdefaults" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What is the determinant of A?\n", "\n", "$A=\\left[ \\begin{array}{ccc}\n", "10 & 2 & 1 \\\\\n", "0 & 1 & 1 \\\\\n", "0 & 0 & 10\\end{array} \\right]$\n", "\n", "![responses to determinant of A](det_A.png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# LU Decomposition\n", "### efficient storage of matrices for solutions\n", "\n", "Considering the same solution set:\n", "\n", "$y=Ax$\n", "\n", "Assume that we can perform Gauss elimination and achieve this formula:\n", "\n", "$Ux=d$ \n", "\n", "Where, $U$ is an upper triangular matrix that we derived from Gauss elimination and $d$ is the set of dependent variables after Gauss elimination. \n", "\n", "Assume there is a lower triangular matrix, $L$, with ones on the diagonal and same dimensions of $U$ and the following is true:\n", "\n", "$L(Ux-d)=Ax-y=0$\n", "\n", "Now, $Ax=LUx$, so $A=LU$, and $y=Ld$.\n", "\n", "$2x_{1}+x_{2}=1$\n", "\n", "$x_{1}+3x_{2}=1$\n", "\n", "\n", "$\\left[ \\begin{array}{cc}\n", "2 & 1 \\\\\n", "1 & 3 \\end{array} \\right]\n", "\\left[\\begin{array}{c} \n", "x_{1} \\\\ \n", "x_{2} \\end{array}\\right]=\n", "\\left[\\begin{array}{c} \n", "1 \\\\\n", "1\\end{array}\\right]$\n", "\n", "f21=0.5\n", "\n", "A(2,1)=1-1 = 0 \n", "\n", "A(2,2)=3-0.5=2.5\n", "\n", "y(2)=1-0.5=0.5\n", "\n", "$L(Ux-d)=\n", "\\left[ \\begin{array}{cc}\n", "1 & 0 \\\\\n", "0.5 & 1 \\end{array} \\right]\n", "\\left(\\left[ \\begin{array}{cc}\n", "2 & 1 \\\\\n", "0 & 2.5 \\end{array} \\right]\n", "\\left[\\begin{array}{c} \n", "x_{1} \\\\ \n", "x_{2} \\end{array}\\right]-\n", "\\left[\\begin{array}{c} \n", "1 \\\\\n", "0.5\\end{array}\\right]\\right)=0$\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A =\n", "\n", " 2 1\n", " 1 3\n", "\n", "L =\n", "\n", " 1.00000 0.00000\n", " 0.50000 1.00000\n", "\n", "U =\n", "\n", " 2.00000 1.00000\n", " 0.00000 2.50000\n", "\n", "ans =\n", "\n", " 2 1\n", " 1 3\n", "\n", "d =\n", "\n", " 1.00000\n", " 0.50000\n", "\n", "y =\n", "\n", " 1\n", " 1\n", "\n" ] } ], "source": [ "A=[2,1;1,3]\n", "L=[1,0;0.5,1]\n", "U=[2,1;0,2.5]\n", "L*U\n", "\n", "d=[1;0.5]\n", "y=L*d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Pivoting for LU factorization\n", "\n", "LU factorization uses the same method as Gauss elimination so it is also necessary to perform partial pivoting when creating the lower and upper triangular matrices. \n", "\n", "Matlab and Octave use pivoting in the command \n", "\n", "[L,U,P]=lu(A)\n", "\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "'lu' is a built-in function from the file libinterp/corefcn/lu.cc\n", "\n", " -- Built-in Function: [L, U] = lu (A)\n", " -- Built-in Function: [L, U, P] = lu (A)\n", " -- Built-in Function: [L, U, P, Q] = lu (S)\n", " -- Built-in Function: [L, U, P, Q, R] = lu (S)\n", " -- Built-in Function: [...] = lu (S, THRES)\n", " -- Built-in Function: Y = lu (...)\n", " -- Built-in Function: [...] = lu (..., \"vector\")\n", " Compute the LU decomposition of A.\n", "\n", " If A is full subroutines from LAPACK are used and if A is sparse\n", " then UMFPACK is used.\n", "\n", " The result is returned in a permuted form, according to the\n", " optional return value P. For example, given the matrix 'a = [1, 2;\n", " 3, 4]',\n", "\n", " [l, u, p] = lu (A)\n", "\n", " returns\n", "\n", " l =\n", "\n", " 1.00000 0.00000\n", " 0.33333 1.00000\n", "\n", " u =\n", "\n", " 3.00000 4.00000\n", " 0.00000 0.66667\n", "\n", " p =\n", "\n", " 0 1\n", " 1 0\n", "\n", " The matrix is not required to be square.\n", "\n", " When called with two or three output arguments and a spare input\n", " matrix, 'lu' does not attempt to perform sparsity preserving column\n", " permutations. Called with a fourth output argument, the sparsity\n", " preserving column transformation Q is returned, such that 'P * A *\n", " Q = L * U'.\n", "\n", " Called with a fifth output argument and a sparse input matrix, 'lu'\n", " attempts to use a scaling factor R on the input matrix such that 'P\n", " * (R \\ A) * Q = L * U'. This typically leads to a sparser and more\n", " stable factorization.\n", "\n", " An additional input argument THRES, that defines the pivoting\n", " threshold can be given. THRES can be a scalar, in which case it\n", " defines the UMFPACK pivoting tolerance for both symmetric and\n", " unsymmetric cases. If THRES is a 2-element vector, then the first\n", " element defines the pivoting tolerance for the unsymmetric UMFPACK\n", " pivoting strategy and the second for the symmetric strategy. By\n", " default, the values defined by 'spparms' are used ([0.1, 0.001]).\n", "\n", " Given the string argument \"vector\", 'lu' returns the values of P\n", " and Q as vector values, such that for full matrix, 'A (P,:) = L *\n", " U', and 'R(P,:) * A (:, Q) = L * U'.\n", "\n", " With two output arguments, returns the permuted forms of the upper\n", " and lower triangular matrices, such that 'A = L * U'. With one\n", " output argument Y, then the matrix returned by the LAPACK routines\n", " is returned. If the input matrix is sparse then the matrix L is\n", " embedded into U to give a return value similar to the full case.\n", " For both full and sparse matrices, 'lu' loses the permutation\n", " information.\n", "\n", " See also: luupdate, ilu, chol, hess, qr, qz, schur, svd.\n", "\n", "Additional help for built-in functions and operators is\n", "available in the online version of the manual. Use the command\n", "'doc ' to search the manual index.\n", "\n", "Help and information about Octave is also available on the WWW\n", "at http://www.octave.org and via the help@octave.org\n", "mailing list.\n" ] } ], "source": [ "help lu" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/svg+xml": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "% time LU solution vs backslash\n", "t_lu=zeros(100,1);\n", "t_bs=zeros(100,1);\n", "for N=1:100\n", " A=rand(N,N);\n", " y=rand(N,1);\n", " [L,U,P]=lu(A);\n", "\n", " tic; d=L\\y; x=U\\d; t_lu(N)=toc;\n", "\n", " tic; x=A\\y; t_bs(N)=toc;\n", "end\n", "plot([1:100],t_lu,[1:100],t_bs) \n", "legend('LU decomp','Octave \\\\')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "Consider the problem again from the intro to Linear Algebra, 4 masses are connected in series to 4 springs with K=10 N/m. What are the final positions of the masses? \n", "\n", "![Springs-masses](../lecture_09/mass_springs.svg)\n", "\n", "The masses haves the following amounts, 1, 2, 3, and 4 kg for masses 1-4. Using a FBD for each mass:\n", "\n", "$m_{1}g+k(x_{2}-x_{1})-kx_{1}=0$\n", "\n", "$m_{2}g+k(x_{3}-x_{2})-k(x_{2}-x_{1})=0$\n", "\n", "$m_{3}g+k(x_{4}-x_{3})-k(x_{3}-x_{2})=0$\n", "\n", "$m_{4}g-k(x_{4}-x_{3})=0$\n", "\n", "in matrix form:\n", "\n", "$\\left[ \\begin{array}{cccc}\n", "2k & -k & 0 & 0 \\\\\n", "-k & 2k & -k & 0 \\\\\n", "0 & -k & 2k & -k \\\\\n", "0 & 0 & -k & k \\end{array} \\right]\n", "\\left[ \\begin{array}{c}\n", "x_{1} \\\\\n", "x_{2} \\\\\n", "x_{3} \\\\\n", "x_{4} \\end{array} \\right]=\n", "\\left[ \\begin{array}{c}\n", "m_{1}g \\\\\n", "m_{2}g \\\\\n", "m_{3}g \\\\\n", "m_{4}g \\end{array} \\right]$" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "K =\n", "\n", " 20 -10 0 0\n", " -10 20 -10 0\n", " 0 -10 20 -10\n", " 0 0 -10 10\n", "\n", "y =\n", "\n", " 9.8100\n", " 19.6200\n", " 29.4300\n", " 39.2400\n", "\n" ] } ], "source": [ "k=10; % N/m\n", "m1=1; % kg\n", "m2=2;\n", "m3=3;\n", "m4=4;\n", "g=9.81; % m/s^2\n", "K=[2*k -k 0 0; -k 2*k -k 0; 0 -k 2*k -k; 0 0 -k k]\n", "y=[m1*g;m2*g;m3*g;m4*g]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This matrix, K, is symmetric. \n", "\n", "K(i,j)==K(j,i)\n", "\n", "Now we can use,\n", "\n", "## Cholesky Factorization\n", "\n", "We can decompose the matrix, K into two matrices, $U$ and $U^{T}$, where\n", "\n", "$K=U^{T}U$\n", "\n", "each of the components of U can be calculated with the following equations:\n", "\n", "$u_{ii}=\\sqrt{a_{ii}-\\sum_{k=1}^{i-1}u_{ki}^{2}}$\n", "\n", "$u_{ij}=\\frac{a_{ij}-\\sum_{k=1}^{i-1}u_{ki}u_{kj}}{u_{ii}}$\n", "\n", "so for K" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "K =\n", "\n", " 20 -10 0 0\n", " -10 20 -10 0\n", " 0 -10 20 -10\n", " 0 0 -10 10\n", "\n" ] } ], "source": [ "K" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "u11 = 4.4721\n", "u12 = -2.2361\n", "u13 = 0\n", "u14 = 0\n", "u22 = 3.8730\n", "u23 = -2.5820\n", "u24 = 0\n", "u33 = 3.6515\n", "u34 = -2.7386\n", "u44 = 1.5811\n", "U =\n", "\n", " 4.47214 -2.23607 0.00000 0.00000\n", " 0.00000 3.87298 -2.58199 0.00000\n", " 0.00000 0.00000 3.65148 -2.73861\n", " 0.00000 0.00000 0.00000 1.58114\n", "\n" ] } ], "source": [ "u11=sqrt(K(1,1))\n", "u12=(K(1,2))/u11\n", "u13=(K(1,3))/u11\n", "u14=(K(1,4))/u11\n", "u22=sqrt(K(2,2)-u12^2)\n", "u23=(K(2,3)-u12*u13)/u22\n", "u24=(K(2,4)-u12*u14)/u22\n", "u33=sqrt(K(3,3)-u13^2-u23^2)\n", "u34=(K(3,4)-u13*u14-u23*u24)/u33\n", "u44=sqrt(K(4,4)-u14^2-u24^2-u34^2)\n", "U=[u11,u12,u13,u14;0,u22,u23,u24;0,0,u33,u34;0,0,0,u44]" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ans =\n", "\n", " 20.00000 -10.00000 0.00000 0.00000\n", " -10.00000 20.00000 -10.00000 0.00000\n", " 0.00000 -10.00000 20.00000 -10.00000\n", " 0.00000 0.00000 -10.00000 10.00000\n", "\n" ] } ], "source": [ "U'*U" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "average time spent for Cholesky factored solution = 1.623154e-05+/-1.166726e-05\n", "average time spent for backslash solution = 1.675844e-05+/-1.187234e-05\n" ] } ], "source": [ "% time solution for Cholesky vs backslash\n", "t_chol=zeros(1000,1);\n", "t_bs=zeros(1000,1);\n", "for i=1:1000\n", " tic; d=U'*y; x=U\\d; t_chol(i)=toc;\n", " tic; x=K\\y; t_bs(i)=toc;\n", "end\n", "fprintf('average time spent for Cholesky factored solution = %e+/-%e',mean(t_chol),std(t_chol))\n", "\n", "fprintf('average time spent for backslash solution = %e+/-%e',mean(t_bs),std(t_bs))" ] } ], "metadata": { "kernelspec": { "display_name": "Octave", "language": "octave", "name": "octave" }, "language_info": { "file_extension": ".m", "help_links": [ { "text": "MetaKernel Magics", "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" } ], "mimetype": "text/x-octave", "name": "octave", "version": "0.19.14" } }, "nbformat": 4, "nbformat_minor": 2 }