Still working towards v0.1.1 docs.
This commit is contained in:
Simon Forman
parent
dbb1fcf4a2
commit
c3a3f5a527
|
|
@ -157,13 +157,6 @@
|
|||
<span class="s1">dudipd == dup dipd</span>
|
||||
<span class="s1">primrec == [i] genrec</span>
|
||||
<span class="s1">step_zero == 0 roll> step</span>
|
||||
<span class="s1">direco == dip rest cons</span>
|
||||
<span class="s1">make_generator == [direco] cons [swap] swoncat cons</span>
|
||||
<span class="s1">gsra == 1 swap [over / + 2 /] cons [dup] swoncat make_generator</span>
|
||||
<span class="s1">_within_P == [first - abs] dip <=</span>
|
||||
<span class="s1">_within_B == roll< popop first</span>
|
||||
<span class="s1">_within_R == [popd x] dip</span>
|
||||
<span class="s1">within == x 0.000001 [_within_P] [_within_B] [_within_R] primrec</span>
|
||||
<span class="s1">'''</span>
|
||||
|
||||
<span class="c1">##Zipper</span>
|
||||
|
|
|
|||
|
|
@ -6,7 +6,7 @@
|
|||
<head>
|
||||
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
<title>Preamble — Thun 0.1.1 documentation</title>
|
||||
<title>Replacing Functions in the Dictionary — Thun 0.1.1 documentation</title>
|
||||
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
|
||||
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
|
||||
<script type="text/javascript" src="../_static/documentation_options.js"></script>
|
||||
|
|
@ -30,14 +30,13 @@
|
|||
<div class="bodywrapper">
|
||||
<div class="body" role="main">
|
||||
|
||||
<div class="section" id="preamble">
|
||||
<h1>Preamble<a class="headerlink" href="#preamble" title="Permalink to this headline">¶</a></h1>
|
||||
<div class="section" id="replacing-functions-in-the-dictionary">
|
||||
<h1>Replacing Functions in the Dictionary<a class="headerlink" href="#replacing-functions-in-the-dictionary" title="Permalink to this headline">¶</a></h1>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">notebook_preamble</span> <span class="k">import</span> <span class="n">D</span><span class="p">,</span> <span class="n">J</span><span class="p">,</span> <span class="n">V</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="a-long-trace">
|
||||
<h1>A long trace<a class="headerlink" href="#a-long-trace" title="Permalink to this headline">¶</a></h1>
|
||||
<h2>A long trace<a class="headerlink" href="#a-long-trace" title="Permalink to this headline">¶</a></h2>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'[23 18] average'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
|
|
@ -86,31 +85,16 @@
|
|||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="replacing-sum-and-size-with-compiled-versions">
|
||||
<h1>Replacing <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> with “compiled” versions.<a class="headerlink" href="#replacing-sum-and-size-with-compiled-versions" title="Permalink to this headline">¶</a></h1>
|
||||
<p>Both <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> are
|
||||
<a class="reference external" href="https://en.wikipedia.org/wiki/Catamorphism">catamorphisms</a>, they
|
||||
each convert a sequence to a single value.</p>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[sum] help'</span><span class="p">)</span>
|
||||
<div class="section" id="replacing-size-with-a-python-version">
|
||||
<h2>Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python Version<a class="headerlink" href="#replacing-size-with-a-python-version" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Both <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> each convert a sequence to a single value.</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="nb">sum</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">step</span>
|
||||
<span class="n">size</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Given</span> <span class="n">a</span> <span class="n">quoted</span> <span class="n">sequence</span> <span class="n">of</span> <span class="n">numbers</span> <span class="k">return</span> <span class="n">the</span> <span class="nb">sum</span><span class="o">.</span>
|
||||
|
||||
<span class="nb">sum</span> <span class="o">==</span> <span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="o">+</span><span class="p">]</span> <span class="n">step</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'[size] help'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">0</span> <span class="n">swap</span> <span class="p">[</span><span class="n">pop</span> <span class="o">++</span><span class="p">]</span> <span class="n">step</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>We can use “compiled” versions (they’re not really compiled in this
|
||||
case, they’re hand-written in Python) to speed up evaluation and make
|
||||
the trace more readable. The <code class="docutils literal notranslate"><span class="pre">sum</span></code> function is already in the library.
|
||||
It gets shadowed by the definition version above during
|
||||
<code class="docutils literal notranslate"><span class="pre">initialize()</span></code>.</p>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.library</span> <span class="k">import</span> <span class="n">SimpleFunctionWrapper</span><span class="p">,</span> <span class="n">primitives</span>
|
||||
<p>An efficient <code class="docutils literal notranslate"><span class="pre">sum</span></code> function is already in the library. But for <code class="docutils literal notranslate"><span class="pre">size</span></code> we can use
|
||||
a “compiled” version hand-written in Python to speed up evaluation and make the trace more readable.</p>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">joy.library</span> <span class="k">import</span> <span class="n">SimpleFunctionWrapper</span>
|
||||
<span class="kn">from</span> <span class="nn">joy.utils.stack</span> <span class="k">import</span> <span class="n">iter_stack</span>
|
||||
|
||||
|
||||
|
|
@ -122,17 +106,16 @@ It gets shadowed by the definition version above during
|
|||
<span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="n">iter_stack</span><span class="p">(</span><span class="n">sequence</span><span class="p">):</span>
|
||||
<span class="n">n</span> <span class="o">+=</span> <span class="mi">1</span>
|
||||
<span class="k">return</span> <span class="n">n</span><span class="p">,</span> <span class="n">stack</span>
|
||||
|
||||
|
||||
<span class="n">sum_</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">p</span> <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">primitives</span> <span class="k">if</span> <span class="n">p</span><span class="o">.</span><span class="n">name</span> <span class="o">==</span> <span class="s1">'sum'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Now we replace them old versions in the dictionary with the new versions
|
||||
<p>Now we replace the old version in the dictionary with the new version,
|
||||
and re-evaluate the expression.</p>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">old_sum</span><span class="p">,</span> <span class="n">D</span><span class="p">[</span><span class="s1">'sum'</span><span class="p">]</span> <span class="o">=</span> <span class="n">D</span><span class="p">[</span><span class="s1">'sum'</span><span class="p">],</span> <span class="n">sum_</span>
|
||||
<span class="n">old_size</span><span class="p">,</span> <span class="n">D</span><span class="p">[</span><span class="s1">'size'</span><span class="p">]</span> <span class="o">=</span> <span class="n">D</span><span class="p">[</span><span class="s1">'size'</span><span class="p">],</span> <span class="n">size</span>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">D</span><span class="p">[</span><span class="s1">'size'</span><span class="p">]</span> <span class="o">=</span> <span class="n">size</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="a-shorter-evaluation">
|
||||
<h2>A Shorter Evaluation<a class="headerlink" href="#a-shorter-evaluation" title="Permalink to this headline">¶</a></h2>
|
||||
<p>You can see that <code class="docutils literal notranslate"><span class="pre">size</span></code> and <code class="docutils literal notranslate"><span class="pre">sum</span></code> now execute in a single step.</p>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">V</span><span class="p">(</span><span class="s1">'[23 18] average'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
|
|
@ -168,6 +151,7 @@ and re-evaluate the expression.</p>
|
|||
<span class="mf">20.5</span> <span class="o">.</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
|
||||
|
|
@ -178,9 +162,12 @@ and re-evaluate the expression.</p>
|
|||
<div class="sphinxsidebarwrapper">
|
||||
<h3><a href="../index.html">Table Of Contents</a></h3>
|
||||
<ul>
|
||||
<li><a class="reference internal" href="#">Preamble</a></li>
|
||||
<li><a class="reference internal" href="#">Replacing Functions in the Dictionary</a><ul>
|
||||
<li><a class="reference internal" href="#a-long-trace">A long trace</a></li>
|
||||
<li><a class="reference internal" href="#replacing-sum-and-size-with-compiled-versions">Replacing <code class="docutils literal notranslate"><span class="pre">sum</span></code> and <code class="docutils literal notranslate"><span class="pre">size</span></code> with “compiled” versions.</a></li>
|
||||
<li><a class="reference internal" href="#replacing-size-with-a-python-version">Replacing <code class="docutils literal notranslate"><span class="pre">size</span></code> with a Python Version</a></li>
|
||||
<li><a class="reference internal" href="#a-shorter-evaluation">A Shorter Evaluation</a></li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
<div class="relations">
|
||||
<h3>Related Topics</h3>
|
||||
|
|
|
|||
|
|
@ -1,258 +0,0 @@
|
|||
|
||||
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
|
||||
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
|
||||
|
||||
<html xmlns="http://www.w3.org/1999/xhtml">
|
||||
<head>
|
||||
<meta http-equiv="X-UA-Compatible" content="IE=Edge" />
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
<title>A Generator for Approximations — Thun 0.1.1 documentation</title>
|
||||
<link rel="stylesheet" href="../_static/alabaster.css" type="text/css" />
|
||||
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
|
||||
<script type="text/javascript" src="../_static/documentation_options.js"></script>
|
||||
<script type="text/javascript" src="../_static/jquery.js"></script>
|
||||
<script type="text/javascript" src="../_static/underscore.js"></script>
|
||||
<script type="text/javascript" src="../_static/doctools.js"></script>
|
||||
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script>
|
||||
<link rel="index" title="Index" href="../genindex.html" />
|
||||
<link rel="search" title="Search" href="../search.html" />
|
||||
|
||||
<link rel="stylesheet" href="../_static/custom.css" type="text/css" />
|
||||
|
||||
|
||||
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
|
||||
|
||||
</head><body>
|
||||
|
||||
|
||||
<div class="document">
|
||||
<div class="documentwrapper">
|
||||
<div class="bodywrapper">
|
||||
<div class="body" role="main">
|
||||
|
||||
<div class="section" id="a-generator-for-approximations">
|
||||
<h1>A Generator for Approximations<a class="headerlink" href="#a-generator-for-approximations" title="Permalink to this headline">¶</a></h1>
|
||||
<p>In <a class="reference internal" href="Generator Programs.html"><span class="doc">Using x to Generate Values</span></a> we derive a function <code class="docutils literal notranslate"><span class="pre">G</span></code> (called <code class="docutils literal notranslate"><span class="pre">make_generator</span></code> in the dictionary) that accepts an initial value and a quoted program and returns a new quoted program that, when driven by the <code class="docutils literal notranslate"><span class="pre">x</span></code> combinator (<a class="reference internal" href="../library.html#joy.library.x" title="joy.library.x"><code class="xref py py-func docutils literal notranslate"><span class="pre">joy.library.x()</span></code></a>), acts like a lazy stream.</p>
|
||||
<p>To make a generator that generates successive approximations let’s start by assuming an initial approximation and then derive the function that computes the next approximation:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">F</span>
|
||||
<span class="o">---------</span>
|
||||
<span class="n">a</span><span class="s1">'</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="section" id="a-function-to-compute-the-next-approximation">
|
||||
<h2>A Function to Compute the Next Approximation<a class="headerlink" href="#a-function-to-compute-the-next-approximation" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Looking at the equation again:</p>
|
||||
<p><span class="math notranslate nohighlight">\(a_{i+1} = \frac{(a_i+\frac{n}{a_i})}{2}\)</span></p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="n">n</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">a</span> <span class="n">n</span> <span class="n">a</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">a</span> <span class="n">n</span><span class="o">/</span><span class="n">a</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">a</span><span class="o">+</span><span class="n">n</span><span class="o">/</span><span class="n">a</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="p">(</span><span class="n">a</span><span class="o">+</span><span class="n">n</span><span class="o">/</span><span class="n">a</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>The function we want has the argument <code class="docutils literal notranslate"><span class="pre">n</span></code> in it:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">F</span> <span class="o">==</span> <span class="n">n</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="make-it-into-a-generator">
|
||||
<h2>Make it into a Generator<a class="headerlink" href="#make-it-into-a-generator" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Our generator would be created by:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">dup</span> <span class="n">F</span><span class="p">]</span> <span class="n">make_generator</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>With <code class="docutils literal notranslate"><span class="pre">n</span></code> as part of the function <code class="docutils literal notranslate"><span class="pre">F</span></code>, but <code class="docutils literal notranslate"><span class="pre">n</span></code> is the input to the <code class="docutils literal notranslate"><span class="pre">sqrt</span></code> function we’re writing. If we let 1 be the initial approximation:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="n">n</span> <span class="mi">1</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="mi">1</span> <span class="n">n</span><span class="o">/</span><span class="mi">1</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="mi">1</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">n</span><span class="o">+</span><span class="mi">1</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="o">/</span><span class="mi">2</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>The generator can be written as:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Example:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span> <span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
<span class="mi">1</span> <span class="mi">23</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
<span class="mi">1</span> <span class="p">[</span><span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
<span class="mi">1</span> <span class="p">[</span><span class="n">dup</span> <span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">make_generator</span>
|
||||
<span class="o">.</span>
|
||||
<span class="o">.</span>
|
||||
<span class="o">.</span>
|
||||
<span class="p">[</span><span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">dup</span> <span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">direco</span><span class="p">]</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="a-generator-of-square-root-approximations">
|
||||
<h2>A Generator of Square Root Approximations<a class="headerlink" href="#a-generator-of-square-root-approximations" title="Permalink to this headline">¶</a></h2>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">gsra</span> <span class="o">==</span> <span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="finding-consecutive-approximations-within-a-tolerance">
|
||||
<h1>Finding Consecutive Approximations <code class="docutils literal notranslate"><span class="pre">within</span></code> a Tolerance<a class="headerlink" href="#finding-consecutive-approximations-within-a-tolerance" title="Permalink to this headline">¶</a></h1>
|
||||
<blockquote>
|
||||
<div>The remainder of a square root finder is a function <em>within</em>, which takes a tolerance and a list of approximations and looks down the list for two successive approximations that differ by no more than the given tolerance.</div></blockquote>
|
||||
<p>From <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why Functional Programming Matters” by John
|
||||
Hughes</a></p>
|
||||
<p>(And note that by “list” he means a lazily-evaluated list.)</p>
|
||||
<p>Using the <em>output</em> <code class="docutils literal notranslate"><span class="pre">[a</span> <span class="pre">G]</span></code> of the above <a class="reference internal" href="Generator Programs.html"><span class="doc">generator</span></a> for square root approximations, and further assuming that the first term <code class="docutils literal notranslate"><span class="pre">a</span></code> has been generated already and epsilon <code class="docutils literal notranslate"><span class="pre">ε</span></code> is handy on the stack…</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
<span class="o">----------------------</span> <span class="n">a</span> <span class="n">b</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="n">b</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
<span class="o">----------------------</span> <span class="n">a</span> <span class="n">b</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o">></span>
|
||||
<span class="o">.</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">x</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
<span class="o">.</span>
|
||||
<span class="o">----------------------</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="section" id="predicate">
|
||||
<h2>Predicate<a class="headerlink" href="#predicate" title="Permalink to this headline">¶</a></h2>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o"><=</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="n">a</span> <span class="n">b</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="n">a</span><span class="o">-</span><span class="n">b</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="nb">abs</span><span class="p">(</span><span class="n">a</span><span class="o">-</span><span class="n">b</span><span class="p">)</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="p">(</span><span class="nb">abs</span><span class="p">(</span><span class="n">a</span><span class="o">-</span><span class="n">b</span><span class="p">)</span><span class="o"><=</span><span class="n">ε</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">P</span> <span class="o">==</span> <span class="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o"><=</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="base-case">
|
||||
<h2>Base-Case<a class="headerlink" href="#base-case" title="Permalink to this headline">¶</a></h2>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">roll</span><span class="o"><</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">a</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">first</span>
|
||||
<span class="n">b</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">B</span> <span class="o">==</span> <span class="n">roll</span><span class="o"><</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="recur">
|
||||
<h2>Recur<a class="headerlink" href="#recur" title="Permalink to this headline">¶</a></h2>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">R0</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">R1</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<ol class="arabic simple">
|
||||
<li>Discard <code class="docutils literal notranslate"><span class="pre">a</span></code>.</li>
|
||||
<li>Use <code class="docutils literal notranslate"><span class="pre">x</span></code> combinator to generate next term from <code class="docutils literal notranslate"><span class="pre">G</span></code>.</li>
|
||||
<li>Run <code class="docutils literal notranslate"><span class="pre">within</span></code> with <code class="docutils literal notranslate"><span class="pre">i</span></code> (it is a <code class="docutils literal notranslate"><span class="pre">primrec</span></code> function.)</li>
|
||||
</ol>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">R0</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">R1</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="p">[</span><span class="n">popd</span> <span class="n">x</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">popd</span> <span class="n">x</span> <span class="n">ε</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">x</span> <span class="n">ε</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">R0</span> <span class="o">==</span> <span class="p">[</span><span class="n">popd</span> <span class="n">x</span><span class="p">]</span> <span class="n">dip</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="setting-up">
|
||||
<h2>Setting up<a class="headerlink" href="#setting-up" title="Permalink to this headline">¶</a></h2>
|
||||
<p>The recursive function we have defined so far needs a slight preamble: <code class="docutils literal notranslate"><span class="pre">x</span></code> to prime the generator and the epsilon value to use:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">a</span> <span class="n">G</span><span class="p">]</span> <span class="n">x</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="within">
|
||||
<h2><code class="docutils literal notranslate"><span class="pre">within</span></code><a class="headerlink" href="#within" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Giving us the following definitions:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">_within_P</span> <span class="o">==</span> <span class="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o"><=</span>
|
||||
<span class="n">_within_B</span> <span class="o">==</span> <span class="n">roll</span><span class="o"><</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
<span class="n">_within_R</span> <span class="o">==</span> <span class="p">[</span><span class="n">popd</span> <span class="n">x</span><span class="p">]</span> <span class="n">dip</span>
|
||||
<span class="n">within</span> <span class="o">==</span> <span class="n">x</span> <span class="n">ε</span> <span class="p">[</span><span class="n">_within_P</span><span class="p">]</span> <span class="p">[</span><span class="n">_within_B</span><span class="p">]</span> <span class="p">[</span><span class="n">_within_R</span><span class="p">]</span> <span class="n">primrec</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="finding-square-roots">
|
||||
<h1>Finding Square Roots<a class="headerlink" href="#finding-square-roots" title="Permalink to this headline">¶</a></h1>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">sqrt</span> <span class="o">==</span> <span class="n">gsra</span> <span class="n">within</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
|
||||
<div class="sphinxsidebarwrapper">
|
||||
<h3><a href="../index.html">Table Of Contents</a></h3>
|
||||
<ul>
|
||||
<li><a class="reference internal" href="#">A Generator for Approximations</a><ul>
|
||||
<li><a class="reference internal" href="#a-function-to-compute-the-next-approximation">A Function to Compute the Next Approximation</a></li>
|
||||
<li><a class="reference internal" href="#make-it-into-a-generator">Make it into a Generator</a></li>
|
||||
<li><a class="reference internal" href="#a-generator-of-square-root-approximations">A Generator of Square Root Approximations</a></li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><a class="reference internal" href="#finding-consecutive-approximations-within-a-tolerance">Finding Consecutive Approximations <code class="docutils literal notranslate"><span class="pre">within</span></code> a Tolerance</a><ul>
|
||||
<li><a class="reference internal" href="#predicate">Predicate</a></li>
|
||||
<li><a class="reference internal" href="#base-case">Base-Case</a></li>
|
||||
<li><a class="reference internal" href="#recur">Recur</a></li>
|
||||
<li><a class="reference internal" href="#setting-up">Setting up</a></li>
|
||||
<li><a class="reference internal" href="#within"><code class="docutils literal notranslate"><span class="pre">within</span></code></a></li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><a class="reference internal" href="#finding-square-roots">Finding Square Roots</a></li>
|
||||
</ul>
|
||||
<div class="relations">
|
||||
<h3>Related Topics</h3>
|
||||
<ul>
|
||||
<li><a href="../index.html">Documentation overview</a><ul>
|
||||
</ul></li>
|
||||
</ul>
|
||||
</div>
|
||||
<div role="note" aria-label="source link">
|
||||
<h3>This Page</h3>
|
||||
<ul class="this-page-menu">
|
||||
<li><a href="../_sources/notebooks/AlsoNewton.rst.txt"
|
||||
rel="nofollow">Show Source</a></li>
|
||||
</ul>
|
||||
</div>
|
||||
<div id="searchbox" style="display: none" role="search">
|
||||
<h3>Quick search</h3>
|
||||
<div class="searchformwrapper">
|
||||
<form class="search" action="../search.html" method="get">
|
||||
<input type="text" name="q" />
|
||||
<input type="submit" value="Go" />
|
||||
<input type="hidden" name="check_keywords" value="yes" />
|
||||
<input type="hidden" name="area" value="default" />
|
||||
</form>
|
||||
</div>
|
||||
</div>
|
||||
<script type="text/javascript">$('#searchbox').show(0);</script>
|
||||
</div>
|
||||
</div>
|
||||
<div class="clearer"></div>
|
||||
</div>
|
||||
<div class="footer" role="contentinfo">
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">
|
||||
<img alt="Creative Commons License" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" />
|
||||
</a>
|
||||
<br />
|
||||
<span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">Thun Documentation</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="https://joypy.osdn.io/" property="cc:attributionName" rel="cc:attributionURL">Simon Forman</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License</a>.<br />Based on a work at <a xmlns:dct="http://purl.org/dc/terms/" href="https://osdn.net/projects/joypy/" rel="dct:source">https://osdn.net/projects/joypy/</a>.
|
||||
Created using <a href="http://sphinx-doc.org/">Sphinx</a> 1.7.3.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -40,146 +40,165 @@
|
|||
</div>
|
||||
<p>Cf. <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why Functional Programming Matters” by John
|
||||
Hughes</a></p>
|
||||
<div class="section" id="finding-the-square-root-of-a-number">
|
||||
<h2>Finding the Square-Root of a Number<a class="headerlink" href="#finding-the-square-root-of-a-number" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Let’s define a function that computes this equation:</p>
|
||||
<div class="section" id="a-generator-for-approximations">
|
||||
<h2>A Generator for Approximations<a class="headerlink" href="#a-generator-for-approximations" title="Permalink to this headline">¶</a></h2>
|
||||
<p>In <a class="reference internal" href="Generator Programs.html"><span class="doc">Using x to Generate Values</span></a> we derive a function (called <code class="docutils literal notranslate"><span class="pre">make_generator</span></code> in the dictionary) that accepts an initial value and a quoted program and returns a new quoted program that, when driven by the <code class="docutils literal notranslate"><span class="pre">x</span></code> combinator (<a class="reference internal" href="../library.html#joy.library.x" title="joy.library.x"><code class="xref py py-func docutils literal notranslate"><span class="pre">joy.library.x()</span></code></a>), acts like a lazy stream.</p>
|
||||
<p>To make a generator that generates successive approximations let’s start by assuming an initial approximation and then derive the function that computes the next approximation:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">F</span>
|
||||
<span class="o">---------</span>
|
||||
<span class="n">a</span><span class="s1">'</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="section" id="a-function-to-compute-the-next-approximation">
|
||||
<h3>A Function to Compute the Next Approximation<a class="headerlink" href="#a-function-to-compute-the-next-approximation" title="Permalink to this headline">¶</a></h3>
|
||||
<p>Looking at the equation again:</p>
|
||||
<p><span class="math notranslate nohighlight">\(a_{i+1} = \frac{(a_i+\frac{n}{a_i})}{2}\)</span></p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">n</span> <span class="n">a</span> <span class="n">Q</span>
|
||||
<span class="o">---------------</span>
|
||||
<span class="p">(</span><span class="n">a</span><span class="o">+</span><span class="n">n</span><span class="o">/</span><span class="n">a</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
|
||||
|
||||
<span class="n">n</span> <span class="n">a</span> <span class="n">tuck</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="n">n</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">a</span> <span class="n">n</span> <span class="n">a</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">a</span> <span class="n">n</span><span class="o">/</span><span class="n">a</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">a</span><span class="o">+</span><span class="n">n</span><span class="o">/</span><span class="n">a</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="p">(</span><span class="n">a</span><span class="o">+</span><span class="n">n</span><span class="o">/</span><span class="n">a</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>We want it to leave n but replace a, so we execute it with <code class="docutils literal notranslate"><span class="pre">unary</span></code>:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Q</span> <span class="o">==</span> <span class="p">[</span><span class="n">tuck</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">unary</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'Q == [tuck / + 2 /] unary'</span><span class="p">)</span>
|
||||
<p>The function we want has the argument <code class="docutils literal notranslate"><span class="pre">n</span></code> in it:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">F</span> <span class="o">==</span> <span class="n">n</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="compute-the-error">
|
||||
<h2>Compute the Error<a class="headerlink" href="#compute-the-error" title="Permalink to this headline">¶</a></h2>
|
||||
<p>And a function to compute the error:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="n">a</span> <span class="n">sqr</span> <span class="o">-</span> <span class="nb">abs</span>
|
||||
<span class="o">|</span><span class="n">n</span><span class="o">-</span><span class="n">a</span><span class="o">**</span><span class="mi">2</span><span class="o">|</span>
|
||||
<div class="section" id="make-it-into-a-generator">
|
||||
<h3>Make it into a Generator<a class="headerlink" href="#make-it-into-a-generator" title="Permalink to this headline">¶</a></h3>
|
||||
<p>Our generator would be created by:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">dup</span> <span class="n">F</span><span class="p">]</span> <span class="n">make_generator</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>This should be <code class="docutils literal notranslate"><span class="pre">nullary</span></code> so as to leave both n and a on the stack
|
||||
below the error.</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">err</span> <span class="o">==</span> <span class="p">[</span><span class="n">sqr</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">nullary</span>
|
||||
<p>With <code class="docutils literal notranslate"><span class="pre">n</span></code> as part of the function <code class="docutils literal notranslate"><span class="pre">F</span></code>, but <code class="docutils literal notranslate"><span class="pre">n</span></code> is the input to the <code class="docutils literal notranslate"><span class="pre">sqrt</span></code> function we’re writing. If we let 1 be the initial approximation:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="n">n</span> <span class="mi">1</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="mi">1</span> <span class="n">n</span><span class="o">/</span><span class="mi">1</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="mi">1</span> <span class="n">n</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span>
|
||||
<span class="n">n</span><span class="o">+</span><span class="mi">1</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="o">/</span><span class="mi">2</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'err == [sqr - abs] nullary'</span><span class="p">)</span>
|
||||
<p>The generator can be written as:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Example:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mi">23</span> <span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
<span class="mi">1</span> <span class="mi">23</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
<span class="mi">1</span> <span class="p">[</span><span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
<span class="mi">1</span> <span class="p">[</span><span class="n">dup</span> <span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">make_generator</span>
|
||||
<span class="o">.</span>
|
||||
<span class="o">.</span>
|
||||
<span class="o">.</span>
|
||||
<span class="p">[</span><span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">dup</span> <span class="mi">23</span> <span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">direco</span><span class="p">]</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="square-root">
|
||||
<h2><code class="docutils literal notranslate"><span class="pre">square-root</span></code><a class="headerlink" href="#square-root" title="Permalink to this headline">¶</a></h2>
|
||||
<p>Now we can define a recursive program that expects a number <code class="docutils literal notranslate"><span class="pre">n</span></code>, an
|
||||
initial estimate <code class="docutils literal notranslate"><span class="pre">a</span></code>, and an epsilon value <code class="docutils literal notranslate"><span class="pre">ε</span></code>, and that leaves on
|
||||
the stack the square root of <code class="docutils literal notranslate"><span class="pre">n</span></code> to within the precision of the
|
||||
epsilon value. (Later on we’ll refine it to generate the initial
|
||||
estimate and hard-code an epsilon value.)</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>n a ε square-root
|
||||
-----------------
|
||||
√n
|
||||
<div class="section" id="a-generator-of-square-root-approximations">
|
||||
<h3>A Generator of Square Root Approximations<a class="headerlink" href="#a-generator-of-square-root-approximations" title="Permalink to this headline">¶</a></h3>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">gsra</span> <span class="o">==</span> <span class="mi">1</span> <span class="n">swap</span> <span class="p">[</span><span class="n">over</span> <span class="o">/</span> <span class="o">+</span> <span class="mi">2</span> <span class="o">/</span><span class="p">]</span> <span class="n">cons</span> <span class="p">[</span><span class="n">dup</span><span class="p">]</span> <span class="n">swoncat</span> <span class="n">make_generator</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>If we apply the two functions <code class="docutils literal notranslate"><span class="pre">Q</span></code> and <code class="docutils literal notranslate"><span class="pre">err</span></code> defined above we get the
|
||||
next approximation and the error on the stack below the epsilon.</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="n">a</span> <span class="n">ε</span> <span class="p">[</span><span class="n">Q</span> <span class="n">err</span><span class="p">]</span> <span class="n">dip</span>
|
||||
<span class="n">n</span> <span class="n">a</span> <span class="n">Q</span> <span class="n">err</span> <span class="n">ε</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">' err ε</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">' e ε</span>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="finding-consecutive-approximations-within-a-tolerance">
|
||||
<h2>Finding Consecutive Approximations <code class="docutils literal notranslate"><span class="pre">within</span></code> a Tolerance<a class="headerlink" href="#finding-consecutive-approximations-within-a-tolerance" title="Permalink to this headline">¶</a></h2>
|
||||
<blockquote>
|
||||
<div>The remainder of a square root finder is a function <em>within</em>, which takes a tolerance and a list of approximations and looks down the list for two successive approximations that differ by no more than the given tolerance.</div></blockquote>
|
||||
<p>From <a class="reference external" href="https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf">“Why Functional Programming Matters” by John
|
||||
Hughes</a></p>
|
||||
<p>(And note that by “list” he means a lazily-evaluated list.)</p>
|
||||
<p>Using the <em>output</em> <code class="docutils literal notranslate"><span class="pre">[a</span> <span class="pre">G]</span></code> of the above <a class="reference internal" href="Generator Programs.html"><span class="doc">generator</span></a> for square root approximations, and further assuming that the first term <code class="docutils literal notranslate"><span class="pre">a</span></code> has been generated already and epsilon <code class="docutils literal notranslate"><span class="pre">ε</span></code> is handy on the stack…</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
<span class="o">----------------------</span> <span class="n">a</span> <span class="n">b</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="n">b</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>Let’s define a recursive function <code class="docutils literal notranslate"><span class="pre">K</span></code> from here.</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="n">a</span><span class="s1">' e ε K</span>
|
||||
|
||||
<span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="n">P</span><span class="p">]</span> <span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
<span class="o">----------------------</span> <span class="n">a</span> <span class="n">b</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o">></span>
|
||||
<span class="o">.</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">x</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
<span class="o">.</span>
|
||||
<span class="o">----------------------</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="section" id="predicate">
|
||||
<h3>Predicate<a class="headerlink" href="#predicate" title="Permalink to this headline">¶</a></h3>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o"><=</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="n">a</span> <span class="n">b</span> <span class="o">-</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="n">a</span><span class="o">-</span><span class="n">b</span> <span class="nb">abs</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="nb">abs</span><span class="p">(</span><span class="n">a</span><span class="o">-</span><span class="n">b</span><span class="p">)</span> <span class="n">ε</span> <span class="o"><=</span>
|
||||
<span class="p">(</span><span class="nb">abs</span><span class="p">(</span><span class="n">a</span><span class="o">-</span><span class="n">b</span><span class="p">)</span><span class="o"><=</span><span class="n">ε</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">P</span> <span class="o">==</span> <span class="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o"><=</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="base-case">
|
||||
<h3>Base-case<a class="headerlink" href="#base-case" title="Permalink to this headline">¶</a></h3>
|
||||
<p>The predicate and the base case are obvious:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="o"><</span><span class="p">]</span> <span class="p">[</span><span class="n">popop</span> <span class="n">popd</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||||
<h3>Base-Case<a class="headerlink" href="#base-case" title="Permalink to this headline">¶</a></h3>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">roll</span><span class="o"><</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">a</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">first</span>
|
||||
<span class="n">b</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="n">a</span><span class="s1">' e ε popop popd</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">' popd</span>
|
||||
<span class="n">a</span><span class="s1">'</span>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">B</span> <span class="o">==</span> <span class="n">roll</span><span class="o"><</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="recur">
|
||||
<h3>Recur<a class="headerlink" href="#recur" title="Permalink to this headline">¶</a></h3>
|
||||
<p>The recursive branch is pretty easy. Discard the error and recur.</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="o"><</span><span class="p">]</span> <span class="p">[</span><span class="n">popop</span> <span class="n">popd</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span><span class="p">]</span> <span class="p">[</span><span class="n">R1</span><span class="p">]</span> <span class="n">genrec</span>
|
||||
<span class="n">K</span> <span class="o">==</span> <span class="p">[</span><span class="o"><</span><span class="p">]</span> <span class="p">[</span><span class="n">popop</span> <span class="n">popd</span><span class="p">]</span> <span class="p">[</span><span class="n">R0</span> <span class="p">[</span><span class="n">K</span><span class="p">]</span> <span class="n">R1</span><span class="p">]</span> <span class="n">ifte</span>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">R0</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">R1</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">n</span> <span class="n">a</span><span class="s1">' e ε R0 [K] R1</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">' e ε popd [Q err] dip [K] i</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">' ε [Q err] dip [K] i</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">' Q err ε [K] i</span>
|
||||
<span class="n">n</span> <span class="n">a</span><span class="s1">''</span> <span class="n">e</span> <span class="n">ε</span> <span class="n">K</span>
|
||||
<ol class="arabic simple">
|
||||
<li>Discard <code class="docutils literal notranslate"><span class="pre">a</span></code>.</li>
|
||||
<li>Use <code class="docutils literal notranslate"><span class="pre">x</span></code> combinator to generate next term from <code class="docutils literal notranslate"><span class="pre">G</span></code>.</li>
|
||||
<li>Run <code class="docutils literal notranslate"><span class="pre">within</span></code> with <code class="docutils literal notranslate"><span class="pre">i</span></code> (it is a <code class="docutils literal notranslate"><span class="pre">primrec</span></code> function.)</li>
|
||||
</ol>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">R0</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">R1</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="p">[</span><span class="n">popd</span> <span class="n">x</span><span class="p">]</span> <span class="n">dip</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">popd</span> <span class="n">x</span> <span class="n">ε</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">x</span> <span class="n">ε</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="p">[</span><span class="n">within</span><span class="p">]</span> <span class="n">i</span>
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
|
||||
<span class="n">b</span> <span class="p">[</span><span class="n">c</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="n">within</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<p>This fragment alone is pretty useful. (<code class="docutils literal notranslate"><span class="pre">R1</span></code> is <code class="docutils literal notranslate"><span class="pre">i</span></code> so this is a <code class="docutils literal notranslate"><span class="pre">primrec</span></code> “primitive recursive” function.)</p>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'K == [<] [popop popd] [popd [Q err] dip] primrec'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'25 10 0.001 dup K'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">5.000000232305737</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'25 10 0.000001 dup K'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">5.000000000000005</span>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">R0</span> <span class="o">==</span> <span class="p">[</span><span class="n">popd</span> <span class="n">x</span><span class="p">]</span> <span class="n">dip</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="initial-approximation-and-epsilon">
|
||||
<h3>Initial Approximation and Epsilon<a class="headerlink" href="#initial-approximation-and-epsilon" title="Permalink to this headline">¶</a></h3>
|
||||
<p>So now all we need is a way to generate an initial approximation and an
|
||||
epsilon value:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">square</span><span class="o">-</span><span class="n">root</span> <span class="o">==</span> <span class="n">dup</span> <span class="mi">3</span> <span class="o">/</span> <span class="mf">0.000001</span> <span class="n">dup</span> <span class="n">K</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">define</span><span class="p">(</span><span class="s1">'square-root == dup 3 / 0.000001 dup K'</span><span class="p">)</span>
|
||||
<div class="section" id="setting-up">
|
||||
<h3>Setting up<a class="headerlink" href="#setting-up" title="Permalink to this headline">¶</a></h3>
|
||||
<p>The recursive function we have defined so far needs a slight preamble: <code class="docutils literal notranslate"><span class="pre">x</span></code> to prime the generator and the epsilon value to use:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">[</span><span class="n">a</span> <span class="n">G</span><span class="p">]</span> <span class="n">x</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
<span class="n">a</span> <span class="p">[</span><span class="n">b</span> <span class="n">G</span><span class="p">]</span> <span class="n">ε</span> <span class="o">...</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
<div class="section" id="examples">
|
||||
<h3>Examples<a class="headerlink" href="#examples" title="Permalink to this headline">¶</a></h3>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'36 square-root'</span><span class="p">)</span>
|
||||
<div class="section" id="within">
|
||||
<h3><code class="docutils literal notranslate"><span class="pre">within</span></code><a class="headerlink" href="#within" title="Permalink to this headline">¶</a></h3>
|
||||
<p>Giving us the following definitions:</p>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">_within_P</span> <span class="o">==</span> <span class="p">[</span><span class="n">first</span> <span class="o">-</span> <span class="nb">abs</span><span class="p">]</span> <span class="n">dip</span> <span class="o"><=</span>
|
||||
<span class="n">_within_B</span> <span class="o">==</span> <span class="n">roll</span><span class="o"><</span> <span class="n">popop</span> <span class="n">first</span>
|
||||
<span class="n">_within_R</span> <span class="o">==</span> <span class="p">[</span><span class="n">popd</span> <span class="n">x</span><span class="p">]</span> <span class="n">dip</span>
|
||||
<span class="n">within</span> <span class="o">==</span> <span class="n">x</span> <span class="n">ε</span> <span class="p">[</span><span class="n">_within_P</span><span class="p">]</span> <span class="p">[</span><span class="n">_within_B</span><span class="p">]</span> <span class="p">[</span><span class="n">_within_R</span><span class="p">]</span> <span class="n">primrec</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">6.000000000000007</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">J</span><span class="p">(</span><span class="s1">'4895048365636 square-root'</span><span class="p">)</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">2212475.6192184356</span>
|
||||
<div class="section" id="finding-square-roots">
|
||||
<h2>Finding Square Roots<a class="headerlink" href="#finding-square-roots" title="Permalink to this headline">¶</a></h2>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">sqrt</span> <span class="o">==</span> <span class="n">gsra</span> <span class="n">within</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="code ipython2 highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">2212475.6192184356</span> <span class="o">*</span> <span class="mf">2212475.6192184356</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="mf">4895048365636.0</span>
|
||||
</pre></div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
|
|
@ -192,15 +211,21 @@ epsilon value:</p>
|
|||
<h3><a href="../index.html">Table Of Contents</a></h3>
|
||||
<ul>
|
||||
<li><a class="reference internal" href="#">Newton’s method</a><ul>
|
||||
<li><a class="reference internal" href="#finding-the-square-root-of-a-number">Finding the Square-Root of a Number</a></li>
|
||||
<li><a class="reference internal" href="#compute-the-error">Compute the Error</a></li>
|
||||
<li><a class="reference internal" href="#square-root"><code class="docutils literal notranslate"><span class="pre">square-root</span></code></a><ul>
|
||||
<li><a class="reference internal" href="#base-case">Base-case</a></li>
|
||||
<li><a class="reference internal" href="#recur">Recur</a></li>
|
||||
<li><a class="reference internal" href="#initial-approximation-and-epsilon">Initial Approximation and Epsilon</a></li>
|
||||
<li><a class="reference internal" href="#examples">Examples</a></li>
|
||||
<li><a class="reference internal" href="#a-generator-for-approximations">A Generator for Approximations</a><ul>
|
||||
<li><a class="reference internal" href="#a-function-to-compute-the-next-approximation">A Function to Compute the Next Approximation</a></li>
|
||||
<li><a class="reference internal" href="#make-it-into-a-generator">Make it into a Generator</a></li>
|
||||
<li><a class="reference internal" href="#a-generator-of-square-root-approximations">A Generator of Square Root Approximations</a></li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><a class="reference internal" href="#finding-consecutive-approximations-within-a-tolerance">Finding Consecutive Approximations <code class="docutils literal notranslate"><span class="pre">within</span></code> a Tolerance</a><ul>
|
||||
<li><a class="reference internal" href="#predicate">Predicate</a></li>
|
||||
<li><a class="reference internal" href="#base-case">Base-Case</a></li>
|
||||
<li><a class="reference internal" href="#recur">Recur</a></li>
|
||||
<li><a class="reference internal" href="#setting-up">Setting up</a></li>
|
||||
<li><a class="reference internal" href="#within"><code class="docutils literal notranslate"><span class="pre">within</span></code></a></li>
|
||||
</ul>
|
||||
</li>
|
||||
<li><a class="reference internal" href="#finding-square-roots">Finding Square Roots</a></li>
|
||||
</ul>
|
||||
</li>
|
||||
</ul>
|
||||
|
|
|
|||
|
|
@ -59,9 +59,9 @@
|
|||
</ul>
|
||||
</li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="Newton-Raphson.html">Newton’s method</a><ul>
|
||||
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#finding-the-square-root-of-a-number">Finding the Square-Root of a Number</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#compute-the-error">Compute the Error</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#square-root"><code class="docutils literal notranslate"><span class="pre">square-root</span></code></a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#a-generator-for-approximations">A Generator for Approximations</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#finding-consecutive-approximations-within-a-tolerance">Finding Consecutive Approximations <code class="docutils literal notranslate"><span class="pre">within</span></code> a Tolerance</a></li>
|
||||
<li class="toctree-l2"><a class="reference internal" href="Newton-Raphson.html#finding-square-roots">Finding Square Roots</a></li>
|
||||
</ul>
|
||||
</li>
|
||||
<li class="toctree-l1"><a class="reference internal" href="Quadratic.html">Quadratic formula</a><ul>
|
||||
|
|
|
|||
Binary file not shown.
File diff suppressed because one or more lines are too long
|
|
@ -1,11 +1,13 @@
|
|||
*************************************
|
||||
Replacing Functions in the Dictionary
|
||||
*************************************
|
||||
|
||||
Preamble
|
||||
~~~~~~~~
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
from notebook_preamble import D, J, V
|
||||
|
||||
|
||||
A long trace
|
||||
~~~~~~~~~~~~
|
||||
|
||||
|
|
@ -60,46 +62,23 @@ A long trace
|
|||
20.5 .
|
||||
|
||||
|
||||
Replacing ``sum`` and ``size`` with "compiled" versions.
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
Replacing ``size`` with a Python Version
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Both ``sum`` and ``size`` are
|
||||
`catamorphisms <https://en.wikipedia.org/wiki/Catamorphism>`__, they
|
||||
each convert a sequence to a single value.
|
||||
Both ``sum`` and ``size`` each convert a sequence to a single value.
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('[sum] help')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
Given a quoted sequence of numbers return the sum.
|
||||
::
|
||||
|
||||
sum == 0 swap [+] step
|
||||
size == 0 swap [pop ++] step
|
||||
|
||||
|
||||
An efficient ``sum`` function is already in the library. But for ``size`` we can use
|
||||
a "compiled" version hand-written in Python to speed up evaluation and make the trace more readable.
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('[size] help')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
0 swap [pop ++] step
|
||||
|
||||
|
||||
|
||||
We can use "compiled" versions (they're not really compiled in this
|
||||
case, they're hand-written in Python) to speed up evaluation and make
|
||||
the trace more readable. The ``sum`` function is already in the library.
|
||||
It gets shadowed by the definition version above during
|
||||
``initialize()``.
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
from joy.library import SimpleFunctionWrapper, primitives
|
||||
from joy.library import SimpleFunctionWrapper
|
||||
from joy.utils.stack import iter_stack
|
||||
|
||||
|
||||
|
|
@ -112,16 +91,16 @@ It gets shadowed by the definition version above during
|
|||
n += 1
|
||||
return n, stack
|
||||
|
||||
|
||||
sum_ = next(p for p in primitives if p.name == 'sum')
|
||||
|
||||
Now we replace them old versions in the dictionary with the new versions
|
||||
Now we replace the old version in the dictionary with the new version,
|
||||
and re-evaluate the expression.
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
old_sum, D['sum'] = D['sum'], sum_
|
||||
old_size, D['size'] = D['size'], size
|
||||
D['size'] = size
|
||||
|
||||
|
||||
A Shorter Evaluation
|
||||
~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
You can see that ``size`` and ``sum`` now execute in a single step.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,195 +0,0 @@
|
|||
|
||||
|
||||
|
||||
|
||||
A Generator for Approximations
|
||||
==============================
|
||||
|
||||
In :doc:`Generator Programs` we derive a function ``G`` (called ``make_generator`` in the dictionary) that accepts an initial value and a quoted program and returns a new quoted program that, when driven by the ``x`` combinator (:py:func:`joy.library.x`), acts like a lazy stream.
|
||||
|
||||
To make a generator that generates successive approximations let's start by assuming an initial approximation and then derive the function that computes the next approximation::
|
||||
|
||||
a F
|
||||
---------
|
||||
a'
|
||||
|
||||
|
||||
A Function to Compute the Next Approximation
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Looking at the equation again:
|
||||
|
||||
:math:`a_{i+1} = \frac{(a_i+\frac{n}{a_i})}{2}`
|
||||
|
||||
::
|
||||
|
||||
a n over / + 2 /
|
||||
a n a / + 2 /
|
||||
a n/a + 2 /
|
||||
a+n/a 2 /
|
||||
(a+n/a)/2
|
||||
|
||||
The function we want has the argument ``n`` in it::
|
||||
|
||||
F == n over / + 2 /
|
||||
|
||||
|
||||
Make it into a Generator
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Our generator would be created by::
|
||||
|
||||
a [dup F] make_generator
|
||||
|
||||
With ``n`` as part of the function ``F``, but ``n`` is the input to the ``sqrt`` function we're writing. If we let 1 be the initial approximation::
|
||||
|
||||
1 n 1 / + 2 /
|
||||
1 n/1 + 2 /
|
||||
1 n + 2 /
|
||||
n+1 2 /
|
||||
(n+1)/2
|
||||
|
||||
The generator can be written as::
|
||||
|
||||
1 swap [over / + 2 /] cons [dup] swoncat make_generator
|
||||
|
||||
Example::
|
||||
|
||||
23 1 swap [over / + 2 /] cons [dup] swoncat make_generator
|
||||
1 23 [over / + 2 /] cons [dup] swoncat make_generator
|
||||
1 [23 over / + 2 /] [dup] swoncat make_generator
|
||||
1 [dup 23 over / + 2 /] make_generator
|
||||
.
|
||||
.
|
||||
.
|
||||
[1 swap [dup 23 over / + 2 /] direco]
|
||||
|
||||
|
||||
A Generator of Square Root Approximations
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
gsra == 1 swap [over / + 2 /] cons [dup] swoncat make_generator
|
||||
|
||||
|
||||
Finding Consecutive Approximations ``within`` a Tolerance
|
||||
=========================================================
|
||||
|
||||
The remainder of a square root finder is a function *within*, which takes a tolerance and a list of approximations and looks down the list for two successive approximations that differ by no more than the given tolerance.
|
||||
|
||||
From `"Why Functional Programming Matters" by John
|
||||
Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__
|
||||
|
||||
(And note that by "list" he means a lazily-evaluated list.)
|
||||
|
||||
Using the *output* ``[a G]`` of the above :doc:`generator <Generator Programs>` for square root approximations, and further assuming that the first term ``a`` has been generated already and epsilon ``ε`` is handy on the stack...
|
||||
|
||||
::
|
||||
|
||||
a [b G] ε within
|
||||
---------------------- a b - abs ε <=
|
||||
b
|
||||
|
||||
::
|
||||
|
||||
a [b G] ε within
|
||||
---------------------- a b - abs ε >
|
||||
.
|
||||
[b G] x ε ...
|
||||
b [c G] ε ...
|
||||
.
|
||||
----------------------
|
||||
b [c G] ε within
|
||||
|
||||
|
||||
|
||||
Predicate
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
a [b G] ε [first - abs] dip <=
|
||||
a [b G] first - abs ε <=
|
||||
a b - abs ε <=
|
||||
a-b abs ε <=
|
||||
abs(a-b) ε <=
|
||||
(abs(a-b)<=ε)
|
||||
|
||||
|
||||
::
|
||||
|
||||
P == [first - abs] dip <=
|
||||
|
||||
|
||||
Base-Case
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
a [b G] ε roll< popop first
|
||||
[b G] ε a popop first
|
||||
[b G] first
|
||||
b
|
||||
|
||||
::
|
||||
|
||||
B == roll< popop first
|
||||
|
||||
|
||||
Recur
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
a [b G] ε R0 [within] R1
|
||||
|
||||
|
||||
1. Discard ``a``.
|
||||
2. Use ``x`` combinator to generate next term from ``G``.
|
||||
3. Run ``within`` with ``i`` (it is a ``primrec`` function.)
|
||||
|
||||
::
|
||||
|
||||
a [b G] ε R0 [within] R1
|
||||
a [b G] ε [popd x] dip [within] i
|
||||
a [b G] popd x ε [within] i
|
||||
[b G] x ε [within] i
|
||||
b [c G] ε [within] i
|
||||
b [c G] ε within
|
||||
|
||||
b [c G] ε within
|
||||
|
||||
::
|
||||
|
||||
R0 == [popd x] dip
|
||||
|
||||
|
||||
Setting up
|
||||
^^^^^^^^^^
|
||||
|
||||
The recursive function we have defined so far needs a slight preamble: ``x`` to prime the generator and the epsilon value to use::
|
||||
|
||||
[a G] x ε ...
|
||||
a [b G] ε ...
|
||||
|
||||
|
||||
``within``
|
||||
^^^^^^^^^^
|
||||
|
||||
Giving us the following definitions::
|
||||
|
||||
_within_P == [first - abs] dip <=
|
||||
_within_B == roll< popop first
|
||||
_within_R == [popd x] dip
|
||||
within == x ε [_within_P] [_within_B] [_within_R] primrec
|
||||
|
||||
|
||||
Finding Square Roots
|
||||
====================
|
||||
|
||||
::
|
||||
|
||||
sqrt == gsra within
|
||||
|
||||
|
||||
|
|
@ -1,6 +1,6 @@
|
|||
|
||||
*********************************************************************
|
||||
`Newton's method <https://en.wikipedia.org/wiki/Newton%27s_method>`__
|
||||
=====================================================================
|
||||
*********************************************************************
|
||||
|
||||
Newton-Raphson for finding the root of an equation.
|
||||
|
||||
|
|
@ -11,193 +11,194 @@ Newton-Raphson for finding the root of an equation.
|
|||
Cf. `"Why Functional Programming Matters" by John
|
||||
Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__
|
||||
|
||||
Finding the Square-Root of a Number
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Let's define a function that computes this equation:
|
||||
A Generator for Approximations
|
||||
==============================
|
||||
|
||||
In :doc:`Generator Programs` we derive a function (called ``make_generator`` in the dictionary) that accepts an initial value and a quoted program and returns a new quoted program that, when driven by the ``x`` combinator (:py:func:`joy.library.x`), acts like a lazy stream.
|
||||
|
||||
To make a generator that generates successive approximations let's start by assuming an initial approximation and then derive the function that computes the next approximation::
|
||||
|
||||
a F
|
||||
---------
|
||||
a'
|
||||
|
||||
|
||||
A Function to Compute the Next Approximation
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Looking at the equation again:
|
||||
|
||||
:math:`a_{i+1} = \frac{(a_i+\frac{n}{a_i})}{2}`
|
||||
|
||||
::
|
||||
|
||||
n a Q
|
||||
---------------
|
||||
(a+n/a)/2
|
||||
|
||||
n a tuck / + 2 /
|
||||
a n over / + 2 /
|
||||
a n a / + 2 /
|
||||
a n/a + 2 /
|
||||
a+n/a 2 /
|
||||
(a+n/a)/2
|
||||
|
||||
We want it to leave n but replace a, so we execute it with ``unary``:
|
||||
The function we want has the argument ``n`` in it::
|
||||
|
||||
F == n over / + 2 /
|
||||
|
||||
|
||||
Make it into a Generator
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
Our generator would be created by::
|
||||
|
||||
a [dup F] make_generator
|
||||
|
||||
With ``n`` as part of the function ``F``, but ``n`` is the input to the ``sqrt`` function we're writing. If we let 1 be the initial approximation::
|
||||
|
||||
1 n 1 / + 2 /
|
||||
1 n/1 + 2 /
|
||||
1 n + 2 /
|
||||
n+1 2 /
|
||||
(n+1)/2
|
||||
|
||||
The generator can be written as::
|
||||
|
||||
1 swap [over / + 2 /] cons [dup] swoncat make_generator
|
||||
|
||||
Example::
|
||||
|
||||
23 1 swap [over / + 2 /] cons [dup] swoncat make_generator
|
||||
1 23 [over / + 2 /] cons [dup] swoncat make_generator
|
||||
1 [23 over / + 2 /] [dup] swoncat make_generator
|
||||
1 [dup 23 over / + 2 /] make_generator
|
||||
.
|
||||
.
|
||||
.
|
||||
[1 swap [dup 23 over / + 2 /] direco]
|
||||
|
||||
|
||||
A Generator of Square Root Approximations
|
||||
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
Q == [tuck / + 2 /] unary
|
||||
gsra == 1 swap [over / + 2 /] cons [dup] swoncat make_generator
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
define('Q == [tuck / + 2 /] unary')
|
||||
Finding Consecutive Approximations ``within`` a Tolerance
|
||||
=========================================================
|
||||
|
||||
Compute the Error
|
||||
^^^^^^^^^^^^^^^^^
|
||||
The remainder of a square root finder is a function *within*, which takes a tolerance and a list of approximations and looks down the list for two successive approximations that differ by no more than the given tolerance.
|
||||
|
||||
And a function to compute the error:
|
||||
From `"Why Functional Programming Matters" by John
|
||||
Hughes <https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.pdf>`__
|
||||
|
||||
(And note that by "list" he means a lazily-evaluated list.)
|
||||
|
||||
Using the *output* ``[a G]`` of the above :doc:`generator <Generator Programs>` for square root approximations, and further assuming that the first term ``a`` has been generated already and epsilon ``ε`` is handy on the stack...
|
||||
|
||||
::
|
||||
|
||||
n a sqr - abs
|
||||
|n-a**2|
|
||||
|
||||
This should be ``nullary`` so as to leave both n and a on the stack
|
||||
below the error.
|
||||
a [b G] ε within
|
||||
---------------------- a b - abs ε <=
|
||||
b
|
||||
|
||||
::
|
||||
|
||||
err == [sqr - abs] nullary
|
||||
a [b G] ε within
|
||||
---------------------- a b - abs ε >
|
||||
.
|
||||
[b G] x ε ...
|
||||
b [c G] ε ...
|
||||
.
|
||||
----------------------
|
||||
b [c G] ε within
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
define('err == [sqr - abs] nullary')
|
||||
|
||||
``square-root``
|
||||
^^^^^^^^^^^^^^^
|
||||
|
||||
Now we can define a recursive program that expects a number ``n``, an
|
||||
initial estimate ``a``, and an epsilon value ``ε``, and that leaves on
|
||||
the stack the square root of ``n`` to within the precision of the
|
||||
epsilon value. (Later on we'll refine it to generate the initial
|
||||
estimate and hard-code an epsilon value.)
|
||||
Predicate
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
n a ε square-root
|
||||
-----------------
|
||||
√n
|
||||
a [b G] ε [first - abs] dip <=
|
||||
a [b G] first - abs ε <=
|
||||
a b - abs ε <=
|
||||
a-b abs ε <=
|
||||
abs(a-b) ε <=
|
||||
(abs(a-b)<=ε)
|
||||
|
||||
If we apply the two functions ``Q`` and ``err`` defined above we get the
|
||||
next approximation and the error on the stack below the epsilon.
|
||||
|
||||
::
|
||||
|
||||
n a ε [Q err] dip
|
||||
n a Q err ε
|
||||
n a' err ε
|
||||
n a' e ε
|
||||
P == [first - abs] dip <=
|
||||
|
||||
Let's define a recursive function ``K`` from here.
|
||||
|
||||
Base-Case
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
n a' e ε K
|
||||
|
||||
K == [P] [E] [R0] [R1] genrec
|
||||
|
||||
Base-case
|
||||
~~~~~~~~~
|
||||
|
||||
The predicate and the base case are obvious:
|
||||
a [b G] ε roll< popop first
|
||||
[b G] ε a popop first
|
||||
[b G] first
|
||||
b
|
||||
|
||||
::
|
||||
|
||||
K == [<] [popop popd] [R0] [R1] genrec
|
||||
B == roll< popop first
|
||||
|
||||
::
|
||||
|
||||
n a' e ε popop popd
|
||||
n a' popd
|
||||
a'
|
||||
|
||||
Recur
|
||||
~~~~~~~~~~
|
||||
|
||||
The recursive branch is pretty easy. Discard the error and recur.
|
||||
^^^^^^^^^^^^^
|
||||
|
||||
::
|
||||
|
||||
K == [<] [popop popd] [R0] [R1] genrec
|
||||
K == [<] [popop popd] [R0 [K] R1] ifte
|
||||
a [b G] ε R0 [within] R1
|
||||
|
||||
|
||||
1. Discard ``a``.
|
||||
2. Use ``x`` combinator to generate next term from ``G``.
|
||||
3. Run ``within`` with ``i`` (it is a ``primrec`` function.)
|
||||
|
||||
::
|
||||
|
||||
n a' e ε R0 [K] R1
|
||||
n a' e ε popd [Q err] dip [K] i
|
||||
n a' ε [Q err] dip [K] i
|
||||
n a' Q err ε [K] i
|
||||
n a'' e ε K
|
||||
a [b G] ε R0 [within] R1
|
||||
a [b G] ε [popd x] dip [within] i
|
||||
a [b G] popd x ε [within] i
|
||||
[b G] x ε [within] i
|
||||
b [c G] ε [within] i
|
||||
b [c G] ε within
|
||||
|
||||
This fragment alone is pretty useful. (``R1`` is ``i`` so this is a ``primrec`` "primitive recursive" function.)
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
define('K == [<] [popop popd] [popd [Q err] dip] primrec')
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('25 10 0.001 dup K')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
5.000000232305737
|
||||
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('25 10 0.000001 dup K')
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
5.000000000000005
|
||||
|
||||
Initial Approximation and Epsilon
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
So now all we need is a way to generate an initial approximation and an
|
||||
epsilon value:
|
||||
b [c G] ε within
|
||||
|
||||
::
|
||||
|
||||
square-root == dup 3 / 0.000001 dup K
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
define('square-root == dup 3 / 0.000001 dup K')
|
||||
|
||||
Examples
|
||||
~~~~~~~~~~
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
J('36 square-root')
|
||||
R0 == [popd x] dip
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
Setting up
|
||||
^^^^^^^^^^
|
||||
|
||||
6.000000000000007
|
||||
The recursive function we have defined so far needs a slight preamble: ``x`` to prime the generator and the epsilon value to use::
|
||||
|
||||
[a G] x ε ...
|
||||
a [b G] ε ...
|
||||
|
||||
|
||||
.. code:: ipython2
|
||||
``within``
|
||||
^^^^^^^^^^
|
||||
|
||||
J('4895048365636 square-root')
|
||||
Giving us the following definitions::
|
||||
|
||||
_within_P == [first - abs] dip <=
|
||||
_within_B == roll< popop first
|
||||
_within_R == [popd x] dip
|
||||
within == x ε [_within_P] [_within_B] [_within_R] primrec
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
Finding Square Roots
|
||||
====================
|
||||
|
||||
2212475.6192184356
|
||||
|
||||
|
||||
.. code:: ipython2
|
||||
|
||||
2212475.6192184356 * 2212475.6192184356
|
||||
|
||||
|
||||
|
||||
|
||||
.. parsed-literal::
|
||||
|
||||
4895048365636.0
|
||||
::
|
||||
|
||||
sqrt == gsra within
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue