initial commit

Author: xpqz

contents/.ipynb_checkpoints/aplway-checkpoint.ipynb

@@ -0,0 +1,239 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Partitions\n",
+    "\n",
+    "> It's harder to read code than to write it. --_Joel Spolsky_"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">done\n",
+       "\n",
+       "Rebuilding user command cache... done\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 1,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "⎕IO ← 0\n",
+    "{}⎕SE.UCMD'box on -s=min -t=tree -f=on'\n",
+    "{}⎕SE.UCMD'rows on'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We often need to group or select items in an array based on some criterion -- perhaps stretches of items that are equal, or perhaps we have a boolean mask indicating which stretches of elements should be joined up.\n",
+    "\n",
+    "Good partition primer on [APLWiki](https://aplwiki.com/wiki/Partition_representations)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Partition `⊆`\n",
+    "\n",
+    "There's even a glyph called [Partition](http://help.dyalog.com/18.0/index.htm#Language/Primitive%20Functions/Partition.htm), `⊆`. It selects groups elements based on a vector where new selections are started where the corresponding element is larger than its predecessor. Ok... that sounds _very_ specific, and quite possibly not what you had in mind. In its simplest form it's like compress, but enclosing elements corresponding to stretches of 1s. Compare:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">┌───┬─┬────┬──┐\n",
+       "│1 2│4│9 10│12│\n",
+       "└───┴─┴────┴──┘\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">1 2 4 9 10 12\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1 1 0 1 0 0 0 0 1 1 0 1 ⊆ ⍳12 ⍝ Partition\n",
+    "1 1 0 1 0 0 0 0 1 1 0 1/⍳12   ⍝ Compress"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Partitioned enclose `A⊂B`\n",
+    "\n",
+    "Partitioned enclose, `A⊂B`, groups items based on a boolean mask where enclosures start on 1. For example:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┬───┬───┬────┐\n",
+       "│1 2│3 4│5 6│7 8│9 10│\n",
+       "└───┴───┴───┴───┴────┘\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "1 0 1 0 1 0 1 0 1 0⊂⍳10"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use this to group stretches of elements which are equal:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">┌─────────┬───┬─┬───────┬───┬───┐\n",
+       "│1 1 1 1 1│2 2│1│4 4 4 4│1 1│2 2│\n",
+       "└─────────┴───┴─┴───────┴───┴───┘\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{⍵⊂⍨1,2≠/⍵} 1 1 1 1 1 2 2 1 4 4 4 4 1 1 2 2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can apply the same technique to group based on sign:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">┌───┬─────┬─┬────────┬───┬─────┐\n",
+       "│0 0│1 2 3│0│¯1 ¯7 ¯8│0 0│1 2 3│\n",
+       "└───┴─────┴─┴────────┴───┴─────┘\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{⍵⊂⍨1,2≠/×⍵} 0 0 1 2 3 0 ¯1 ¯7 ¯8 0 0 1 2 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the above two examples we generate the mask by a windowed reduction of size 2:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<span style=\"white-space:pre; font-family: monospace\">0 1 0 0 1 1 0 0 1 0 1 0 0\n",
+       "</span>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "{2≠/×⍵} 0 0 1 2 3 0 ¯1 ¯7 ¯8 0 0 1 2 3"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "but we also need to prepend a 1, as we want the first partition to start at the beginning."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Dyalog APL",
+   "language": "apl",
+   "name": "dyalog-kernel"
+  },
+  "language_info": {
+   "file_extension": ".apl",
+   "mimetype": "text/apl",
+   "name": "APL"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}