New in v16.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monadic function `⍸`\n",
    "*Where* returns the indices of the 1s in the Boolean argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 3 4 7\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍸1 0 1 1 0 0 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 1\n",
       "1 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┬───┬───┐\n",
       "│1 1│1 3│2 1│2 2│\n",
       "└───┴───┴───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M←2 3⍴1 0 1 1\n",
    "M\n",
    "⍸M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dyadic function `⍸`\n",
    "*Interval index* takes a list of sorted arrays on the left, and for each array on the right, tells which \"gap\" (interval) it belongs to:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 3 4 1 2\n",
       "</span>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 10 100 1000⍸0 500 2000 3 10 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So 0 is in interval number 0 (that is, before 1–10). 500 is in interval 3, which is 100–1000, etc. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Monadic function `⊆`\n",
    "This one is called *Nest* because it guarantees you that the result is nested (non-simple).\n",
    "`(1 2)(3 4 5)` is already nested, so `⊆` won't do anything: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬─────┐\n",
       "│1 2│3 4 5│\n",
       "└───┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬─────┐\n",
       "│1 2│3 4 5│\n",
       "└───┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 2)(3 4 5)\n",
    "⊆(1 2)(3 4 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`1 2 3` is not nested, so `⊆` will nest it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┐\n",
       "│1 2 3│\n",
       "└─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 2 3\n",
    "⊆1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dyadic function `⊆`\n",
    "*Partition* was formerly only available as `{⎕ML←3 ⋄ ⍺⊂⍵}`. It partitions its right argument letting a new partition begin whenever an element is higher than its neighbour in the left. Also, elements indicated by 0s are dropped completely:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─┬──┬───┬──┐\n",
       "│H│lo│ Wo│rl│\n",
       "└─┴──┴───┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 0 0 1 1 3 2 2 5 5 0⊆'Hello World'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dyadic operator `@`\n",
    "The *At* operator does exactly what it says. What's on its left gets done **at** the position indicated by its right operand:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HXllX\n",
       "</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('X'@2 5) 'Hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also give an array which matches the selected elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HXllY\n",
       "</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "('XY'@2 5) 'Hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use it to modify rather than replace elements:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10 ¯20 30 40 ¯50 60\n",
       "</span>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(-@2 5) 10 20 30 40 50 60"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">10 27 30 40 57 60\n",
       "</span>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 (+@2 5) 10 20 30 40 50 60"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we use a function right operand, it gets applied to the right argument, and the result must be a Boolean mask which then used instead of the list of indices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 0 0 0 1 0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(∊∘⎕A) 'Hello World'  ⍝ ⎕A is the uppercase alphabet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">xello xorld\n",
       "</span>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'x'@(∊∘⎕A) 'Hello World'  ⍝ replace those"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dyadic operator `⌺`\n",
    "*Stencil* (as in [stencil code](https://en.wikipedia.org/wiki/Stencil_code)) and the symbol is supposed to evoke the picture of a stencil over a paper. It takes a function left operand and an array right operand, and derives a monadic function.\n",
    "\n",
    "The right operand specifies what neighbourhoods to apply to. E.g. in Game of Life, the neighbourhoods are 3-by-3 sub-matrices centred on each element in the input array. The function operand gets called dyadically with the right argument being a neighbourhood and the argument left being information about whether he neighbourhood overlaps an edge of the original argument world.\n",
    "\n",
    "To see how it works, we'll use `{⊂⍵}` as left operand. It just encloses the right argument (`⍵`, that is, the neighbourhood) so we can see it. As right operand (neighbourhood size) we use `3 3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">ABCDEF\n",
       "GHIJKL\n",
       "MNOPQR\n",
       "STUVWX\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 6⍴⎕A  ⍝ our world"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┬───┬───┬───┬───┐\n",
       "│   │   │   │   │   │   │\n",
       "│ AB│ABC│BCD│CDE│DEF│EF │\n",
       "│ GH│GHI│HIJ│IJK│JKL│KL │\n",
       "├───┼───┼───┼───┼───┼───┤\n",
       "│ AB│ABC│BCD│CDE│DEF│EF │\n",
       "│ GH│GHI│HIJ│IJK│JKL│KL │\n",
       "│ MN│MNO│NOP│OPQ│PQR│QR │\n",
       "├───┼───┼───┼───┼───┼───┤\n",
       "│ GH│GHI│HIJ│IJK│JKL│KL │\n",
       "│ MN│MNO│NOP│OPQ│PQR│QR │\n",
       "│ ST│STU│TUV│UVW│VWX│WX │\n",
       "├───┼───┼───┼───┼───┼───┤\n",
       "│ MN│MNO│NOP│OPQ│PQR│QR │\n",
       "│ ST│STU│TUV│UVW│VWX│WX │\n",
       "│   │   │   │   │   │   │\n",
       "└───┴───┴───┴───┴───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "({⊂⍵}⌺3 3) 4 6⍴⎕A  ⍝ the neighbourhoods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We got a 4-by-6 matrix of neighbourhoods back. Notice that all the neighbourhoods are 3-by-3, even at the edges, at which they were padded with spaces. The padding was done sometimes on top, sometimes on the left, sometimes on the right, and sometimes on the bottom. The information about that is in the left argument (`⍺`) of the operand function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────┬────┬────┬────┬────┬─────┐\n",
       "│1 1 │1 0 │1 0 │1 0 │1 0 │1 ¯1 │\n",
       "├────┼────┼────┼────┼────┼─────┤\n",
       "│0 1 │0 0 │0 0 │0 0 │0 0 │0 ¯1 │\n",
       "├────┼────┼────┼────┼────┼─────┤\n",
       "│0 1 │0 0 │0 0 │0 0 │0 0 │0 ¯1 │\n",
       "├────┼────┼────┼────┼────┼─────┤\n",
       "│¯1 1│¯1 0│¯1 0│¯1 0│¯1 0│¯1 ¯1│\n",
       "└────┴────┴────┴────┴────┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "({⊂⍺}⌺3 3) 4 6⍴⎕A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, each cell contains two elements, one for rows, and one for columns. Positive indicates left/top. Negative is right/bottom. The magnitude indicates how many rows/columns were padded. This fits nicely with dyadic `↓` (*Drop*), which as left argument takes the number of (rows,columns) to drop from its right argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──┬───┬───┬───┬───┬──┐\n",
       "│AB│ABC│BCD│CDE│DEF│EF│\n",
       "│GH│GHI│HIJ│IJK│JKL│KL│\n",
       "├──┼───┼───┼───┼───┼──┤\n",
       "│AB│ABC│BCD│CDE│DEF│EF│\n",
       "│GH│GHI│HIJ│IJK│JKL│KL│\n",
       "│MN│MNO│NOP│OPQ│PQR│QR│\n",
       "├──┼───┼───┼───┼───┼──┤\n",
       "│GH│GHI│HIJ│IJK│JKL│KL│\n",
       "│MN│MNO│NOP│OPQ│PQR│QR│\n",
       "│ST│STU│TUV│UVW│VWX│WX│\n",
       "├──┼───┼───┼───┼───┼──┤\n",
       "│MN│MNO│NOP│OPQ│PQR│QR│\n",
       "│ST│STU│TUV│UVW│VWX│WX│\n",
       "└──┴───┴───┴───┴───┴──┘\n",
       "</span>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "({⊂⍺↓⍵}⌺3 3) 4 6⍴⎕A"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Dyalog APL",
   "language": "apl",
   "name": "dyalog-kernel"
  },
  "language_info": {
   "file_extension": ".apl",
   "mimetype": "text/apl",
   "name": "APL"
  },
  "tryapl": {
   "category": "Highlights of Recent Releases",
   "description": "Language extensions in Dyalog APL version 16.0",
   "name": "New in version 16.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}