Modifying Rank and Depth.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook covers the monadic definitions of `↑`, `↓`, `⊂` and `⊃`. Whose return values tend to differ in rank or depth from their arguments."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mix\n",
    "\n",
    "Monadic `↑` (Mix) is a useful function for creating higher rank arrays. Mix  assembles the items of an array into a higher-rank array with one less level of nesting. For example, given a vector of vectors, it returns a matrix with each vector as a row."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3\n",
       "4 2 2\n",
       "a b c\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑(1 2 3)(4 2 2)'abc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┐\n",
       "│1 2│3 4│\n",
       "├───┼───┤\n",
       "│5 6│7 8│\n",
       "└───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑((1 2)(3 4))((5 6)(7 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the vectors in the argument are different in shape a fill element is used to pad the array to a rectangle. The fill element is the type of the first element.\n",
    "\n",
    "The *typical* number is `0`, and the *typical* character is `' '`. The type of an array is the array of the types of its elements - The same array, but where each simple scalar is replaced by it's type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3\n",
       "3 3 0\n",
       "4 3 2\n",
       "x    \n",
       "</span>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑(1 2 3)(3 3)(4 3 2)'x'"
   ]
  },
  {
   "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 6│\n",
       "├───┼───┼───┤\n",
       "│7 8│9  │0 0│\n",
       "└───┴───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑((1 2)(3 4)(5 6))((7 8) 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fill element for `(7 8) 9` is the type of `7 8`; `0 0`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When mixing a vector of higher rank arrays, the result will have a rank one more than the array of greatest rank in the argument. Mixing a vector of matrices will create a 3 dimensional array where each matrix is a plane."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">ab\n",
       "cd\n",
       "  \n",
       "ef\n",
       "gh\n",
       "  \n",
       "ij\n",
       "kl\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑(2 2⍴'abcd')(2 2⍴'efgh')(2 2⍴'ijkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, if the shapes are not all the same, the mismatched arrays are filled with the prototype of their first element:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 0\n",
       "3 1 0\n",
       "2 3 0\n",
       "     \n",
       "a b c\n",
       "a b c\n",
       "     \n",
       "     \n",
       "x x  \n",
       "x x  \n",
       "     \n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑(3 2⍴1 2 3)(2 3⍴'abc')(2 2⍴'x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, the shape of each layer is `3 3` which is the smallest shape that the all the layers can be extended to. The rows of the first element get extended, the columns of the second, and both rows and columns are extended on the last element.\n",
    "\n",
    "If the ranks of the arrays in the argument are different, the shapes are padded with `1`s. For example a length 4 vector may become a 1 by 4 matrix. After the ranks are extended the shapes are then checked and extended as before"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3\n",
       "0 0 0\n",
       "0 0 0\n",
       "     \n",
       "0 0 0\n",
       "0 0 0\n",
       "0 0 0\n",
       "     \n",
       "     \n",
       "A A  \n",
       "A A  \n",
       "     \n",
       "     \n",
       "A A  \n",
       "A A  \n",
       "     \n",
       "     \n",
       "     \n",
       "4 5 0\n",
       "6 4 0\n",
       "5 6 0\n",
       "     \n",
       "0 0 0\n",
       "0 0 0\n",
       "0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑(1 2 3)(2 2 2⍴'A')(3 2⍴4 5 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If an array `A` has shape `X` and the shape of each item (after extension) in `A` is `Y`, then `⍴↑A` is `X,Y`. The shapes `X` and `Y` are *mixed*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split\n",
    "\n",
    "Monadic `↓` (Split) is the counterpart to mix. It converts a higher rank array into a nested array. The result of split will have a rank one less than the argument, unless the argument is scalar, in which case the rank will remain `0`.\n",
    "\n",
    "The shape of an array is *split* at the last element by split. For example, an array of shape `1 2 3 4` will be split into an array of shape `1 2 3`. What happens to the `4`? The last element of the shape becomes the shape of the items at depth 1 in the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┐\n",
       "│1 2│3 4│\n",
       "└───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓2 2⍴1 2 3 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌────────┬────────┬────────┐\n",
       "│1 2 3   │4 5 6   │7 8 9   │\n",
       "├────────┼────────┼────────┤\n",
       "│10 11 12│13 14 15│16 17 18│\n",
       "├────────┼────────┼────────┤\n",
       "│19 20 21│22 23 24│25 26 27│\n",
       "└────────┴────────┴────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓3 3 3⍴⍳27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬───┬─────┐\n",
       "│1 2 3│abc│3 4 0│\n",
       "└─────┴───┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓↑(1 2 3)'abc'(3 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───────────┬─────────┬───────────┐\n",
       "│┌───┬─┬───┐│┌─┬───┬─┐│┌───┬─┬───┐│\n",
       "││1 1│3│1 1│││3│1 1│3│││1 1│3│1 1││\n",
       "││1 1│ │1 1│││ │1 1│ │││1 1│ │1 1││\n",
       "│└───┴─┴───┘│└─┴───┴─┘│└───┴─┴───┘│\n",
       "└───────────┴─────────┴───────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓3 3⍴(2 2⍴1) 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the argument is a vector `V`, it's rank is 1. Splitting it will result in an array of shape `⍬` whose contents have the shape of `V`; a scalar that itself contains a vector. These are known as enclosed vectors or, more generally, nested scalars."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┐\n",
       "│7 6 2│\n",
       "└─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓7 6 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⍴⍴ ↓7 6 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numbers and characters are known as simple scalars, because their depth is 0. Splitting a simple scalar does nothing, the result is the argument itself. However, splitting nested scalars increases their (absolute) depth by 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┐\n",
       "│┌───┐│\n",
       "││4 5││\n",
       "│└───┘│\n",
       "└─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓↓4 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mix also will do nothing to a simple scalar, but will decrease the depth of nested scalars by 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┐\n",
       "│1 2 3│\n",
       "└─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑↓↓1 2 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">APL\n",
       "</span>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↑↓'APL'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A common use of mix and split is to perform matrix operations on a vector of vectors. For example transpose:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┬───┬───┐\n",
       "│aei│bfj│cgk│dhl│\n",
       "└───┴───┴───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "↓⍉↑ 'abcd' 'efgh' 'ijkl'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enclose\n",
    "\n",
    "Monadic `⊂` (enclose) is used simply to enclose any array to form a scalar. It will increase the depth of an array by 1, unless applied to simple scalar where it has no effect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┐\n",
       "│1 2 3│\n",
       "└─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊂1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is useful in conjunction with scalar functions. Or any function that treat scalars differently."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">5 7 9\n",
       "</span>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 5 6+1 2 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬─────┬─────┐\n",
       "│5 6 7│6 7 8│7 8 9│\n",
       "└─────┴─────┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 5 6 + ⊂1 2 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, `1 2 3` is added to each of `4 5 6` separately."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">xy\n",
       "xy\n",
       "</span>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 2⍴2 3⍴'xy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌───┬───┐\n",
       "│xyx│xyx│\n",
       "│yxy│yxy│\n",
       "├───┼───┤\n",
       "│xyx│xyx│\n",
       "│yxy│yxy│\n",
       "└───┴───┘\n",
       "</span>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 2⍴⊂2 3⍴'xy'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple scalars cannot be enclosed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊂1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Disclose\n",
    "\n",
    "Monadic `⊃` (disclose, also called first) is the counterpart to `⊂`. It will take the first item at depth 1 from an array. For a nested array, this has the effect of undoing an enclose (disclosing)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">abcd\n",
       "</span>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃⊂'abcd'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────────┐\n",
       "│5 4 3 2 1│\n",
       "└─────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃⊂⊂5 4 3 2 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6\n",
       "</span>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃6 2 3 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">APLAP\n",
       "LAPLA\n",
       "PLAPL\n",
       "APLAP\n",
       "LAPLA\n",
       "PLAPL\n",
       "</span>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃3 3⍴⊂6 5⍴'APL'"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Dyalog APL",
   "language": "apl",
   "name": "dyalog-kernel"
  },
  "language_info": {
   "file_extension": ".apl",
   "mimetype": "text/apl",
   "name": "APL"
  },
  "tryapl": {
   "category": "Closer Looks at Some Functions",
   "description": "Modifying rank and depth with Mix, Split, Enclose, and First",
   "name": "Modifying Rank and Depth: ↑ ↓ ⊂ ⊃"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}