Fresh build

xpqz · Aug 12, 2021 · 45cd68f · 45cd68f
1 parent d7be5e9
commit 45cd68f
Show file tree

Hide file tree

Showing 8 changed files with 204 additions and 7 deletions.
diff --git a/contents/_build/.doctrees/environment.pickle b/contents/_build/.doctrees/environment.pickle
diff --git a/contents/_build/.doctrees/rank.doctree b/contents/_build/.doctrees/rank.doctree
diff --git a/contents/_build/.jupyter_cache/global.db b/contents/_build/.jupyter_cache/global.db
diff --git a/contents/_build/html/_sources/rank.ipynb b/contents/_build/html/_sources/rank.ipynb
@@ -964,7 +964,7 @@
  "source": [
  "## Atop\n",
  "\n",
- "As we mentioned above, from version 18 of Dyalog, `⍤` can also be _Atop_ if given a right operand function instead of array. We'll see more of different kinds of _Atop_ later, but for now it's a functional composition rule, stating that (for the dyadic case),\n",
+ "As we mentioned above, from version 18 of Dyalog, `⍤` can also be _Atop_ if given a right operand function instead of array. We'll see more of different kinds of _Atop_ later in the [tacit](./tacit.ipynb) chapter, but for now it's a functional composition rule, stating that (for the dyadic case),\n",
  "```apl\n",
  "X f⍤g Y → f X g Y\n",
  "```\n",
@@ -977,7 +977,86 @@
  "X f⍤g Y → f X g Y\n",
  "```\n",
  "\n",
- "As the monadic _Atop_ is equivalent for `∘` and `⍤`, it's worth using `⍤` for both monadic and dyadic atops for consistency."
+ "Another way to think about it is that in the dyadic case, the difference between `∘` and `⍤` is which operand function (`f` or `g`) gets the left argument. In the monadic case, _Atop_ is equivalent for `∘` and `⍤`, so it's worth using `⍤` for both monadic and dyadic atops for consistency. \n",
+ "\n",
+ "Here is a simple example of a dyadic _Atop_,"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<span style=\"white-space:pre; font-family: monospace\">¯5 ¯7 ¯9\n",
+ "</span>"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 2 3 -⍤+ 4 5 6 ⍝ Negate the sum of two vectors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "which, following the `X f⍤g Y → f X g Y` rule, is the same as"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<span style=\"white-space:pre; font-family: monospace\">¯5 ¯7 ¯9\n",
+ "</span>"
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-1 2 3+4 5 6 ⍝ Negate the sum of two vectors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "or, as a tacit formulation (which we'll cover in more detail later),"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<span style=\"white-space:pre; font-family: monospace\">¯5 ¯7 ¯9\n",
+ "</span>"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 2 3 (-+) 4 5 6 ⍝ Negate the sum of two vectors"
  ]
  },
  {

diff --git a/contents/_build/html/rank.html b/contents/_build/html/rank.html
@@ -842,7 +842,7 @@ <h2>Rank drills<a class="headerlink" href="#rank-drills" title="Permalink to thi
 </div>
 <div class="section" id="atop">
 <h2>Atop<a class="headerlink" href="#atop" title="Permalink to this headline">¶</a></h2>
-<p>As we mentioned above, from version 18 of Dyalog, <code class="docutils literal notranslate"><span class="pre">⍤</span></code> can also be <em>Atop</em> if given a right operand function instead of array. We’ll see more of different kinds of <em>Atop</em> later, but for now it’s a functional composition rule, stating that (for the dyadic case),</p>
+<p>As we mentioned above, from version 18 of Dyalog, <code class="docutils literal notranslate"><span class="pre">⍤</span></code> can also be <em>Atop</em> if given a right operand function instead of array. We’ll see more of different kinds of <em>Atop</em> later in the <a class="reference internal" href="tacit.html"><span class="doc std std-doc">tacit</span></a> chapter, but for now it’s a functional composition rule, stating that (for the dyadic case),</p>
 <div class="highlight-apl notranslate"><div class="highlight"><pre><span></span><span class="nv">X</span> <span class="nv">f</span><span class="na">⍤</span><span class="nv">g</span> <span class="nv">Y</span> <span class="kd">→</span> <span class="nv">f</span> <span class="nv">X</span> <span class="nv">g</span> <span class="nv">Y</span>
 </pre></div>
 </div>
@@ -853,7 +853,40 @@ <h2>Atop<a class="headerlink" href="#atop" title="Permalink to this headline">¶
 <span class="nv">X</span> <span class="nv">f</span><span class="na">⍤</span><span class="nv">g</span> <span class="nv">Y</span> <span class="kd">→</span> <span class="nv">f</span> <span class="nv">X</span> <span class="nv">g</span> <span class="nv">Y</span>
 </pre></div>
 </div>
-<p>As the monadic <em>Atop</em> is equivalent for <code class="docutils literal notranslate"><span class="pre">∘</span></code> and <code class="docutils literal notranslate"><span class="pre">⍤</span></code>, it’s worth using <code class="docutils literal notranslate"><span class="pre">⍤</span></code> for both monadic and dyadic atops for consistency.</p>
+<p>Another way to think about it is that in the dyadic case, the difference between <code class="docutils literal notranslate"><span class="pre">∘</span></code> and <code class="docutils literal notranslate"><span class="pre">⍤</span></code> is which operand function (<code class="docutils literal notranslate"><span class="pre">f</span></code> or <code class="docutils literal notranslate"><span class="pre">g</span></code>) gets the left argument. In the monadic case, <em>Atop</em> is equivalent for <code class="docutils literal notranslate"><span class="pre">∘</span></code> and <code class="docutils literal notranslate"><span class="pre">⍤</span></code>, so it’s worth using <code class="docutils literal notranslate"><span class="pre">⍤</span></code> for both monadic and dyadic atops for consistency.</p>
+<p>Here is a simple example of a dyadic <em>Atop</em>,</p>
+<div class="cell docutils container">
+<div class="cell_input docutils container">
+<div class="highlight-APL notranslate"><div class="highlight"><pre><span></span><span class="m">1</span> <span class="m">2</span> <span class="m">3</span> <span class="o">-</span><span class="na">⍤</span><span class="o">+</span> <span class="m">4</span> <span class="m">5</span> <span class="m">6</span> <span class="c1">⍝ Negate the sum of two vectors</span>
+</pre></div>
+</div>
+</div>
+<div class="cell_output docutils container">
+<div class="output text_html"><span style="white-space:pre; font-family: monospace">¯5 ¯7 ¯9
+</span></div></div>
+</div>
+<p>which, following the <code class="docutils literal notranslate"><span class="pre">X</span> <span class="pre">f⍤g</span> <span class="pre">Y</span> <span class="pre">→</span> <span class="pre">f</span> <span class="pre">X</span> <span class="pre">g</span> <span class="pre">Y</span></code> rule, is the same as</p>
+<div class="cell docutils container">
+<div class="cell_input docutils container">
+<div class="highlight-APL notranslate"><div class="highlight"><pre><span></span><span class="o">-</span><span class="m">1</span> <span class="m">2</span> <span class="m">3</span><span class="o">+</span><span class="m">4</span> <span class="m">5</span> <span class="m">6</span> <span class="c1">⍝ Negate the sum of two vectors</span>
+</pre></div>
+</div>
+</div>
+<div class="cell_output docutils container">
+<div class="output text_html"><span style="white-space:pre; font-family: monospace">¯5 ¯7 ¯9
+</span></div></div>
+</div>
+<p>or, as a tacit formulation (which we’ll cover in more detail later),</p>
+<div class="cell docutils container">
+<div class="cell_input docutils container">
+<div class="highlight-APL notranslate"><div class="highlight"><pre><span></span><span class="m">1</span> <span class="m">2</span> <span class="m">3</span> <span class="p">(</span><span class="o">-+</span><span class="p">)</span> <span class="m">4</span> <span class="m">5</span> <span class="m">6</span> <span class="c1">⍝ Negate the sum of two vectors</span>
+</pre></div>
+</div>
+</div>
+<div class="cell_output docutils container">
+<div class="output text_html"><span style="white-space:pre; font-family: monospace">¯5 ¯7 ¯9
+</span></div></div>
+</div>
 </div>
 </div>
 

diff --git a/contents/_build/html/searchindex.js b/contents/_build/html/searchindex.js
diff --git a/contents/_build/jupyter_execute/rank.apl b/contents/_build/jupyter_execute/rank.apl
@@ -63,4 +63,10 @@ A/⍤1⊢B
 ]DISPLAY ⊖⍤2⊢t
 ]DISPLAY ⊖⍤1⊢t
 
