Website build

Author: colinjcotter

Computationallinearalgebracourse.pdf

@@ -687,7 +687,7 @@ <h2><span class="section-number">2.6. </span>Householder triangulation<a class="
 done so, you will need to modified
 <a class="reference internal" href="cla_utils.html#cla_utils.exercises3.householder" title="cla_utils.exercises3.householder"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises3.householder()</span></code></a> to use the <code class="docutils literal notranslate"><span class="pre">kmax</span></code>
 argument. You may make use of the built-in triangular solve
-algorithm <a class="reference external" href="http://scipy.github.io/devdocs/reference/generated/scipy.linalg.solve_triangular.html#scipy.linalg.solve_triangular" title="(in SciPy v1.8.0.dev0+2084.abafdff)"><code class="xref py py-func docutils literal notranslate"><span class="pre">scipy.linalg.solve_triangular()</span></code></a> (we shall consider
+algorithm <a class="reference external" href="http://scipy.github.io/devdocs/reference/generated/scipy.linalg.solve_triangular.html#scipy.linalg.solve_triangular" title="(in SciPy v1.9.0.dev0+1049.c9cdbf2)"><code class="xref py py-func docutils literal notranslate"><span class="pre">scipy.linalg.solve_triangular()</span></code></a> (we shall consider
 triangular matrix algorithms briefly later). The test script
 <code class="docutils literal notranslate"><span class="pre">test_exercises3.py</span></code> in the <code class="docutils literal notranslate"><span class="pre">test</span></code> directory will also test this
 function.</p>
@@ -799,7 +799,7 @@ <h2><span class="section-number">2.7. </span>Application: Least squares problems
 appropriate augmented matrix <span class="math notranslate nohighlight">\(\hat{A}\)</span>, calling
 <a class="reference internal" href="cla_utils.html#cla_utils.exercises3.householder" title="cla_utils.exercises3.householder"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises3.householder()</span></code></a> and extracting appropriate
 subarrays using slice notation, before using
-<a class="reference external" href="http://scipy.github.io/devdocs/reference/generated/scipy.linalg.solve_triangular.html#scipy.linalg.solve_triangular" title="(in SciPy v1.8.0.dev0+2084.abafdff)"><code class="xref py py-func docutils literal notranslate"><span class="pre">scipy.linalg.solve_triangular()</span></code></a> to solve the resulting upper triangular
+<a class="reference external" href="http://scipy.github.io/devdocs/reference/generated/scipy.linalg.solve_triangular.html#scipy.linalg.solve_triangular" title="(in SciPy v1.9.0.dev0+1049.c9cdbf2)"><code class="xref py py-func docutils literal notranslate"><span class="pre">scipy.linalg.solve_triangular()</span></code></a> to solve the resulting upper triangular
 system, before returning the solution <span class="math notranslate nohighlight">\(x\)</span>. The test script
 <code class="docutils literal notranslate"><span class="pre">test_exercises3.py</span></code> in the <code class="docutils literal notranslate"><span class="pre">test</span></code> directory will also test this
 function.</p>

L2_QR_factorisation.html

@@ -746,7 +746,7 @@ <h2><span class="section-number">3.9. </span>Stability<a class="headerlink" href
 <div><div class="math notranslate nohighlight">
 \[\frac{\|\tilde{f}(x)-f(\tilde{x})\|}{\|f(\tilde{x})\|} = \mathcal{O}(\varepsilon),\]</div>
 </div></blockquote>
-<p>for all <span class="math notranslate nohighlight">\(\tilde{x}\)</span> with</p>
+<p>there exists <span class="math notranslate nohighlight">\(\tilde{x}\)</span> with</p>
 <blockquote>
 <div><div class="math notranslate nohighlight">
 \[\frac{\|\tilde{x}-x\|}{\|x\|} = \mathcal{O}(\varepsilon).\]</div>

L3_analysing_algorithms.html

@@ -66,8 +66,8 @@ <h2><span class="section-number">4.1. </span>An algorithm for LU decomposition<a
 <iframe allowfullscreen="true" src="https://player.vimeo.com/video/454095315" style="border: 0; height: 345px; width: 560px">
 </iframe></div></details><p>The computational way to view Gaussian elimination is through the LU
 decomposition of an invertible matrix, <span class="math notranslate nohighlight">\(A=LU\)</span>, where <span class="math notranslate nohighlight">\(L\)</span> is lower
-triangular (<span class="math notranslate nohighlight">\(l_{ij}=0\)</span> for <span class="math notranslate nohighlight">\(j&lt;i\)</span>) and <span class="math notranslate nohighlight">\(U\)</span> is upper triangular
-(<span class="math notranslate nohighlight">\(u_{ij}=0\)</span> for <span class="math notranslate nohighlight">\(j&gt;i\)</span>). Here we use the symbol <span class="math notranslate nohighlight">\(U\)</span> instead of <span class="math notranslate nohighlight">\(R\)</span> to
+triangular (<span class="math notranslate nohighlight">\(l_{ij}=0\)</span> for <span class="math notranslate nohighlight">\(j&gt;i\)</span>) and <span class="math notranslate nohighlight">\(U\)</span> is upper triangular
+(<span class="math notranslate nohighlight">\(u_{ij}=0\)</span> for <span class="math notranslate nohighlight">\(j&lt;i\)</span>). Here we use the symbol <span class="math notranslate nohighlight">\(U\)</span> instead of <span class="math notranslate nohighlight">\(R\)</span> to
 emphasise that we are looking as square matrices.  The process of
 obtaining the <span class="math notranslate nohighlight">\(LU\)</span> decomposition is very similar to the Householder
 algorithm, in that we repeatedly left multiply <span class="math notranslate nohighlight">\(A\)</span> by matrices to
@@ -346,7 +346,7 @@ <h2><span class="section-number">4.1. </span>An algorithm for LU decomposition<a
 They should use forward and backward substitution to solve lower
 and upper triangular systems respectively. The interfaces are set
 so that multiple right hand sides can be provided and solved at the
-same time. The functions should only use one loop over the columns
+same time. The functions should only use one loop over the rows
 of <span class="math notranslate nohighlight">\(L\)</span> (or <span class="math notranslate nohighlight">\(U\)</span>), to efficiently solve the multiple problems. The
 test script <code class="docutils literal notranslate"><span class="pre">test_exercises6.py</span></code> in the <code class="docutils literal notranslate"><span class="pre">test</span></code> directory will
 test these functions.</p>
@@ -672,8 +672,8 @@ <h2><span class="section-number">4.4. </span>Taking advantage of matrix structur
 \end{pmatrix}.\end{split}\]</div>
 </div></blockquote>
 <p>A generalisation of a diagonal matrix is a banded matrix, where
