build based on c7cba5f

dev/.documenter-siteinfo.json

@@ -1 +1 @@
-{"documenter":{"julia_version":"1.10.5","generation_timestamp":"2024-09-02T11:57:03","documenter_version":"1.6.0"}}
+{"documenter":{"julia_version":"1.10.5","generation_timestamp":"2024-09-09T15:08:46","documenter_version":"1.7.0"}}

dev/julia_mpi.ipynb

@@ -1497,46 +1497,46 @@
     "function matmul_mpi_3!(C,A,B)\n",
     "```\n",
     "\n",
-    "Assume that the input matrices `A` and `B` are given only on rank 0, the other ranks get dummy matrices with zero rows and zero columns to save memory. You need to communicate the required parts to other ranks. For simplicity you can assume that `A` and `B` are square matrices and that the number of rows is a multiple of the number of processes (on rank 0). The result `C` should be overwritten only on rank 0. You can use the following cell to implement and check your result."
+    "Assume that the input matrices `A` and `B` are given only on rank 0, the other ranks get dummy matrices with zero rows and zero columns to save memory. You need to communicate the required parts to other ranks. For simplicity you can assume that `A` and `B` are square matrices and that the number of rows is a multiple of the number of processes (on rank 0). The result `C` should be overwritten only on rank 0. You can use the following cell to implement and check your result. Copy the code below to a file called `ex1.jl`. Modify the file (e.g. with vscode).  Run it from the Julia REPL using the `run` function as explained in the [Getting Started tutorial](https://www.francescverdugo.com/XM_40017/dev/getting_started_with_julia/#Running-MPI-code)."
    ]
   },
   {
-   "cell_type": "code",
+   "cell_type": "markdown",
-   "execution_count": null,
+   "id": "4fa53366",
-   "id": "265c4593",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "code = quote\n",
+    "```julia\n",
-    "    using MPI\n",
+    "# ex1.jl (begin)\n",
-    "    MPI.Init()\n",
+    "using MPI\n",
-    "    function matmul_mpi_3!(C,A,B)\n",
+    "MPI.Init()\n",
-    "        # Implement here\n",
+    "function matmul_mpi_3!(C,A,B)\n",
-    "    end\n",
+    "    # Implement here\n",
-    "    function testit(load)\n",
-    "        comm = MPI.COMM_WORLD\n",
-    "        rank = MPI.Comm_rank(comm)\n",
-    "        if rank == 0\n",
-    "            P = MPI.Comm_size(comm)\n",
-    "            N = load*P\n",
-    "        else\n",
-    "            N = 0\n",
-    "        end\n",
-    "        A = rand(N,N)\n",
-    "        B = rand(N,N)\n",
-    "        C = similar(A)\n",
-    "        matmul_mpi_3!(C,A,B)\n",
-    "        if rank == 0\n",
-    "            if !(C ≈ A*B)\n",
-    "                println(\"Check not passed\")\n",
-    "            else\n",
-    "                println(\"Check passed!\")\n",
-    "            end\n",
-    "        end\n",
-    "    end\n",
-    "    testit(100)\n",
     "end\n",
-    "run(`$(mpiexec()) -np 4 julia --project=. -e $code`);"
+    "function testit(load)\n",
+    "    comm = MPI.COMM_WORLD\n",
+    "    rank = MPI.Comm_rank(comm)\n",
+    "    if rank == 0\n",
+    "        P = MPI.Comm_size(comm)\n",
+    "        N = load*P\n",
+    "    else\n",
+    "        N = 0\n",
+    "    end\n",
+    "    A = rand(N,N)\n",
+    "    B = rand(N,N)\n",
+    "    C = similar(A)\n",
+    "    matmul_mpi_3!(C,A,B)\n",
+    "    if rank == 0\n",
+    "        if !(C ≈ A*B)\n",
+    "            println(\"Test failed 😢\")\n",
+    "        else\n",
+    "            println(\"Test passed 🥳\")\n",
+    "        end\n",
+    "    end\n",
+    "end\n",
+    "testit(100)\n",
+    "end\n",
+    "# ex1.jl (end)\n",
+    "```"
    ]
   },
   {
@@ -1548,7 +1548,7 @@
     "\n",
     "Implement this \"simple\" algorithm (the telephone game):\n",
     "\n",
-    "Rank 0 generates a message (an integer). Rank 0 sends the message to rank 1. Rank 1 receives the message, increments the message by 1, and sends the result to rank 2. Rank 2 receives the message, increments the message by 1, and sends the result to rank 3. Etc. The last rank sends back the message to rank 0 closing the ring. See the next figure. Implement the communications using MPI. Do not use `Distributed`.\n"
+    "Rank 0 generates a message (an integer). Rank 0 sends the message to rank 1. Rank 1 receives the message, increments the message by 1, and sends the result to rank 2. Rank 2 receives the message, increments the message by 1, and sends the result to rank 3. Etc. The last rank sends back the message to rank 0 closing the ring. See the next figure. Implement the communications using MPI. Do not use `Distributed`. Use a text editor and the Julia REPL. Do not try to implement the code in a notebook.\n"
    ]
   },
   {

dev/julia_mpi_src/index.html

@@ -9171,54 +9171,52 @@ a.anchor-link {
 <h3 id="Exercise-1">Exercise 1<a class="anchor-link" href="#Exercise-1">¶</a></h3><p>Implement the parallel matrix-matrix multiplication (Algorithm 3) in previous notebook using MPI instead of <code>Distributed</code>. Use this function signature:</p>
 <div class="highlight"><pre><span></span><span class="k">function</span><span class="w"> </span><span class="n">matmul_mpi_3!</span><span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">)</span>
 </pre></div>
-<p>Assume that the input matrices <code>A</code> and <code>B</code> are given only on rank 0, the other ranks get dummy matrices with zero rows and zero columns to save memory. You need to communicate the required parts to other ranks. For simplicity you can assume that <code>A</code> and <code>B</code> are square matrices and that the number of rows is a multiple of the number of processes (on rank 0). The result <code>C</code> should be overwritten only on rank 0. You can use the following cell to implement and check your result.</p>
+<p>Assume that the input matrices <code>A</code> and <code>B</code> are given only on rank 0, the other ranks get dummy matrices with zero rows and zero columns to save memory. You need to communicate the required parts to other ranks. For simplicity you can assume that <code>A</code> and <code>B</code> are square matrices and that the number of rows is a multiple of the number of processes (on rank 0). The result <code>C</code> should be overwritten only on rank 0. You can use the following cell to implement and check your result. Copy the code below to a file called <code>ex1.jl</code>. Modify the file (e.g. with vscode).  Run it from the Julia REPL using the <code>run</code> function as explained in the <a href="https://www.francescverdugo.com/XM_40017/dev/getting_started_with_julia/#Running-MPI-code">Getting Started tutorial</a>.</p>
 </div>
 </div>
 </div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs" id="cell-id=265c4593">
+</div>
+<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=4fa53366">
 <div class="jp-Cell-inputWrapper" tabindex="0">
 <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
 </div>
-<div class="jp-InputArea jp-Cell-inputArea">
+<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [ ]:</div>
+</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+<div class="highlight"><pre><span></span><span class="c"># ex1.jl (begin)</span>
-<div class="cm-editor cm-s-jupyter">
+<span class="k">using</span><span class="w"> </span><span class="n">MPI</span>
-<div class="highlight hl-julia"><pre><span></span><span class="n">code</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="k">quote</span>
+<span class="n">MPI</span><span class="o">.</span><span class="n">Init</span><span class="p">()</span>
-<span class="w">    </span><span class="k">using</span><span class="w"> </span><span class="n">MPI</span>
+<span class="k">function</span><span class="w"> </span><span class="n">matmul_mpi_3!</span><span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">)</span>
-<span class="w">    </span><span class="n">MPI</span><span class="o">.</span><span class="n">Init</span><span class="p">()</span>
+<span class="w">    </span><span class="c"># Implement here</span>
-<span class="w">    </span><span class="k">function</span><span class="w"> </span><span class="n">matmul_mpi_3!</span><span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">)</span>
-<span class="w">        </span><span class="c"># Implement here</span>
-<span class="w">    </span><span class="k">end</span>
-<span class="w">    </span><span class="k">function</span><span class="w"> </span><span class="n">testit</span><span class="p">(</span><span class="n">load</span><span class="p">)</span>
-<span class="w">        </span><span class="n">comm</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MPI</span><span class="o">.</span><span class="n">COMM_WORLD</span>
-<span class="w">        </span><span class="n">rank</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MPI</span><span class="o">.</span><span class="n">Comm_rank</span><span class="p">(</span><span class="n">comm</span><span class="p">)</span>
-<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="n">rank</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
-<span class="w">            </span><span class="n">P</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MPI</span><span class="o">.</span><span class="n">Comm_size</span><span class="p">(</span><span class="n">comm</span><span class="p">)</span>
-<span class="w">            </span><span class="n">N</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">load</span><span class="o">*</span><span class="n">P</span>
-<span class="w">        </span><span class="k">else</span>
-<span class="w">            </span><span class="n">N</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
-<span class="w">        </span><span class="k">end</span>
-<span class="w">        </span><span class="n">A</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">rand</span><span class="p">(</span><span class="n">N</span><span class="p">,</span><span class="n">N</span><span class="p">)</span>
-<span class="w">        </span><span class="n">B</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">rand</span><span class="p">(</span><span class="n">N</span><span class="p">,</span><span class="n">N</span><span class="p">)</span>
-<span class="w">        </span><span class="n">C</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">similar</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
-<span class="w">        </span><span class="n">matmul_mpi_3!</span><span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">)</span>
-<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="n">rank</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
-<span class="w">            </span><span class="k">if</span><span class="w"> </span><span class="o">!</span><span class="p">(</span><span class="n">C</span><span class="w"> </span><span class="o">≈</span><span class="w"> </span><span class="n">A</span><span class="o">*</span><span class="n">B</span><span class="p">)</span>
-<span class="w">                </span><span class="n">println</span><span class="p">(</span><span class="s">"Check not passed"</span><span class="p">)</span>
-<span class="w">            </span><span class="k">else</span>
-<span class="w">                </span><span class="n">println</span><span class="p">(</span><span class="s">"Check passed!"</span><span class="p">)</span>
-<span class="w">            </span><span class="k">end</span>
-<span class="w">        </span><span class="k">end</span>
-<span class="w">    </span><span class="k">end</span>
-<span class="w">    </span><span class="n">testit</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
 <span class="k">end</span>
-<span class="n">run</span><span class="p">(</span><span class="sb">`</span><span class="si">$</span><span class="p">(</span><span class="n">mpiexec</span><span class="p">())</span><span class="sb"> -np 4 julia --project=. -e </span><span class="si">$code</span><span class="sb">`</span><span class="p">);</span>
+<span class="k">function</span><span class="w"> </span><span class="n">testit</span><span class="p">(</span><span class="n">load</span><span class="p">)</span>
+<span class="w">    </span><span class="n">comm</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MPI</span><span class="o">.</span><span class="n">COMM_WORLD</span>
+<span class="w">    </span><span class="n">rank</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MPI</span><span class="o">.</span><span class="n">Comm_rank</span><span class="p">(</span><span class="n">comm</span><span class="p">)</span>
+<span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="n">rank</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
+<span class="w">        </span><span class="n">P</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">MPI</span><span class="o">.</span><span class="n">Comm_size</span><span class="p">(</span><span class="n">comm</span><span class="p">)</span>
+<span class="w">        </span><span class="n">N</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">load</span><span class="o">*</span><span class="n">P</span>
+<span class="w">    </span><span class="k">else</span>
+<span class="w">        </span><span class="n">N</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">0</span>
+<span class="w">    </span><span class="k">end</span>
+<span class="w">    </span><span class="n">A</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">rand</span><span class="p">(</span><span class="n">N</span><span class="p">,</span><span class="n">N</span><span class="p">)</span>
+<span class="w">    </span><span class="n">B</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">rand</span><span class="p">(</span><span class="n">N</span><span class="p">,</span><span class="n">N</span><span class="p">)</span>
+<span class="w">    </span><span class="n">C</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">similar</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
+<span class="w">    </span><span class="n">matmul_mpi_3!</span><span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">)</span>
+<span class="w">    </span><span class="k">if</span><span class="w"> </span><span class="n">rank</span><span class="w"> </span><span class="o">==</span><span class="w"> </span><span class="mi">0</span>
+<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="o">!</span><span class="p">(</span><span class="n">C</span><span class="w"> </span><span class="o">≈</span><span class="w"> </span><span class="n">A</span><span class="o">*</span><span class="n">B</span><span class="p">)</span>
+<span class="w">            </span><span class="n">println</span><span class="p">(</span><span class="s">"Test failed 😢"</span><span class="p">)</span>
+<span class="w">        </span><span class="k">else</span>
+<span class="w">            </span><span class="n">println</span><span class="p">(</span><span class="s">"Test passed 🥳"</span><span class="p">)</span>
+<span class="w">        </span><span class="k">end</span>
+<span class="w">    </span><span class="k">end</span>
+<span class="k">end</span>
+<span class="n">testit</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
+<span class="k">end</span>
+<span class="c"># ex1.jl (end)</span>
 </pre></div>
 </div>
 </div>
 </div>
 </div>
-</div>
 <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=a8e1c623">
 <div class="jp-Cell-inputWrapper" tabindex="0">
 <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
@@ -9226,7 +9224,7 @@ a.anchor-link {
 <div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
 </div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
 <h3 id="Exercise-2">Exercise 2<a class="anchor-link" href="#Exercise-2">¶</a></h3><p>Implement this "simple" algorithm (the telephone game):</p>
-<p>Rank 0 generates a message (an integer). Rank 0 sends the message to rank 1. Rank 1 receives the message, increments the message by 1, and sends the result to rank 2. Rank 2 receives the message, increments the message by 1, and sends the result to rank 3. Etc. The last rank sends back the message to rank 0 closing the ring. See the next figure. Implement the communications using MPI. Do not use <code>Distributed</code>.</p>
+<p>Rank 0 generates a message (an integer). Rank 0 sends the message to rank 1. Rank 1 receives the message, increments the message by 1, and sends the result to rank 2. Rank 2 receives the message, increments the message by 1, and sends the result to rank 3. Etc. The last rank sends back the message to rank 0 closing the ring. See the next figure. Implement the communications using MPI. Do not use <code>Distributed</code>. Use a text editor and the Julia REPL. Do not try to implement the code in a notebook.</p>
 </div>
 </div>
 </div>

dev/mpi_collectives.ipynb

@@ -898,77 +898,6 @@
     "After learning this material and the previous MPI notebook, you have a solid basis to start implementing sophisticated parallel algorithms using MPI."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "c6b23485",
-   "metadata": {},
-   "source": [
-    "## Exercises"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "90dc58bb",
-   "metadata": {},
-   "source": [
-    "### Exercise 1\n",
-    "\n",
-    "In the parallel implementation of the Jacobi method in previous notebook, we assumed that the method runs for a given number of iterations. However, other stopping criteria are used in practice. The following sequential code implements a version of Jacobi in which the method iterates until the norm of the difference between u and u_new is below a tolerance.\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0fcb0cd6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "function jacobi_with_tol(n,tol)\n",
-    "    u = zeros(n+2)\n",
-    "    u[1] = -1\n",
-    "    u[end] = 1\n",
-    "    u_new = copy(u)\n",
-    "    increment = similar(u)\n",
-    "    while true\n",
-    "        for i in 2:(n+1)\n",
-    "            u_new[i] = 0.5*(u[i-1]+u[i+1])\n",
-    "        end\n",
-    "        increment .= u_new .- u\n",
-    "        norm_increment = 0.0\n",
-    "        for i in 1:n\n",
-    "            increment_i = increment[i]\n",
-    "            norm_increment += increment_i*increment_i\n",
-    "        end\n",
-    "        norm_increment = sqrt(norm_increment)\n",
-    "        if norm_increment < tol*n\n",
-    "            return u_new\n",
-    "        end\n",
-    "        u, u_new = u_new, u\n",
-    "    end\n",
-    "    u\n",
-    "end"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "dbf0c3b8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "n = 10\n",
-    "tol = 1e-12\n",
-    "jacobi_with_tol(n,tol)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "aab1455e",
-   "metadata": {},
-   "source": [
-    "Implement a parallel version of this algorithm. Recommended: start with the parallel implementation given in the previous notebook (see function `jacobi_mpi`) and introduce the new stopping criteria. Think carefully about which MPI operations you need to use in this case."
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "5e8f6e6a",

dev/mpi_collectives_src/index.html

@@ -8451,92 +8451,6 @@ a.anchor-link {
 </div>
 </div>
 </div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=c6b23485">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h2 id="Exercises">Exercises<a class="anchor-link" href="#Exercises">¶</a></h2>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=90dc58bb">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="Exercise-1">Exercise 1<a class="anchor-link" href="#Exercise-1">¶</a></h3><p>In the parallel implementation of the Jacobi method in previous notebook, we assumed that the method runs for a given number of iterations. However, other stopping criteria are used in practice. The following sequential code implements a version of Jacobi in which the method iterates until the norm of the difference between u and u_new is below a tolerance.</p>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs" id="cell-id=0fcb0cd6">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [ ]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-julia"><pre><span></span><span class="k">function</span><span class="w"> </span><span class="n">jacobi_with_tol</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">tol</span><span class="p">)</span>
-<span class="w">    </span><span class="n">u</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">zeros</span><span class="p">(</span><span class="n">n</span><span class="o">+</span><span class="mi">2</span><span class="p">)</span>
-<span class="w">    </span><span class="n">u</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="o">-</span><span class="mi">1</span>
-<span class="w">    </span><span class="n">u</span><span class="p">[</span><span class="k">end</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span>
-<span class="w">    </span><span class="n">u_new</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">copy</span><span class="p">(</span><span class="n">u</span><span class="p">)</span>
-<span class="w">    </span><span class="n">increment</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">similar</span><span class="p">(</span><span class="n">u</span><span class="p">)</span>
-<span class="w">    </span><span class="k">while</span><span class="w"> </span><span class="nb">true</span>
-<span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="mi">2</span><span class="o">:</span><span class="p">(</span><span class="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
-<span class="w">            </span><span class="n">u_new</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">0.5</span><span class="o">*</span><span class="p">(</span><span class="n">u</span><span class="p">[</span><span class="n">i</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span><span class="o">+</span><span class="n">u</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">])</span>
-<span class="w">        </span><span class="k">end</span>
-<span class="w">        </span><span class="n">increment</span><span class="w"> </span><span class="o">.=</span><span class="w"> </span><span class="n">u_new</span><span class="w"> </span><span class="o">.-</span><span class="w"> </span><span class="n">u</span>
-<span class="w">        </span><span class="n">norm_increment</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">0.0</span>
-<span class="w">        </span><span class="k">for</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="k">in</span><span class="w"> </span><span class="mi">1</span><span class="o">:</span><span class="n">n</span>
-<span class="w">            </span><span class="n">increment_i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">increment</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
-<span class="w">            </span><span class="n">norm_increment</span><span class="w"> </span><span class="o">+=</span><span class="w"> </span><span class="n">increment_i</span><span class="o">*</span><span class="n">increment_i</span>
-<span class="w">        </span><span class="k">end</span>
-<span class="w">        </span><span class="n">norm_increment</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">sqrt</span><span class="p">(</span><span class="n">norm_increment</span><span class="p">)</span>
-<span class="w">        </span><span class="k">if</span><span class="w"> </span><span class="n">norm_increment</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">tol</span><span class="o">*</span><span class="n">n</span>
-<span class="w">            </span><span class="k">return</span><span class="w"> </span><span class="n">u_new</span>
-<span class="w">        </span><span class="k">end</span>
-<span class="w">        </span><span class="n">u</span><span class="p">,</span><span class="w"> </span><span class="n">u_new</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">u_new</span><span class="p">,</span><span class="w"> </span><span class="n">u</span>
-<span class="w">    </span><span class="k">end</span>
-<span class="w">    </span><span class="n">u</span>
-<span class="k">end</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs" id="cell-id=dbf0c3b8">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [ ]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-julia"><pre><span></span><span class="n">n</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">10</span>
-<span class="n">tol</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mf">1e-12</span>
-<span class="n">jacobi_with_tol</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">tol</span><span class="p">)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=aab1455e">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<p>Implement a parallel version of this algorithm. Recommended: start with the parallel implementation given in the previous notebook (see function <code>jacobi_mpi</code>) and introduce the new stopping criteria. Think carefully about which MPI operations you need to use in this case.</p>
-</div>
-</div>
-</div>
-</div>
 <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=5e8f6e6a">
 <div class="jp-Cell-inputWrapper" tabindex="0">
 <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">