Justifying Text.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "overall-olympus",
   "metadata": {},
   "source": [
    "# Justifying Text\n",
    "\n",
    "In this notebook we will take a look at how to write some _array-oriented_ APL code that justifies some text.\n",
    "In case you are wondering what \"justified text\" is, take a look at the [example in the Wikipedia](https://en.wikipedia.org/wiki/Typographic_alignment#Examples).\n",
    "\n",
    "(The content of this notebook draws heavily from [Lesson 42](https://chat.stackexchange.com/rooms/52405/conversation/lesson-42-array-coding-style-in-depth) of the [APL Cultivation chat lessons](https://chat.stackexchange.com/rooms/info/52405/the-apl-orchard?tab=conversations) and is a written follow-up to Rodrigo Girão Serrão's presentation at [APL Seeds'21](https://www.dyalog.com/apl-seeds-user-meetings/aplseeds21.htm).)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "juvenile-killing",
   "metadata": {},
   "source": [
    "## The Text We'll Justify\n",
    "\n",
    "While we prototype our solution that justifies some text, let us define some text to play around with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "voluntary-baker",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌──────────────────────────────┬──────────────────────────┬────────────────────────────┬────────────────────────────┬─────────────────────┐\n",
       "│To APL, or not to APL, that is│the question: whether 'tis│nobler in the mind to suffer│the slings and arrows of the│outrageous fortune...│\n",
       "└──────────────────────────────┴──────────────────────────┴────────────────────────────┴────────────────────────────┴─────────────────────┘\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← text ← 'To APL, or not to APL, that is' 'the question: whether ''tis' 'nobler in the mind to suffer' 'the slings and arrows of the' 'outrageous fortune...'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fancy-oxford",
   "metadata": {},
   "source": [
    "Now we have a vector with 5 elements, where each box represents one of the lines of the text we want to justify:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "wicked-grocery",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "≢text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "severe-teacher",
   "metadata": {},
   "source": [
    "## Data Format\n",
    "\n",
    "However, instead of dealing with a vector of \"strings\" – which in APL we call _character vectors_ – it would be more useful to work with the text data in a different format:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "separated-syndication",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">To APL, or not to APL, that is\n",
       "the question: whether 'tis    \n",
       "nobler in the mind to suffer  \n",
       "the slings and arrows of the  \n",
       "outrageous fortune...         \n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "graduate-helicopter",
   "metadata": {},
   "source": [
    "If we work with the text in this format, it looks more like printed text on a page and it also becomes easier to develop our solution.\n",
    "With that in mind, let us redefine our `text` variable to hold the text like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "personal-surprise",
   "metadata": {},
   "outputs": [],
   "source": [
    "text ← ↑text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "meaning-monkey",
   "metadata": {},
   "source": [
    "We can look at `↑` (which is called _mix_) as a function that is stacking _up_ the vectors that compose `text`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "peripheral-closing",
   "metadata": {},
   "source": [
    "The resulting data we have is now a _matrix_: a two-dimensional structure composed of characters.\n",
    "The way you check `text` is a matrix is by asking APL to tell you the shape of `text`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fluid-beaver",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5 30\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍴text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "contemporary-disabled",
   "metadata": {},
   "source": [
    "`⍴` is called _shape_ and it tells you that `text` has `5` rows and `30` columns..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expanded-passage",
   "metadata": {},
   "source": [
    "But that is certainly interesting, because some of the lines are clearly shorter than 30 characters...\n",
    "When we used `↑` to convert our `text` to a matrix, APL padded the shorter lines with spaces so that all lines had the same length."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "social-science",
   "metadata": {},
   "source": [
    "The easiest way to verify that we actually have trailing whitespace on the shorter lines is by using `@` to replace them with something else:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "sublime-schema",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">To⎕APL,⎕or⎕not⎕to⎕APL,⎕that⎕is\n",
       "the⎕question:⎕whether⎕'tis⎕⎕⎕⎕\n",
       "nobler⎕in⎕the⎕mind⎕to⎕suffer⎕⎕\n",
       "the⎕slings⎕and⎕arrows⎕of⎕the⎕⎕\n",
       "outrageous⎕fortune...⎕⎕⎕⎕⎕⎕⎕⎕⎕\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'⎕'@(' '=⊢)text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "everyday-milton",
   "metadata": {},
   "source": [
    "You can read the line above as\n",
    "\n",
    " > “Put the character `'⎕'` _at_ the positions where the character `' '` is _equal_ to the characters in the `text` matrix.”"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sunset-belgium",
   "metadata": {},
   "source": [
    "Working with a matrix of characters is already half of the work done, because it does simplify our code greatly."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "mature-israel",
   "metadata": {},
   "source": [
    "## The Matrix We Want to Build\n",
    "\n",
    "Of course this particular data format is only useful because we had an idea for how to solve this problem of justifying some text.\n",
    "Let us take another look at the matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "applied-solution",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">To APL, or not to APL, that is\n",
       "the question: whether 'tis    \n",
       "nobler in the mind to suffer  \n",
       "the slings and arrows of the  \n",
       "outrageous fortune...         \n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "standard-chemical",
   "metadata": {},
   "source": [
    "In order to justify this text, what we want to do is take the trailing spaces and spread them along the inner spaces of each line.\n",
    "In essence, we want to go from\n",
    "\n",
    "```APL\n",
    "⍝ To⎕APL,⎕or⎕not⎕to⎕APL,⎕that⎕is\n",
    "⍝ the⎕question:⎕whether⎕'tis⎕⎕⎕⎕\n",
    "⍝ nobler⎕in⎕the⎕mind⎕to⎕suffer⎕⎕\n",
    "⍝ the⎕slings⎕and⎕arrows⎕of⎕the⎕⎕\n",
    "⍝ outrageous⎕fortune...⎕⎕⎕⎕⎕⎕⎕⎕⎕\n",
    "```\n",
    "\n",
    "to\n",
    "\n",
    "```APL\n",
    "⍝ To⎕APL,⎕or⎕not⎕to⎕APL,⎕that⎕is\n",
    "⍝ the⎕⎕⎕question:⎕⎕whether⎕⎕'tis\n",
    "⍝ nobler⎕⎕in⎕⎕the⎕mind⎕to⎕suffer\n",
    "⍝ the⎕⎕slings⎕⎕and⎕arrows⎕of⎕the\n",
    "⍝ outrageous⎕⎕⎕⎕⎕⎕⎕⎕⎕⎕fortune...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unable-friendly",
   "metadata": {},
   "source": [
    "If we take a closer look at the second row of these two matrices, we notice that there were four trailing spaces that got divided as evenly as possible among the three inner spaces that existed: the first space (between “the” and “question”) is now 3 spaces wide and the two other spaces are 2 spaces wide:\n",
    "\n",
    "```APL\n",
    "⍝ the⎕question:⎕whether⎕'tis⎕⎕⎕⎕\n",
    "⍝ the⎕⎕⎕question:⎕⎕whether⎕⎕'tis\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "arbitrary-equilibrium",
   "metadata": {},
   "source": [
    "In order to achieve this, what we will do is a build an integer matrix (with a shape that matches the shape of `text`) and each integer in that matrix will tell how many copies of each character we want in the final result."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bright-surname",
   "metadata": {},
   "source": [
    "For example, for the second row of `text`, we would like this integer row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "rotary-specialist",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">t h e   q u e s t i o n :   w h e t h e r   ' t i s        \n",
       "1 1 1 3 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 2 1 1 1 1 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chars ← 'the question: whether ''tis    '\n",
    "ints  ← 1 1 1 3 1 1 1 1 1 1 1 1 1 2 1 1 1 1 1 1 1 2 1 1 1 1 0 0 0 0\n",
    "↑chars ints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "special-viewer",
   "metadata": {},
   "source": [
    "Each integer below each character tells how many copies of that character we want:\n",
    "\n",
    " - below letters and punctuation there is always a `1`, because we want to preserve that character as-is;\n",
    " - below the trailing spaces we have a `0`, because we want to remove that character from the line; and\n",
    " - below the inner spaces there are the numbers `3` and `2`, because we want to create copies of those characters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "streaming-pillow",
   "metadata": {},
   "source": [
    "Without further ado, let's start building this matrix.\n",
    "We will do it in three simpler steps."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sealed-coffee",
   "metadata": {},
   "source": [
    "## The Characters to Keep\n",
    "\n",
    "### Finding Spaces\n",
    "\n",
    "The first step is computing a Boolean matrix that will help us distinguish the trailing spaces from all other characters.\n",
    "Let us start by identifying the spaces in the `text` matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "derived-basics",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 1 1 1\n",
       "0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 1 1\n",
       "0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "handed-albuquerque",
   "metadata": {},
   "source": [
    "### Trailing Spaces\n",
    "\n",
    "What we want to do now is take the Boolean matrix above and extract another Boolean matrix that contains `1` for all characters in the `text` that we care about and that contains `0` in the positions of the trailing spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "durable-touch",
   "metadata": {},
   "source": [
    "To achieve this effect, we first use `spaces` to create a matrix that identifies the trailing spaces with `1`s, and _then_ we negate that matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "sitting-warrior",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌽∧\\⌽' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "secure-rugby",
   "metadata": {},
   "source": [
    "There are three distinct symbols in the line above, so what do they do?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "apparent-costa",
   "metadata": {},
   "source": [
    "`⌽` is the _reverse_ function and the way it works is really simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "parallel-aggregate",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">4 3 2 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌽1 2 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "least-brunswick",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">si taht ,LPA ot ton ro ,LPA oT\n",
       "    sit' rehtehw :noitseuq eht\n",
       "  reffus ot dnim eht ni relbon\n",
       "  eht fo sworra dna sgnils eht\n",
       "         ...enutrof suoegartuo\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌽text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "emotional-subsection",
   "metadata": {},
   "source": [
    "The part that may require a deeper explanation is the `∧\\` part.\n",
    "Start by noticing that `∧` is the Boolean _and_ function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "applied-charm",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0∧0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "confused-syria",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0∧1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "confused-ladder",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1∧0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "soviet-brave",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1∧1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "personalized-somerset",
   "metadata": {},
   "source": [
    "(In APL we use `0` for “false” and `1` for “true”.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "treated-prime",
   "metadata": {},
   "source": [
    "### Reduce and Scan\n",
    "\n",
    "Then `\\` is an _operator_: an APL glyph that takes a function and modifies it in some way.\n",
    "To understand what `\\` does, let us start by looking at the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "finished-reality",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">120\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2×3×4×5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "industrial-outreach",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">120\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "×/2 3 4 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "mysterious-unknown",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">79\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10+45+23+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "attached-audio",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">79\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/10 45 23 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "atomic-toronto",
   "metadata": {},
   "source": [
    "Can you spot the pattern?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hispanic-dance",
   "metadata": {},
   "source": [
    "`/` is the _reduce_ operator: it takes a function on its left and puts it in between the elements of the vector on the right."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "further-honolulu",
   "metadata": {},
   "source": [
    "`\\` is the _scan_ operator and works in a similar manner, but it gives you the intermediate results as well:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "european-spirituality",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2 6 24 120\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2) (2×3) (2×3×4) (2×3×4×5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "pending-grammar",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">2 6 24 120\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "×\\2 3 4 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "altered-criticism",
   "metadata": {},
   "source": [
    "### Reducing and Scanning with `∧`\n",
    "\n",
    "`f/` can often be read as a single unit:\n",
    " - `+/` is \"sum\"\n",
    " - `×/` is \"product\"\n",
    " - `,/` is \"join\"\n",
    " - ..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "focused-siemens",
   "metadata": {},
   "source": [
    "In particular, `∧/` is read as \"all\", as it returns `1` only if all elements are `1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "colored-study",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧/1 1 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "express-mason",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧/1 1 0 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "alpha-supervision",
   "metadata": {},
   "source": [
    "Tied with `∧/` is `∧\\` which returns the partial results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "pharmaceutical-enterprise",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧\\1 1 0 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "divine-binary",
   "metadata": {},
   "source": [
    "Because of the interpretation of `∧/` and the way `\\` scans the input vector, `∧\\` takes a Boolean vector and returns a Boolean vector with the leading `1`s preserved and everything else as `0`s:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "focal-camel",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧\\1 1 1 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "superior-phrase",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧\\1 1 0 0 1 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "engaged-reality",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧\\0 1 1 1 1 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "useful-arizona",
   "metadata": {},
   "source": [
    "You can read `∧\\` as \"were all `1` so far?\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interim-license",
   "metadata": {},
   "source": [
    "### Reducing and Scanning a Matrix\n",
    "\n",
    "When you use `f/` or `f\\` with a matrix, it is as if you did `f/` or `f\\` on each row separately, so"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "dated-netherlands",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7 7 7 7 10\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "underlying-instruction",
   "metadata": {},
   "source": [
    "tells you how many spaces each line has, for example."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attempted-payment",
   "metadata": {},
   "source": [
    "Now you should be able to better grasp what we did above: `⌽spaces` puts the trailing spaces in the beginning and then `∧\\` makes it so that only the leading `1`s remain:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "minimal-broadcast",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "∧\\⌽' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "joined-maine",
   "metadata": {},
   "source": [
    "When we reverse once more we put the `1`s back in their place, therefore creating a Boolean matrix that tells us exactly where the trailing spaces are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "important-maryland",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌽∧\\⌽' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "jewish-lancaster",
   "metadata": {},
   "source": [
    "We can negate this matrix, therefore creating a matrix that tells us what characters we want to keep and which characters (the trailing spaces) to discard:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "special-poker",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← keep ← ~⌽∧\\⌽' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cordless-duplicate",
   "metadata": {},
   "source": [
    "The function `~` above is the _negate_ function and it turns `0`s into `1`s and `1`s into `0`s."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "whole-export",
   "metadata": {},
   "source": [
    "## Inner Space Expansion\n",
    "\n",
    "Now that we have two Boolean matrices, one that tells the positions that contain spaces, and another that tells the positions that contain characters to keep, we can combine them to create a matrix with the positions of the inner spaces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "designing-complement",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← inner ← keep∧' '=text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "latin-microphone",
   "metadata": {},
   "source": [
    "We will now investigate, for each of the positions marked in this `inner` matrix, how many spaces should be added in those positions."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "modular-sampling",
   "metadata": {},
   "source": [
    "In order to figure that out, we first need to know how many trailing spaces each row has to distribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "infectious-extraction",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 4 2 2 9\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← trail ← +/~keep"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "confident-marker",
   "metadata": {},
   "source": [
    "Just remember that `+/` sums each row and `~keep` has `1`s where the trailing spaces are."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fixed-brown",
   "metadata": {},
   "source": [
    "Similarly, we need to know how many positions exist that could receive trailing spaces, but this is just a matter of summing the `inner` matrix along the rows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "colonial-monaco",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7 3 5 5 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← spaces ← +/inner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "resistant-delay",
   "metadata": {},
   "source": [
    "Let us put the `trail` and `spaces` vectors on top of each other:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "relevant-filling",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 4 2 2 9\n",
       "7 3 5 5 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑trail spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "french-version",
   "metadata": {},
   "source": [
    "Here is what this means:\n",
    " - the 1st row has `0` trailing spaces that need to be distributed among `7` positions;\n",
    " - the 2nd row has `4` trailing spaces that need to be distributed among `3` positions;\n",
    " - ...\n",
    " - the 5th row has `9` trailing spaces that need to be distributed among `1` position."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "divine-saver",
   "metadata": {},
   "source": [
    "If we divide `trail` by `spaces` we can figure out how many spaces to add to each position in each row:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "remarkable-mediterranean",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1.33333 0.4 0.4 9\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trail÷spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "political-australia",
   "metadata": {},
   "source": [
    "However, we cannot add `1.33333` spaces in a position, nor `0.4` spaces.\n",
    "We can only add whole characters, so let us round those values down:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "buried-reality",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 0 0 9\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⌊trail÷spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "great-oregon",
   "metadata": {},
   "source": [
    "This shows how many spaces each position in each row can get, so let us encode that information in the `inner` matrix that we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "stunning-configuration",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "occasional-philadelphia",
   "metadata": {},
   "source": [
    "The `inner` matrix just says which positions can receive spaces, but we want a matrix that says _how many_ spaces to add in each position."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "retained-tiger",
   "metadata": {},
   "source": [
    "One of the simplest ways to do that is by multiplying each row by the corresponding value in `⌊trail÷spaces`.\n",
    "It would be great if we could write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "hydraulic-azerbaijan",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "RANK ERROR: Mismatched left and right argument ranks\n",
      "      inner×⌊trail÷spaces\n",
      "           ∧\n"
     ]
    }
   ],
   "source": [
    "inner × ⌊trail÷spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "joined-germany",
   "metadata": {},
   "source": [
    "But unfortunately we cannot, so we need to tell APL that the `×` _times_ function should operate on each _row_ of `inner` and each _element_ of the vector `⌊trail÷spaces`, and we can do that with the _rank_ operator `⍤`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "documented-stewart",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← add ← inner (×⍤1 0) ⌊trail÷spaces"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "naughty-branch",
   "metadata": {},
   "source": [
    "First, note that in each row, the `1`s have been replaced by the corresponding number in `⌊trail÷spaces`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "macro-production",
   "metadata": {},
   "source": [
    "The _rank_ operator `⍤` is a really powerful operator but it might take some time to wrap your head around it.\n",
    "I can recommend [Richard Park's webinars on the _rank_ operator](https://aplcart.info/pub/?q=the%20rank%20operator#)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loved-penalty",
   "metadata": {},
   "source": [
    "## Extra Spaces\n",
    "\n",
    "You might have noticed that the `add` matrix, that tells you how many spaces can be added to each position, does not account for all the trailing spaces that had to be distributed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "sustained-skating",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 3 0 0 9\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "outer-outreach",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 4 2 2 9\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "later-upper",
   "metadata": {},
   "source": [
    "That is because some of the rows were such that the number of inner spaces did not divide into the total number of trailing spaces that had to be distributed.\n",
    "We still need to distribute these spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "divided-newman",
   "metadata": {},
   "source": [
    "First of all, how many do we still have to distribute?\n",
    "You can compute it as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "owned-criticism",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 2 2 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trail - +/add"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dramatic-seattle",
   "metadata": {},
   "source": [
    "But it can also be"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "controlling-teaching",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 2 2 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spaces|trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "colonial-circular",
   "metadata": {},
   "source": [
    "if you make use of the _residue_ function `|` ."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "international-exposure",
   "metadata": {},
   "source": [
    "### Enumerating the Inner Spaces\n",
    "\n",
    "Now that we know how many spaces are missing in each row, we need to figure out which of the `inner` positions receive those extra spaces.\n",
    "From the result of `spaces|trail` we see that\n",
    " - 1st and 5th rows need no extra spaces;\n",
    " - 2nd row needs 1 extra space; and\n",
    " - 3rd and 4th rows need 2 extra spaces;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "listed-oasis",
   "metadata": {},
   "source": [
    "We wish to create a matrix, similar to `inner`, but that tells us what positions get these extra spaces.\n",
    "In order to get there, we start by scanning `inner` with `+`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "genetic-joining",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 1 1 1 1 2 2 2 3 3 3 3 4 4 4 5 5 5 5 5 6 6 6 6 6 7 7 7\n",
       "0 0 0 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3\n",
       "0 0 0 0 0 0 1 1 1 2 2 2 2 3 3 3 3 3 4 4 4 5 5 5 5 5 5 5 5 5\n",
       "0 0 0 1 1 1 1 1 1 1 2 2 2 2 3 3 3 3 3 3 3 4 4 4 5 5 5 5 5 5\n",
       "0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+\\inner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "recent-gabriel",
   "metadata": {},
   "source": [
    "Notice that this creates an interesting integer matrix, where the value in each row increases by `1` whenever we hit a `1` in the original `inner` matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "informed-brick",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "piano-sandwich",
   "metadata": {},
   "source": [
    "If we multiply the two together, we get an enumeration of the marked `inner` positions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "toxic-prophet",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 0 0 2 0 0 3 0 0 0 4 0 0 5 0 0 0 0 6 0 0 0 0 7 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 2 0 0 0 3 0 0 0 0 4 0 0 5 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 2 0 0 0 3 0 0 0 0 0 0 4 0 0 5 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inner × +\\inner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "serial-surfing",
   "metadata": {},
   "source": [
    "Now we can see which of these numbered positions need an extra space.\n",
    "We can do so by comparing the rows of that matrix with the values in `spaces|trail`.\n",
    "Again, we cannot do this directly:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "sensitive-heath",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "RANK ERROR: Mismatched left and right argument ranks\n",
      "      (inner×+\\inner)≤spaces|trail\n",
      "                     ∧\n"
     ]
    }
   ],
   "source": [
    "(inner×+\\inner) ≤ spaces|trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "strong-oliver",
   "metadata": {},
   "source": [
    "We need to use the _rank_ operator `⍤` once more to pair the rows of `inner×+\\inner` with the values of `spaces|trail`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "spoken-supplement",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 0 1 1 1 1 0 1 1 0 1 1 1 0 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 0 1 1 0 1 1 1 1 1 1 1 1\n",
       "1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 0 1 1 0 1 1 1 1 1\n",
       "1 1 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(inner×+\\inner) (≤⍤1 0) spaces|trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "equivalent-hierarchy",
   "metadata": {},
   "source": [
    "This result looks funny because our comparison also looked at all of the `0`s in the `inner` matrix, although we don't care about those.\n",
    "In order to fix it, we need to multiply by `inner` again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "worthy-penalty",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inner × (inner×+\\inner) (≤⍤1 0) spaces|trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "broken-tattoo",
   "metadata": {},
   "source": [
    "Now this shows the positions that will receive one extra space.\n",
    "Let us save it in a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "fifteen-auditor",
   "metadata": {},
   "outputs": [],
   "source": [
    "extra ← inner × (inner×+\\inner) (≤⍤1 0) spaces|trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "informed-montreal",
   "metadata": {},
   "source": [
    "Notice that we could multiply by `inner` just once, in the end, instead of twice:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "interpreted-automation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inner × (+\\inner) (≤⍤1 0) spaces|trail"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "angry-mission",
   "metadata": {},
   "source": [
    "## Putting Everything Together\n",
    "\n",
    "We have our three matrices `keep`, `add`, and `extra`, so we can build the matrix we set out to build:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "shaped-paraguay",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1 1 1 1 1 1 1  1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
       "1 1 1 3 1 1 1 1 1 1  1 1 1 2 1 1 1 1 1 1 1 2 1 1 1 1 0 0 0 0\n",
       "1 1 1 1 1 1 2 1 1 2  1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0\n",
       "1 1 1 2 1 1 1 1 1 1  2 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0\n",
       "1 1 1 1 1 1 1 1 1 1 10 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keep+add+extra"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "durable-blade",
   "metadata": {},
   "source": [
    "We just have to use it to replicate the original characters by the correct amount:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "impaired-macro",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">To APL, or not to APL, that is\n",
       "the question: whether 'tis    \n",
       "nobler in the mind to suffer  \n",
       "the slings and arrows of the  \n",
       "outrageous fortune...         \n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "typical-dodge",
   "metadata": {},
   "source": [
    "Luckily, APL has a _replicate_ function, which is also in the symbol `/`.\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "skilled-gossip",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">DAAOOO\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 0 2 0 3 0 / 'DYALOG'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "desperate-crisis",
   "metadata": {},
   "source": [
    "Unfortunately, `/` does not work as-is with two matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "intense-seeker",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "RANK ERROR\n",
      "      (keep+add+extra)/text\n",
      "                      ∧\n"
     ]
    }
   ],
   "source": [
    "(keep+add+extra)/text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interesting-gregory",
   "metadata": {},
   "source": [
    "We need to flatten the two matrices with `,`, and then use `⍴` to _reshape_ the result back to its original _shape_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "damaged-quality",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">To APL, or not to APL, that is\n",
       "the   question:  whether  'tis\n",
       "nobler  in  the mind to suffer\n",
       "the  slings  and arrows of the\n",
       "outrageous          fortune...\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(⍴text)⍴(,keep+add+extra)/,text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "incorporated-finland",
   "metadata": {},
   "source": [
    "## Writing a Dfn\n",
    "\n",
    "If we take all our code and put it in a (single-line) dfn, here is what we get:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "binary-cricket",
   "metadata": {},
   "outputs": [],
   "source": [
    "Just ← { keep ← ~⌽∧\\⌽' '=⍵ ⋄ inner ← keep∧' '=⍵ ⋄ trail ← +/~keep ⋄ spaces ← +/inner ⋄ add ← inner(×⍤1 0)⌊trail÷spaces ⋄ extra ← inner×(+\\inner)(≤⍤1 0)spaces|trail ⋄ (⍴⍵)⍴(,keep+add+extra)/,⍵ }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "typical-switch",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">To APL, or not to APL, that is\n",
       "the   question:  whether  'tis\n",
       "nobler  in  the mind to suffer\n",
       "the  slings  and arrows of the\n",
       "outrageous          fortune...\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Just text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bottom-client",
   "metadata": {},
   "source": [
    "(Notice that, for one, this implementation may not be the best solution to this task, but was written in this way because of the context in which it was presented. Secondly, this dfn should probably be defined across multiple lines, but current limitations of the [TryAPL](https://tryapl.org) site mean we can only define one-line dfns.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "final-therapy",
   "metadata": {},
   "source": [
    "## A More Robust Function\n",
    "\n",
    "While our code works quite well, it has a very serious shortcoming:\n",
    "it does not work on text with empty lines..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "graphic-religious",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">This is the first line.   \n",
       "                          \n",
       "This is another paragraph.\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "text ← ↑'This is the first line.' '' 'This is another paragraph.'\n",
    "text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "verified-efficiency",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DOMAIN ERROR: Divide by zero\n",
      "Just[0] Just←{keep←~⌽∧\\⌽' '=⍵ ⋄ inner←keep∧' '=⍵ ⋄ trail←+/~keep ⋄ spaces←+/inner ⋄ add←inner(×⍤1 0)⌊trail÷spaces ⋄ extra←inner×(+\\inner)(≤⍤1 0)spaces|trail ⋄ (⍴⍵)⍴(,keep+add+extra)/,⍵}\n",
      "                                                                                                          ∧\n"
     ]
    }
   ],
   "source": [
    "Just text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sorted-gambling",
   "metadata": {},
   "source": [
    "Gladly, we can fix this without too much trouble.\n",
    "We can just add some pre-processing to ignore blank lines or lines that do not need justifying (lines that have only 1 word or lines that are too short) and reuse our `Just` function.\n",
    "\n",
    "(This was shown in the APL Seeds presentation very briefly, with no explanation, as it was used to justify a text with approximately 12.500 lines (a text file of Jules Verne's “Twenty Thousand Leagues Under the Sea”, [downloaded from Project Gutenberg](http://www.gutenberg.org/ebooks/164).)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "backed-albuquerque",
   "metadata": {},
   "outputs": [],
   "source": [
    "BetterJust ← { s ← ' '=⍵ ⋄ t ← ⌽∧\\⌽s ⋄ fewWs ← 0=+/s-t ⋄ shortL ← (+/t)>0.25×⊃⌽⍴⍵ ⋄ use ← ~fewWs∨shortL ⋄ result ← ⍵ ⋄ (use⌿result) ← Just use⌿⍵ ⋄ result }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "seasonal-constant",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">This  is  the  first line.\n",
       "                          \n",
       "This is another paragraph.\n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BetterJust text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "settled-batch",
   "metadata": {},
   "source": [
    "We can also take our original text, add a header and a blank line for demonstration purposes, and justify it again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "third-frost",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HAMLET                        \n",
       "                              \n",
       "To APL, or not to APL, that is\n",
       "the question: whether 'tis    \n",
       "nobler in the mind to suffer  \n",
       "the slings and arrows of the  \n",
       "outrageous fortune...         \n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⎕← text ← ↑'HAMLET' '' 'To APL, or not to APL, that is' 'the question: whether ''tis' 'nobler in the mind to suffer' 'the slings and arrows of the' 'outrageous fortune...'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "advised-kingdom",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">HAMLET                        \n",
       "                              \n",
       "To APL, or not to APL, that is\n",
       "the   question:  whether  'tis\n",
       "nobler  in  the mind to suffer\n",
       "the  slings  and arrows of the\n",
       "outrageous fortune...         \n",
       "\n",
       "</span>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BetterJust text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "legislative-motorcycle",
   "metadata": {},
   "source": [
    "Notice that, now, the last line doesn't get justified because it is \"too short\".\n",
    "What \"too short\" means is controlled by a parameter in the `BetterJust` function, which is set to `0.25` right now (meaning lines that have 25% or more of trailing whitespace are not justified)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "elder-bryan",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Dyalog APL",
   "language": "apl",
   "name": "dyalog-kernel"
  },
  "language_info": {
   "file_extension": ".apl",
   "mimetype": "text/apl",
   "name": "APL"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}