-<span class="math notranslate nohighlight">\(A_{ij}=0\)</span> for <span class="math notranslate nohighlight">\(i&gt;j+p\)</span> and for <span class="math notranslate nohighlight">\(i&lt;j-q\)</span>. We call <span class="math notranslate nohighlight">\(p\)</span> the upper
-bandwidth of <span class="math notranslate nohighlight">\(A\)</span>; <span class="math notranslate nohighlight">\(q\)</span> is the lower bandwidth. When the matrix is
+<span class="math notranslate nohighlight">\(A_{ij}=0\)</span> for <span class="math notranslate nohighlight">\(i&gt;j+p\)</span> and for <span class="math notranslate nohighlight">\(i&lt;j-q\)</span>. We call <span class="math notranslate nohighlight">\(p\)</span> the lower
+bandwidth of <span class="math notranslate nohighlight">\(A\)</span>; <span class="math notranslate nohighlight">\(q\)</span> is the upper bandwidth. When the matrix is
 banded, there are already zeros below the diagonal of <span class="math notranslate nohighlight">\(A\)</span>, so we know
 that the corresponding entries in the <span class="math notranslate nohighlight">\(L_k\)</span> matrices will be zero.
 Further, because there are zeros above the diagonal of <span class="math notranslate nohighlight">\(A\)</span>, these do

L4_LU_decomposition.html

@@ -344,7 +344,7 @@ <h2><span class="section-number">5.3. </span>Similarity transformation to upper
 <li><p><span class="math notranslate nohighlight">\(v_k\gets \mbox{sign}(x_1)\|x\|_2e_1 + x\)</span></p></li>
 <li><p><span class="math notranslate nohighlight">\(v_k\gets v_k/\|v\|_2\)</span></p></li>
 <li><p><span class="math notranslate nohighlight">\(A_{k+1:m,k:m} \gets A_{k+1:m,k:m}- 2v_k(v_k^*A_{k+1:m,k:m})\)</span></p></li>
