Website build

colinjcotter · colinjcotter · commit 4c984580e101 · 2022-10-04T16:50:22.000+01:00
diff --git a/Computationallinearalgebracourse.pdf b/Computationallinearalgebracourse.pdf
diff --git a/L1_preliminaries.html b/L1_preliminaries.html
@@ -694,7 +694,7 @@ <h2><span class="section-number">1.7. </span>Unitary matrices<a class="headerlin
         <span class="proof-type">Exercise 1.23</span>
         
     </div><div class="proof-content">
-<p>The <a class="reference internal" href="cla_utils.html#cla_utils.exercises2.solveQ" title="cla_utils.exercises2.solveQ"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises2.solveQ()</span></code></a> function has been left
+<p>The <code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises2.solveQ()</span></code> function has been left
 unimplemented. Given a square unitary matrix <span class="math notranslate nohighlight">\(Q\)</span> and a vector <span class="math notranslate nohighlight">\(b\)</span>
 it should solve <span class="math notranslate nohighlight">\(Qx=b\)</span> using information above (it is not expected
 to work when <span class="math notranslate nohighlight">\(Q\)</span> is not unitary or square). The test script
diff --git a/L2_QR_factorisation.html b/L2_QR_factorisation.html
@@ -710,7 +710,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.10.0.dev0+1685.9578695)"><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.10.0.dev0+1989.d4a75c8)"><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>
@@ -840,7 +840,7 @@ <h2><span class="section-number">2.7. </span>Application: Least squares problems
 by forming an 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.10.0.dev0+1685.9578695)"><code class="xref py py-func docutils literal notranslate"><span class="pre">scipy.linalg.solve_triangular()</span></code></a> to solve the resulting upper
+<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.10.0.dev0+1989.d4a75c8)"><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>
diff --git a/L3_analysing_algorithms.html b/L3_analysing_algorithms.html
@@ -984,9 +984,9 @@ <h2><span class="section-number">3.11. </span>Backward stability for solving a l
         <span class="proof-type">Exercise 3.26</span>
         
     </div><div class="proof-content">
-<p>Complete the function <a class="reference internal" href="cla_utils.html#cla_utils.exercises5.back_stab_solve_R" title="cla_utils.exercises5.back_stab_solve_R"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises5.back_stab_solve_R()</span></code></a>
+<p>Complete the function <a class="reference internal" href="cla_utils.html#cla_utils.exercises5.back_stab_solve_U" title="cla_utils.exercises5.back_stab_solve_U"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises5.back_stab_solve_U()</span></code></a>
 so that it verifies backward stability for back substitution, using
-<code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises5.solve_R()</span></code>.</p>
+<code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises5.solve_U()</span></code>.</p>
 </div></div><p>Using the individual backward stability of these three algorithms,
 we show the following result.</p>
 <div class="proof proof-type-theorem" id="id27">
diff --git a/L4_LU_decomposition.html b/L4_LU_decomposition.html
@@ -622,7 +622,7 @@ <h2><span class="section-number">4.3. </span>Stability of LU factorisation<a cla
 factor,</p>
 <blockquote>
 <div><div class="math notranslate nohighlight">
-\[\rho = \frac{\max_{ij}|u_{ij}|}{|a_{ij}|}.\]</div>
+\[\rho = \frac{\max_{ij}|u_{ij}|}{\max_{ij}|a_{ij}|}.\]</div>
 </div></blockquote>
 </div></div><p>Thus, partial pivoting (and complete pivoting turns out not to help
 much extra) can keep the entries in <span class="math notranslate nohighlight">\(L\)</span> under control, but there can
diff --git a/L5_eigenvalues.html b/L5_eigenvalues.html
@@ -499,7 +499,7 @@ <h2><span class="section-number">5.4. </span>Rayleigh quotient<a class="headerli
 <li><p>Finding an eigenvector <span class="math notranslate nohighlight">\(v\)</span> of <span class="math notranslate nohighlight">\(A\)</span> with eigenvalue <span class="math notranslate nohighlight">\(\lambda\)</span> (you can use <a class="reference external" href="https://numpy.org/doc/stable/reference/generated/numpy.linalg.eig.html#numpy.linalg.eig" title="(in NumPy v1.23)"><code class="xref py py-func docutils literal notranslate"><span class="pre">numpy.linalg.eig()</span></code></a> for this),</p></li>
 <li><p>Choosing a perturbation vector <span class="math notranslate nohighlight">\(r\)</span>, and perturbation parameter <span class="math notranslate nohighlight">\(\epsilon&gt;0\)</span>,</p></li>
 <li><p>Comparing the Rayleigh quotient of <span class="math notranslate nohighlight">\(v + \epsilon r\)</span> with <span class="math notranslate nohighlight">\(\lambda\)</span>,</p></li>