+1 2 3 -⍤+ 4 5 6 ⍝ Negate the sum of two vectors
+
+-1 2 3+4 5 6 ⍝ Negate the sum of two vectors
+
+1 2 3 (-+) 4 5 6 ⍝ Negate the sum of two vectors
+
 
diff --git a/contents/_build/jupyter_execute/rank.ipynb b/contents/_build/jupyter_execute/rank.ipynb
@@ -970,7 +970,7 @@
  "source": [
  "## Atop\n",
  "\n",
- "As we mentioned above, from version 18 of Dyalog, `⍤` can also be _Atop_ if given a right operand function instead of array. We'll see more of different kinds of _Atop_ later, but for now it's a functional composition rule, stating that (for the dyadic case),\n",
+ "As we mentioned above, from version 18 of Dyalog, `⍤` can also be _Atop_ if given a right operand function instead of array. We'll see more of different kinds of _Atop_ later in the [tacit](./tacit.ipynb) chapter, but for now it's a functional composition rule, stating that (for the dyadic case),\n",
  "```apl\n",
  "X f⍤g Y → f X g Y\n",
  "```\n",
@@ -983,7 +983,86 @@
  "X f⍤g Y → f X g Y\n",
  "```\n",
  "\n",
- "As the monadic _Atop_ is equivalent for `∘` and `⍤`, it's worth using `⍤` for both monadic and dyadic atops for consistency."
+ "Another way to think about it is that in the dyadic case, the difference between `∘` and `⍤` is which operand function (`f` or `g`) gets the left argument. In the monadic case, _Atop_ is equivalent for `∘` and `⍤`, so it's worth using `⍤` for both monadic and dyadic atops for consistency. \n",
+ "\n",
+ "Here is a simple example of a dyadic _Atop_,"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<span style=\"white-space:pre; font-family: monospace\">¯5 ¯7 ¯9\n",
+ "</span>"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 2 3 -⍤+ 4 5 6 ⍝ Negate the sum of two vectors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "which, following the `X f⍤g Y → f X g Y` rule, is the same as"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 26,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<span style=\"white-space:pre; font-family: monospace\">¯5 ¯7 ¯9\n",
+ "</span>"
+ ]
+ },
+ "execution_count": 26,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "-1 2 3+4 5 6 ⍝ Negate the sum of two vectors"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "or, as a tacit formulation (which we'll cover in more detail later),"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 27,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<span style=\"white-space:pre; font-family: monospace\">¯5 ¯7 ¯9\n",
+ "</span>"
+ ]
+ },
+ "execution_count": 27,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "1 2 3 (-+) 4 5 6 ⍝ Negate the sum of two vectors"
  ]
  },
  {