-<li><p><span class="math notranslate nohighlight">\(A_{1:m,k+1:m} \gets A_{1:m,k+1:m}- 2(A_{1:m,k+1:m,k:m}v_k)v_k^*\)</span></p></li>
+<li><p><span class="math notranslate nohighlight">\(A_{1:m,k+1:m} \gets A_{1:m,k+1:m}- 2(A_{1:m,k+1:m}v_k)v_k^*\)</span></p></li>
 </ul>
 </li>
 <li><p>END FOR</p></li>
@@ -512,7 +512,7 @@ <h2><span class="section-number">5.5. </span>Power iteration<a class="headerlink
 <details>
 <summary>
 Supplementary video</summary><div class="video_wrapper" style="">
-<iframe allowfullscreen="true" src="https://player.vimeo.com/video/454124710" style="border: 0; height: 345px; width: 560px">
+<iframe allowfullscreen="true" src="https://player.vimeo.com/video/454124701" style="border: 0; height: 345px; width: 560px">
 </iframe></div></details><p>Power iteration is a simple method for finding the eigenvalue of
 <span class="math notranslate nohighlight">\(A\)</span> with largest eigenvalue (in magnitude). It is based on the following
 idea. We expand a vector <span class="math notranslate nohighlight">\(v\)</span> in eigenvectors of <span class="math notranslate nohighlight">\(A\)</span>,</p>

L5_eigenvalues.html

@@ -6,15 +6,14 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>cla_utils.exercises8 &#8212; Computational linear algebra course 2020.0 documentation</title>
-    <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
-    <link rel="stylesheet" href="../../_static/fenics.css" type="text/css" />
+    <link rel="stylesheet" type="text/css" href="../../_static/pygments.css" />
+    <link rel="stylesheet" type="text/css" href="../../_static/fenics.css" />
     <link rel="stylesheet" type="text/css" href="../../_static/proof.css" />
-    <script id="documentation_options" data-url_root="../../" src="../../_static/documentation_options.js"></script>
+    <script data-url_root="../../" id="documentation_options" src="../../_static/documentation_options.js"></script>
     <script src="../../_static/jquery.js"></script>
     <script src="../../_static/underscore.js"></script>
     <script src="../../_static/doctools.js"></script>
     <script src="../../_static/proof.js"></script>
-    <script async="async" src="https://cdn.jsdelivr.net/npm/mathjax@2/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
     <link rel="index" title="Index" href="../../genindex.html" />
     <link rel="search" title="Search" href="../../search.html" />
 <!--[if lte IE 6]>
