diff --git a/.nojekyll b/.nojekyll
index 456a8322..48fdcdb3 100644
--- a/.nojekyll
+++ b/.nojekyll
@@ -1 +1 @@
-97b04b1b
\ No newline at end of file
+2a7889cb
\ No newline at end of file
diff --git a/index.html b/index.html
index 14c84799..d7a4c1df 100644
--- a/index.html
+++ b/index.html
@@ -725,7 +725,10 @@
     <h2 id="toc-title">Table of contents</h2>
    
   <ul>
-  <li><a href="#preface" id="toc-preface" class="nav-link active" data-scroll-target="#preface">Preface</a></li>
+  <li><a href="#preface" id="toc-preface" class="nav-link active" data-scroll-target="#preface">Preface</a>
+  <ul class="collapse">
+  <li><a href="#running-julia" id="toc-running-julia" class="nav-link" data-scroll-target="#running-julia">Running Julia</a></li>
+  </ul></li>
   </ul>
 <div class="toc-actions"><ul><li><a href="https://github.com/jverzani/CalculusWithJuliaNotes.jl/edit/main/quarto/index.qmd" class="toc-action"><i class="bi bi-github"></i>Edit this page</a></li><li><a href="https://github.com/jverzani/CalculusWithJuliaNotes.jl/issues/new" class="toc-action"><i class="bi empty"></i>Report an issue</a></li></ul></div></nav>
     </div>
@@ -780,8 +783,17 @@ <h1 class="unnumbered">Preface</h1>
 <p>These notes are presented in pages covering a fairly focused concept, in a spirit similar to a section of a book. Just like a book, there are try-it-yourself questions at the end of each page. All have a limited number of self-graded answers. These notes borrow ideas from many sources, for example <span class="citation" data-cites="Strang">Strang (<a href="references.html#ref-Strang" role="doc-biblioref">n.d.</a>)</span>, <span class="citation" data-cites="Knill">Knill (<a href="references.html#ref-Knill" role="doc-biblioref">n.d.</a>)</span>, <span class="citation" data-cites="Schey">Schey (<a href="references.html#ref-Schey" role="doc-biblioref">1997</a>)</span>, <span class="citation" data-cites="Thomas">Hass, Heil, and Weir (<a href="references.html#ref-Thomas" role="doc-biblioref">2018</a>)</span>, <span class="citation" data-cites="RogawskiAdams">Rogawski, Adams, and Franzosa (<a href="references.html#ref-RogawskiAdams" role="doc-biblioref">2019</a>)</span>, several Wikipedia pages, and other sources.</p>
 <p>These notes are accompanied by a <code>Julia</code> package <code>CalculusWithJulia</code> that provides some simple functions to streamline some common tasks and loads some useful packages that will be used repeatedly.</p>
 <p>These notes are presented as a Quarto book. To learn more about Quarto books visit <a href="https://quarto.org/docs/books" class="uri">https://quarto.org/docs/books</a>.</p>
-<p>These notes may be compiled into a <code>pdf</code> file through Quarto. As the result is rather large, we do not provide that file for download. For the interested reader, downloading the repository, instantiating the environment, and running <code>quarto</code> to render to <code>pdf</code> in the <code>quarto</code> subdirectory should produce that file (after some time).</p>
+<!--
+These notes may be compiled into a `pdf` file through Quarto. As the result is rather large, we do not provide that file for download. For the interested reader, downloading the repository, instantiating the environment, and running `quarto` to render to `pdf` in the `quarto` subdirectory should produce that file (after some time).
+-->
 <p>To <em>contribute</em> – say by suggesting addition topics, correcting a mistake, or fixing a typo – click the “Edit this page” link and join the list of <a href="https://github.com/jverzani/CalculusWithJuliaNotes.jl/graphs/contributors">contributors</a>. Thanks to all contributors and a <em>very</em> special thanks to <code>@fangliu-tju</code> for their careful and most-appreciated proofreading.</p>
+<section id="running-julia" class="level2">
+<h2 class="anchored" data-anchor-id="running-julia">Running Julia</h2>
+<p><code>Julia</code> is installed quite easily with the <code>juliaup</code> utility. There are some brief installation notes in the overview of <code>Julia</code> commands. To run <code>Julia</code> through the web (though in a resource-constrained manner), these links resolve to <code>binder.org</code> instances:</p>
+<ul>
+<li><p><a href="https://mybinder.org/v2/gh/jverzani/CalculusWithJuliaBinder.jl/main?labpath=blank-notebook.ipynb"><img src="https://mybinder.org/badge_logo.svg" class="img-fluid" alt="Binder"></a> (Image without SymPy)</p></li>
+<li><p><a href="https://mybinder.org/v2/gh/jverzani/CalculusWithJuliaBinder.jl/sympy?labpath=blank-notebook.ipynb"><img src="https://mybinder.org/badge_logo.svg" class="img-fluid" alt="Binder"></a> (Image with SymPy, longer to load)</p></li>
+</ul>
 <hr>
 <p>Calculus with Julia version 0.21, produced on June 8, 2024.</p>
 
@@ -804,6 +816,7 @@ <h1 class="unnumbered">Preface</h1>
 </div>
 </div>
 </section>
+</section>
 
 </main> <!-- /main -->
 <script id="quarto-html-after-body" type="application/javascript">
diff --git a/precalc/julia_overview.html b/precalc/julia_overview.html
index b1663b5c..83fb658e 100644
--- a/precalc/julia_overview.html
+++ b/precalc/julia_overview.html
@@ -789,7 +789,8 @@ <h1 class="title"><span class="chapter-number">17</span>&nbsp; <span class="chap
 <p>The <a href="http://www.julialang.org"><code>Julia</code></a> programming language is well suited as a computer accompaniment while learning the concepts of calculus. The following overview covers the language-specific aspects of the pre-calculus part of the <a href="calculuswithjulia.github.io">Calculus with Julia</a> notes.</p>
 <section id="installing-julia" class="level2" data-number="17.1">
 <h2 data-number="17.1" class="anchored" data-anchor-id="installing-julia"><span class="header-section-number">17.1</span> Installing <code>Julia</code></h2>
-<p><code>Julia</code> is an <em>open source</em> project which allows anyone with a supported computer to use it. To install locally, the <a href="https://julialang.org/downloads/">downloads</a> page has several different binaries for installation. Additionally, the downloads page contains a link to a docker image. For Microsoft Windows, the new <a href="https://github.com/JuliaLang/juliaup">juilaup</a> installer may be of interest; it is available from the Windows Store. <code>Julia</code> can also be compiled from source.</p>
+<p><code>Julia</code> is an <em>open source</em> project which allows anyone with a supported computer to use it free of charge.</p>
+<p>To install locally, the <a href="https://julialang.org/downloads/">downloads</a> page has directions to use the <code>Juliaup</code> utility for managing an installation. There are also links to several different binaries for manual installation. Additionally, the downloads page contains a link to a docker image. <code>Julia</code> can also be compiled from source.</p>
 <p><code>Julia</code> can also be run through the web.</p>
 <p>The <a href="https://mybinder.org/">https://mybinder.org/</a> service in particular allows free access, though limited in terms of allotted memory and with a relatively short timeout for inactivity.</p>
 <ul>
@@ -857,13 +858,13 @@ <h2 data-number="17.3" class="anchored" data-anchor-id="augmenting-base-julia"><
 <p>For other interfaces to <code>Julia</code> some more detail is needed.</p>
 <p>The <code>Julia</code> package manager makes add-on packages very easy to install.</p>
 <p>Julia comes with just a few built-in packages, one being <code>Pkg</code> which manages subsequent package installation. To add more packages, we first must <em>load</em> the <code>Pkg</code> package. This is done by issuing the following command:</p>
-<div id="3051e397" class="cell" data-execution_count="7">
+<div id="700f351f" class="cell" data-execution_count="7">
 <div class="sourceCode cell-code" id="cb4"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="im">using</span> <span class="bu">Pkg</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
 <p>The <code>using</code> command loads the specified package and makes all its <em>exported</em> values available for direct use. There is also the <code>import</code> command which allows the user to select which values should be imported from the package, if any, and otherwise gives access to the new functionality through the dot syntax.</p>
 <p>Packages need to be loaded just once per session.</p>
 <p>To use <code>Pkg</code> to “add” another package, we would have a command like:</p>