-<li><p>Plotting (on a log-log graph, use <a class="reference external" href="https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.loglog.html#matplotlib.pyplot.loglog" title="(in Matplotlib v3.5.3)"><code class="xref py py-func docutils literal notranslate"><span class="pre">matplotlib.pyplot.loglog()</span></code></a>) the error in estimating the eigenvalue as a function of <span class="math notranslate nohighlight">\(\epsilon\)</span>.</p></li>
+<li><p>Plotting (on a log-log graph, use <a class="reference external" href="https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.loglog.html#matplotlib.pyplot.loglog" title="(in Matplotlib v3.6.0)"><code class="xref py py-func docutils literal notranslate"><span class="pre">matplotlib.pyplot.loglog()</span></code></a>) the error in estimating the eigenvalue as a function of <span class="math notranslate nohighlight">\(\epsilon\)</span>.</p></li>
 </ol>
 <p>The best way to do this is to plot the computed data values as points,
 and then superpose a line plot of <span class="math notranslate nohighlight">\(a\epsilon^k\)</span> for appropriate
@@ -773,7 +773,7 @@ <h2><span class="section-number">5.8. </span>The pure QR algorithm<a class="head
 <a class="reference internal" href="cla_utils.html#cla_utils.exercises9.get_B100" title="cla_utils.exercises9.get_B100"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises9.get_B100()</span></code></a>,
 <a class="reference internal" href="cla_utils.html#cla_utils.exercises9.get_C100" title="cla_utils.exercises9.get_C100"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises9.get_C100()</span></code></a>, and
 <a class="reference internal" href="cla_utils.html#cla_utils.exercises9.get_D100" title="cla_utils.exercises9.get_D100"><code class="xref py py-func docutils literal notranslate"><span class="pre">cla_utils.exercises9.get_D100()</span></code></a>. You can use
-<a class="reference external" href="https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.pcolor.html#matplotlib.pyplot.pcolor" title="(in Matplotlib v3.5.3)"><code class="xref py py-func docutils literal notranslate"><span class="pre">matplotlib.pyplot.pcolor()</span></code></a> to visualise the entries,
+<a class="reference external" href="https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.pcolor.html#matplotlib.pyplot.pcolor" title="(in Matplotlib v3.6.0)"><code class="xref py py-func docutils literal notranslate"><span class="pre">matplotlib.pyplot.pcolor()</span></code></a> to visualise the entries,
 or compute norms of the components of the matrices below the diagonal,
 for example. What do you observe? How does this relate to the structure
 of the four matrices?</p>
@@ -1012,7 +1012,7 @@ <h2><span class="section-number">5.11. </span>The practical QR algorithm<a class
 <p>This is very cheap, we just read off the bottom right-hand corner
 from <span class="math notranslate nohighlight">\(A^{(k)}\)</span>! This is called the Rayleigh quotient shift.</p>
 <p>It turns out that the Rayleigh quotient shift is not guaranteed to
-work in all cases, so there is an alernative approach called the
+work in all cases, so there is an alternative approach called the
 Wilkinson shift, but we won’t discuss that here.</p>
 </section>
 </section>
diff --git a/L6_krylov.html b/L6_krylov.html
@@ -364,13 +364,15 @@ <h2><span class="section-number">6.4. </span>Convergence of GMRES<a class="heade
 well-conditioned, and <span class="math notranslate nohighlight">\(p(x)\)</span> is small for all <span class="math notranslate nohighlight">\(x\in \Lambda(A)\)</span>.  This
 latter condition is not trivial due to the <span class="math notranslate nohighlight">\(p(0)=1\)</span> requirement. One
 way it can happen is if <span class="math notranslate nohighlight">\(A\)</span> has all eigenvalues clustered in a small