@@ -87,12 +86,13 @@ <h1>Source code for cla_utils.exercises8</h1><div class="highlight"><pre>
 
 <div class="viewcode-block" id="hessenberg_ev"><a class="viewcode-back" href="../../cla_utils.html#cla_utils.exercises8.hessenberg_ev">[docs]</a><span class="k">def</span> <span class="nf">hessenberg_ev</span><span class="p">(</span><span class="n">H</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">    Given a Hessenberg matrix, return the eigenvalues and eigenvectors.</span>
+<span class="sd">    Given a Hessenberg matrix, return the eigenvectors.</span>
 
 <span class="sd">    :param H: an mxm numpy array</span>
 
-<span class="sd">    :return ee: an m dimensional numpy array containing the eigenvalues of H</span>
 <span class="sd">    :return V: an mxm numpy array whose columns are the eigenvectors of H</span>
+
+<span class="sd">    Do not change this function.</span>
 <span class="sd">    &quot;&quot;&quot;</span>
     <span class="n">m</span><span class="p">,</span> <span class="n">n</span> <span class="o">=</span> <span class="n">H</span><span class="o">.</span><span class="n">shape</span>
     <span class="k">assert</span><span class="p">(</span><span class="n">m</span><span class="o">==</span><span class="n">n</span><span class="p">)</span>
@@ -123,7 +123,7 @@ <h1>Source code for cla_utils.exercises8</h1><div class="highlight"><pre>
     </div>
     <div class="footer" role="contentinfo">
         &#169; Copyright 2020, Colin J. Cotter.
-      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 3.4.3.
+      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.2.0.
     </div>
   </body>
 </html>

_modules/cla_utils/exercises8.html

@@ -704,7 +704,7 @@ we have to lower our aspirations depending on the condition number of `A`.
 
 	 \frac{\|\tilde{f}(x)-f(\tilde{x})\|}{\|f(\tilde{x})\|} = \mathcal{O}(\varepsilon),
 
-   for all `\tilde{x}` with
+   there exists `\tilde{x}` with
 
       .. math::
 

_sources/L3_analysing_algorithms.rst.txt

@@ -21,8 +21,8 @@ An algorithm for LU decomposition
 
 The computational way to view Gaussian elimination is through the LU
 decomposition of an invertible matrix, `A=LU`, where `L` is lower
-triangular (`l_{ij}=0` for `j<i`) and `U` is upper triangular
-(`u_{ij}=0` for `j>i`). Here we use the symbol `U` instead of `R` to
+triangular (`l_{ij}=0` for `j>i`) and `U` is upper triangular
+(`u_{ij}=0` for `j<i`). Here we use the symbol `U` instead of `R` to
 emphasise that we are looking as square matrices.  The process of
 obtaining the `LU` decomposition is very similar to the Householder
 algorithm, in that we repeatedly left multiply `A` by matrices to
@@ -324,7 +324,7 @@ requires `m-k+1` multiplications and subtractions, and is iterated
    They should use forward and backward substitution to solve lower
    and upper triangular systems respectively. The interfaces are set
    so that multiple right hand sides can be provided and solved at the
-   same time. The functions should only use one loop over the columns
+   same time. The functions should only use one loop over the rows
    of `L` (or `U`), to efficiently solve the multiple problems. The
    test script ``test_exercises6.py`` in the ``test`` directory will
    test these functions.
@@ -652,8 +652,8 @@ of `A` is
       \end{pmatrix}.
 
 A generalisation of a diagonal matrix is a banded matrix, where
-`A_{ij}=0` for `i>j+p` and for `i<j-q`. We call `p` the upper
-bandwidth of `A`; `q` is the lower bandwidth. When the matrix is
+`A_{ij}=0` for `i>j+p` and for `i<j-q`. We call `p` the lower
+bandwidth of `A`; `q` is the upper bandwidth. When the matrix is
 banded, there are already zeros below the diagonal of `A`, so we know
 that the corresponding entries in the `L_k` matrices will be zero.
 Further, because there are zeros above the diagonal of `A`, these do

_sources/L4_LU_decomposition.rst.txt

@@ -287,7 +287,7 @@ pseudo-code.
   * `v_k\gets \mbox{sign}(x_1)\|x\|_2e_1 + x`
   * `v_k\gets v_k/\|v\|_2`
   * `A_{k+1:m,k:m} \gets A_{k+1:m,k:m}- 2v_k(v_k^*A_{k+1:m,k:m})`
-  * `A_{1:m,k+1:m} \gets A_{1:m,k+1:m}- 2(A_{1:m,k+1:m,k:m}v_k)v_k^*`
+  * `A_{1:m,k+1:m} \gets A_{1:m,k+1:m}- 2(A_{1:m,k+1:m}v_k)v_k^*`
 * END FOR
 
 Note the similarities and differences with the Householder algorithm
@@ -456,7 +456,7 @@ Power iteration
 
 .. details:: Supplementary video
 
-   .. vimeo:: 454124710
+   .. vimeo:: 454124701
 
 Power iteration is a simple method for finding the eigenvalue of
 `A` with largest eigenvalue (in magnitude). It is based on the following

_sources/L5_eigenvalues.rst.txt

@@ -30,3 +30,14 @@ repositories for Autumn 2021. An up to date version is in the
 7. Corrected the sign of inequalities in :code:`test_solve_U` and
    :code:`test_solve_L`. And then uncorrected them again, they were right
    in the first place.
+
+8. Fixed the sign of the inequalities in the discussion of $L$ and $U$ matrices.
+
+9. Loop over rows, not columns in solve_U and solve_L.
+
+10. Use integers for permutations in test_perm.
+
+11. Remove line break from description in setup.py for compatibility with release v59.0.0 of setuptools.
+
+12. Corrected the docstring in :code:`hessenberg_ev`, as it only returns
+the eigenvectors.