sforman/Thun
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Minor docs cleanup.

Browse Source
This commit is contained in:
Simon Forman
2018-06-06 11:20:31 -07:00
parent 0de5029c98
commit 637d4efa6a
13 changed files with 373 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/sphinx_docs/_build/html/_modules/joy/library.html
+17 -13
View File
@@ -1177,14 +1177,17 @@
<span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">cond</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> like a case statement; works by rewriting into a chain of ifte.</span>
<span class="sd"> This combinator works like a case statement. It expects a single quote</span>
<span class="sd"> on the stack that must contain zero or more condition quotes and a </span>
<span class="sd"> default quote. Each condition clause should contain a quoted predicate</span>
<span class="sd"> followed by the function expression to run if that predicate returns</span>
<span class="sd"> true. If no predicates return true the default function runs.</span>
<span class="sd"> [..[[Bi] Ti]..[D]] -&gt; ...</span>
<span class="sd"> It works by rewriting into a chain of nested `ifte` expressions, e.g.::</span>
<span class="sd"> [[[B0] T0] [[B1] T1] [D]] cond</span>
<span class="sd"> -----------------------------------------</span>
<span class="sd"> [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
<span class="sd"> [[[B0] T0] [[B1] T1] [D]] cond</span>
<span class="sd"> -----------------------------------------</span>
<span class="sd"> [B0] [T0] [[B1] [T1] [D] ifte] ifte</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">conditions</span><span class="p">,</span> <span class="n">stack</span> <span class="o">=</span> <span class="n">stack</span>
@@ -1433,9 +1436,10 @@
<div class="viewcode-block" id="cmp_"><a class="viewcode-back" href="../../library.html#joy.library.cmp_">[docs]</a><span class="nd">@inscribe</span>
<span class="nd">@FunctionWrapper</span>
<span class="k">def</span> <span class="nf">cmp_</span><span class="p">(</span><span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span><span class="p">):</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> cmp takes two values and three quoted programs on the stack and runs</span>
<span class="sd"> one of the three depending on the results of comparing the two values:</span>
<span class="sd">&#39;&#39;&#39;</span>
<span class="sd"> cmp takes two values and three quoted programs on the stack and runs</span>
<span class="sd"> one of the three depending on the results of comparing the two values:</span>
<span class="sd"> ::</span>
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a &gt; b</span>
@@ -1448,10 +1452,10 @@
<span class="sd"> a b [G] [E] [L] cmp</span>
<span class="sd"> ------------------------- a &lt; b</span>
<span class="sd"> L</span>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">L</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">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">expression</span> <span class="o">=</span> <span class="n">pushback</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
<span class="sd"> &#39;&#39;&#39;</span>
<span class="n">L</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">G</span><span class="p">,</span> <span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">stack</span><span class="p">))))</span> <span class="o">=</span> <span class="n">stack</span>
<span class="n">expression</span> <span class="o">=</span> <span class="n">pushback</span><span class="p">(</span><span class="n">G</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">L</span> <span class="k">if</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span> <span class="k">else</span> <span class="n">E</span><span class="p">,</span> <span class="n">expression</span><span class="p">)</span>
<span class="k">return</span> <span class="n">stack</span><span class="p">,</span> <span class="n">expression</span><span class="p">,</span> <span class="n">dictionary</span></div>
<span class="c1">#def nullary(S, expression, dictionary):</span>
docs/sphinx_docs/_build/html/index.html
+1
View File
@@ -135,6 +135,7 @@ interesting aspects. It’s quite a treasure trove.</p>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Replacing.html">Replacing Functions in the Dictionary</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Ordered_Binary_Trees.html">Treating Trees I: Ordered Binary Trees</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Treestep.html">Treating Trees II: <code class="docutils literal notranslate"><span class="pre">treestep</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Generator Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Newton-Raphson.html">Newton’s method</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/Quadratic.html">Quadratic formula</a></li>
<li class="toctree-l2"><a class="reference internal" href="notebooks/NoUpdates.html">No Updates</a></li>
docs/sphinx_docs/_build/html/library.html
+24 -24
View File
@@ -198,24 +198,19 @@ Boolean value (so empty string, zero, etc. are counted as false, etc.)</p>
<code class="descclassname">joy.library.</code><code class="descname">cmp_</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cmp_"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cmp_" title="Permalink to this definition"></a></dt>
<dd><p>cmp takes two values and three quoted programs on the stack and runs
one of the three depending on the results of comparing the two values:</p>
<blockquote>
<div><blockquote>
<div>a b [G] [E] [L] cmp</div></blockquote>
<dl class="docutils">
<dt>————————- a &gt; b</dt>
<dd><blockquote class="first">
<div>G</div></blockquote>
<p class="last">a b [G] [E] [L] cmp</p>
</dd>
<dt>————————- a = b</dt>
<dd><blockquote class="first">
<div>E</div></blockquote>
<p class="last">a b [G] [E] [L] cmp</p>
</dd>
<dt>————————- a &lt; b</dt>
<dd>L</dd>
</dl>
</div></blockquote>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</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">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&gt;</span> <span class="n">b</span>
<span class="n">G</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</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">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">=</span> <span class="n">b</span>
<span class="n">E</span>
<span class="n">a</span> <span class="n">b</span> <span class="p">[</span><span class="n">G</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">L</span><span class="p">]</span> <span class="nb">cmp</span>
<span class="o">-------------------------</span> <span class="n">a</span> <span class="o">&lt;</span> <span class="n">b</span>
<span class="n">L</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
@@ -227,12 +222,17 @@ one of the three depending on the results of comparing the two values:</p>
<dl class="function">
<dt id="joy.library.cond">
<code class="descclassname">joy.library.</code><code class="descname">cond</code><span class="sig-paren">(</span><em>stack</em>, <em>expression</em>, <em>dictionary</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/joy/library.html#cond"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#joy.library.cond" title="Permalink to this definition"></a></dt>
<dd><p>like a case statement; works by rewriting into a chain of ifte.</p>
<p>[..[[Bi] Ti]..[D]] -&gt; …</p>
<blockquote>
<div>[[[B0] T0] [[B1] T1] [D]] cond</div></blockquote>
<blockquote>
<div>[B0] [T0] [[B1] [T1] [D] ifte] ifte</div></blockquote>
<dd><p>This combinator works like a case statement. It expects a single quote
on the stack that must contain zero or more condition quotes and a
default quote. Each condition clause should contain a quoted predicate
followed by the function expression to run if that predicate returns
true. If no predicates return true the default function runs.</p>
<p>It works by rewriting into a chain of nested <cite>ifte</cite> expressions, e.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span> <span class="p">[[[</span><span class="n">B0</span><span class="p">]</span> <span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]]</span> <span class="n">cond</span>
<span class="o">-----------------------------------------</span>
<span class="p">[</span><span class="n">B0</span><span class="p">]</span> <span class="p">[</span><span class="n">T0</span><span class="p">]</span> <span class="p">[[</span><span class="n">B1</span><span class="p">]</span> <span class="p">[</span><span class="n">T1</span><span class="p">]</span> <span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="n">ifte</span><span class="p">]</span> <span class="n">ifte</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
docs/sphinx_docs/_build/html/notebooks/Generator Programs.html
+119 -135
View File
File diff suppressed because one or more lines are too long
docs/sphinx_docs/_build/html/notebooks/index.html
+11
View File
@@ -73,6 +73,17 @@
<li class="toctree-l2"><a class="reference internal" href="Treestep.html#putting-it-together">Putting it together</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="Generator Programs.html">Using <code class="docutils literal notranslate"><span class="pre">x</span></code> to Generate Values</a><ul>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#direco"><code class="docutils literal notranslate"><span class="pre">direco</span></code></a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#making-generators">Making Generators</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#generating-multiples-of-three-and-five">Generating Multiples of Three and Five</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#project-euler-problem-one">Project Euler Problem One</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#a-generator-for-the-fibonacci-sequence">A generator for the Fibonacci Sequence.</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#project-euler-problem-two">Project Euler Problem Two</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#how-to-compile-these">How to compile these?</a></li>
<li class="toctree-l2"><a class="reference internal" href="Generator Programs.html#an-interesting-variation">An Interesting Variation</a></li>
</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#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>
docs/sphinx_docs/_build/html/searchindex.js
+1 -1
View File
File diff suppressed because one or more lines are too long
docs/sphinx_docs/notebooks/Generator Programs.rst
+120 -156
View File
@@ -8,31 +8,40 @@ Cf. jp-reprod.html
from notebook_preamble import J, V, define
Consider the ``x`` combinator ``x == dup i``:
Consider the ``x`` combinator:
::
x == dup i
We can apply it to a quoted program consisting of some value ``a`` and
some function ``B``:
::
[a B] x
[a B] a B
Let ``B`` ``swap`` the ``a`` with the quote and run some function
``[C]`` on it.
Let ``B`` function ``swap`` the ``a`` with the quote and run some
function ``C`` on it to generate a new value ``b``:
::
B == swap [C] dip
[a B] a B
[a B] a swap [C] dip
a [a B] [C] dip
a C [a B]
b [a B]
Now discard the quoted ``a`` with ``rest`` and ``cons`` the result of
``C`` on ``a`` whatever that is:
Now discard the quoted ``a`` with ``rest`` then ``cons`` ``b``:
::
aC [a B] rest cons
aC [B] cons
[aC B]
b [a B] rest cons
b [B] cons
[b B]
Altogether, this is the definition of ``B``:
@@ -40,9 +49,8 @@ Altogether, this is the definition of ``B``:
B == swap [C] dip rest cons
We can create a quoted program that generates the Natural numbers
(integers 0, 1, 2, ...) by using ``0`` for ``a`` and ``[dup ++]`` for
``[C]``:
We can make a generator for the Natural numbers (0, 1, 2, ...) by using
``0`` for ``a`` and ``[dup ++]`` for ``[C]``:
::
@@ -85,7 +93,7 @@ After one application of ``x`` the quoted program contains ``1`` and
``direco``
~~~~~~~~~~
----------
.. code:: ipython2
@@ -113,20 +121,17 @@ After one application of ``x`` the quoted program contains ``1`` and
0 [1 swap [dup ++] direco] .
Generating Generators
=====================
Making Generators
-----------------
We want to go from:
We want to define a function that accepts ``a`` and ``[C]`` and builds
our quoted program:
::
a [C] G
to:
::
[a swap [C] direco]
a [C] G
-------------------------
[a swap [C] direco]
Working in reverse:
@@ -145,65 +150,30 @@ Reading from the bottom up:
G == [direco] cons [swap] swap concat cons
G == [direco] cons [swap] swoncat cons
We can try it out:
::
0 [dup ++] G
.. code:: ipython2
define('G == [direco] cons [swap] swoncat cons')
Let's try it out:
.. code:: ipython2
V('0 [dup ++] G')
J('0 [dup ++] G')
.. parsed-literal::
. 0 [dup ++] G
0 . [dup ++] G
0 [dup ++] . G
0 [dup ++] . [direco] cons [swap] swoncat cons
0 [dup ++] [direco] . cons [swap] swoncat cons
0 [[dup ++] direco] . [swap] swoncat cons
0 [[dup ++] direco] [swap] . swoncat cons
0 [[dup ++] direco] [swap] . swap concat cons
0 [swap] [[dup ++] direco] . concat cons
0 [swap [dup ++] direco] . cons
[0 swap [dup ++] direco] .
[0 swap [dup ++] direco]
.. code:: ipython2
V('0 [dup ++] G x')
J('0 [dup ++] G x x x pop')
.. parsed-literal::
. 0 [dup ++] G x
0 . [dup ++] G x
0 [dup ++] . G x
0 [dup ++] . [direco] cons [swap] swoncat cons x
0 [dup ++] [direco] . cons [swap] swoncat cons x
0 [[dup ++] direco] . [swap] swoncat cons x
0 [[dup ++] direco] [swap] . swoncat cons x
0 [[dup ++] direco] [swap] . swap concat cons x
0 [swap] [[dup ++] direco] . concat cons x
0 [swap [dup ++] direco] . cons x
[0 swap [dup ++] direco] . x
[0 swap [dup ++] direco] . 0 swap [dup ++] direco
[0 swap [dup ++] direco] 0 . swap [dup ++] direco
0 [0 swap [dup ++] direco] . [dup ++] direco
0 [0 swap [dup ++] direco] [dup ++] . direco
0 [0 swap [dup ++] direco] [dup ++] . dip rest cons
0 . dup ++ [0 swap [dup ++] direco] rest cons
0 0 . ++ [0 swap [dup ++] direco] rest cons
0 1 . [0 swap [dup ++] direco] rest cons
0 1 [0 swap [dup ++] direco] . rest cons
0 1 [swap [dup ++] direco] . cons
0 [1 swap [dup ++] direco] .
0 1 2
Powers of 2
@@ -211,77 +181,32 @@ Powers of 2
.. code:: ipython2
J('1 [dup 1 <<] G x x x x x x x x x')
J('1 [dup 1 <<] G x x x x x x x x x pop')
.. parsed-literal::
1 2 4 8 16 32 64 128 256 [512 swap [dup 1 <<] direco]
1 2 4 8 16 32 64 128 256
``n [x] times``
===============
``[x] times``
~~~~~~~~~~~~~
If we have one of these quoted programs we can drive it using ``times``
with the ``x`` combinator.
Let's define a word ``n_range`` that takes a starting integer and a
count and leaves that many consecutive integers on the stack. For
example:
.. code:: ipython2
J('23 [dup ++] G 5 [x] times pop')
J('23 [dup ++] G 5 [x] times')
.. parsed-literal::
23 24 25 26 27
We can use ``dip`` to untangle ``[dup ++] G`` from the arguments.
.. code:: ipython2
J('23 5 [[dup ++] G] dip [x] times pop')
.. parsed-literal::
23 24 25 26 27
Now that the givens (arguments) are on the left we have the definition
we're looking for:
.. code:: ipython2
define('n_range == [[dup ++] G] dip [x] times pop')
.. code:: ipython2
J('450 10 n_range')
.. parsed-literal::
450 451 452 453 454 455 456 457 458 459
This is better just using the ``times`` combinator though...
.. code:: ipython2
J('450 9 [dup ++] times')
.. parsed-literal::
450 451 452 453 454 455 456 457 458 459
23 24 25 26 27 [28 swap [dup ++] direco]
Generating Multiples of Three and Five
======================================
--------------------------------------
Look at the treatment of the Project Euler Problem One in `Developing a
Program.ipynb <./Developing%20a%20Program.ipynb>`__ and you'll see that
@@ -338,16 +263,6 @@ If we plug ``14811`` and ``[PE1.1]`` into our generator form...
[14811 swap [PE1.1] direco]
.. code:: ipython2
J('[14811 swap [PE1.1] direco] x')
.. parsed-literal::
3 [3702 swap [PE1.1] direco]
...we get a generator that works for seven cycles before it reaches
zero:
@@ -371,6 +286,16 @@ if so.
define('PE1.1.check == dup [pop 14811] [] branch')
.. code:: ipython2
J('14811 [PE1.1.check PE1.1] G')
.. parsed-literal::
[14811 swap [PE1.1.check PE1.1] direco]
.. code:: ipython2
J('[14811 swap [PE1.1.check PE1.1] direco] 21 [x] times')
@@ -381,6 +306,11 @@ if so.
3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 [0 swap [PE1.1.check PE1.1] direco]
(It would be more efficient to reset the int every seven cycles but
that's a little beyond the scope of this article. This solution does
extra work, but not much, and we're not using it "in production" as they
say.)
Run 466 times
~~~~~~~~~~~~~
@@ -402,17 +332,17 @@ If we drive our generator 466 times and sum the stack we get 999.
.. code:: ipython2
J('[14811 swap [PE1.1.check PE1.1] dip rest cons] 466 [x] times')
J('[14811 swap [PE1.1.check PE1.1] direco] 466 [x] times')
.. parsed-literal::
3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 [57 swap [PE1.1.check PE1.1] dip rest cons]
3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 1 2 3 3 2 1 3 [57 swap [PE1.1.check PE1.1] direco]
.. code:: ipython2
J('[14811 swap [PE1.1.check PE1.1] dip rest cons] 466 [x] times pop enstacken sum')
J('[14811 swap [PE1.1.check PE1.1] direco] 466 [x] times pop enstacken sum')
.. parsed-literal::
@@ -421,25 +351,13 @@ If we drive our generator 466 times and sum the stack we get 999.
Project Euler Problem One
=========================
-------------------------
.. code:: ipython2
define('PE1.2 == + dup [+] dip')
Now we can add ``PE1.2`` to the quoted program given to ``times``.
.. code:: ipython2
J('0 0 [0 swap [PE1.1.check PE1.1] direco] 466 [x [PE1.2] dip] times popop')
.. parsed-literal::
233168
Or using ``G`` we can write:
Now we can add ``PE1.2`` to the quoted program given to ``G``.
.. code:: ipython2
@@ -452,7 +370,7 @@ Or using ``G`` we can write:
A generator for the Fibonacci Sequence.
=======================================
---------------------------------------
Consider:
@@ -507,30 +425,31 @@ And therefore:
[b+a b a F] [popdd over] infra
[b b+a b F]
And lastly:
But we can just use ``cons`` to carry ``b+a`` into the quote:
::
[b a F] b+a [popdd over] cons infra
[b a F] [b+a popdd over] infra
[b b+a b F]
Lastly:
::
[b b+a b F] uncons
b [b+a b F]
Done.
Putting it all together:
::
F == + swons [popdd over] infra uncons
And:
::
F == + [popdd over] cons infra uncons
fib_gen == [1 1 F]
.. code:: ipython2
define('fib == + swons [popdd over] infra uncons')
define('fib == + [popdd over] cons infra uncons')
.. code:: ipython2
@@ -547,11 +466,12 @@ And:
Project Euler Problem Two
~~~~~~~~~~~~~~~~~~~~~~~~~
-------------------------
::
By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms.
By considering the terms in the Fibonacci sequence whose values do not exceed four million,
find the sum of the even-valued terms.
Now that we have a generator for the Fibonacci sequence, we need a
function that adds a term in the sequence to a sum if it is even, and
@@ -669,7 +589,51 @@ Replace ``x`` with our new driver function ``PE2.2`` and start our
How to compile these?
=====================
---------------------
You would probably start with a special version of ``G``, and perhaps
modifications to the default ``x``?
An Interesting Variation
------------------------
.. code:: ipython2
define('codireco == cons dip rest cons')
.. code:: ipython2
V('[0 [dup ++] codireco] x')
.. parsed-literal::
. [0 [dup ++] codireco] x
[0 [dup ++] codireco] . x
[0 [dup ++] codireco] . 0 [dup ++] codireco
[0 [dup ++] codireco] 0 . [dup ++] codireco
[0 [dup ++] codireco] 0 [dup ++] . codireco
[0 [dup ++] codireco] 0 [dup ++] . cons dip rest cons
[0 [dup ++] codireco] [0 dup ++] . dip rest cons
. 0 dup ++ [0 [dup ++] codireco] rest cons
0 . dup ++ [0 [dup ++] codireco] rest cons
0 0 . ++ [0 [dup ++] codireco] rest cons
0 1 . [0 [dup ++] codireco] rest cons
0 1 [0 [dup ++] codireco] . rest cons
0 1 [[dup ++] codireco] . cons
0 [1 [dup ++] codireco] .
.. code:: ipython2
define('G == [codireco] cons cons')
.. code:: ipython2
J('230 [dup ++] G 5 [x] times pop')
.. parsed-literal::
230 231 232 233 234
docs/sphinx_docs/notebooks/index.rst
+1
View File
@@ -12,6 +12,7 @@ These essays are adapted from Jupyter notebooks. I hope to have those hosted so
Replacing
Ordered_Binary_Trees
Treestep
Generator Programs
Newton-Raphson
Quadratic
NoUpdates