-number of groups. Then we can find a low degree polynomial that passes
-through 1 at <span class="math notranslate nohighlight">\(x=0\)</span>, and 0 near each of the clusters. Then GMRES will
-essentially converge in a small number of iterations (equal to the
-degree of the polynomial). There are problems if the eigenvalues are
-scattered over a wide region of the complex plane: we need a very
-high degree polynomial to make <span class="math notranslate nohighlight">\(p(x)\)</span> small at all the eigenvalues and
-hence we need a very large number of iterations.</p>
+number of groups, away from $0$. Then we can find a low degree
+polynomial that passes through 1 at <span class="math notranslate nohighlight">\(x=0\)</span>, and 0 near each of the
+clusters. Then GMRES will essentially converge in a small number of
+iterations (equal to the degree of the polynomial). There are problems
+if the eigenvalues are scattered over a wide region of the complex
+plane: we need a very high degree polynomial to make <span class="math notranslate nohighlight">\(p(x)\)</span> small at
+all the eigenvalues and hence we need a very large number of
+iterations. Similarly there are problems if eigenvalues are very close
+to zero.</p>
 <div class="proof proof-type-exercise" id="id4">
 
     <div class="proof-title">
diff --git a/_modules/cla_utils/exercises2.html b/_modules/cla_utils/exercises2.html
@@ -5,7 +5,7 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>cla_utils.exercises2 &#8212; Computational linear algebra course 2020.0 documentation</title>
+    <title>cla_utils.exercises2 &#8212; Computational linear algebra course 2022.0 documentation</title>
     <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" />
@@ -68,7 +68,7 @@ <h1>Source code for cla_utils.exercises2</h1><div class="highlight"><pre>
     <span class="k">return</span> <span class="n">r</span><span class="p">,</span> <span class="n">u</span></div>
 
 