-<div id="93c2a896" class="cell" data-execution_count="8">
+<div id="c2237ffa" class="cell" data-execution_count="8">
 <div class="sourceCode cell-code" id="cb5"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="bu">Pkg</span>.<span class="fu">add</span>(<span class="st">"CalculusWithJulia"</span>)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
 <p>This command instructs <code>Julia</code> to look at its <em>general registry</em> for the <code>CalculusWithJulia.jl</code> package, download it, then install it. Once installed, a package only needs to be brought into play with the <code>using</code> or <code>import</code> commands.</p>
@@ -883,7 +884,7 @@ <h2 data-number="17.3" class="anchored" data-anchor-id="augmenting-base-julia"><
 <p>Packages can be updated through the command <code>Pkg.update()</code>, and removed with <code>Pkg.rm(pkgname)</code>.</p>
 <p>By default packages are installed in a common area. It may be desirable to keep packages for projects isolated. For this the <code>Pkg.activate</code> command can be used. This feature allows a means to have reproducible environments even if <code>Julia</code> or the packages used are upgraded, possibly introducing incompatibilities.</p>
 <p>For these notes, the following packages, among others, are used:</p>
-<div id="7b428bae" class="cell" data-execution_count="9">
+<div id="873d7463" class="cell" data-execution_count="9">
 <div class="sourceCode cell-code" id="cb6"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="bu">Pkg</span>.<span class="fu">add</span>(<span class="st">"CalculusWithJulia"</span>) <span class="co"># for some simplifying functions and a few packages (SpecialFunctions, ForwardDiff)</span></span>
 <span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a><span class="bu">Pkg</span>.<span class="fu">add</span>(<span class="st">"Plots"</span>)  <span class="co"># for basic plotting</span></span>
 <span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="bu">Pkg</span>.<span class="fu">add</span>(<span class="st">"SymPy"</span>)  <span class="co"># for symbolic math</span></span>
@@ -895,7 +896,7 @@ <h2 data-number="17.3" class="anchored" data-anchor-id="augmenting-base-julia"><
 <section id="julia-commands" class="level2" data-number="17.4">
 <h2 data-number="17.4" class="anchored" data-anchor-id="julia-commands"><span class="header-section-number">17.4</span> <code>Julia</code> commands</h2>
 <p>In a <code>Jupyter</code> notebook or <code>Pluto</code> notebook, commands are typed into a notebook cell:</p>
-<div id="73a4f028" class="cell" data-execution_count="10">
+<div id="37d89867" class="cell" data-execution_count="10">
 <div class="sourceCode cell-code" id="cb7"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="fl">2</span> <span class="op">+</span> <span class="fl">2</span>   <span class="co"># use shift-enter to evaluate</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="8">
 <pre><code>4</code></pre>
@@ -917,14 +918,14 @@ <h2 data-number="17.5" class="anchored" data-anchor-id="numbers-variable-types">
 <li>Complex numbers <code>2 + 0im</code></li>
 </ul>
 <p><code>Julia</code>’s parser finds the appropriate type for the value, when read in. The following all create the number <span class="math inline">\(1\)</span> first as an integer, then a rational, then a floating point number, again as floating point number, and finally as a complex number:</p>
-<div id="53d2f67b" class="cell" data-execution_count="11">
+<div id="18f28ae8" class="cell" data-execution_count="11">
 <div class="sourceCode cell-code" id="cb9"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="fl">1</span>, <span class="fl">1</span><span class="op">//</span><span class="fl">1</span>, <span class="fl">1.0</span>, <span class="fl">1e0</span>, <span class="fl">1</span> <span class="op">+</span> <span class="fl">0im</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="9">
 <pre><code>(1, 1//1, 1.0, 1.0, 1 + 0im)</code></pre>
 </div>
 </div>
 <p>As much as possible, operations involving certain types of numbers will produce output of a given type. For example, both of these divisions produce a floating point answer, even though mathematically, they need not:</p>
-<div id="b0de650f" class="cell" data-execution_count="12">
+<div id="d7e0f819" class="cell" data-execution_count="12">
 <div class="sourceCode cell-code" id="cb11"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="fl">2</span><span class="op">/</span><span class="fl">1</span>, <span class="fl">1</span><span class="op">/</span><span class="fl">2</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="10">
 <pre><code>(2.0, 0.5)</code></pre>
@@ -932,7 +933,7 @@ <h2 data-number="17.5" class="anchored" data-anchor-id="numbers-variable-types">
 </div>
 <p>Some powers with negative bases, like <code>(-3.0)^(1/3)</code>, are not defined. However, <code>Julia</code> provides the special-case function <code>cbrt</code> (and <code>sqrt</code>) for handling these.</p>
 <p>Integer operations may silently overflow, producing odd answers, at first glance:</p>
-<div id="e9d3415d" class="cell" data-execution_count="13">
+<div id="b2589532" class="cell" data-execution_count="13">
 <div class="sourceCode cell-code" id="cb13"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb13-1"><a href="#cb13-1" aria-hidden="true" tabindex="-1"></a><span class="fl">2</span><span class="op">^</span><span class="fl">64</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="11">
 <pre><code>0</code></pre>
@@ -940,7 +941,7 @@ <h2 data-number="17.5" class="anchored" data-anchor-id="numbers-variable-types">
 </div>
 <p>(Though the output is predictable, if overflow is taken into consideration appropriately.)</p>
 <p>When different types of numbers are mixed, <code>Julia</code> will usually promote the values to a common type before the operation:</p>
-<div id="074df945" class="cell" data-execution_count="14">
+<div id="14085894" class="cell" data-execution_count="14">
 <div class="sourceCode cell-code" id="cb15"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb15-1"><a href="#cb15-1" aria-hidden="true" tabindex="-1"></a>(<span class="fl">2</span> <span class="op">+</span> <span class="fl">1</span><span class="op">//</span><span class="fl">2</span>) <span class="op">+</span> <span class="fl">0.5</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="12">
 <pre><code>3.0</code></pre>
@@ -952,7 +953,7 @@ <h2 data-number="17.5" class="anchored" data-anchor-id="numbers-variable-types">
 <section id="vectors" class="level3" data-number="17.5.1">
 <h3 data-number="17.5.1" class="anchored" data-anchor-id="vectors"><span class="header-section-number">17.5.1</span> Vectors</h3>
 <p>A vector is an indexed collection of similarly typed values. Vectors can be constructed with square brackets (syntax for concatenation):</p>
-<div id="fdd99383" class="cell" data-execution_count="15">
+<div id="477e2aa8" class="cell" data-execution_count="15">
 <div class="sourceCode cell-code" id="cb17"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb17-1"><a href="#cb17-1" aria-hidden="true" tabindex="-1"></a>[<span class="fl">1</span>, <span class="fl">1</span>, <span class="fl">2</span>, <span class="fl">3</span>, <span class="fl">5</span>, <span class="fl">8</span>]</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="13">
 <pre><code>6-element Vector{Int64}:
@@ -965,7 +966,7 @@ <h3 data-number="17.5.1" class="anchored" data-anchor-id="vectors"><span class="
 </div>
 </div>
 <p>Values will be promoted to a common type (or type <code>Any</code> if none exists). For example, this vector will have type <code>Float64</code> due to the <code>1/3</code> computation:</p>
-<div id="ad8d440e" class="cell" data-execution_count="16">
+<div id="05ba31a1" class="cell" data-execution_count="16">
 <div class="sourceCode cell-code" id="cb19"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb19-1"><a href="#cb19-1" aria-hidden="true" tabindex="-1"></a>[<span class="fl">1</span>, <span class="fl">1</span><span class="op">//</span><span class="fl">2</span>, <span class="fl">1</span><span class="op">/</span><span class="fl">3</span>]</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="14">
 <pre><code>3-element Vector{Float64}:
@@ -982,13 +983,13 @@ <h3 data-number="17.5.1" class="anchored" data-anchor-id="vectors"><span class="
 </ul>
 <p>These constructs return range objects. A range object <em>compactly</em> stores the values it references. To see all the values, they can be collected with the <code>collect</code> function, though this is rarely needed in practice.</p>
 <p>Random sequences are formed by <code>rand</code>, among others:</p>
-<div id="6a3a5acf" class="cell" data-execution_count="17">
+<div id="58ba0c06" class="cell" data-execution_count="17">
 <div class="sourceCode cell-code" id="cb21"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb21-1"><a href="#cb21-1" aria-hidden="true" tabindex="-1"></a><span class="fu">rand</span>(<span class="fl">3</span>)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="15">
 <pre><code>3-element Vector{Float64}:
- 0.9280016644651431
- 0.23849211233576195
- 0.11690529588442855</code></pre>
+ 0.1274898327027475
+ 0.516610179123885
+ 0.3360580223517624</code></pre>
 </div>
 </div>
 <p>The call <code>rand()</code> returns a single random number (in <span class="math inline">\([0,1)\)</span>.)</p>
@@ -997,7 +998,7 @@ <h3 data-number="17.5.1" class="anchored" data-anchor-id="vectors"><span class="
 <section id="variables" class="level2" data-number="17.6">
 <h2 data-number="17.6" class="anchored" data-anchor-id="variables"><span class="header-section-number">17.6</span> Variables</h2>
 <p>Values can be assigned variable names, with <code>=</code>. There are some variants</p>
-<div id="db62562e" class="cell" data-execution_count="18">
+<div id="2ad404f1" class="cell" data-execution_count="18">
 <div class="sourceCode cell-code" id="cb23"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb23-1"><a href="#cb23-1" aria-hidden="true" tabindex="-1"></a>u <span class="op">=</span> <span class="fl">2</span></span>
 <span id="cb23-2"><a href="#cb23-2" aria-hidden="true" tabindex="-1"></a>a_really_long_name <span class="op">=</span> <span class="fl">3</span></span>
 <span id="cb23-3"><a href="#cb23-3" aria-hidden="true" tabindex="-1"></a>a0, b0 <span class="op">=</span> <span class="fl">1</span>, <span class="fl">2</span>    <span class="co"># multiple assignment</span></span>
@@ -1007,14 +1008,14 @@ <h2 data-number="17.6" class="anchored" data-anchor-id="variables"><span class="
 </div>
 </div>
 <p>The names can be short, as above, or more verbose. Variable names can’t start with a number, but can include numbers. Variables can also include <a href="../misc/unicode.html">Unicode</a> or even be an emoji.</p>
-<div id="bdeff63e" class="cell" data-execution_count="19">
+<div id="295f0db3" class="cell" data-execution_count="19">
 <div class="sourceCode cell-code" id="cb25"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb25-1"><a href="#cb25-1" aria-hidden="true" tabindex="-1"></a>α, β <span class="op">=</span> <span class="cn">π</span><span class="op">/</span><span class="fl">3</span>, <span class="cn">π</span><span class="op">/</span><span class="fl">4</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="17">
 <pre><code>(1.0471975511965976, 0.7853981633974483)</code></pre>
 </div>
 </div>
 <p>We can then use the variables to reference the values:</p>
-<div id="fbce20ad" class="cell" data-execution_count="20">
+<div id="faf8be13" class="cell" data-execution_count="20">
 <div class="sourceCode cell-code" id="cb27"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb27-1"><a href="#cb27-1" aria-hidden="true" tabindex="-1"></a>u <span class="op">+</span> a_really_long_name <span class="op">+</span> a0 <span class="op">-</span> b0 <span class="op">+</span> α</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="18">
 <pre><code>5.047197551196597</code></pre>
@@ -1027,7 +1028,7 @@ <h2 data-number="17.6" class="anchored" data-anchor-id="variables"><span class="
 <h2 data-number="17.7" class="anchored" data-anchor-id="functions"><span class="header-section-number">17.7</span> Functions</h2>
 <p>Functions in <code>Julia</code> are first-class objects. In these notes, we often pass them as arguments to other functions. There are many built-in functions and it is easy to define new functions.</p>
 <p>We “call” a function by passing argument(s) to it, grouped by parentheses:</p>
-<div id="979832b9" class="cell" data-execution_count="21">
+<div id="a00f7fec" class="cell" data-execution_count="21">
 <div class="sourceCode cell-code" id="cb29"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb29-1"><a href="#cb29-1" aria-hidden="true" tabindex="-1"></a><span class="fu">sqrt</span>(<span class="fl">10</span>)</span>
 <span id="cb29-2"><a href="#cb29-2" aria-hidden="true" tabindex="-1"></a><span class="fu">sin</span>(<span class="cn">pi</span><span class="op">/</span><span class="fl">3</span>)</span>
 <span id="cb29-3"><a href="#cb29-3" aria-hidden="true" tabindex="-1"></a><span class="fu">log</span>(<span class="fl">5</span>, <span class="fl">100</span>)   <span class="co"># log base 5 of 100</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
@@ -1036,7 +1037,7 @@ <h2 data-number="17.7" class="anchored" data-anchor-id="functions"><span class="
 </div>
 </div>
 <p>Without parentheses, the name (usually) refers to a generic name and the output lists the number of available implementations (methods).</p>
-<div id="3e6772a8" class="cell" data-execution_count="22">
+<div id="6353ca21" class="cell" data-execution_count="22">
 <div class="sourceCode cell-code" id="cb31"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb31-1"><a href="#cb31-1" aria-hidden="true" tabindex="-1"></a>log</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="20">
 <pre><code>log (generic function with 42 methods)</code></pre>
@@ -1076,7 +1077,7 @@ <h4 class="anchored" data-anchor-id="useful-functions">Useful functions</h4>
 <hr>
 <p>In a Pluto session, the “Live docs” area shows inline documentation for the current object.</p>
 <p>For other uses of <code>Julia</code>, the built-in documentation for an object is accessible through a leading <code>?</code>, say, <code>?sign</code>. There is also the <code>@doc</code> macro, for example:</p>
-<div id="7567315f" class="cell" data-execution_count="23">
+<div id="6cb58a6f" class="cell" data-execution_count="23">
 <div class="sourceCode cell-code" id="cb36"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb36-1"><a href="#cb36-1" aria-hidden="true" tabindex="-1"></a><span class="pp">@doc</span> sign</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
 <hr>
@@ -1085,7 +1086,7 @@ <h4 class="anchored" data-anchor-id="useful-functions">Useful functions</h4>
 <section id="user-defined-functions" class="level3" data-number="17.7.2">
 <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions"><span class="header-section-number">17.7.2</span> User-defined functions</h3>
 <p>Simple mathematical functions can be defined using standard mathematical notation:</p>
-<div id="60b48b2a" class="cell" data-execution_count="24">
+<div id="05dd3741" class="cell" data-execution_count="24">
 <div class="sourceCode cell-code" id="cb37"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb37-1"><a href="#cb37-1" aria-hidden="true" tabindex="-1"></a><span class="fu">f</span>(x) <span class="op">=</span> <span class="op">-</span><span class="fl">16</span>x<span class="op">^</span><span class="fl">2</span> <span class="op">+</span> <span class="fl">100</span>x <span class="op">+</span> <span class="fl">2</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="21">
 <pre><code>f (generic function with 1 method)</code></pre>
@@ -1093,7 +1094,7 @@ <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions
 </div>
 <p>The argument <code>x</code> is passed into the body of function.</p>
 <p>Other values are found from the environment where defined:</p>
-<div id="7ab87a70" class="cell" data-hold="true" data-execution_count="25">
+<div id="13def81f" class="cell" data-hold="true" data-execution_count="25">
 <div class="sourceCode cell-code" id="cb39"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb39-1"><a href="#cb39-1" aria-hidden="true" tabindex="-1"></a>a <span class="op">=</span> <span class="fl">1</span></span>
 <span id="cb39-2"><a href="#cb39-2" aria-hidden="true" tabindex="-1"></a><span class="fu">f</span>(x) <span class="op">=</span> <span class="fl">2</span><span class="op">*</span>a <span class="op">+</span> x</span>
 <span id="cb39-3"><a href="#cb39-3" aria-hidden="true" tabindex="-1"></a><span class="fu">f</span>(<span class="fl">3</span>)   <span class="co"># 2 * 1 + 3</span></span>
@@ -1104,7 +1105,7 @@ <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions
 </div>
 </div>
 <p>User-defined functions can have <span class="math inline">\(0\)</span>, <span class="math inline">\(1\)</span> or more arguments:</p>
-<div id="cd00ea94" class="cell" data-execution_count="26">
+<div id="a549c646" class="cell" data-execution_count="26">
 <div class="sourceCode cell-code" id="cb41"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb41-1"><a href="#cb41-1" aria-hidden="true" tabindex="-1"></a><span class="fu">area</span>(w, h) <span class="op">=</span> w<span class="op">*</span>h</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="23">
 <pre><code>area (generic function with 1 method)</code></pre>
@@ -1112,7 +1113,7 @@ <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions
 </div>
 <p>Julia makes different <em>methods</em> for <em>generic</em> function names, so function definitions whose argument specification is different are for different uses, even if the name is the same. This is <em>polymorphism</em>. The practical use is that it means users need only remember a much smaller set of function names, as attempts are made to give common expectations to the same name. (That is, <code>+</code> should be used only for “add” ing objects, however defined.)</p>
 <p>Functions can be defined with <em>keyword</em> arguments that may have defaults specified:</p>
-<div id="c52b7ea7" class="cell" data-hold="true" data-execution_count="27">
+<div id="35389552" class="cell" data-hold="true" data-execution_count="27">
 <div class="sourceCode cell-code" id="cb43"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb43-1"><a href="#cb43-1" aria-hidden="true" tabindex="-1"></a><span class="fu">f</span>(x; m<span class="op">=</span><span class="fl">1</span>, b<span class="op">=</span><span class="fl">0</span>) <span class="op">=</span> m<span class="op">*</span>x <span class="op">+</span> b     <span class="co"># note ";"</span></span>
 <span id="cb43-2"><a href="#cb43-2" aria-hidden="true" tabindex="-1"></a><span class="fu">f</span>(<span class="fl">1</span>)                         <span class="co"># uses m=1, b=0   -&gt; 1 * 1 + 0</span></span>
 <span id="cb43-3"><a href="#cb43-3" aria-hidden="true" tabindex="-1"></a><span class="fu">f</span>(<span class="fl">1</span>, m<span class="op">=</span><span class="fl">10</span>)                   <span class="co"># uses m=10, b=0  -&gt; 10 * 1 + 0</span></span>
@@ -1122,7 +1123,7 @@ <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions
 </div>
 </div>
 <p>Longer functions can be defined using the <code>function</code> keyword, the last command executed is returned:</p>
-<div id="bf985cc9" class="cell" data-execution_count="28">
+<div id="f44f9a2b" class="cell" data-execution_count="28">
 <div class="sourceCode cell-code" id="cb45"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb45-1"><a href="#cb45-1" aria-hidden="true" tabindex="-1"></a><span class="kw">function</span> <span class="fu">𝒇</span>(x)</span>
 <span id="cb45-2"><a href="#cb45-2" aria-hidden="true" tabindex="-1"></a>  y <span class="op">=</span> x<span class="op">^</span><span class="fl">2</span></span>
 <span id="cb45-3"><a href="#cb45-3" aria-hidden="true" tabindex="-1"></a>  z <span class="op">=</span> y <span class="op">-</span> <span class="fl">3</span></span>
@@ -1133,7 +1134,7 @@ <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions
 </div>
 </div>
 <p>Functions without names, <em>anonymous functions</em>, are made with the <code>-&gt;</code> syntax as in:</p>
-<div id="52b447ae" class="cell" data-execution_count="29">
+<div id="0a070027" class="cell" data-execution_count="29">
 <div class="sourceCode cell-code" id="cb47"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb47-1"><a href="#cb47-1" aria-hidden="true" tabindex="-1"></a>x <span class="op">-&gt;</span> <span class="fu">cos</span>(x)<span class="op">^</span><span class="fl">2</span> <span class="op">-</span> <span class="fu">cos</span>(<span class="fl">2</span>x)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="26">
 <pre><code>#20 (generic function with 1 method)</code></pre>
@@ -1145,7 +1146,7 @@ <h3 data-number="17.7.2" class="anchored" data-anchor-id="user-defined-functions
 <section id="conditional-statements" class="level2" data-number="17.8">
 <h2 data-number="17.8" class="anchored" data-anchor-id="conditional-statements"><span class="header-section-number">17.8</span> Conditional statements</h2>
 <p><code>Julia</code> provides the traditional <code>if-else-end</code> statements, but more conveniently has a <code>ternary</code> operator for the simplest case:</p>
-<div id="3d9908c0" class="cell" data-execution_count="30">
+<div id="216ed300" class="cell" data-execution_count="30">
 <div class="sourceCode cell-code" id="cb49"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb49-1"><a href="#cb49-1" aria-hidden="true" tabindex="-1"></a><span class="fu">our_abs</span>(x) <span class="op">=</span> (x <span class="op">&lt;</span> <span class="fl">0</span>) ? <span class="op">-</span>x <span class="op">:</span> x</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="27">
 <pre><code>our_abs (generic function with 1 method)</code></pre>
@@ -1155,7 +1156,7 @@ <h2 data-number="17.8" class="anchored" data-anchor-id="conditional-statements">
 <section id="looping" class="level2" data-number="17.9">
 <h2 data-number="17.9" class="anchored" data-anchor-id="looping"><span class="header-section-number">17.9</span> Looping</h2>
 <p>Iterating over a collection can be done with the traditional <code>for</code> loop. However, there are list comprehensions to mimic the definition of a set:</p>
-<div id="786d4520" class="cell" data-execution_count="31">
+<div id="acd81eeb" class="cell" data-execution_count="31">
 <div class="sourceCode cell-code" id="cb51"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb51-1"><a href="#cb51-1" aria-hidden="true" tabindex="-1"></a>[x<span class="op">^</span><span class="fl">2</span> for x <span class="kw">in</span> <span class="fl">1</span><span class="op">:</span><span class="fl">10</span>]</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="28">
 <pre><code>10-element Vector{Int64}:
@@ -1172,7 +1173,7 @@ <h2 data-number="17.9" class="anchored" data-anchor-id="looping"><span class="he
 </div>
 </div>
 <p>Comprehensions can be filtered through the <code>if</code> keyword</p>
-<div id="d4993712" class="cell" data-execution_count="32">
+<div id="20e2a92e" class="cell" data-execution_count="32">
 <div class="sourceCode cell-code" id="cb53"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb53-1"><a href="#cb53-1" aria-hidden="true" tabindex="-1"></a>[x<span class="op">^</span><span class="fl">2</span> for x <span class="kw">in</span> <span class="fl">1</span><span class="op">:</span><span class="fl">10</span> if <span class="fu">iseven</span>(x)]</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="29">
 <pre><code>5-element Vector{Int64}:
@@ -1184,7 +1185,7 @@ <h2 data-number="17.9" class="anchored" data-anchor-id="looping"><span class="he
 </div>
 </div>
 <p>This is more efficient than creating the collection then filtering, as is done with:</p>
-<div id="6181cc2d" class="cell" data-execution_count="33">
+<div id="fe47a339" class="cell" data-execution_count="33">
 <div class="sourceCode cell-code" id="cb55"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb55-1"><a href="#cb55-1" aria-hidden="true" tabindex="-1"></a><span class="fu">filter</span>(iseven, [x<span class="op">^</span><span class="fl">2</span> for x <span class="kw">in</span> <span class="fl">1</span><span class="op">:</span><span class="fl">10</span>])</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="30">
 <pre><code>5-element Vector{Int64}:
@@ -1199,7 +1200,7 @@ <h2 data-number="17.9" class="anchored" data-anchor-id="looping"><span class="he
 <section id="broadcasting-mapping" class="level2" data-number="17.10">
 <h2 data-number="17.10" class="anchored" data-anchor-id="broadcasting-mapping"><span class="header-section-number">17.10</span> Broadcasting, mapping</h2>
 <p>A function can be applied to each element of a vector through mapping or broadcasting. The latter is implemented in a succinct notation. Calling a function with a “.” before its opening “(” will apply the function to each individual value in the argument:</p>
-<div id="04085823" class="cell" data-execution_count="34">
+<div id="870b4856" class="cell" data-execution_count="34">
 <div class="sourceCode cell-code" id="cb57"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb57-1"><a href="#cb57-1" aria-hidden="true" tabindex="-1"></a>xs <span class="op">=</span> [<span class="fl">1</span>,<span class="fl">2</span>,<span class="fl">3</span>,<span class="fl">4</span>,<span class="fl">5</span>]</span>
 <span id="cb57-2"><a href="#cb57-2" aria-hidden="true" tabindex="-1"></a><span class="fu">sin</span>.(xs)     <span class="co"># gives back [sin(1), sin(2), sin(3), sin(4), sin(5)]</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="31">
@@ -1214,7 +1215,7 @@ <h2 data-number="17.10" class="anchored" data-anchor-id="broadcasting-mapping"><
 <p>For “infix” operators, the dot precedes the operator, as in this example instructing pointwise multiplication of each element in <code>xs</code>:</p>
 <pre class="{juila}"><code>xs .* xs</code></pre>
 <p>Alternatively, the more traditional <code>map</code> can be used:</p>
-<div id="e93cf73d" class="cell" data-execution_count="35">
+<div id="e43b4584" class="cell" data-execution_count="35">
 <div class="sourceCode cell-code" id="cb60"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb60-1"><a href="#cb60-1" aria-hidden="true" tabindex="-1"></a><span class="fu">map</span>(sin, xs)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="32">
 <pre><code>5-element Vector{Float64}:
@@ -1230,7 +1231,7 @@ <h2 data-number="17.10" class="anchored" data-anchor-id="broadcasting-mapping"><
 <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="header-section-number">17.11</span> Plotting</h2>
 <p>Plotting is <em>not</em> built-in to <code>Julia</code>, rather added through add-on packages. <code>Julia</code>’s <code>Plots</code> package is an interface to several plotting packages. We mention <code>plotly</code> (built-in) for web based graphics, <code>pyplot</code>, and <code>gr</code> (also built into <code>Plots</code>) for other graphics.</p>
 <p>We must load <code>Plots</code> before we can plot (and it must be installed before we can load it):</p>
-<div id="8c0d874c" class="cell" data-execution_count="36">
+<div id="dfb44543" class="cell" data-execution_count="36">
 <div class="sourceCode cell-code" id="cb62"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb62-1"><a href="#cb62-1" aria-hidden="true" tabindex="-1"></a><span class="im">using</span> <span class="bu">Plots</span></span>
 <span id="cb62-2"><a href="#cb62-2" aria-hidden="true" tabindex="-1"></a><span class="fu">plotly</span>()  <span class="co"># optionally change the backend from the default</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="33">
@@ -1238,10 +1239,10 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
 </div>
 </div>
 <p>With <code>Plots</code> loaded, we can plot a function by passing the function object by name to <code>plot</code>, specifying the range of <code>x</code> values to show, as follows:</p>
-<div id="ecdef0d4" class="cell" data-execution_count="37">
+<div id="39675d83" class="cell" data-execution_count="37">
 <div class="sourceCode cell-code" id="cb64"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb64-1"><a href="#cb64-1" aria-hidden="true" tabindex="-1"></a><span class="fu">plot</span>(sin, <span class="fl">0</span>, <span class="fl">2</span>pi) <span class="co"># plot a function - by name - over an interval [a,b]</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="34">
-    <div id="93d1775b-cd6c-4e6b-9488-d89eb40a7a03" style="width:672px;height:480px;"></div>
+    <div id="34fad5bc-e192-47b4-8968-6cf28561f232" style="width:672px;height:480px;"></div>
     <script>
         requirejs.config({
         paths: {
@@ -1250,7 +1251,7 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
     });
     require(['plotly'], function (Plotly) {
 
-    Plotly.newPlot('93d1775b-cd6c-4e6b-9488-d89eb40a7a03', [
+    Plotly.newPlot('34fad5bc-e192-47b4-8968-6cf28561f232', [
     {
         "showlegend": true,
         "mode": "lines",
@@ -1638,12 +1639,12 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
 </div>
 <p>!!! note This is in the form of <strong>the</strong> basic pattern employed: <code>verb(function_object, arguments...)</code>. The verb in this example is <code>plot</code>, the object <code>sin</code>, the arguments <code>0, 2pi</code> to specify <code>[a,b]</code> domain to plot over.</p>
 <p>Plotting more than one function over <code>[a,b]</code> is achieved through the <code>plot!</code> function, which modifies the existing plot (<code>plot</code> creates a new one) by adding a new layer:</p>
-<div id="d7a33dd5" class="cell" data-execution_count="38">
+<div id="ea3103cd" class="cell" data-execution_count="38">
 <div class="sourceCode cell-code" id="cb65"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb65-1"><a href="#cb65-1" aria-hidden="true" tabindex="-1"></a><span class="fu">plot</span>(sin, <span class="fl">0</span>, <span class="fl">2</span>pi)</span>
 <span id="cb65-2"><a href="#cb65-2" aria-hidden="true" tabindex="-1"></a><span class="fu">plot!</span>(cos, <span class="fl">0</span>, <span class="fl">2</span>pi)</span>
 <span id="cb65-3"><a href="#cb65-3" aria-hidden="true" tabindex="-1"></a><span class="fu">plot!</span>(zero, <span class="fl">0</span>, <span class="fl">2</span>pi) <span class="co"># add the line y=0</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="35">
-    <div id="00247803-1518-4800-8321-b21f203bc767" style="width:672px;height:480px;"></div>
+    <div id="b0ad07a6-0e25-4440-8c37-43c664af4ecb" style="width:672px;height:480px;"></div>
     <script>
         requirejs.config({
         paths: {
@@ -1652,7 +1653,7 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
     });
     require(['plotly'], function (Plotly) {
 
-    Plotly.newPlot('00247803-1518-4800-8321-b21f203bc767', [
+    Plotly.newPlot('b0ad07a6-0e25-4440-8c37-43c664af4ecb', [
     {
         "showlegend": true,
         "mode": "lines",
@@ -2357,12 +2358,12 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
 </div>
 </div>
 <p>Individual points are added with <code>scatter</code> or <code>scatter!</code>:</p>
-<div id="12130461" class="cell" data-execution_count="39">
+<div id="c2590bf0" class="cell" data-execution_count="39">
 <div class="sourceCode cell-code" id="cb66"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb66-1"><a href="#cb66-1" aria-hidden="true" tabindex="-1"></a><span class="fu">plot</span>(sin, <span class="fl">0</span>, <span class="fl">2</span>pi, legend<span class="op">=</span><span class="cn">false</span>)</span>
 <span id="cb66-2"><a href="#cb66-2" aria-hidden="true" tabindex="-1"></a><span class="fu">plot!</span>(cos, <span class="fl">0</span>, <span class="fl">2</span>pi)</span>
 <span id="cb66-3"><a href="#cb66-3" aria-hidden="true" tabindex="-1"></a><span class="fu">scatter!</span>([<span class="cn">pi</span><span class="op">/</span><span class="fl">4</span>, <span class="cn">pi</span><span class="op">+</span><span class="cn">pi</span><span class="op">/</span><span class="fl">4</span>], [<span class="fu">sin</span>(<span class="cn">pi</span><span class="op">/</span><span class="fl">4</span>), <span class="fu">sin</span>(<span class="cn">pi</span> <span class="op">+</span> <span class="cn">pi</span><span class="op">/</span><span class="fl">4</span>)])</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="36">
-    <div id="9e804718-13f2-4dba-af0a-6b656fe0813c" style="width:672px;height:480px;"></div>
+    <div id="a1a2fa51-848c-4bdb-87e3-352a3c1a6a89" style="width:672px;height:480px;"></div>
     <script>
         requirejs.config({
         paths: {
@@ -2371,7 +2372,7 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
     });
     require(['plotly'], function (Plotly) {
 
-    Plotly.newPlot('9e804718-13f2-4dba-af0a-6b656fe0813c', [
+    Plotly.newPlot('a1a2fa51-848c-4bdb-87e3-352a3c1a6a89', [
     {
         "showlegend": true,
         "mode": "lines",
@@ -2998,10 +2999,10 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
 </div>
 <p>(The extra argument <code>legend=false</code> suppresses the automatic legend drawing. There are many other useful arguments to adjust a graphic. For example, passing <code>markersize=10</code> to the <code>scatter!</code> command would draw the points larger than the default.)</p>
 <p>Plotting an <em>anonymous</em> function is a bit more immediate than the two-step approach of defining a named function then calling <code>plot</code> with this as an argument:</p>
-<div id="0d402663" class="cell" data-execution_count="40">
+<div id="3129621e" class="cell" data-execution_count="40">
 <div class="sourceCode cell-code" id="cb67"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb67-1"><a href="#cb67-1" aria-hidden="true" tabindex="-1"></a><span class="fu">plot</span>( x <span class="op">-&gt;</span> <span class="fu">exp</span>(<span class="op">-</span>x<span class="op">/</span><span class="cn">pi</span>) <span class="op">*</span> <span class="fu">sin</span>(x), <span class="fl">0</span>, <span class="fl">2</span>pi)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="37">
-    <div id="05099244-a1e4-42a3-bb4e-7a8ddc7e0cfa" style="width:672px;height:480px;"></div>
+    <div id="ec70266f-5152-4fcb-a562-279a7882b326" style="width:672px;height:480px;"></div>
     <script>
         requirejs.config({
         paths: {
@@ -3010,7 +3011,7 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
     });
     require(['plotly'], function (Plotly) {
 
-    Plotly.newPlot('05099244-a1e4-42a3-bb4e-7a8ddc7e0cfa', [
+    Plotly.newPlot('ec70266f-5152-4fcb-a562-279a7882b326', [
     {
         "showlegend": true,
         "mode": "lines",
@@ -3393,12 +3394,12 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
 </div>
 </div>
 <p>The <code>scatter!</code> function used above takes two vectors of values to describe the points to plot, one for the <span class="math inline">\(x\)</span> values and one for the matching <span class="math inline">\(y\)</span> values. The <code>plot</code> function can also produce plots with this interface. For example, here we use a comprehension to produce <code>y</code> values from the specified <code>x</code> values:</p>
-<div id="90d42262" class="cell" data-hold="true" data-execution_count="41">
+<div id="8e6ecde7" class="cell" data-hold="true" data-execution_count="41">
 <div class="sourceCode cell-code" id="cb68"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb68-1"><a href="#cb68-1" aria-hidden="true" tabindex="-1"></a>xs <span class="op">=</span> <span class="fu">range</span>(<span class="fl">0</span>, <span class="fl">2</span>pi, length<span class="op">=</span><span class="fl">251</span>)</span>
 <span id="cb68-2"><a href="#cb68-2" aria-hidden="true" tabindex="-1"></a>ys <span class="op">=</span> [<span class="fu">sin</span>(<span class="fl">2</span>x) <span class="op">+</span> <span class="fu">sin</span>(<span class="fl">3</span>x) <span class="op">+</span> <span class="fu">sin</span>(<span class="fl">4</span>x) for x <span class="kw">in</span> xs]</span>
 <span id="cb68-3"><a href="#cb68-3" aria-hidden="true" tabindex="-1"></a><span class="fu">plot</span>(xs, ys)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="38">
-    <div id="97ac00fe-1737-4b8e-9eff-a08f773efb1a" style="width:672px;height:480px;"></div>
+    <div id="d7acfa26-f865-49fd-ad43-78bd61bd79e3" style="width:672px;height:480px;"></div>
     <script>
         requirejs.config({
         paths: {
@@ -3407,7 +3408,7 @@ <h2 data-number="17.11" class="anchored" data-anchor-id="plotting"><span class="
     });
     require(['plotly'], function (Plotly) {
 
-    Plotly.newPlot('97ac00fe-1737-4b8e-9eff-a08f773efb1a', [
+    Plotly.newPlot('d7acfa26-f865-49fd-ad43-78bd61bd79e3', [
     {
         "showlegend": true,
         "mode": "lines",
@@ -4097,10 +4098,10 @@ <h2 data-number="17.12" class="anchored" data-anchor-id="equations"><span class=
 <section id="symbolic-math" class="level2" data-number="17.13">
 <h2 data-number="17.13" class="anchored" data-anchor-id="symbolic-math"><span class="header-section-number">17.13</span> Symbolic math</h2>
 <p>Symbolic math is available through an add-on package <code>SymPy</code> (among others). Once loaded, symbolic variables are created with the macro <code>@syms</code>:</p>
-<div id="150774bc" class="cell" data-execution_count="42">
+<div id="216e5cda" class="cell" data-execution_count="42">
 <div class="sourceCode cell-code" id="cb69"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb69-1"><a href="#cb69-1" aria-hidden="true" tabindex="-1"></a><span class="im">using</span> <span class="bu">SymPy</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 </div>
-<div id="2f87d056" class="cell" data-execution_count="43">
+<div id="2724ce56" class="cell" data-execution_count="43">
 <div class="sourceCode cell-code" id="cb70"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb70-1"><a href="#cb70-1" aria-hidden="true" tabindex="-1"></a><span class="pp">@syms</span> x a b c</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="40">
 <pre><code>(x, a, b, c)</code></pre>
@@ -4108,14 +4109,14 @@ <h2 data-number="17.13" class="anchored" data-anchor-id="symbolic-math"><span cl
 </div>
 <p>(A macro rewrites values into other commands before they are interpreted. Macros are prefixed with the <code>@</code> sign. In this use, the “macro” <code>@syms</code> translates <code>x a b c</code> into a command involving <code>SymPy</code>s <code>symbols</code> function.)</p>
 <p>Symbolic expressions - unlike numeric expressions - are not immediately evaluated, though they may be simplified:</p>
-<div id="c8f0130c" class="cell" data-execution_count="44">
+<div id="0ce5779f" class="cell" data-execution_count="44">
 <div class="sourceCode cell-code" id="cb72"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb72-1"><a href="#cb72-1" aria-hidden="true" tabindex="-1"></a>p <span class="op">=</span> a<span class="op">*</span>x<span class="op">^</span><span class="fl">2</span> <span class="op">+</span> b<span class="op">*</span>x <span class="op">+</span> c</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display cell-output-markdown" data-execution_count="41">
 <p><span class="math inline">\(a x^{2} + b x + c\)</span></p>
 </div>
 </div>
 <p>To substitute a value, we can use <code>Julia</code>’s <code>pair</code> notation (<code>variable=&gt;value</code>):</p>
-<div id="9236742a" class="cell" data-execution_count="45">
+<div id="311b3feb" class="cell" data-execution_count="45">
 <div class="sourceCode cell-code" id="cb73"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb73-1"><a href="#cb73-1" aria-hidden="true" tabindex="-1"></a><span class="fu">p</span>(x<span class="op">=&gt;</span><span class="fl">2</span>), <span class="fu">p</span>(x<span class="op">=&gt;</span><span class="fl">2</span>, a<span class="op">=&gt;</span><span class="fl">3</span>, b<span class="op">=&gt;</span><span class="fl">4</span>, c<span class="op">=&gt;</span><span class="fl">1</span>)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="42">
 <pre><code>(4*a + 2*b + c, 21)</code></pre>
@@ -4123,10 +4124,10 @@ <h2 data-number="17.13" class="anchored" data-anchor-id="symbolic-math"><span cl
 </div>
 <p>This is convenient notation for calling the <code>subs</code> function for <code>SymPy</code>.</p>
 <p>SymPy expressions of a single free variable can be plotted directly:</p>
-<div id="1e2a4fae" class="cell" data-execution_count="46">
+<div id="f6788b39" class="cell" data-execution_count="46">
 <div class="sourceCode cell-code" id="cb75"><pre class="sourceCode julia code-with-copy"><code class="sourceCode julia"><span id="cb75-1"><a href="#cb75-1" aria-hidden="true" tabindex="-1"></a><span class="fu">plot</span>(<span class="fl">64</span> <span class="op">-</span> (<span class="fl">1</span><span class="op">/</span><span class="fl">2</span>)<span class="op">*</span><span class="fl">32</span> <span class="op">*</span> x<span class="op">^</span><span class="fl">2</span>, <span class="fl">0</span>, <span class="fl">2</span>)</span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
 <div class="cell-output cell-output-display" data-execution_count="43">
-    <div id="0fa919d0-6c4e-4e27-8c5c-b89f43ef8e49" style="width:672px;height:480px;"></div>
+    <div id="4582340e-ee01-43db-9962-196f17d4ead3" style="width:672px;height:480px;"></div>
     <script>
         requirejs.config({
         paths: {
@@ -4135,7 +4136,7 @@ <h2 data-number="17.13" class="anchored" data-anchor-id="symbolic-math"><span cl
     });
     require(['plotly'], function (Plotly) {
 
-    Plotly.newPlot('0fa919d0-6c4e-4e27-8c5c-b89f43ef8e49', [
+    Plotly.newPlot('4582340e-ee01-43db-9962-196f17d4ead3', [
     {
         "showlegend": true,
         "mode": "lines",
diff --git a/search.json b/search.json
index de0cc4ba..afdf4805 100644
--- a/search.json
+++ b/search.json
@@ -4,7 +4,17 @@
     "href": "index.html",
     "title": "Calculus with Julia",
     "section": "",
-    "text": "Preface\n\n\n\nCalculus with Julia\n\n\n\nThis is a set of notes for learning calculus using the Julia language. Julia is an open-source programming language with an easy to learn syntax that is well suited for this task.\nRead “Getting started with Julia” to learn how to install and customize Julia for following along with these notes. Read “Julia interfaces” to review different ways to interact with a Julia installation.\nSince the mid 90s there has been a push to teach calculus using many different points of view. The Harvard style rule of four says that as much as possible the conversation should include a graphical, numerical, algebraic, and verbal component. These notes use the programming language Julia to illustrate the graphical, numerical, and, at times, the algebraic aspects of calculus.\nThere are many examples of integrating a computer algebra system (such as Mathematica, Maple, or Sage) into the calculus conversation. Computer algebra systems can be magical. The popular WolframAlpha website calls the full power of Mathematica while allowing an informal syntax that is flexible enough to be used as a backend for Apple’s Siri feature. (“Siri what is the graph of x squared minus 4?”) For learning purposes, computer algebra systems model very well the algebraic/symbolic treatment of the material while providing means to illustrate the numeric aspects. These notes are a bit different in that Julia is primarily used for the numeric style of computing and the algebraic/symbolic treatment is added on. Doing the symbolic treatment by hand can be very beneficial while learning, and computer algebra systems make those exercises seem kind of redundant, as the finished product can be produced much more easily.\nOur real goal is to get at the concepts using technology as much as possible without getting bogged down in the mechanics of the computer language. We feel Julia has a very natural syntax that makes the initial start up not so much more difficult than using a calculator, but with a language that has a tremendous upside. The notes restrict themselves to a reduced set of computational concepts. This set is sufficient for working many of the problems in calculus, but do not cover thoroughly many aspects of programming. (Those who are interested can go off on their own and Julia provides a rich opportunity to do so.) Within this restricted set, are operators that make many of the computations of calculus reduce to a function call of the form action(function, arguments...). With a small collection of actions that can be composed, many of the problems associated with introductory calculus can be attacked.\nThese notes are presented in pages covering a fairly focused concept, in a spirit similar to a section of a book. Just like a book, there are try-it-yourself questions at the end of each page. All have a limited number of self-graded answers. These notes borrow ideas from many sources, for example Strang (n.d.), Knill (n.d.), Schey (1997), Hass, Heil, and Weir (2018), Rogawski, Adams, and Franzosa (2019), several Wikipedia pages, and other sources.\nThese notes are accompanied by a Julia package CalculusWithJulia that provides some simple functions to streamline some common tasks and loads some useful packages that will be used repeatedly.\nThese notes are presented as a Quarto book. To learn more about Quarto books visit https://quarto.org/docs/books.\nThese notes may be compiled into a pdf file through Quarto. As the result is rather large, we do not provide that file for download. For the interested reader, downloading the repository, instantiating the environment, and running quarto to render to pdf in the quarto subdirectory should produce that file (after some time).\nTo contribute – say by suggesting addition topics, correcting a mistake, or fixing a typo – click the “Edit this page” link and join the list of contributors. Thanks to all contributors and a very special thanks to @fangliu-tju for their careful and most-appreciated proofreading.\n\nCalculus with Julia version 0.21, produced on June 8, 2024.\n\n\n\n\nHass, Joel R., Christopher E. Heil, and Maurice D. Weir. 2018. Thomas’ Calculus. Pearson.\n\n\nKnill, Oliver. n.d. “Some Teaching Notes.” https://people.math.harvard.edu/~knill/teach/index.html.\n\n\nRogawski, Jon, Colin Adams, and Robert Franzosa. 2019. Calculus. Macmillan.\n\n\nSchey, H. M. 1997. Div, Grad, Curl, and All That. W.W. Norton.\n\n\nStrang, Gilbert. n.d. “Calculus.” Wellesley-Cambridge Press. https://ocw.mit.edu/courses/res-18-001-calculus-online-textbook-spring-2005/.",
+    "text": "Preface\nThis is a set of notes for learning calculus using the Julia language. Julia is an open-source programming language with an easy to learn syntax that is well suited for this task.\nRead “Getting started with Julia” to learn how to install and customize Julia for following along with these notes. Read “Julia interfaces” to review different ways to interact with a Julia installation.\nSince the mid 90s there has been a push to teach calculus using many different points of view. The Harvard style rule of four says that as much as possible the conversation should include a graphical, numerical, algebraic, and verbal component. These notes use the programming language Julia to illustrate the graphical, numerical, and, at times, the algebraic aspects of calculus.\nThere are many examples of integrating a computer algebra system (such as Mathematica, Maple, or Sage) into the calculus conversation. Computer algebra systems can be magical. The popular WolframAlpha website calls the full power of Mathematica while allowing an informal syntax that is flexible enough to be used as a backend for Apple’s Siri feature. (“Siri what is the graph of x squared minus 4?”) For learning purposes, computer algebra systems model very well the algebraic/symbolic treatment of the material while providing means to illustrate the numeric aspects. These notes are a bit different in that Julia is primarily used for the numeric style of computing and the algebraic/symbolic treatment is added on. Doing the symbolic treatment by hand can be very beneficial while learning, and computer algebra systems make those exercises seem kind of redundant, as the finished product can be produced much more easily.\nOur real goal is to get at the concepts using technology as much as possible without getting bogged down in the mechanics of the computer language. We feel Julia has a very natural syntax that makes the initial start up not so much more difficult than using a calculator, but with a language that has a tremendous upside. The notes restrict themselves to a reduced set of computational concepts. This set is sufficient for working many of the problems in calculus, but do not cover thoroughly many aspects of programming. (Those who are interested can go off on their own and Julia provides a rich opportunity to do so.) Within this restricted set, are operators that make many of the computations of calculus reduce to a function call of the form action(function, arguments...). With a small collection of actions that can be composed, many of the problems associated with introductory calculus can be attacked.\nThese notes are presented in pages covering a fairly focused concept, in a spirit similar to a section of a book. Just like a book, there are try-it-yourself questions at the end of each page. All have a limited number of self-graded answers. These notes borrow ideas from many sources, for example Strang (n.d.), Knill (n.d.), Schey (1997), Hass, Heil, and Weir (2018), Rogawski, Adams, and Franzosa (2019), several Wikipedia pages, and other sources.\nThese notes are accompanied by a Julia package CalculusWithJulia that provides some simple functions to streamline some common tasks and loads some useful packages that will be used repeatedly.\nThese notes are presented as a Quarto book. To learn more about Quarto books visit https://quarto.org/docs/books.\nTo contribute – say by suggesting addition topics, correcting a mistake, or fixing a typo – click the “Edit this page” link and join the list of contributors. Thanks to all contributors and a very special thanks to @fangliu-tju for their careful and most-appreciated proofreading.",
+    "crumbs": [
+      "Preface"
+    ]
+  },
+  {
+    "objectID": "index.html#running-julia",
+    "href": "index.html#running-julia",
+    "title": "Calculus with Julia",
+    "section": "Running Julia",
+    "text": "Running Julia\nJulia is installed quite easily with the juliaup utility. There are some brief installation notes in the overview of Julia commands. To run Julia through the web (though in a resource-constrained manner), these links resolve to binder.org instances:\n\n (Image without SymPy)\n (Image with SymPy, longer to load)\n\n\nCalculus with Julia version 0.21, produced on June 8, 2024.\n\n\n\n\nHass, Joel R., Christopher E. Heil, and Maurice D. Weir. 2018. Thomas’ Calculus. Pearson.\n\n\nKnill, Oliver. n.d. “Some Teaching Notes.” https://people.math.harvard.edu/~knill/teach/index.html.\n\n\nRogawski, Jon, Colin Adams, and Robert Franzosa. 2019. Calculus. Macmillan.\n\n\nSchey, H. M. 1997. Div, Grad, Curl, and All That. W.W. Norton.\n\n\nStrang, Gilbert. n.d. “Calculus.” Wellesley-Cambridge Press. https://ocw.mit.edu/courses/res-18-001-calculus-online-textbook-spring-2005/.",
     "crumbs": [
       "Preface"
     ]
@@ -1059,7 +1069,7 @@
     "href": "precalc/julia_overview.html",
     "title": "17  Overview of Julia commands",
     "section": "",
-    "text": "17.1 Installing Julia\nJulia is an open source project which allows anyone with a supported computer to use it. To install locally, the downloads page has several different binaries for installation. Additionally, the downloads page contains a link to a docker image. For Microsoft Windows, the new juilaup installer may be of interest; it is available from the Windows Store. Julia can also be compiled from source.\nJulia can also be run through the web.\nThe https://mybinder.org/ service in particular allows free access, though limited in terms of allotted memory and with a relatively short timeout for inactivity.\nGoogle colab offers a free service with more computing power than binder, though setup is a bit more fussy. To use colab, you need to execute a command that downloads Julia and installs the CalculusWithJulia package and a plotting package. (Modify the pkg\"add ...\" command to add other desired packages):\nAfter this executes (which can take quite some time, as in a few minutes) under the Runtime menu select Change runtime type and then select Julia.\nAfter that, in a cell execute these commands to load the two installed packages:\nAs mentioned, other packages can be chosen for installation.",
+    "text": "17.1 Installing Julia\nJulia is an open source project which allows anyone with a supported computer to use it free of charge.\nTo install locally, the downloads page has directions to use the Juliaup utility for managing an installation. There are also links to several different binaries for manual installation. Additionally, the downloads page contains a link to a docker image. Julia can also be compiled from source.\nJulia can also be run through the web.\nThe https://mybinder.org/ service in particular allows free access, though limited in terms of allotted memory and with a relatively short timeout for inactivity.\nGoogle colab offers a free service with more computing power than binder, though setup is a bit more fussy. To use colab, you need to execute a command that downloads Julia and installs the CalculusWithJulia package and a plotting package. (Modify the pkg\"add ...\" command to add other desired packages):\nAfter this executes (which can take quite some time, as in a few minutes) under the Runtime menu select Change runtime type and then select Julia.\nAfter that, in a cell execute these commands to load the two installed packages:\nAs mentioned, other packages can be chosen for installation.",
     "crumbs": [
       "Precalculus Concepts",
       "<span class='chapter-number'>17</span>  <span class='chapter-title'>Overview of Julia commands</span>"
@@ -1114,7 +1124,7 @@
     "href": "precalc/julia_overview.html#numbers-variable-types",
     "title": "17  Overview of Julia commands",
     "section": "17.5 Numbers, variable types",
-    "text": "17.5 Numbers, variable types\nJulia has many different number types beyond the floating point type employed by most calculators. These include\n\nFloating point numbers: 0.5\nIntegers: 2\nRational numbers: 1//2\nComplex numbers 2 + 0im\n\nJulia’s parser finds the appropriate type for the value, when read in. The following all create the number \\(1\\) first as an integer, then a rational, then a floating point number, again as floating point number, and finally as a complex number:\n\n1, 1//1, 1.0, 1e0, 1 + 0im\n\n(1, 1//1, 1.0, 1.0, 1 + 0im)\n\n\nAs much as possible, operations involving certain types of numbers will produce output of a given type. For example, both of these divisions produce a floating point answer, even though mathematically, they need not:\n\n2/1, 1/2\n\n(2.0, 0.5)\n\n\nSome powers with negative bases, like (-3.0)^(1/3), are not defined. However, Julia provides the special-case function cbrt (and sqrt) for handling these.\nInteger operations may silently overflow, producing odd answers, at first glance:\n\n2^64\n\n0\n\n\n(Though the output is predictable, if overflow is taken into consideration appropriately.)\nWhen different types of numbers are mixed, Julia will usually promote the values to a common type before the operation:\n\n(2 + 1//2) + 0.5\n\n3.0\n\n\nJulia will first add 2 and 1//2 promoting 2 to rational before doing so. Then add the result, 5//2 to 0.5 by promoting 5//2 to the floating point number 2.5 before proceeding.\nJulia uses a special type to store a handful of irrational constants such as pi. The special type allows these constants to be treated without round off, until they mix with other floating point numbers. There are some functions that require these be explicitly promoted to floating point. This can be done by calling float.\nThe standard mathematical operations are implemented by +, -, *, /, ^. Parentheses are used for grouping.\n\n17.5.1 Vectors\nA vector is an indexed collection of similarly typed values. Vectors can be constructed with square brackets (syntax for concatenation):\n\n[1, 1, 2, 3, 5, 8]\n\n6-element Vector{Int64}:\n 1\n 1\n 2\n 3\n 5\n 8\n\n\nValues will be promoted to a common type (or type Any if none exists). For example, this vector will have type Float64 due to the 1/3 computation:\n\n[1, 1//2, 1/3]\n\n3-element Vector{Float64}:\n 1.0\n 0.5\n 0.3333333333333333\n\n\n(Vectors are used as a return type from some functions, as such, some familiarity is needed.)\nRegular arithmetic sequences can be defined by either:\n\nRange operations: a:h:b or a:b which produces a generator of values starting at a separated by h (h is 1 in the last form) until they reach b.\nThe range function: range(a, b, length=n) which produces a generator of n values between a and b;\n\nThese constructs return range objects. A range object compactly stores the values it references. To see all the values, they can be collected with the collect function, though this is rarely needed in practice.\nRandom sequences are formed by rand, among others:\n\nrand(3)\n\n3-element Vector{Float64}:\n 0.9280016644651431\n 0.23849211233576195\n 0.11690529588442855\n\n\nThe call rand() returns a single random number (in \\([0,1)\\).)",
+    "text": "17.5 Numbers, variable types\nJulia has many different number types beyond the floating point type employed by most calculators. These include\n\nFloating point numbers: 0.5\nIntegers: 2\nRational numbers: 1//2\nComplex numbers 2 + 0im\n\nJulia’s parser finds the appropriate type for the value, when read in. The following all create the number \\(1\\) first as an integer, then a rational, then a floating point number, again as floating point number, and finally as a complex number:\n\n1, 1//1, 1.0, 1e0, 1 + 0im\n\n(1, 1//1, 1.0, 1.0, 1 + 0im)\n\n\nAs much as possible, operations involving certain types of numbers will produce output of a given type. For example, both of these divisions produce a floating point answer, even though mathematically, they need not:\n\n2/1, 1/2\n\n(2.0, 0.5)\n\n\nSome powers with negative bases, like (-3.0)^(1/3), are not defined. However, Julia provides the special-case function cbrt (and sqrt) for handling these.\nInteger operations may silently overflow, producing odd answers, at first glance:\n\n2^64\n\n0\n\n\n(Though the output is predictable, if overflow is taken into consideration appropriately.)\nWhen different types of numbers are mixed, Julia will usually promote the values to a common type before the operation:\n\n(2 + 1//2) + 0.5\n\n3.0\n\n\nJulia will first add 2 and 1//2 promoting 2 to rational before doing so. Then add the result, 5//2 to 0.5 by promoting 5//2 to the floating point number 2.5 before proceeding.\nJulia uses a special type to store a handful of irrational constants such as pi. The special type allows these constants to be treated without round off, until they mix with other floating point numbers. There are some functions that require these be explicitly promoted to floating point. This can be done by calling float.\nThe standard mathematical operations are implemented by +, -, *, /, ^. Parentheses are used for grouping.\n\n17.5.1 Vectors\nA vector is an indexed collection of similarly typed values. Vectors can be constructed with square brackets (syntax for concatenation):\n\n[1, 1, 2, 3, 5, 8]\n\n6-element Vector{Int64}:\n 1\n 1\n 2\n 3\n 5\n 8\n\n\nValues will be promoted to a common type (or type Any if none exists). For example, this vector will have type Float64 due to the 1/3 computation:\n\n[1, 1//2, 1/3]\n\n3-element Vector{Float64}:\n 1.0\n 0.5\n 0.3333333333333333\n\n\n(Vectors are used as a return type from some functions, as such, some familiarity is needed.)\nRegular arithmetic sequences can be defined by either:\n\nRange operations: a:h:b or a:b which produces a generator of values starting at a separated by h (h is 1 in the last form) until they reach b.\nThe range function: range(a, b, length=n) which produces a generator of n values between a and b;\n\nThese constructs return range objects. A range object compactly stores the values it references. To see all the values, they can be collected with the collect function, though this is rarely needed in practice.\nRandom sequences are formed by rand, among others:\n\nrand(3)\n\n3-element Vector{Float64}:\n 0.1274898327027475\n 0.516610179123885\n 0.3360580223517624\n\n\nThe call rand() returns a single random number (in \\([0,1)\\).)",
     "crumbs": [
       "Precalculus Concepts",
       "<span class='chapter-number'>17</span>  <span class='chapter-title'>Overview of Julia commands</span>"