-<div class="viewcode-block" id="solveQ"><a class="viewcode-back" href="../../cla_utils.html#cla_utils.exercises2.solveQ">[docs]</a><span class="k">def</span> <span class="nf">solveQ</span><span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
+<div class="viewcode-block" id="solve_Q"><a class="viewcode-back" href="../../cla_utils.html#cla_utils.exercises2.solve_Q">[docs]</a><span class="k">def</span> <span class="nf">solve_Q</span><span class="p">(</span><span class="n">Q</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Given a unitary mxm matrix Q and a vector b, solve Qx=b for x.</span>
 
@@ -194,7 +194,7 @@ <h1>Source code for cla_utils.exercises2</h1><div class="highlight"><pre>
       <div class="clearer"></div>
     </div>
     <div class="footer" role="contentinfo">
-        &#169; Copyright 2020, Colin J. Cotter.
+        &#169; Copyright 2020-2022, Colin J. Cotter.
       Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.2.0.
     </div>
   </body>
diff --git a/_modules/cla_utils/exercises5.html b/_modules/cla_utils/exercises5.html
@@ -88,7 +88,7 @@ <h1>Source code for cla_utils.exercises5</h1><div class="highlight"><pre>
         <span class="k">raise</span> <span class="ne">NotImplementedError</span></div>
 
 
-<div class="viewcode-block" id="back_stab_solve_R"><a class="viewcode-back" href="../../cla_utils.html#cla_utils.exercises5.back_stab_solve_R">[docs]</a><span class="k">def</span> <span class="nf">back_stab_solve_R</span><span class="p">(</span><span class="n">m</span><span class="p">):</span>
+<div class="viewcode-block" id="back_stab_solve_U"><a class="viewcode-back" href="../../cla_utils.html#cla_utils.exercises5.back_stab_solve_U">[docs]</a><span class="k">def</span> <span class="nf">back_stab_solve_U</span><span class="p">(</span><span class="n">m</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Verify backward stability for back substitution for</span>
 <span class="sd">    real mxm matrices.</span>
diff --git a/_sources/L3_analysing_algorithms.rst.txt b/_sources/L3_analysing_algorithms.rst.txt
@@ -940,9 +940,9 @@ for some upper triangular perturbation such that `\|\delta
 
 .. proof:exercise::
 
-   Complete the function :func:`cla_utils.exercises5.back_stab_solve_R`
+   Complete the function :func:`cla_utils.exercises5.back_stab_solve_U`
    so that it verifies backward stability for back substitution, using
-   :func:`cla_utils.exercises5.solve_R`.
+   :func:`cla_utils.exercises5.solve_U`.
 
 Using the individual backward stability of these three algorithms,
 we show the following result.
diff --git a/_sources/L4_LU_decomposition.rst.txt b/_sources/L4_LU_decomposition.rst.txt
@@ -596,7 +596,7 @@ in the following result (which we also do not prove).
 
       .. math::
 
-	 \rho = \frac{\max_{ij}|u_{ij}|}{|a_{ij}|}.
+	 \rho = \frac{\max_{ij}|u_{ij}|}{\max_{ij}|a_{ij}|}.
 
 Thus, partial pivoting (and complete pivoting turns out not to help
 much extra) can keep the entries in `L` under control, but there can
diff --git a/_sources/L5_eigenvalues.rst.txt b/_sources/L5_eigenvalues.rst.txt
@@ -938,5 +938,5 @@ This is very cheap, we just read off the bottom right-hand corner
 from `A^{(k)}`! This is called the Rayleigh quotient shift.
 
 It turns out that the Rayleigh quotient shift is not guaranteed to
-work in all cases, so there is an alernative approach called the
+work in all cases, so there is an alternative approach called the
 Wilkinson shift, but we won't discuss that here.
diff --git a/_sources/L6_krylov.rst.txt b/_sources/L6_krylov.rst.txt
@@ -338,13 +338,15 @@ Hence we see that GMRES will converge quickly if `V` is
 well-conditioned, and `p(x)` is small for all `x\in \Lambda(A)`.  This
 latter condition is not trivial due to the `p(0)=1` requirement. One
 way it can happen is if `A` has all eigenvalues clustered in a small
-number of groups. Then we can find a low degree polynomial that passes
-through 1 at `x=0`, and 0 near each of the clusters. Then GMRES will
-essentially converge in a small number of iterations (equal to the
-degree of the polynomial). There are problems if the eigenvalues are
-scattered over a wide region of the complex plane: we need a very
-high degree polynomial to make `p(x)` small at all the eigenvalues and
-hence we need a very large number of iterations.
+number of groups, away from $0$. Then we can find a low degree
+polynomial that passes through 1 at `x=0`, and 0 near each of the
+clusters. Then GMRES will essentially converge in a small number of
+iterations (equal to the degree of the polynomial). There are problems
+if the eigenvalues are scattered over a wide region of the complex
+plane: we need a very high degree polynomial to make `p(x)` small at
+all the eigenvalues and hence we need a very large number of
+iterations. Similarly there are problems if eigenvalues are very close
+to zero.
 
 .. proof:exercise::
 
diff --git a/_sources/exercises.rst.txt b/_sources/exercises.rst.txt
@@ -252,6 +252,20 @@ checked out (this should contain folders called `doc`, `cla_utils`,
 
 This creates a venv called "clavenv" (it is recommended you keep this
 name to avoid spuriously committing venv files to the git repository).
+  
+.. hint::
+
+   There is an alternative method if you are using Anaconda Python. In
+   this case, you need to type::
+
+     conda create --name clavenv
+     
+.. hint::
+
+   If you decide to give your venv a different name, please add that
+   name to the .gitignore file in your git repository. If you don't
+   know what this means, probably best to use the name "clavenv".
+  
 
 In VSCode, you will be asked if you want to make this venv the default
 for your project. Select "yes" as this will help to ensure that it is
@@ -294,6 +308,11 @@ On Windows the command is::
 Obviously if you are typing this in a folder other than the one
 containing the venv, you need to modify the path accordingly.
 
+If you are using Anaconda Python, you need to instead type::
+
+  conda activate clavenv
+  conda deactivate
+  
 Installing the course package to the venv
 -----------------------------------------
 
@@ -425,21 +444,21 @@ check the code you have just written. These are located in the
 ``test`` folder and employ the `pytest <http://pytest.org/>`_
 testing framework. You run the tests with:: 
 
-   py.test test_script.py
+   pytest test_script.py
 
 from the bash Terminal, replacing ``test_script.py`` with the appropriate
-test file name. The ``-x`` option to ``py.test`` will cause the test
+test file name. The ``-x`` option to ``pytest`` will cause the test
 to stop at the first failure it finds, which is often the best place
 to start fixing a problem. For those familiar with debuggers, the
 ``--pdb`` option will drop you into the Python debugger at the first
 error.
 
-You can also run all the tests by running ``py.test`` on the tests
+You can also run all the tests by running ``pytest`` on the tests
 folder. This works particularly well with the -x option, resulting
 in the tests being run in course order and stopping at the first
 failing test::
 
-  py.test -x tests/
+  pytest -x tests/
 
 You should make sure that your code passes tests before moving on
 to the next exercise.
diff --git a/cla_utils.html b/cla_utils.html
diff --git a/exercises.html b/exercises.html
diff --git a/genindex.html b/genindex.html
diff --git a/objects.inv b/objects.inv
diff --git a/searchindex.js b/searchindex.js
