APL to NumPy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "0ecd6f5e",
   "metadata": {},
   "source": [
    "# APL to NumPy Translation\n",
    "Examples taken from the \"Primer\" Cheat Sheet available on https://tryapl.org/\n",
    "\n",
    "-----------------------------"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "43a665a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "33429202",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Numpy Code Output'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#------------------------\n",
    "# Example Cell Structure\n",
    "#------------------------\n",
    "\n",
    "#       {APL Code Example}\n",
    "# {APL Output}\n",
    "\n",
    "numpy_code_example = \"Numpy Code Input\"\n",
    "numpy_code_example = numpy_code_example.replace(\"Input\", \"Output\")\n",
    "numpy_code_example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0bc3ad2",
   "metadata": {},
   "source": [
    "----------------------------\n",
    "## General Functions\n",
    "----------------------------\n",
    "#### A place for functions that are utilized out of the order they are defined"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c766953c",
   "metadata": {},
   "source": [
    "## Rank"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0be2c4d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a very important idea to understand for arrays.\n",
    "# Essentially you split an nd-array into multiple arrays\n",
    "# of a specified dimension.\n",
    "\n",
    "# see below for more information:\n",
    "# https://xpqz.github.io/learnapl/rank.html \n",
    "# https://help.dyalog.com/18.2/Content/Language/Primitive%20Operators/Rank.htm\n",
    "\n",
    "def rank(dim_idx, arr):\n",
    "    # if you ask for a rank higher than exists in this array\n",
    "    # just return the original array \n",
    "    # enclosed in a list for consistency\n",
    "    if dim_idx > arr.ndim - 1:\n",
    "        return list(enclose(arr))\n",
    "    \n",
    "    # reverse order to work with python indexing more easily\n",
    "    shape = list(reversed(arr.shape))\n",
    "    slices = shape[dim_idx:]\n",
    "    \n",
    "    # split into sub-arrays\n",
    "    get_splits = lambda arr, count: np.split(np.ravel(arr), count)\n",
    "    slice_count = np.multiply.reduce(slices)\n",
    "    splits = get_splits(arr, slice_count)\n",
    "    \n",
    "    # need to reshape arrays if looking for rank > 1\n",
    "    if dim_idx > 1:\n",
    "        shape.pop(dim_idx)\n",
    "        new_shape = list(reversed(shape))\n",
    "        splits = [\n",
    "            s.reshape(new_shape) \n",
    "            for s in splits\n",
    "        ]\n",
    "        \n",
    "    return splits"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e25cce21",
   "metadata": {},
   "source": [
    "----------------------------\n",
    "## Mathematics\n",
    "----------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d6011c4",
   "metadata": {},
   "source": [
    "## Plus (+)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "121bcf18",
   "metadata": {},
   "source": [
    "### Monadic - Conjugate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "080d4c81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.2-0.j,  0. -4.j, -5. +6.j])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       + 1.2 0j4 ¯5j¯6\n",
    "# 1.2 0J¯4 ¯5J6\n",
    "\n",
    "np.vectorize(complex.conjugate)(\n",
    "    np.array([1.2, complex(0, 4), complex(-5, -6)])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a8e07b5",
   "metadata": {},
   "source": [
    "### Dyadic - Plus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "26103343",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([11, 12, 13, 14])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 4 + 10\n",
    "# 11 12 13 14\n",
    "\n",
    "np.array([1, 2, 3, 4]) + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0f4adf0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, -2,  4])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 + 2 ¯4 1\n",
    "# 3 ¯2 4\n",
    "\n",
    "np.array([1, 2, 3]) + np.array([2, -4, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "412ea2a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +/ 1 2 3\n",
    "# 6\n",
    "\n",
    "np.add.reduce([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc1707d2",
   "metadata": {},
   "source": [
    "## Minus (-)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d06de10",
   "metadata": {},
   "source": [
    "### Monadic - Negate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "be026216",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-3.2,  7. , -0. ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       - 3.2 ¯7 0\n",
    "# ¯3.2 7 0\n",
    "\n",
    "np.negative(\n",
    "    [3.2, -7, 0]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d09f82fc",
   "metadata": {},
   "source": [
    "### Dyadic - Minus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7a0b0a76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-2,  2,  4])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 7 9 - 5\n",
    "# ¯2 2 4\n",
    "\n",
    "np.array([3, 7, 9]) - 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9b96e0b2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, -2,  0])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       5 1 4 - 2 3 4\n",
    "# 3 ¯2 0\n",
    "\n",
    "np.array([5, 1, 4]) - np.array([2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b61f640",
   "metadata": {},
   "source": [
    "## Times (×)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd28c6ab",
   "metadata": {},
   "source": [
    "### Monadic - Direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c31e86c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1., -1.,  0.])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       × 3.1 ¯2 0 3j4\n",
    "# 1 ¯1 0 0.6J0.8\n",
    "#\n",
    "# Left off the complex # in python\n",
    "\n",
    "np.sign(\n",
    "    [3.1, -2, 0]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d21a09aa",
   "metadata": {},
   "source": [
    "### Dyadic - Times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8fe0bb13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-6., 12.,  9.])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ¯3 4.5 × ¯3 ¯4 2\n",
    "# ¯6 12 9\n",
    "\n",
    "np.array([2, -3, 4.5]) * np.array([-3, -4, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "db060f7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 10, 40])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 1 4 × 10\n",
    "# 30 10 40\n",
    "\n",
    "np.array([3, 1, 4]) * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "2b8a52aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ×/ 2 3 4\n",
    "# 24\n",
    "\n",
    "np.multiply.reduce(\n",
    "    [2, 3, 4]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb62710",
   "metadata": {},
   "source": [
    "## Divide (÷)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6400f7b",
   "metadata": {},
   "source": [
    "### Monadic - Reciprocal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "93d5761b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 0.5       , 0.33333333])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ÷ 1 2 3\n",
    "# 1 0.5 0.333333\n",
    "\n",
    "np.reciprocal(\n",
    "    [1.0, 2.0, 3.0]  # will not work with integers here \n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f760d83",
   "metadata": {},
   "source": [
    "### Dyadic - Divide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "45c3c1bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25      , 0.4       , 0.42857143])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ÷ 4 5 7\n",
    "# 0.25 0.4 0.428571\n",
    "\n",
    "np.array([1, 2, 3]) / np.array([4, 5, 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d667fd68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5., 20.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       10 ÷ ¯2 0.5\n",
    "# ¯5 20\n",
    "\n",
    "10 / np.array([-2, 0.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19789359",
   "metadata": {},
   "source": [
    "## Upstile (⌈)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86445890",
   "metadata": {},
   "source": [
    "### Monadic - Ceiling (Round Up)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "75b101ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4., -3.,  3.,  0.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌈ 3.4 ¯3.4 3 0\n",
    "# 4 ¯3 3 0\n",
    "\n",
    "np.ceil(\n",
    "    [3.4, -3.4, 3, 0]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e0f3d99",
   "metadata": {},
   "source": [
    "### Dyadic - Maximum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "a738e24a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8.1, -2. ])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1.1 ¯2 ⌈ 8.1 ¯3.4\n",
    "# 8.1 ¯2\n",
    "\n",
    "np.fmax(\n",
    "    [1.1, -2], [8.1, -3.4]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "dec8c3e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌈/ 3 1 4 1\n",
    "# 4\n",
    "\n",
    "np.array([3, 1, 4, 1]).max()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df964019",
   "metadata": {},
   "source": [
    "## Downstile (⌊)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5c8b991",
   "metadata": {},
   "source": [
    "### Monadic - Floor (Round Down)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1cad58bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3., -4.,  3.,  0.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌊ 3.4 ¯3.4 3 0\n",
    "# 3 ¯4 3 0\n",
    "\n",
    "np.floor(\n",
    "    [3.4, -3.4, 3, 0]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee30e07a",
   "metadata": {},
   "source": [
    "### Dyadic - Minimum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "2aa64249",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.1, -3.4])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1.1 ¯2 ⌊ 8.1 ¯3.4\n",
    "# 1.1 ¯3.4\n",
    "\n",
    "np.fmin(\n",
    "    [1.1, -2], [8.1, -3.4]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0b5e24ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌊/ 3 1 4 1\n",
    "# 1\n",
    "\n",
    "np.array([3, 1, 4, 1]).min()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d20155a",
   "metadata": {},
   "source": [
    "## Star (*)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fbcc754",
   "metadata": {},
   "source": [
    "### Monadic - Exponential"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "fbcc6725",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 2.71828183, 7.3890561 ])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       * 0 1 2\n",
    "# 1 2.71828 7.38906\n",
    "\n",
    "np.exp(\n",
    "    [0, 1, 2]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc129b87",
   "metadata": {},
   "source": [
    "### Dyadic - Power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "75b1c51e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7., 25.])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#      49 5 ¯4 * 0.5 2 0.5\n",
    "# 7 25 0J2\n",
    "#\n",
    "# Left off the complex # in python\n",
    "\n",
    "np.array([49, 5]) ** np.array([0.5, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea3a5f60",
   "metadata": {},
   "source": [
    "## Exclamation Mark (!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cc1efe5",
   "metadata": {},
   "source": [
    "### Monadic - Factorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bdde261a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([     6, 362880])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ! 3 9 ¯0.11\n",
    "# 6 362880 1.07683\n",
    "#\n",
    "# Left off the non-integral value # in python\n",
    "\n",
    "import math\n",
    "\n",
    "np.vectorize(math.factorial)(\n",
    "    [3, 9]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17ae181d",
   "metadata": {},
   "source": [
    "### Dyadic - Binomial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d5b2acba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 10, 20])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 1 3 ! 3 10 ¯0.11\n",
    "# 3 10 ¯0.0429385\n",
    "#\n",
    "# Left off the non-integral value # in python\n",
    "\n",
    "from itertools import combinations\n",
    "\n",
    "def unique_groups(alpha, omega):\n",
    "    return sum(\n",
    "               1 for _ in\n",
    "               combinations(\n",
    "                   range(omega), \n",
    "                   alpha\n",
    "               )\n",
    "           )\n",
    "\n",
    "np.vectorize(unique_groups)(\n",
    "    [2, 1, 3], [3, 10, 6]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13cac006",
   "metadata": {},
   "source": [
    "## Stile (|)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f5361e7",
   "metadata": {},
   "source": [
    "### Monadic - Magnitude (Absolute value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "fceeed6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.3, 4. , 0. , 5. ])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       | 2.3 ¯4 0 3j4\n",
    "# 2.3 4 0 5\n",
    "\n",
    "np.absolute(\n",
    "    [2.3, -4, 0, complex(3, 4)]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c39296",
   "metadata": {},
   "source": [
    "### Dyadic - Residue (Remainder/Modulus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "2976f98e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  7., -2.])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 10 ¯2.5 | 7 ¯13 8\n",
    "# 1 7 ¯2\n",
    "\n",
    "np.array([7, -13, 8]) % np.array([2, 10, -2.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc7859bb",
   "metadata": {},
   "source": [
    "## Log (⍟)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bd6e753",
   "metadata": {},
   "source": [
    "### Monadic - Natural Logarithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "9ee9b6d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.69314718, 1.09861229, 1.        ])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍟ 1 2 3 2.7182818285\n",
    "# 0 0.693147 1.09861 1\n",
    "\n",
    "np.log(\n",
    "    [1, 2, 3, 2.7182818285]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93db5a43",
   "metadata": {},
   "source": [
    "### Dyadic - Logarithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "edefaecd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5., 3.])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Based on: https://en.wikipedia.org/wiki/Logarithm#Change_of_base\n",
    "\n",
    "#       2 10 ⍟ 32 1000\n",
    "# 5 3\n",
    "\n",
    "def log_base_change(base, number):\n",
    "    return np.log(number) / np.log(base)\n",
    "\n",
    "np.vectorize(log_base_change)(\n",
    "    [2, 10], [32, 1000]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f514213a",
   "metadata": {},
   "source": [
    "## Circle (○)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b742bf70",
   "metadata": {},
   "source": [
    "### Monadic - Pi Times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "392b3936",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 3.14159265, 6.28318531])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ○ 0 1 2\n",
    "# 0 3.14159 6.28319\n",
    "\n",
    "pi_times = lambda x: x * math.pi\n",
    "np.vectorize(pi_times)(\n",
    "    [0, 1, 2]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f58995f",
   "metadata": {},
   "source": [
    "### Dyadic - Circular Functions (Trig)\n",
    "          Note: Angles are in radians \n",
    "                radians ← ○ degrees ÷ 180"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "6e362aa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# APL has the 25 \"circular\" functions below built into this ○ function \n",
    "# and able to be called by the number passed into alpha \n",
    "# \n",
    "#       1 ○ 0 1.5707963 3.1415927\n",
    "# 0 1 ¯4.64102E¯8\n",
    "# \n",
    "#  ⍺   ⍺ ○ ⍵         ⍺   ⍺ ○ ⍵    \n",
    "#                    0   (1-⍵*2)*0.5\n",
    "# ¯1   Arcsin ⍵      1   Sine ⍵\n",
    "# ¯2   Arccos ⍵      2   Cosine ⍵\n",
    "# ¯3   Arctan ⍵      3   Tangent ⍵\n",
    "# ¯4   (¯1+⍵*2)*0.5  4   (1+⍵*2)*0.5\n",
    "# ¯5   Arcsinh ⍵     5   Sinh ⍵\n",
    "# ¯6   Arccosh ⍵     6   Cosh ⍵\n",
    "# ¯7   Arctanh ⍵     7   Tanh ⍵\n",
    "# ¯8   -8○⍵          8   (-1+⍵*2)*0.5\n",
    "# ¯9   ⍵             9   real part of ⍵\n",
    "# ¯10  +⍵           10   |⍵\n",
    "# ¯11  ⍵×0J1        11   imaginary part of ⍵\n",
    "# ¯12  *⍵×0J1       12   phase of ⍵\n",
    "\n",
    "circle_dict = {\n",
    "    0: lambda x: (1-x**2)**0.5,\n",
    "    1: np.sin,\n",
    "    2: np.cos,\n",
    "    3: np.tan,\n",
    "    4: lambda x: (1+x**2)**0.5,\n",
    "    5: np.sinh,\n",
    "    6: np.cosh,\n",
    "    7: np.tanh,\n",
    "    8: lambda x: (-1*(1+x**2))**0.5,\n",
    "    9: np.real,\n",
    "    10: np.absolute,\n",
    "    11: np.imag,\n",
    "    12: np.angle,\n",
    "    \n",
    "    -1: np.arcsin,\n",
    "    -2: np.arccos,\n",
    "    -3: np.arctan,\n",
    "    -4: lambda x: (-1+x**2)**0.5,\n",
    "    -5: np.arcsinh,\n",
    "    -6: np.arccosh,\n",
    "    -7: np.arctanh,\n",
    "    -8: lambda x: complex(0, ((1+x**2)*-1)**0.5),\n",
    "    -9: lambda x: x,\n",
    "    -10: complex.conjugate,\n",
    "    -11: lambda x: complex(0, x),\n",
    "    -12: lambda x: np.exp(complex(0, x)),\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cb7266e",
   "metadata": {},
   "source": [
    "## Domino (⌹)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de17f31d",
   "metadata": {},
   "source": [
    "### Monadic - Matrix Inverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "226a28c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[-2. ,  1. ],\n",
       "        [ 1.5, -0.5]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2\n",
    "# 3 4\n",
    "#       ⌹ mat\n",
    "# ¯2    1\n",
    "#  1.5 ¯0.5\n",
    "\n",
    "mat = np.matrix('1 2; 3 4')\n",
    "mat.I"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cea6fcb",
   "metadata": {},
   "source": [
    "### Dyadic - Matrix Divide"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "2c8bf59f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[-4. ,  4.5]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       5 6 ⌹ mat\n",
    "# ¯4 4.5\n",
    "\n",
    "mat = np.matrix('1 2; 3 4')\n",
    "vector = np.array([5, 6])\n",
    "\n",
    "np.dot(mat.I , vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13a8745a",
   "metadata": {},
   "source": [
    "## Up Tack (⊥)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b9c168c",
   "metadata": {},
   "source": [
    "### Dyadic - Decode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "69761503",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ⊥ 1 1 0 1   ⍝ binary decode\n",
    "# 13\n",
    "\n",
    "arr = np.array([1, 1, 0, 1])\n",
    "arr_str = \"\".join((str(i) for i in arr))\n",
    "\n",
    "int(arr_str, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a95ffe6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ⍝ mixed radix: conversion of hours,\n",
    "# ⍝ minutes and seconds to seconds:\n",
    "\n",
    "#       24 60 60 ⊥ 2 46 40\n",
    "# 10000\n",
    "\n",
    "def decode_mixed_radix(alpha, omega):\n",
    "    assert len(alpha) == len(omega)\n",
    "    result = 0\n",
    "    \n",
    "    for i in range(len(alpha)):        \n",
    "        temp = omega[i]\n",
    "        \n",
    "        for j in range(i+1, len(alpha)):\n",
    "            temp *= alpha[j]\n",
    "            \n",
    "        result += temp\n",
    "        \n",
    "    return result\n",
    "\n",
    "decode_mixed_radix(\n",
    "    np.array([24, 60, 60]),\n",
    "    np.array([2, 46, 40]),\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac5dc4ae",
   "metadata": {},
   "source": [
    "## Down Tack (⊤)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6329e7bb",
   "metadata": {},
   "source": [
    "### Dyadic - Encode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "53211c07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, 46, 40])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ⍝ mixed radix: encode of 10000 seconds\n",
    "# ⍝ to hours, minutes and seconds:\n",
    "\n",
    "#       24 60 60 ⊤ 10000\n",
    "# 2 46 40\n",
    "\n",
    "def encode_mixed_radix(alpha, omega):\n",
    "    alpha = alpha[::-1]\n",
    "    result = []\n",
    "    \n",
    "    for a in alpha:\n",
    "        omega, remainder = divmod(omega, a)\n",
    "        result.append(remainder)\n",
    "    \n",
    "    return np.array(result[::-1])\n",
    "    \n",
    "\n",
    "encode_mixed_radix([24, 60, 60], 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "fe39dc67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 1],\n",
       "       [1, 1, 1],\n",
       "       [0, 1, 0],\n",
       "       [1, 1, 0]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 2 2 2 ⊤ 5 7 12   ⍝ binary encode\n",
    "# 0 0 1\n",
    "# 1 1 1\n",
    "# 0 1 0\n",
    "# 1 1 0\n",
    "\n",
    "def encode(alpha, omega):\n",
    "    result = []\n",
    "    for o in omega:\n",
    "        result.append(            \n",
    "            encode_mixed_radix(alpha, o)\n",
    "        )\n",
    "    return np.array(result).T\n",
    "\n",
    "encode([2, 2, 2, 2], [5, 7, 12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4d6c58f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0],\n",
       "       [0, 0, 1],\n",
       "       [2, 3, 0]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "encode([2, 3, 4], [2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bf5c179",
   "metadata": {},
   "source": [
    "## Question Mark (?)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ebdd317",
   "metadata": {},
   "source": [
    "### Monadic - Roll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "852d79bf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 6, 3, 2])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ? 6 6 6 6 6\n",
    "# 4 3 6 3 5\n",
    "\n",
    "import random\n",
    "random.seed(42)  # prevents it from changing each time\n",
    "\n",
    "# APL will never return zero as a choice here\n",
    "roll = lambda x: random.choice(range(1, x+1))\n",
    "np.vectorize(roll)([6, 6, 6, 6, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "c21633e7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.02501076, 0.27502932])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ? 0 0\n",
    "# 0.260561 0.929928\n",
    "\n",
    "# APL will never return zero as a choice here\n",
    "random.seed(42)\n",
    "roll_zero = lambda x: random.random()\n",
    "np.vectorize(roll_zero)([0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc6f26bf",
   "metadata": {},
   "source": [
    "### Dyadic - Deal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "e25be40d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([41,  8,  2, 48, 18, 16, 15,  9,  7, 35,  6, 38, 28])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       13 ? 52\n",
    "# 36 31 44 11 27 42 13 8 2 33 19 34 6\n",
    "\n",
    "random.seed(42)\n",
    "\n",
    "def sample(alpha, omega):\n",
    "    return random.sample(range(1, omega + 1), alpha)\n",
    "\n",
    "np.array(\n",
    "    sample(13, 52)\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "096c8fcf",
   "metadata": {},
   "source": [
    "-------------------------\n",
    "## Logic and Comparison\n",
    "-------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5f312fe",
   "metadata": {},
   "source": [
    "## Tilde (~)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cfac8c2",
   "metadata": {},
   "source": [
    "### Monadic - NOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "8a6ea960",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 1, 0]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ~ 0 1 0 1\n",
    "# 1 0 1 0\n",
    "\n",
    "def logic_not(omega):\n",
    "    return [\n",
    "        int(np.logical_not(o)) \n",
    "        for o in omega\n",
    "    ]\n",
    "        \n",
    "logic_not(\n",
    "    [0, 1, 0, 1]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9263d02",
   "metadata": {},
   "source": [
    "### Dyadic - Without"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "cec9bed3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 1 4 1 5 ~ 5 1\n",
    "# 3 4\n",
    "\n",
    "def without(alpha, omega):\n",
    "    return [\n",
    "        a for a in alpha \n",
    "        if a not in omega\n",
    "    ]\n",
    "\n",
    "np.array(\n",
    "    without(\n",
    "        [3, 1, 4, 1, 5], [5, 1]\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "590d0de9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['aa', 'cc'], dtype='<U2')"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'aa' 'bb' 'cc' 'bb'  ~ 'bb' 'xx'\n",
    "# ┌──┬──┐\n",
    "# │aa│cc│\n",
    "# └──┴──┘\n",
    "\n",
    "np.array(\n",
    "    without(\n",
    "        ['aa', 'bb', 'cc', 'bb'], ['bb', 'xx']\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5c33677",
   "metadata": {},
   "source": [
    "## Logical AND (∧)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10fee0fa",
   "metadata": {},
   "source": [
    "### Dyadic - Lowest Common Multiple (AND)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "8f73eff5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 1])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 0 1 ∧ 0 0 1 1\n",
    "# 0 0 0 1\n",
    "\n",
    "np.vectorize(np.lcm)(\n",
    "    [0, 1, 0, 1], [0, 0, 1, 1]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "a0ffa07b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([105,   1,   4,   0])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       15 1 2 7 ∧ 35 1 4 0\n",
    "# 105 1 4 0\n",
    "\n",
    "np.vectorize(np.lcm)(\n",
    "    [15, 1, 2, 7], [35, 1, 4, 0]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a97d5d7",
   "metadata": {},
   "source": [
    "## Logical OR (∨)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c23223",
   "metadata": {},
   "source": [
    "### Dyadic - Greatest Common Divisor (OR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "4141cbad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 1])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 0 1 ∨ 0 0 1 1\n",
    "# 0 1 1 1\n",
    "\n",
    "np.vectorize(np.gcd)(\n",
    "    [0, 1, 0, 1], [0, 0, 1, 1]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "5ade3fdd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 1, 2, 7])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       15 1 2 7 ∨ 35 1 4 0\n",
    "# 5 1 2 7\n",
    "\n",
    "np.vectorize(np.gcd)(\n",
    "    [15, 1, 2, 7], [35, 1, 4, 0]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cc29b30",
   "metadata": {},
   "source": [
    "## Logical NAND (⍲)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81adff3",
   "metadata": {},
   "source": [
    "### Dyadic - NAND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "592a465a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 0])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 0 1 ⍲ 0 0 1 1\n",
    "# 1 1 1 0\n",
    "\n",
    "def nand(alpha, omega):\n",
    "    return int(\n",
    "        not (alpha and omega)\n",
    "    )\n",
    "\n",
    "np.vectorize(nand)(\n",
    "    [0, 1, 0, 1], [0, 0, 1, 1]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac9101a6",
   "metadata": {},
   "source": [
    "## Logical NOR (⍱)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c1820ed",
   "metadata": {},
   "source": [
    "### Dyadic - NOR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "5719290b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 0])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 0 1 ⍱ 0 0 1 1\n",
    "# 1 0 0 0\n",
    "\n",
    "def nor(alpha, omega):\n",
    "    return int(\n",
    "        not (alpha or omega)\n",
    "    )\n",
    "\n",
    "np.vectorize(nor)(\n",
    "    [0, 1, 0, 1], [0, 0, 1, 1]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abc4321d",
   "metadata": {},
   "source": [
    "## Less Than (<)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3076ef8e",
   "metadata": {},
   "source": [
    "### Dyadic - Less Than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a0858ceb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 < 4 2 ¯1\n",
    "# 1 0 0\n",
    "\n",
    "(np.array([1, 2, 3]) < np.array([4, 2, -1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "5928d52d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 < 2\n",
    "# 1 0 0\n",
    "\n",
    "(np.array([1, 2, 3]) < 2).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34b8fbe6",
   "metadata": {},
   "source": [
    "## Greater Than (>)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdffb410",
   "metadata": {},
   "source": [
    "### Dyadic - Greater Than"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "5df0163d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 > 4 2 ¯1\n",
    "# 0 0 1\n",
    "\n",
    "(np.array([1, 2, 3]) > np.array([4, 2, -1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "430e4b7a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 1])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 > 2\n",
    "# 0 0 1\n",
    "\n",
    "(np.array([1, 2, 3]) > 2).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64279f3e",
   "metadata": {},
   "source": [
    "## Less Than Or Equal To (≤)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55489a28",
   "metadata": {},
   "source": [
    "### Dyadic - Less Than or Equal To"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "750cd35e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 0])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ≤ 4 2 ¯1\n",
    "# 1 1 0\n",
    "\n",
    "(np.array([1, 2, 3]) <= np.array([4, 2, -1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "f50e584b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 0])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ≤ 2\n",
    "# 1 1 0\n",
    "\n",
    "(np.array([1, 2, 3]) <= 2).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35bdb827",
   "metadata": {},
   "source": [
    "## Greater Than Or Equal To (≥)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46a862c2",
   "metadata": {},
   "source": [
    "### Dyadic - Greater Than Or Equal To"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "9d6a76a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ≥ 4 2 ¯1\n",
    "# 0 1 1\n",
    "\n",
    "(np.array([1, 2, 3]) >= np.array([4, 2, -1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "ffd969c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ≥ 2\n",
    "# 0 1 1\n",
    "\n",
    "(np.array([1, 2, 3]) >= 2).astype(int)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a010e774",
   "metadata": {},
   "source": [
    "## Equal (=)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ca7e29",
   "metadata": {},
   "source": [
    "### Dyadic - Equal To"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "09f2087e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 0])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 = 4 2 ¯1\n",
    "# 0 1 0\n",
    "\n",
    "(np.array([1, 2, 3]) == np.array([4, 2, -1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "cbfc8440",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 0, 1])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 0 1 = 0 0 1 1\n",
    "# 1 0 0 1\n",
    "\n",
    "(np.array([0, 1, 0, 1]) == np.array([0, 0, 1, 1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "0bfb4668",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 0, 1, 0, 1])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Banana' = 'a'\n",
    "# 0 1 0 1 0 1\n",
    "\n",
    "def equal_to(alpha, omega):\n",
    "    return np.array(\n",
    "        [a == omega for a in alpha]\n",
    "    ).astype(int)\n",
    "\n",
    "equal_to(\n",
    "    'Banana', 'a'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "811feb6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       7 = '7'\n",
    "# 0\n",
    "\n",
    "int(7 == '7')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfaa95ff",
   "metadata": {},
   "source": [
    "## Not Equal (≠)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68d0d1f7",
   "metadata": {},
   "source": [
    "### Monadic - Unique Mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "033107ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 0, 0, 0])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≠ 'Banana'\n",
    "# 1 1 1 0 0 0\n",
    "\n",
    "def unique_mask(omega):\n",
    "    list_ = list(omega)\n",
    "    uniq = np.unique(list_, return_index=True)\n",
    "    uniq_idx = uniq[1]\n",
    "    return np.array(\n",
    "        [i in uniq_idx for i, _ in enumerate(omega)]\n",
    "    ).astype(int)\n",
    "\n",
    "unique_mask('Banana')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "203639d0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≠ 'Mississippi'\n",
    "# 1 1 1 0 0 0 0 0 1 0 0\n",
    "\n",
    "unique_mask('Mississippi')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "854b7474",
   "metadata": {},
   "source": [
    "### Dyadic - Not Equal To"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "6633ca39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 1])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ≠ 4 2 ¯1\n",
    "# 1 0 1\n",
    "\n",
    "(np.array([1, 2, 3]) != np.array([4, 2, -1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "67f26e19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 0])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 0 1 ≠ 0 0 1 1\n",
    "# 0 1 1 0\n",
    "\n",
    "(np.array([0, 1, 0, 1]) != np.array([0, 0, 1, 1])).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "4e8bfb82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 1, 0, 1, 0])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Banana' ≠ 'a'\n",
    "# 1 0 1 0 1 0\n",
    "\n",
    "def not_equal_to(alpha, omega):\n",
    "    return np.array(\n",
    "        [a != omega for a in alpha]\n",
    "    ).astype(int)\n",
    "\n",
    "not_equal_to(\n",
    "    'Banana', 'a'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3cd80aa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       7 ≠ '7'\n",
    "# 1\n",
    "\n",
    "int(7 != '7')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4096ea57",
   "metadata": {},
   "source": [
    "## Equal Underbar (≡)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c4cca84",
   "metadata": {},
   "source": [
    "### Monadic - Depth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "ea4775a7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# based on / modified from a function found at: \n",
    "# https://stackoverflow.com/questions/33788456/easy-way-to-determine-a-nesting-level-of-nested-tuples-in-python\n",
    "\n",
    "#       ≡ 7\n",
    "# 0\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def depth(omega):\n",
    "    max_depth = 0\n",
    "    \n",
    "    # prevents making this recursive by keeping a running tab\n",
    "    # of where things stand along the way\n",
    "    Checklist = [(omega, max_depth)]\n",
    "    \n",
    "    # allows to check for even nesting at the end\n",
    "    # by designating some datatypes as being at the lowest level\n",
    "    Dtypes = defaultdict(set)\n",
    "    \n",
    "    while Checklist:\n",
    "        x, depth = Checklist.pop()\n",
    "        if isinstance(x, (list, tuple, np.ndarray)):\n",
    "            Dtypes[depth].add(type(x))\n",
    "            for a in x:\n",
    "                Checklist.append((a, depth+1))\n",
    "                \n",
    "        elif isinstance(x, str):\n",
    "            if len(x) > 1 and str not in Dtypes[depth]:\n",
    "                Dtypes[depth].add(str)\n",
    "                max_depth += 1\n",
    "            else:\n",
    "                # char\n",
    "                Dtypes[depth].add('LOWEST')\n",
    "                max_depth = max(max_depth, depth)\n",
    "                \n",
    "        else:\n",
    "            # number\n",
    "            Dtypes[depth].add('LOWEST')\n",
    "            max_depth = max(max_depth, depth)\n",
    "            \n",
    "    # Check for even nesting and return\n",
    "    for level, dtypes in Dtypes.items():\n",
    "        if \"LOWEST\" in dtypes and len(dtypes) > 1:\n",
    "            return max_depth * -1\n",
    "    \n",
    "    return max_depth\n",
    "        \n",
    "\n",
    "depth(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "94933cae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≡ 'abc'\n",
    "# 1\n",
    "\n",
    "depth('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "48eb06e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≡ (1 2)(3 4)\n",
    "# 2\n",
    "\n",
    "depth(\n",
    "    (\n",
    "        np.array([1, 2]), \n",
    "        np.array([3, 4])\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "232cc762",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≡ (1 2)(3 4)5\n",
    "# ¯2\n",
    "\n",
    "depth(\n",
    "    (\n",
    "        np.array([1, 2]),\n",
    "        np.array([3, 4]), \n",
    "        5.0\n",
    "    )\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "235d63aa",
   "metadata": {},
   "source": [
    "### Dyadic - Match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9a8c6d9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'b' 'e' 'x' ≡ 'bex'\n",
    "# 1\n",
    "\n",
    "def match(alpha, omega):\n",
    "    if len(alpha) != len(omega):\n",
    "        return 0\n",
    "    else:\n",
    "        result = [\n",
    "            alpha[i] == omega[i] \n",
    "            for i in range(len(alpha))\n",
    "        ]\n",
    "    return int(all(result))\n",
    "\n",
    "match(['b', 'e', 'x'], 'bex')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "df94cf98",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 ≡ 1 1\n",
    "# 0\n",
    "\n",
    "match([1], [1, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a420ad46",
   "metadata": {},
   "source": [
    "## Equal Underbar Slash (≢)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e558880",
   "metadata": {},
   "source": [
    "### Monadic - Tally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "57b163e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≢ 'a'\n",
    "# 1\n",
    "\n",
    "len('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "952b72a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≢ 7 4 2\n",
    "# 3\n",
    "\n",
    "len([7, 4, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "a89a3a48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≢ 5 4 3⍴0 \n",
    "# 5\n",
    "\n",
    "len([5, 4, *np.zeros(3)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "56de1a4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ≢ (1 2)(3 4)\n",
    "# 2\n",
    "\n",
    "len(\n",
    "    [(1, 2), (3, 4)]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "16c13270",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "≢ mat = 2\n",
      "⍴ mat = (2, 3)\n"
     ]
    }
   ],
   "source": [
    "#      mat\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "#       ≢ mat   ⍝ note how \\\n",
    "\n",
    "# 2\n",
    "#       ⍴ mat   ⍝ differs from \\\n",
    "\n",
    "# 2 3\n",
    "\n",
    "mat = np.matrix(\"1 2 3;4 5 6\")\n",
    "print(mat)\n",
    "\n",
    "print(\"≢ mat =\", len(mat))\n",
    "print(\"⍴ mat =\", mat.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f14a341",
   "metadata": {},
   "source": [
    "### Dyadic - Not Match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "2d990f67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'bex' ≢ 'b','e','x' \n",
    "# 0\n",
    "\n",
    "def not_match(alpha, omega):\n",
    "    if len(alpha) != len(omega):\n",
    "        return 1\n",
    "    else:\n",
    "        result = [\n",
    "            alpha[i] != omega[i] \n",
    "            for i in range(len(alpha))\n",
    "        ]\n",
    "    return int(all(result))\n",
    "\n",
    "not_match('bex', ['b', 'e', 'x'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "b9071fc0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 ≢ 1 1\n",
    "# 1\n",
    "\n",
    "not_match([1], [1, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a7ada46",
   "metadata": {},
   "source": [
    "--------------------------------\n",
    "## Structural\n",
    "--------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebef5e76",
   "metadata": {},
   "source": [
    "## Rho (⍴)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79025b62",
   "metadata": {},
   "source": [
    "### Monadic - Shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "c9628ed7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       ⍴ mat\n",
    "# 3 4\n",
    "\n",
    "mat = np.matrix('1 2 3 4;5 6 7 8;9 10 11 12')\n",
    "mat.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "4191926a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2,)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍴⍴ mat\n",
    "# 2\n",
    "\n",
    "np.array(mat.shape).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "cf6af6da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9,)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍴ 'your boat'\n",
    "# 9\n",
    "\n",
    "np.array(list('your boat')).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "a74b4db4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍴ 7\n",
    "#\n",
    "\n",
    "np.array(7).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "b3d4d8b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0,)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍴⍴ 7\n",
    "# 0\n",
    "\n",
    "np.array(np.array(7).shape).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69910d70",
   "metadata": {},
   "source": [
    "### Dyadic - Reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "54edbde2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 2, 3, 4],\n",
       "        [5, 6, 7, 1],\n",
       "        [2, 3, 4, 5]],\n",
       "\n",
       "       [[6, 7, 1, 2],\n",
       "        [3, 4, 5, 6],\n",
       "        [7, 1, 2, 3]]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 3 4 ⍴ 1 2 3 4 5 6 7\n",
    "# 1 2 3 4\n",
    "# 5 6 7 1\n",
    "# 2 3 4 5\n",
    "\n",
    "# 6 7 1 2\n",
    "# 3 4 5 6\n",
    "# 7 1 2 3\n",
    "\n",
    "np.resize(np.arange(1, 8), [2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23cf7ca0",
   "metadata": {},
   "source": [
    "## Comma (,)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1442d330",
   "metadata": {},
   "source": [
    "### Monadic - Ravel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "88b6ec8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cube    ⍝ 3D array\n",
    "# 1 2\n",
    "# 3 4\n",
    "\n",
    "# 5 6\n",
    "# 7 8\n",
    "#       , cube\n",
    "# 1 2 3 4 5 6 7 8\n",
    "\n",
    "cube = [[1, 2],[3, 4]], [[5, 6], [7, 8]]\n",
    "cube = np.array(cube)\n",
    "print(cube)\n",
    "np.ravel(cube)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "32278157",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ,[2 3] cube    ⍝ Ravel with axes\n",
    "# 1 2 3 4\n",
    "# 5 6 7 8\n",
    "\n",
    "def ravel_with_axes(omega, axes):\n",
    "    if isinstance(axes, (int, np.int64)):\n",
    "        try:\n",
    "            assert axes < omega.ndim\n",
    "        except AssertionError:\n",
    "            raise ValueError(\"RANK ERROR: Invalid axis\")\n",
    "        else:\n",
    "            result = omega\n",
    "            \n",
    "    elif isinstance(axes, float):\n",
    "        ax_floor = int(np.floor(axes))\n",
    "        result = np.expand_dims(omega, ax_floor)\n",
    "    \n",
    "    elif isinstance(axes, (list, tuple, np.ndarray)):\n",
    "        result = np.ravel(omega)\n",
    "        ravelled_axes = [omega.shape[a-1] for a in axes]\n",
    "        first_idx = axes[0]\n",
    "        new_size = np.multiply.reduce(ravelled_axes)\n",
    "        new_shape = [o for i, o in enumerate(omega.shape) if i+1 not in axes]\n",
    "        new_shape.insert(first_idx, new_size)\n",
    "        result = result.reshape(new_shape)\n",
    "        \n",
    "    return result\n",
    "\n",
    "ravel_with_axes(cube, [2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca17e7db",
   "metadata": {},
   "source": [
    "### Dyadic - Catenate/Laminate (Join)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "17a8e34d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 , 4 5 6\n",
    "# 1 2 3 4 5 6\n",
    "\n",
    "np.append(\n",
    "    np.array([1, 2, 3]), \n",
    "    np.array([4, 5, 6])\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "f2bd6080",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2, 99],\n",
       "        [ 3,  4, 99]],\n",
       "\n",
       "       [[ 5,  6, 99],\n",
       "        [ 7,  8, 99]]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cube , 99\n",
    "# 1 2 99\n",
    "# 3 4 99\n",
    "\n",
    "# 5 6 99\n",
    "# 7 8 99\n",
    "\n",
    "\n",
    "def catenate(alpha, omega):\n",
    "    if isinstance(alpha, (int, np.int64)):\n",
    "        return alpha, omega\n",
    "    elif isinstance(alpha, (list, tuple, np.ndarray)):\n",
    "        omega_count = np.multiply(alpha.shape[0], alpha.shape[1])\n",
    "        omega_array = np.array([omega for i in range(omega_count)])\n",
    "        new_shape = alpha.shape[:2]\n",
    "        omega_array = omega_array.reshape(new_shape)\n",
    "        result = np.dstack((\n",
    "            alpha, \n",
    "            omega_array \n",
    "        ))\n",
    "        return result\n",
    "\n",
    "\n",
    "catenate(cube, 99)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "f3875db9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ,[0.5] 4 5 6   ⍝ Laminate\n",
    "# 1 2 3\n",
    "# 4 5 6 \n",
    "\n",
    "\n",
    "def final_dim(arr):\n",
    "    return np.ravel(np.array(arr).shape)[-1]\n",
    "\n",
    "def laminate(alpha, omega, first=False):\n",
    "    if isinstance(omega, (int, np.int64)):\n",
    "        alpha_ravel = np.ravel(alpha)\n",
    "        \n",
    "        if first:\n",
    "            final_alpha_dim_size = final_dim(alpha)\n",
    "            result = np.hstack((\n",
    "                alpha_ravel,\n",
    "                np.array([omega for i in range(final_alpha_dim_size)])\n",
    "            ))\n",
    "            \n",
    "            return result.reshape((\n",
    "                *alpha.shape[:-2],\n",
    "                alpha.shape[-2] + 1, \n",
    "                alpha.shape[-1]\n",
    "            ))\n",
    "        \n",
    "        else:\n",
    "            result = np.hstack((\n",
    "                alpha_ravel,\n",
    "                np.array([omega for i in alpha_ravel])\n",
    "            ))\n",
    "            return result.reshape(\n",
    "                2, *alpha.shape\n",
    "            )\n",
    "    \n",
    "    elif isinstance(omega, (list, tuple, np.ndarray)):\n",
    "        try:\n",
    "            final_alpha_dim_size = final_dim(alpha)\n",
    "            final_omega_dim_size = final_dim(omega)\n",
    "            assert final_alpha_dim_size == final_omega_dim_size\n",
    "        except AssertionError:\n",
    "            raise ValueError(\"LENGTH ERROR\", final_alpha_dim_size, final_omega_dim_size)\n",
    "        else:\n",
    "            return np.vstack((alpha, omega))\n",
    "    \n",
    "\n",
    "laminate([1, 2, 3], [4, 5, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "048e5382",
   "metadata": {},
   "source": [
    "## Comma Bar (⍪)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52adcda4",
   "metadata": {},
   "source": [
    "### Monadic - Table"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "cf64964a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍪ 2 3 4\n",
    "# 2\n",
    "# 3\n",
    "# 4\n",
    "\n",
    "def table(omega):\n",
    "    if omega.ndim == 1:\n",
    "        result = omega.reshape(\n",
    "            *omega.shape, 1\n",
    "        )\n",
    "    elif omega.ndim == 2:\n",
    "        result = omega\n",
    "    else:\n",
    "        shape_1 = omega.shape[0]\n",
    "        shape_2 = np.multiply.reduce(\n",
    "            omega.shape[1:]\n",
    "        )\n",
    "        result = omega.reshape((shape_1, shape_2))\n",
    "    \n",
    "    return result\n",
    "\n",
    "table(np.array([2, 3, 4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "488994a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cube    ⍝ 3D array\n",
    "# 1 2\n",
    "# 3 4\n",
    "\n",
    "# 5 6\n",
    "# 7 8\n",
    "#       ⍪ cube\n",
    "# 1 2 3 4\n",
    "# 5 6 7 8\n",
    "\n",
    "cube = np.arange(1, 9).reshape(2, 2, 2)\n",
    "print(cube)\n",
    "table(cube)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be02d44a",
   "metadata": {},
   "source": [
    "### Dyadic - Catenate First/Laminate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "1d5519d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [0, 0, 0]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "\n",
    "#       mat ⍪ 0\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "# 0 0 0\n",
    "\n",
    "mat = np.matrix(\"1 2 3;4 5 6\")\n",
    "laminate(mat, 0, first=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "0a4ec07c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 2, 3],\n",
       "        [4, 5, 6],\n",
       "        [7, 8, 9]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat ⍪ 7 8 9\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "# 7 8 9\n",
    "\n",
    "laminate(mat, np.array([7, 8, 9]), first=True)\n",
    "# simpler version:\n",
    "# np.vstack((\n",
    "#     mat,\n",
    "#     np.array([7, 8, 9])\n",
    "# ))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "994ec805",
   "metadata": {},
   "source": [
    "## Circle Stile (⌽)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2532d0d1",
   "metadata": {},
   "source": [
    "### Monadic - Reverse"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "32b916b9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'smart'"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌽ 'trams'\n",
    "# smart\n",
    "\n",
    "'trams'[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "3cc58761",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[ 4,  3,  2,  1],\n",
       "        [ 8,  7,  6,  5],\n",
       "        [12, 11, 10,  9]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       ⌽ mat\n",
    "#  4  3  2 1\n",
    "#  8  7  6 5\n",
    "# 12 11 10 9\n",
    "\n",
    "\n",
    "mat = np.matrix('1 2 3 4;5 6 7 8;9 10 11 12')\n",
    "print(mat)\n",
    "\n",
    "np.flip(mat, axis=1)  # also `mat[:,::-1]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "c353afbb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 9, 10, 11, 12],\n",
       "        [ 5,  6,  7,  8],\n",
       "        [ 1,  2,  3,  4]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌽[1] mat\n",
    "# 9 10 11 12\n",
    "# 5  6  7  8\n",
    "# 1  2  3  4\n",
    "\n",
    "np.flip(mat, axis=0)  # also `mat[::-1]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48a0e173",
   "metadata": {},
   "source": [
    "### Dyadic - Rotate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "ab574586",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'StandHat'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 ⌽ 'HatStand'\n",
    "# StandHat\n",
    "\n",
    "def rotate(alpha, omega):\n",
    "    # apparently NumPy and APL have a different idea about the direction of a roll\n",
    "    alpha = alpha * -1\n",
    "    \n",
    "    result = np.roll(list(omega), alpha)\n",
    "    if isinstance(omega, str):\n",
    "        result = \"\".join(result)\n",
    "    return result\n",
    "\n",
    "rotate(3, 'HatStand')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "22942a60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯2 ⌽ 1 2 3 4 5 6\n",
    "# 5 6 1 2 3 4\n",
    "\n",
    "rotate(-2, [1, 2, 3, 4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "47e304f4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 4,  1,  2,  3],\n",
       "        [ 8,  5,  6,  7],\n",
       "        [12,  9, 10, 11]])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯1 ⌽ mat\n",
    "#  4 1  2  3\n",
    "#  8 5  6  7\n",
    "# 12 9 10 11\n",
    "\n",
    "def rotate_matrix(alpha, omega, rotate_columns=False):\n",
    "    if rotate_columns:\n",
    "        omega = omega.T\n",
    "        \n",
    "    try:\n",
    "        assert len(alpha) == len(omega)\n",
    "        \n",
    "        result = []\n",
    "        for a, o in zip(alpha, omega):\n",
    "            o = list(np.ravel(o))\n",
    "            result.append(\n",
    "                rotate(a, o)\n",
    "            )\n",
    "        result = np.vstack(result)\n",
    "    \n",
    "    except TypeError:\n",
    "        o1, o2 = np.hsplit(omega, [alpha])\n",
    "        result = np.hstack((o2, o1))\n",
    "    \n",
    "    if rotate_columns:\n",
    "        result = result.T\n",
    "        \n",
    "    return result\n",
    "\n",
    "rotate_matrix(-1, mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "56908e5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  1],\n",
       "       [ 8,  5,  6,  7],\n",
       "       [11, 12,  9, 10]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 ¯1 2 ⌽ mat\n",
    "#  2  3 4  1\n",
    "#  8  5 6  7\n",
    "# 11 12 9 10\n",
    "\n",
    "rotate_matrix([1, -1, 2], mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "8e5cc3a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  6, 11, 12],\n",
       "       [ 5, 10,  3,  4],\n",
       "       [ 9,  2,  7,  8]])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 2 ¯1 ⌽[1] mat\n",
    "# 1  6 11 12\n",
    "# 5 10  3  4\n",
    "# 9  2  7  8\n",
    "\n",
    "rotate_matrix([0, 1, 2, -1], mat, rotate_columns=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66dd214f",
   "metadata": {},
   "source": [
    "## Circle Bar (⊖)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c4e1799",
   "metadata": {},
   "source": [
    "### Monadic - Reverse First"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "5dd6a511",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[ 9, 10, 11, 12],\n",
       "        [ 5,  6,  7,  8],\n",
       "        [ 1,  2,  3,  4]])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       ⊖ mat\n",
    "# 9 10 11 12\n",
    "# 5  6  7  8\n",
    "# 1  2  3  4\n",
    "\n",
    "mat = np.matrix('1 2 3 4;5 6 7 8;9 10 11 12')\n",
    "print(mat)\n",
    "mat[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ccc28f9",
   "metadata": {},
   "source": [
    "### Dyadic - Rotate First"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "0b9b5463",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  6, 11, 12],\n",
       "       [ 5, 10,  3,  4],\n",
       "       [ 9,  2,  7,  8]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       0 1 2 ¯1 ⊖ mat\n",
    "# 1  6 11 12\n",
    "# 5 10  3  4\n",
    "# 9  2  7  8\n",
    "\n",
    "rotate_matrix([0, 1, 2, -1], mat, rotate_columns=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "619d4dd6",
   "metadata": {},
   "source": [
    "## Transpose (⍉)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "915c4239",
   "metadata": {},
   "source": [
    "### Monadic - Transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "483fbbeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 4],\n",
       "        [2, 5],\n",
       "        [3, 6]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "\n",
    "#       ⍉ mat\n",
    "# 1 4\n",
    "# 2 5\n",
    "# 3 6\n",
    "\n",
    "mat = np.matrix('1 2 3; 4 5 6')\n",
    "mat.T"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70c1f7b4",
   "metadata": {},
   "source": [
    "### Dyadic - Dyadic Transpose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "6a768828",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 4],\n",
       "        [2, 5],\n",
       "        [3, 6]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 1 ⍉ mat\n",
    "# 1 4\n",
    "# 2 5\n",
    "# 3 6\n",
    "\n",
    "np.transpose(mat, (1, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "a2c3a87d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1, 5]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 1 ⍉ mat   ⍝ leading diagonal\n",
    "# 1 5\n",
    "\n",
    "mat.diagonal()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67cde45a",
   "metadata": {},
   "source": [
    "## Up Arrow (↑)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdbe5cb8",
   "metadata": {},
   "source": [
    "### Monadic - Mix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "335bd0a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['Hip'],\n",
       "       ['Hop']], dtype='<U3')"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ↑ 'Hip' 'Hop'\n",
    "# Hip\n",
    "# Hop\n",
    "\n",
    "np.array(['Hip', 'Hop']).reshape((2, 1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "12581ba2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 4],\n",
       "       [5, 0],\n",
       "       [3, 0]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ↑ (6 4) 5 3\n",
    "# 6 4\n",
    "# 5 0\n",
    "# 3 0\n",
    "\n",
    "def safe_len(var):\n",
    "    try:\n",
    "        result = len(var)\n",
    "    except:\n",
    "        result = 1\n",
    "    return result\n",
    "\n",
    "\n",
    "def blank(var):\n",
    "    if isinstance(var, str):\n",
    "        result = \" \"\n",
    "    else:\n",
    "        result = 0\n",
    "    return result\n",
    "\n",
    "\n",
    "def mix(omega, transpose=False):\n",
    "    lens = [safe_len(o) for o in omega]\n",
    "    max_lens = max(lens)\n",
    "    \n",
    "    result = []\n",
    "    for len_, o in zip(lens, omega):\n",
    "        try:\n",
    "            o = list(o)\n",
    "        except TypeError:\n",
    "            o = [o]\n",
    "        \n",
    "        if len_ < max_lens:\n",
    "            o.extend([\n",
    "                blank(r) for r in \n",
    "                range(max_lens - len_)\n",
    "            ])\n",
    "            \n",
    "        result.append(\n",
    "            np.array(o)\n",
    "        )\n",
    "    \n",
    "    result = np.array(result)\n",
    "    if transpose:\n",
    "        result = result.T\n",
    "    return result\n",
    "\n",
    "\n",
    "mix([(6, 4), 5, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "692e7b3d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['H', 'H'],\n",
       "       ['i', 'o'],\n",
       "       ['p', 'p']], dtype='<U1')"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ↑[0.5] 'Hip' 'Hop'\n",
    "# HH\n",
    "# io\n",
    "# pp\n",
    "\n",
    "mix(['Hip', 'Hop'], transpose=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d18df083",
   "metadata": {},
   "source": [
    "### Dyadic - Take"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "77598f80",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pine'"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       4 ↑ 'Pineapple'\n",
    "# Pine\n",
    "\n",
    "def take(alpha, omega):\n",
    "    # One way or another, convert omega to a list\n",
    "    # and grab the length of that list\n",
    "    try:\n",
    "        result = list(omega)\n",
    "    except TypeError:\n",
    "        result = [omega]\n",
    "    len_ = len(result)\n",
    "\n",
    "    # Return nothing if nothing is desired\n",
    "    if alpha == 0:\n",
    "        return None\n",
    "    \n",
    "    elif alpha > 0:\n",
    "        if len_ < alpha:\n",
    "            result.extend([\n",
    "                blank(omega) for r in \n",
    "                range(alpha - len_)\n",
    "            ])\n",
    "        else:\n",
    "            result = result[:alpha]\n",
    "            \n",
    "    else:  # alpha < 0\n",
    "        abs_alpha = abs(alpha)\n",
    "        \n",
    "        # Add blanks to the front if alpha is negative\n",
    "        if len_ < abs_alpha:\n",
    "            extra = [\n",
    "                blank(omega) for r in \n",
    "                range(abs_alpha - len_)\n",
    "            ]\n",
    "            extra.extend(result)\n",
    "            result = extra\n",
    "        else:\n",
    "            result = result[alpha:]\n",
    "    \n",
    "    # join together if it's a string\n",
    "    if isinstance(omega, str):\n",
    "        result = \"\".join(result)\n",
    "    \n",
    "    return result\n",
    "    \n",
    "take(4, \"Pineapple\")  # simpler way is 'Pineapple'[:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "f4a0a234",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯5 ↑ 'Pineapple'\n",
    "# apple\n",
    "\n",
    "take(-5, \"Pineapple\")  # simpler way is 'Pineapple'[-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "68df57ee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[2, 3, 4],\n",
       "        [6, 7, 8]])"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       2 ¯3 ↑ mat\n",
    "# 2 3 4\n",
    "# 6 7 8\n",
    "\n",
    "mat = np.matrix(\"1 2 3 4;5 6 7 8;9 10 11 12\")\n",
    "print(mat)\n",
    "mat[:2,-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "a82a20b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯2 ↑ mat\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "mat[-2:, :]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "2dab2ba3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [7., 0., 0.]])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯2 3 ↑ 7\n",
    "# 0 0 0\n",
    "# 7 0 0\n",
    "\n",
    "arr = np.zeros(6).reshape((2, 3))\n",
    "arr[-1,0] = 7\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc996d05",
   "metadata": {},
   "source": [
    "## Down Arrow (↓)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f22abc20",
   "metadata": {},
   "source": [
    "### Monadic - Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "4d52e88f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[matrix([[1, 2, 3, 4]]), matrix([[5, 6, 7, 8]]), matrix([[ 9, 10, 11, 12]])]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       ↓ mat\n",
    "# ┌───────┬───────┬──────────┐\n",
    "# │1 2 3 4│5 6 7 8│9 10 11 12│\n",
    "# └───────┴───────┴──────────┘\n",
    "\n",
    "mat = np.matrix(\"1 2 3 4;5 6 7 8;9 10 11 12\")\n",
    "print(mat)\n",
    "np.vsplit(mat, len(mat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "8462b9c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[matrix([[1, 5, 9]]),\n",
       " matrix([[ 2,  6, 10]]),\n",
       " matrix([[ 3,  7, 11]]),\n",
       " matrix([[ 4,  8, 12]])]"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ↓[1] mat\n",
    "# ┌─────┬──────┬──────┬──────┐\n",
    "# │1 5 9│2 6 10│3 7 11│4 8 12│\n",
    "# └─────┴──────┴──────┴──────┘\n",
    "\n",
    "np.vsplit(mat.T, len(mat.T))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2f06b7f",
   "metadata": {},
   "source": [
    "### Dyadic - Drop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "49dff4ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'apple'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       4 ↓ 'Pineapple'\n",
    "# apple\n",
    "\n",
    "'Pineapple'[4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "9b7618a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Pine'"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯5 ↓ 'Pineapple'\n",
    "# Pine\n",
    "\n",
    "\n",
    "'Pineapple'[:-5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "c4eaa251",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 5,  6],\n",
       "        [ 9, 10]])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 ¯2 ↓ mat\n",
    "# 5  6\n",
    "# 9 10\n",
    "\n",
    "mat[1:, :-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "98be9226",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 5,  6,  7,  8],\n",
       "        [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 ↓ mat\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "mat[1:, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5d75ff2",
   "metadata": {},
   "source": [
    "## Left Shoe (⊂)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e65f113b",
   "metadata": {},
   "source": [
    "### Monadic - Enclose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "35ba2b93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([1]) array([2, 3])]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[array([1]), array([2, 3])]], dtype=object)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1(2 3)\n",
    "# ┌─┬───┐\n",
    "# │1│2 3│\n",
    "# └─┴───┘\n",
    "#       ⊂ 1(2 3)\n",
    "# ┌───────┐\n",
    "# │┌─┬───┐│\n",
    "# ││1│2 3││\n",
    "# │└─┴───┘│\n",
    "# └───────┘\n",
    "\n",
    "def enclose(omega):\n",
    "    return np.array([omega])\n",
    "\n",
    "var = np.array(\n",
    "    [\n",
    "        np.array([1]), \n",
    "        np.array([2, 3])\n",
    "    ],\n",
    "    dtype=object\n",
    ")\n",
    "print(var)\n",
    "enclose(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "ae978ff9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[array([1]), array([2, 3])]]], dtype=object)"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊂⊂ 1(2 3)\n",
    "# ┌─────────┐\n",
    "# │┌───────┐│\n",
    "# ││┌─┬───┐││\n",
    "# │││1│2 3│││\n",
    "# ││└─┴───┘││\n",
    "# │└───────┘│\n",
    "# └─────────┘\n",
    "\n",
    "enclose(enclose(var))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83fc1b3b",
   "metadata": {},
   "source": [
    "### Dyadic - Partitioned Enclose"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "908b6c5f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([array([2, 3]), array([4])], dtype=object)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#        0 1 0 1 ⊂ 1 2 3 4\n",
    "# ┌───┬─┐\n",
    "# │2 3│4│\n",
    "# └───┴─┘\n",
    "\n",
    "def dyadic_enclose(alpha, omega):\n",
    "    assert len(alpha) == len(omega)\n",
    "    result = []\n",
    "    previous_1 = None\n",
    "    for i, a in enumerate(alpha):\n",
    "        if a == 1:\n",
    "            if previous_1 is not None:\n",
    "                result.append(omega[previous_1:i])\n",
    "            previous_1 = i\n",
    "    result.append(omega[previous_1:len(alpha)+1])\n",
    "    return np.array(result, dtype=object)\n",
    "            \n",
    "\n",
    "dyadic_enclose(\n",
    "    np.array([0, 1, 0, 1]), \n",
    "    np.array([1, 2, 3, 4])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "287aeba5",
   "metadata": {},
   "source": [
    "## Left Shoe Underbar (⊆)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4860b3e6",
   "metadata": {},
   "source": [
    "### Monadic - Nest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "470a34d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array('this', dtype='<U4')"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊆ 'this'\n",
    "# ┌────┐\n",
    "# │this│\n",
    "# └────┘\n",
    "\n",
    "np.array('this')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "3c629d82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['this', 'that'], dtype='<U4')"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊆ 'this' 'that'\n",
    "# ┌────┬────┐\n",
    "# │this│that│\n",
    "# └────┴────┘\n",
    "\n",
    "np.array(['this', 'that'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcb7085e",
   "metadata": {},
   "source": [
    "### Dyadic - Partition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "9a7f5b51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([array([1]), array([4, 5])], dtype=object)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 0 0 1 1 ⊆ 1 2 3 4 5\n",
    "# ┌─┬───┐\n",
    "# │1│4 5│\n",
    "# └─┴───┘\n",
    "\n",
    "def dyadic_partition(alpha, omega):\n",
    "    assert len(alpha) == len(omega)\n",
    "    result = []\n",
    "    temp = []\n",
    "    vals = set(alpha)\n",
    "    \n",
    "    # Boolean only\n",
    "    if vals == {0, 1}:\n",
    "        for a, o in zip(alpha, omega):\n",
    "            if a == 1:\n",
    "                temp.append(o)\n",
    "            elif temp:\n",
    "                result.append(\n",
    "                    np.array(temp)\n",
    "                )\n",
    "                temp = []\n",
    "        if temp:\n",
    "            result.append(\n",
    "                np.array(temp)\n",
    "            )\n",
    "        result = np.array(result, dtype=object)\n",
    "    \n",
    "    # Groupings\n",
    "    else:\n",
    "        all_previous = []\n",
    "        last = \"\"\n",
    "        for a, o in zip(alpha, omega):\n",
    "            if last == \"\" or \\\n",
    "               last == a or \\\n",
    "               a in all_previous:\n",
    "                   temp.append(o)\n",
    "            elif temp:\n",
    "                result.append(\n",
    "                    np.array(temp)\n",
    "                )\n",
    "                temp = []\n",
    "                temp.append(o)\n",
    "                \n",
    "            all_previous.append(a)\n",
    "            last = a\n",
    "            \n",
    "        if temp:\n",
    "            result.append(\n",
    "                np.array(temp)\n",
    "            )\n",
    "        result = np.array(result, dtype=object)\n",
    "    \n",
    "    if isinstance(omega, str):\n",
    "        result = np.array([\"\".join(r) for r in result])\n",
    "    return result\n",
    "    \n",
    "\n",
    "dyadic_partition([1, 0, 0, 1, 1], [1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "00d8c78f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([array([1, 2]), array([3, 4, 5])], dtype=object)"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#        1 1 2 2 2⊆⍳5\n",
    "# ┌───┬─────┐\n",
    "# │1 2│3 4 5│\n",
    "# └───┴─────┘\n",
    "\n",
    "dyadic_partition([1, 1, 2, 2, 2], np.arange(1, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "c1f6f7dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['many', 'a', 'time'], dtype='<U4')"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#     ' ' (≠⊆⊢) ' many a  time'\n",
    "# ┌────┬─┬────┐\n",
    "# │many│a│time│\n",
    "# └────┴─┴────┘\n",
    "\n",
    "split_on_spaces = lambda x: dyadic_partition(not_equal_to(x, ' '), x)\n",
    "split_on_spaces(' many a  time')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58d711f4",
   "metadata": {},
   "source": [
    "## Epsilon (∊)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3277d1b8",
   "metadata": {},
   "source": [
    "### Monadic - Enlist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "ce2e31f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "#       ∊ 0 mat (7 8) 9\n",
    "# 0 1 2 3 4 5 6 7 8 9\n",
    "\n",
    "def enlist(omega):\n",
    "    result = []\n",
    "    for o in omega:\n",
    "        result.extend(\n",
    "            np.ravel(o)\n",
    "        )\n",
    "    return np.array(\n",
    "        result\n",
    "    )\n",
    "\n",
    "\n",
    "mat = np.matrix(\"1 2 3;4 5 6\")\n",
    "print(mat)\n",
    "\n",
    "enlist([0, mat, (7, 8), 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "5563f221",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', 'abc', '1', 'abc', '1', 'abc'], dtype='<U3')"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ∊ 2 3⍴1 'abc'\n",
    "# 1 abc 1 abc 1 abc\n",
    "\n",
    "enlist(\n",
    "    np.resize([1, 'abc'], [2, 3])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07db1b1b",
   "metadata": {},
   "source": [
    "### Dyadic - Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "ae9050f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1])"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'abc' 4 ∊ 4 'ab' 'abcd'\n",
    "# 0 1\n",
    "\n",
    "def membership(alpha, omega):\n",
    "    alpha_shape = np.array(alpha).shape\n",
    "    alpha = np.ravel(alpha)\n",
    "    omega = np.ravel(omega)\n",
    "    result = []\n",
    "    for a in alpha:\n",
    "        result.append(\n",
    "            int(a in omega)\n",
    "        )\n",
    "    return np.array(result).reshape(*alpha_shape)\n",
    "\n",
    "membership(['abc', 4], [4, 'ab', 'abcd'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "5530608b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0],\n",
       "       [1, 0, 1]])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat ∊ 6 2 7 4\n",
    "# 0 1 0\n",
    "# 1 0 1\n",
    "\n",
    "membership(mat, [6, 2, 7, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d31e69c",
   "metadata": {},
   "source": [
    "--------------------------------------------\n",
    "## Selection and Set Operations\n",
    "--------------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70455c90",
   "metadata": {},
   "source": [
    "## Squad (⌷)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33d35beb",
   "metadata": {},
   "source": [
    "### Monadic - Materialise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "6d4c3445",
   "metadata": {},
   "outputs": [],
   "source": [
    "#       ⌷ ⍵\n",
    "# If ⍵ is an array, returns ⍵.\n",
    "# If ⍵ is ref to an instance of a Class with a \n",
    "# Numbered Default property, all items of that property\n",
    "# are returned.\n",
    "# If ⍵ is a collection, returns all elements\n",
    "# in the collection as an array.\n",
    "\n",
    "def materialise(omega):\n",
    "    if isinstance(omega, np.ndarray):\n",
    "        return omega\n",
    "    else:\n",
    "        return np.ravel(omega)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0d2ae97",
   "metadata": {},
   "source": [
    "### Dyadic - Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "5089721b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       2 3 ⌷ mat\n",
    "# 7\n",
    "\n",
    "mat = np.matrix(\"1 2 3 4;5 6 7 8;9 10 11 12\")\n",
    "print(mat)\n",
    "mat[1, 2]  # base 0 numbering in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "2d6e1b10",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[5, 6, 7, 8]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ⌷ mat\n",
    "# 5 6 7 8\n",
    "\n",
    "mat[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "291fe4c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 2],\n",
       "        [ 6],\n",
       "        [10]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ⌷[2] mat\n",
    "# 2 6 10\n",
    "\n",
    "mat[:,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07bab6fa",
   "metadata": {},
   "source": [
    "## Right Shoe (⊃)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ea83160",
   "metadata": {},
   "source": [
    "### Monadic - First"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "4041e4fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'W'"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊃ 'Word'\n",
    "# W\n",
    "\n",
    "\"Word\"[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "f02af871",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊃ (1 2)(3 4 5)\n",
    "# 1 2\n",
    "\n",
    "[(1, 2), (3, 4, 5)][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78f20425",
   "metadata": {},
   "source": [
    "### Dyadic - Pick"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "ea74c645",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'r'"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 ⊃ 'Word'\n",
    "# r\n",
    "\n",
    "\"Word\"[2]  # APL defaults to base-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "a3b6ea8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4, 5)"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ⊃ (1 2)(3 4 5)\n",
    "# 3 4 5\n",
    "\n",
    "[(1, 2), (3, 4, 5)][1]  # base 0 numbering in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "b2716710",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 1 ⊃ (1 2)(3 4 5)\n",
    "# 3\n",
    "\n",
    "[(1, 2), (3, 4, 5)][1][0]  # base 0 numbering in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a4fcbdb",
   "metadata": {},
   "source": [
    "## Slash (/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09735db7",
   "metadata": {},
   "source": [
    "### Monadic - Replicate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "37087b41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 6, 6, 7, 0, 0, 9, 9])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 1 ¯2 2 / 6 7 8 9\n",
    "# 6 6 6 7 0 0 9 9\n",
    "\n",
    "def replicate(alpha, omega):\n",
    "    assert len(alpha) == len(omega)\n",
    "    \n",
    "    result = []\n",
    "    count = -1\n",
    "    for a in alpha:\n",
    "        count += 1\n",
    "        if a < 0:\n",
    "            for i in range(abs(a)):\n",
    "                result.append(0)\n",
    "        for i in range(a):\n",
    "            result.append(omega[count])\n",
    "                \n",
    "    return np.array(\n",
    "        result\n",
    "    )\n",
    "\n",
    "replicate([3, 1, -2, 2], [6, 7, 8, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "21437c86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hat'"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 0 1 0 1 / 'Heart'\n",
    "# Hat\n",
    "\n",
    "def mask(alpha, omega):\n",
    "    idx = [i for i in range(len(alpha)) if alpha[i] == 1]\n",
    "    result = [omega[i] for i in range(len(omega)) if i in idx]\n",
    "    \n",
    "    if isinstance(omega, str):\n",
    "        result = \"\".join(result)\n",
    "    return result\n",
    "\n",
    "mask([1, 0, 1, 0, 1], \"Heart\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2e4fd03",
   "metadata": {},
   "source": [
    "### Dyadic - Reduce (Fold, N-Wise Reduce)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "1d4dfd75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +/ 1 2 3 4 5\n",
    "# 15\n",
    "\n",
    "np.array([1, 2, 3, 4, 5]).sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "2e870af5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5, 7, 9])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 +/ 1 2 3 4 5   ⍝ pair-wise sum\n",
    "# 3 5 7 9\n",
    "\n",
    "def group_wise_sum(alpha, omega):\n",
    "    result = []\n",
    "    for i in range(len(omega) - alpha + 1):\n",
    "        result.append(\n",
    "            sum(omega[i:i + alpha])\n",
    "        )\n",
    "    return np.array(\n",
    "        result\n",
    "    )\n",
    "\n",
    "group_wise_sum(2, [1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "41c3eb09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3  4]\n",
      "  [ 5  6  7  8]\n",
      "  [ 9 10 11 12]]\n",
      "\n",
      " [[13 14 15 16]\n",
      "  [17 18 19 20]\n",
      "  [21 22 23 24]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[10, 26, 42],\n",
       "       [58, 74, 90]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cube    ⍝ 3D array\n",
    "#  1  2  3  4\n",
    "#  5  6  7  8\n",
    "#  9 10 11 12\n",
    "\n",
    "# 13 14 15 16\n",
    "# 17 18 19 20\n",
    "# 21 22 23 24\n",
    "\n",
    "#       +/ cube\n",
    "# 10 26 42\n",
    "# 58 74 90\n",
    "\n",
    "cube = np.arange(1, 25).reshape((2, 3, 4))\n",
    "print(cube)\n",
    "cube.sum((2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "6352ceb3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14, 16, 18, 20],\n",
       "       [22, 24, 26, 28],\n",
       "       [30, 32, 34, 36]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +/[1] cube    ⍝ sum of planes\n",
    "# 14 16 18 20\n",
    "# 22 24 26 28\n",
    "# 30 32 34 36\n",
    "\n",
    "cube.sum((0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "544a7673",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15, 18, 21, 24],\n",
       "       [51, 54, 57, 60]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +/[2] cube    ⍝ column sums\n",
    "# 15 18 21 24\n",
    "# 51 54 57 60\n",
    "\n",
    "cube.sum((1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16953ec5",
   "metadata": {},
   "source": [
    "## Slash Bar (⌿)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20aa435c",
   "metadata": {},
   "source": [
    "### Monadic - Reduce First"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "838f1e2a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[15, 18, 21, 24]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       +⌿ mat\n",
    "# 15 18 21 24\n",
    "\n",
    "mat = np.matrix(\"1 2 3 4;5 6 7 8;9 10 11 12\")\n",
    "print(mat)\n",
    "np.sum(mat, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "0e1dd832",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  8, 10, 12],\n",
       "       [14, 16, 18, 20]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 +⌿ mat     ⍝ pair-wise\n",
    "#  6  8 10 12\n",
    "# 14 16 18 20\n",
    "\n",
    "def matrix_column_group_wise_sum(alpha, omega):\n",
    "    assert omega.ndim == 2\n",
    "    result = []\n",
    "    for o in omega.T:\n",
    "        gws = group_wise_sum(alpha, np.ravel(o))\n",
    "        result.append(gws)\n",
    "    return np.array(result).T\n",
    "\n",
    "matrix_column_group_wise_sum(2, mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e182f36",
   "metadata": {},
   "source": [
    "### Dyadic - Replicate First (Compress First)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "10e2db7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 9, 10, 11, 12],\n",
       "       [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 0 2 ⌿ mat\n",
    "# 1  2  3  4\n",
    "# 9 10 11 12\n",
    "# 9 10 11 12\n",
    "\n",
    "def replicate_first(alpha, omega):\n",
    "    result = []\n",
    "    omega_split = np.vsplit(omega, len(omega))\n",
    "    \n",
    "    for a, o in zip(alpha, omega_split):\n",
    "        for i in range(a):\n",
    "            result.append(\n",
    "                np.ravel(o)\n",
    "            )\n",
    "    \n",
    "    return np.array(result)\n",
    "\n",
    "\n",
    "replicate_first([1, 0, 2], mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd2f137f",
   "metadata": {},
   "source": [
    "## Backslash (\\\\)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "099255e0",
   "metadata": {},
   "source": [
    "### Monadic - Scan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "0e5d3747",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  6, 10, 15])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +\\ 1 2 3 4 5\n",
    "# 1 3 6 10 15\n",
    "\n",
    "def scan(arr, func, axis=0):\n",
    "    '''\n",
    "    Thank you, sputnick1124:\n",
    "    https://github.com/ThePoetCoder/APL-to-NumPy/issues/4#issue-2096712337\n",
    "    '''\n",
    "    ufunc = np.frompyfunc(func, 2, 1)\n",
    "    return ufunc.accumulate(arr, axis=axis, dtype=object).astype(arr.dtype)\n",
    "\n",
    "scan(np.array([1, 2, 3, 4, 5]), np.add)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "253ddd9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[ 1,  3,  6, 10],\n",
       "        [ 5, 11, 18, 26],\n",
       "        [ 9, 19, 30, 42]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       +\\ mat\n",
    "# 1  3  6 10\n",
    "# 5 11 18 26\n",
    "# 9 19 30 42\n",
    "\n",
    "mat = np.matrix(\"1 2 3 4;5 6 7 8;9 10 11 12\")\n",
    "print(mat)\n",
    "scan(mat, np.add, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "32f72479",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 1,  2,  3,  4],\n",
       "        [ 6,  8, 10, 12],\n",
       "        [15, 18, 21, 24]])"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +\\[1] mat\n",
    "#  1  2  3  4\n",
    "#  6  8 10 12\n",
    "# 15 18 21 24\n",
    "\n",
    "scan(mat, np.add, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c49bb13e",
   "metadata": {},
   "source": [
    "### Dyadic - Expand"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "9ea3bb89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 7, 7, 0, 0, 8, 8, 8, 8])"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 ¯2 4 \\ 7 8\n",
    "# 7 7 7 0 0 8 8 8 8\n",
    "\n",
    "def expand(alpha, omega):    \n",
    "    result = []\n",
    "    count = -1\n",
    "    for a in alpha:\n",
    "        count += 1\n",
    "        if a < 0:\n",
    "            count -= 1\n",
    "            for i in range(abs(a)):\n",
    "                result.append(0)\n",
    "        for i in range(a):\n",
    "            result.append(omega[count])\n",
    "                \n",
    "    return np.array(\n",
    "        result\n",
    "    )\n",
    "\n",
    "expand([3, -2, 4], [7, 8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "54a596a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H a t'"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 0 1 0 1 \\ 'Hat'\n",
    "# H a t\n",
    "\n",
    "def expand_string(alpha, omega):\n",
    "    assert sum(alpha) == len(omega)\n",
    "    \n",
    "    result = []\n",
    "    count = 0\n",
    "    for a in alpha:        \n",
    "        if a == 1:\n",
    "            result.append(omega[count])\n",
    "            count += 1\n",
    "            \n",
    "        elif a == 0:\n",
    "            result.append(\" \")\n",
    "            \n",
    "        else:\n",
    "            raise ValueError\n",
    "        \n",
    "    result = \"\".join(result)\n",
    "    return result\n",
    "\n",
    "expand_string([1, 0, 1, 0, 1], \"Hat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff61a755",
   "metadata": {},
   "source": [
    "## Backslash Bar (⍀)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "328bf5e4",
   "metadata": {},
   "source": [
    "### Monadic - Scan First"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "4b92e3db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[ 1,  2,  3,  4],\n",
       "        [ 6,  8, 10, 12],\n",
       "        [15, 18, 21, 24]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "#\n",
    "#       +⍀ mat\n",
    "#  1  2  3  4\n",
    "#  6  8 10 12\n",
    "# 15 18 21 24 \n",
    "\n",
    "mat = np.matrix(\"1 2 3 4;5 6 7 8;9 10 11 12\")\n",
    "print(mat)\n",
    "np.cumsum(mat, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fa77129",
   "metadata": {},
   "source": [
    "### Dyadic - Expand First"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "725b27c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4],\n",
       "       [ 0,  0,  0,  0],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 5,  6,  7,  8],\n",
       "       [ 9, 10, 11, 12]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 0 2 1 ⍀ mat\n",
    "# 1  2  3  4\n",
    "# 0  0  0  0\n",
    "# 5  6  7  8\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "def expand_first(alpha, omega):\n",
    "    result = []\n",
    "    omega_split = np.vsplit(omega, len(omega))\n",
    "    o_len = len(np.ravel(omega_split[0]))\n",
    "    zero_row = np.array([0 for i in range(o_len)])\n",
    "    idx = -1\n",
    "    \n",
    "    for a in alpha:\n",
    "        if a:\n",
    "            idx += 1\n",
    "            for i in range(a):\n",
    "                result.append(\n",
    "                    np.ravel(omega_split[idx])\n",
    "                )\n",
    "        else:\n",
    "            result.append(zero_row)\n",
    "    \n",
    "    return np.array(result)\n",
    "\n",
    "expand_first([1, 0, 2, 1], mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b413fbf9",
   "metadata": {},
   "source": [
    "## Down Shoe (∪)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45df24a3",
   "metadata": {},
   "source": [
    "### Monadic - Unique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "748b06d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', '2', 'ab', 'ba'], dtype='<U2')"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ∪ 'ab' 'ba' 'ab' 1 1 2\n",
    "# ┌──┬──┬─┬─┐\n",
    "# │ab│ba│1│2│\n",
    "# └──┴──┴─┴─┘\n",
    "\n",
    "np.unique(['ab', 'ba', 'ab', 1, 1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "2ca9a3d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['flywheel']\n",
      " ['shyster']\n",
      " ['flywheel']]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array(['flywheel', 'shyster'], dtype='<U8')"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# flywheel\n",
    "# shyster \n",
    "# flywheel\n",
    "#      ∪mat\n",
    "# flywheel\n",
    "# shyster \n",
    "\n",
    "mat = np.vstack((\n",
    "          np.array('flywheel'),\n",
    "          np.array('shyster'),\n",
    "          np.array('flywheel')\n",
    "      ))\n",
    "print(mat)\n",
    "np.unique(mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34ed7115",
   "metadata": {},
   "source": [
    "### Dyadic - Union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "6240470c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['a', 'ab', 'cde', 'fg'], dtype='<U3')"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'ab' 'cde' 'fg' ∪ 'a' 'ab'\n",
    "# ┌──┬───┬──┬─┐\n",
    "# │ab│cde│fg│a│\n",
    "# └──┴───┴──┴─┘\n",
    "\n",
    "np.union1d(['ab', 'cde', 'fg'], ['a', 'ab'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d52b2685",
   "metadata": {},
   "source": [
    "## Up Shoe (∩)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a66d639a",
   "metadata": {},
   "source": [
    "### Dyadic - Intersection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "16ade1b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['22', 'ab'], dtype='<U21')"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       22 'ab' 'fg' ∩ 'a' 'ab' 22\n",
    "# ┌──┬──┐\n",
    "# │22│ab│\n",
    "# └──┴──┘\n",
    "\n",
    "np.intersect1d([22, 'ab', 'fg'], ['a', 'ab', 22])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f17f86a",
   "metadata": {},
   "source": [
    "## Left Tack (⊣)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a236fea",
   "metadata": {},
   "source": [
    "### Monadic - Same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "f8bcbd13",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊣  1 2 3\n",
    "# 1 2 3\n",
    "\n",
    "def same(omega):\n",
    "    return omega\n",
    "\n",
    "same(\n",
    "    np.array([1, 2, 3])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8d7ef75",
   "metadata": {},
   "source": [
    "### Dyadic - Left"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "e0587934",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'L'"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'L' ⊣ 'R'\n",
    "# L\n",
    "\n",
    "def left(alpha, omega):\n",
    "    return alpha\n",
    "\n",
    "left('L', 'R')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "f1cc3d97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊣/ 1 2 3\n",
    "# 1\n",
    "\n",
    "[1, 2, 3][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bb6d0fc",
   "metadata": {},
   "source": [
    "## Right Tack (⊢)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40acc170",
   "metadata": {},
   "source": [
    "### Monadic - Same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "8e059798",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊢  1 2 3\n",
    "# 1 2 3\n",
    "\n",
    "same(\n",
    "    np.array([1, 2, 3])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "951d8f69",
   "metadata": {},
   "source": [
    "### Dyadic - Right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "9b37c3f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'R'"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'L' ⊢ 'R'\n",
    "# R\n",
    "\n",
    "def right(alpha, omega):\n",
    "    return omega\n",
    "\n",
    "right('L', 'R')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "4b8beaeb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊢/ 1 2 3\n",
    "# 3\n",
    "\n",
    "[1, 2, 3][-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c3852d7",
   "metadata": {},
   "source": [
    "----------------------\n",
    "## Search and Ordering\n",
    "----------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ee5e301",
   "metadata": {},
   "source": [
    "## Iota (⍳)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45799b5f",
   "metadata": {},
   "source": [
    "### Monadic - Index Generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "5e9a7c4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍳ 10\n",
    "# 1 2 3 4 5 6 7 8 9 10\n",
    "\n",
    "def index(omega):\n",
    "    if isinstance(omega, (int, np.int64)):\n",
    "        return np.arange(omega)\n",
    "\n",
    "    elif isinstance(omega, (list, tuple, np.ndarray)):\n",
    "        # determine how high to count up\n",
    "        omega_count = np.multiply.reduce(omega)\n",
    "        \n",
    "        # get initial list\n",
    "        omega_array = [\n",
    "            encode_mixed_radix(omega, i)\n",
    "            for i in range(omega_count)\n",
    "        ]\n",
    "        \n",
    "        # split by row\n",
    "        last = omega[-1]\n",
    "        omega_array = [omega_array[:last]] + [omega_array[last:]]\n",
    "        \n",
    "        # prepare as array\n",
    "        dtype_ = tuple(int for o in omega)\n",
    "        omega_array = np.array(omega_array, dtype=dtype_)\n",
    "        return omega_array\n",
    "        \n",
    "index(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "8664f830",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 0],\n",
       "        [0, 1],\n",
       "        [0, 2]],\n",
       "\n",
       "       [[1, 0],\n",
       "        [1, 1],\n",
       "        [1, 2]]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍳ 2 3\n",
    "# ┌───┬───┬───┐\n",
    "# │1 1│1 2│1 3│\n",
    "# ├───┼───┼───┤\n",
    "# │2 1│2 2│2 3│\n",
    "# └───┴───┴───┘\n",
    "\n",
    "\n",
    "index([2, 3])  #base 0 numbering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3db6775",
   "metadata": {},
   "source": [
    "### Dyadic - Index Of"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "2c2078ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 10]"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'ABCDABCDEF' ⍳ 'ACF'\n",
    "# 1 3 10\n",
    "\n",
    "def index_of(alpha, omega, base_1 = False):\n",
    "    result = []\n",
    "    \n",
    "    for o in omega:\n",
    "        result.append(alpha.index(o))\n",
    "    \n",
    "    if base_1:\n",
    "        result = [i + 1 for i in result]\n",
    "        \n",
    "    return result\n",
    "\n",
    "index_of('ABCDABCDEF', 'ACF', base_1 = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "id": "b86f7d88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([2])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2\n",
    "# 3 4\n",
    "# 5 6\n",
    "#       mat ⍳ 5 6\n",
    "# 3\n",
    "\n",
    "mat = np.matrix(\"1 2;3 4;5 6\")\n",
    "print(mat)\n",
    "np.where((mat==(5, 6)).all(axis=1))[0]  # displays 2 instead of 3 due to base 0 numbering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c91918c7",
   "metadata": {},
   "source": [
    "## Iota Underbar (⍸)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dda3fc1",
   "metadata": {},
   "source": [
    "### Monadic - Where"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "fa96e3db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 4])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍸ 1 0 0 1 1\n",
    "# 1 4 5\n",
    "\n",
    "\n",
    "def where(omega):\n",
    "    omega_array = np.array(omega)\n",
    "    if omega_array.ndim == 1:\n",
    "        result = [i for i, o in enumerate(omega) if o]\n",
    "        return np.array(result)\n",
    "    else:\n",
    "        omega_ravel = np.ravel(omega)\n",
    "        result = []\n",
    "        for i, o in enumerate(omega_ravel):\n",
    "            if o:\n",
    "                result.append(\n",
    "                    encode_mixed_radix(\n",
    "                        omega.shape, \n",
    "                        i\n",
    "                    )\n",
    "                )\n",
    "        return np.array(result)\n",
    "            \n",
    "where([1, 0, 0, 1, 1])  # base zero numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "ef81de36",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 0]\n",
      " [1 0 1]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [1, 0],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       bmat\n",
    "# 0 1 0\n",
    "# 1 0 1\n",
    "#       ⍸ bmat\n",
    "# ┌───┬───┬───┐\n",
    "# │1 2│2 1│2 3│\n",
    "# └───┴───┴───┘\n",
    "\n",
    "bmat = np.matrix(\"0 1 0;1 0 1\")\n",
    "print(bmat)\n",
    "where(bmat)  # base zero numbering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ab57da",
   "metadata": {},
   "source": [
    "### Dyadic - Interval Index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "c047e061",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 5, 1, 3, 4, 2])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'AEIOU' ⍸ 'DYALOG'\n",
    "# 1 5 1 3 4 2\n",
    "\n",
    "\n",
    "import bisect\n",
    "\n",
    "def create_index_dict(text):\n",
    "    letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "    letters = letters + letters.lower()\n",
    "    prev = 0\n",
    "    numbers = []\n",
    "    for letter in letters:\n",
    "        if letter in text:\n",
    "            prev += 1\n",
    "        numbers.append(prev)\n",
    "    return {k: v for k, v in zip(letters, numbers)}\n",
    "\n",
    "\n",
    "def interval_index(alpha, omega):\n",
    "    alpha_ravel = np.ravel(alpha)\n",
    "    if list(alpha_ravel) != sorted(alpha_ravel):\n",
    "        print(f\"{alpha} != {sorted(alpha)}\")\n",
    "        raise ValueError(\"DOMAIN ERROR: Left argument must be sorted ascending\")\n",
    "    \n",
    "    elif isinstance(alpha, str):\n",
    "        idx_dict = create_index_dict(alpha)\n",
    "        return np.array(\n",
    "            [idx_dict[o] for o in omega]\n",
    "        )\n",
    "    \n",
    "    else:\n",
    "        alpha = np.array(alpha)\n",
    "        if alpha.ndim == 2:\n",
    "            #split out columns\n",
    "            col_count = len(alpha.T)\n",
    "            cols = [alpha[:,c] for c in range(col_count)]\n",
    "            \n",
    "            # bisect each\n",
    "            indexes = [\n",
    "                        bisect.bisect(col, omega[i])\n",
    "                        for i, col in enumerate(cols)\n",
    "                      ]\n",
    "            \n",
    "            # favor the leftmost column\n",
    "            first_idx = indexes[0]\n",
    "            rest_indexes = indexes[1:]\n",
    "            if first_idx - 2 >= min(rest_indexes):\n",
    "                if cols[0][first_idx-1] < omega[0]:\n",
    "                    return first_idx\n",
    "                else:\n",
    "                    return first_idx - 1\n",
    "            else:\n",
    "                return min(indexes)\n",
    "            \n",
    "        elif alpha.ndim == 1:\n",
    "            return np.array(\n",
    "                [\n",
    "                    bisect.bisect(alpha, o) \n",
    "                    for o in omega\n",
    "                ]\n",
    "            )\n",
    "\n",
    "interval_index('AEIOU', 'DYALOG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "65dd4b56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 1, 2, 2, 3, 3])"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 4 6 ⍸ 1 2 3 4 5 6 7\n",
    "# 0 1 1 2 2 3 3\n",
    "\n",
    "interval_index([2, 4, 6], [1, 2, 3, 4, 5, 6, 7])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "556170a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2\n",
    "# 3 4\n",
    "# 5 6\n",
    "#       mat ⍸ 3 3\n",
    "# 1\n",
    "\n",
    "mat = np.matrix(\"1 2;3 4;5 6\")\n",
    "print(mat)\n",
    "\n",
    "interval_index(mat, [3, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "c1806930",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat ⍸ 3 5\n",
    "# 2\n",
    "\n",
    "interval_index(mat, [3, 5]) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9730226",
   "metadata": {},
   "source": [
    "## Epsilon Underbar (⍷)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45d5d896",
   "metadata": {},
   "source": [
    "### Dyadic - Find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "3576117a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 0, 1, 0, 0]"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'ana' ⍷ 'Banana'\n",
    "# 0 1 0 1 0 0\n",
    "\n",
    "def find(alpha, omega):\n",
    "    result = []\n",
    "    len_alpha = len(alpha)\n",
    "    for i in range(len(omega)):\n",
    "        try:\n",
    "            if omega[i:i + len_alpha] == alpha:\n",
    "                result.append(1)\n",
    "            else:\n",
    "                result.append(0)\n",
    "        except:\n",
    "            result.append(0)\n",
    "    return result\n",
    "\n",
    "find('ana', 'Banana')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "6be2c0a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[matrix([[0, 1],\n",
      "        [1, 0]])\n",
      " matrix([[0, 1, 0, 0],\n",
      "        [1, 0, 0, 1],\n",
      "        [0, 0, 1, 0],\n",
      "        [0, 1, 0, 0]])]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0],\n",
       "       [0, 0, 1, 0],\n",
       "       [0, 1, 0, 0],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       X Y\n",
    "# ┌───┬───────┐\n",
    "# │0 1│0 1 0 0│\n",
    "# │1 0│1 0 0 1│\n",
    "# │   │0 0 1 0│\n",
    "# │   │0 1 0 0│\n",
    "# └───┴───────┘\n",
    "\n",
    "#       X ⍷ Y\n",
    "# 1 0 0 0\n",
    "# 0 0 1 0\n",
    "# 0 1 0 0\n",
    "# 0 0 0 0\n",
    "\n",
    "\n",
    "from skimage.util import view_as_windows\n",
    "\n",
    "\n",
    "def extract(array):\n",
    "    result = []\n",
    "    for a in array:\n",
    "        result.extend((*a,))\n",
    "    return result\n",
    "\n",
    "\n",
    "def remove_padding(array, padding):\n",
    "    result = list(array.shape)\n",
    "    \n",
    "    if array.ndim >= 1:\n",
    "        result[-1] = array.shape[-1] - padding[-1]\n",
    "        \n",
    "        if array.ndim >= 2:\n",
    "            result[-2] = array.shape[-2] - padding[-2]\n",
    "    \n",
    "    return result\n",
    "\n",
    "\n",
    "def find_array(alpha, omega):\n",
    "    # break out to the correct rank\n",
    "    ranked_omega = rank(alpha.ndim, omega)\n",
    "    \n",
    "    # split into windows of the same shape as we're looking for\n",
    "    windows = [view_as_windows(ro, alpha.shape) for ro in ranked_omega]\n",
    "    \n",
    "    # extract the windows to the same depth of nesting\n",
    "    for i in range(alpha.ndim):\n",
    "        windows = extract(windows)\n",
    "    \n",
    "    # determine how much padding will be needed on the rows and columns\n",
    "    padding = np.array(np.array(alpha).shape) - 1\n",
    "    \n",
    "    # Calculate every window that matches alpha\n",
    "    result = np.array(\n",
    "        [\n",
    "            np.all(window==alpha) \n",
    "            for window in windows\n",
    "        ]\n",
    "    )\n",
    "    \n",
    "    # remove padding from the initial shape\n",
    "    new_shape = remove_padding(omega, padding)\n",
    "    result = result.reshape(new_shape).astype(int)\n",
    "    \n",
    "    # add padding back on\n",
    "    result = np.pad(\n",
    "        result, \n",
    "        (\n",
    "            (0, padding[-2]), \n",
    "            (0, padding[-1])\n",
    "        ), \n",
    "        'constant',\n",
    "        constant_values=0\n",
    "    )\n",
    "    return result\n",
    "\n",
    "X = np.matrix(\"0 1;1 0\")\n",
    "Y = np.matrix(\"0 1 0 0;1 0 0 1;0 0 1 0;0 1 0 0\")\n",
    "print(np.array([X, Y], dtype=object))\n",
    "find_array(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cc6c23",
   "metadata": {},
   "source": [
    "### Dyadic - Find"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "968b7197",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 0, 1, 0, 0]"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'ana' ⍷ 'Banana'\n",
    "# 0 1 0 1 0 0\n",
    "\n",
    "def find(alpha, omega):\n",
    "    result = []\n",
    "    len_alpha = len(alpha)\n",
    "    for i in range(len(omega)):\n",
    "        try:\n",
    "            if omega[i:i + len_alpha] == alpha:\n",
    "                result.append(1)\n",
    "            else:\n",
    "                result.append(0)\n",
    "        except:\n",
    "            result.append(0)\n",
    "    return result\n",
    "\n",
    "find('ana', 'Banana')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "id": "166f4b14",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[matrix([[0, 1],\n",
      "        [1, 0]])\n",
      " matrix([[0, 1, 0, 0],\n",
      "        [1, 0, 0, 1],\n",
      "        [0, 0, 1, 0],\n",
      "        [0, 1, 0, 0]])]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 0, 0],\n",
       "       [0, 0, 1, 0],\n",
       "       [0, 1, 0, 0],\n",
       "       [0, 0, 0, 0]])"
      ]
     },
     "execution_count": 187,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       X Y\n",
    "# ┌───┬───────┐\n",
    "# │0 1│0 1 0 0│\n",
    "# │1 0│1 0 0 1│\n",
    "# │   │0 0 1 0│\n",
    "# │   │0 1 0 0│\n",
    "# └───┴───────┘\n",
    "\n",
    "#       X ⍷ Y\n",
    "# 1 0 0 0\n",
    "# 0 0 1 0\n",
    "# 0 1 0 0\n",
    "# 0 0 0 0\n",
    "\n",
    "\n",
    "from skimage.util import view_as_windows\n",
    "\n",
    "\n",
    "def extract(array):\n",
    "    result = []\n",
    "    for a in array:\n",
    "        result.extend((*a,))\n",
    "    return result\n",
    "\n",
    "\n",
    "def remove_padding(array, padding):\n",
    "    result = list(array.shape)\n",
    "    \n",
    "    if array.ndim >= 1:\n",
    "        result[-1] = array.shape[-1] - padding[-1]\n",
    "        \n",
    "        if array.ndim >= 2:\n",
    "            result[-2] = array.shape[-2] - padding[-2]\n",
    "    \n",
    "    return result\n",
    "\n",
    "\n",
    "def find_array(alpha, omega):\n",
    "    # break out to the correct rank\n",
    "    ranked_omega = rank(alpha.ndim, omega)\n",
    "    \n",
    "    # split into windows of the same shape as we're looking for\n",
    "    windows = [view_as_windows(ro, alpha.shape) for ro in ranked_omega]\n",
    "    \n",
    "    # extract the windows to the same depth of nesting\n",
    "    for i in range(alpha.ndim):\n",
    "        windows = extract(windows)\n",
    "    \n",
    "    # determine how much padding will be needed on the rows and columns\n",
    "    padding = np.array(np.array(alpha).shape) - 1\n",
    "    \n",
    "    # Calculate every window that matches alpha\n",
    "    result = np.array(\n",
    "        [\n",
    "            np.all(window==alpha) \n",
    "            for window in windows\n",
    "        ]\n",
    "    )\n",
    "    \n",
    "    # remove padding from the initial shape\n",
    "    new_shape = remove_padding(omega, padding)\n",
    "    result = result.reshape(new_shape).astype(int)\n",
    "    \n",
    "    # add padding back on\n",
    "    result = np.pad(\n",
    "        result, \n",
    "        (\n",
    "            (0, padding[-2]), \n",
    "            (0, padding[-1])\n",
    "        ), \n",
    "        'constant',\n",
    "        constant_values=0\n",
    "    )\n",
    "    return result\n",
    "\n",
    "X = np.matrix(\"0 1;1 0\")\n",
    "Y = np.matrix(\"0 1 0 0;1 0 0 1;0 0 1 0;0 1 0 0\")\n",
    "print(np.array([X, Y], dtype=object))\n",
    "find_array(X, Y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e61e9583",
   "metadata": {},
   "source": [
    "## Grade Up (⍋)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5b49842",
   "metadata": {},
   "source": [
    "### Monadic - Grade Up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "e9bb3e86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 0, 2, 3]"
      ]
     },
     "execution_count": 188,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indices which would select items in ascending order.\n",
    "#\n",
    "#       ⍋ 33 11 44 66 22\n",
    "# 2 5 1 3 4\n",
    "\n",
    "def monadic_grade_up(omega):\n",
    "    result = []\n",
    "    sorted_omega = sorted(omega)\n",
    "    prev = []\n",
    "    for val in sorted_omega:\n",
    "        i = omega.index(val)\n",
    "        while i in prev:\n",
    "            i = omega.index(val, i + 1)\n",
    "        result.append(i)\n",
    "        prev.append(i)\n",
    "\n",
    "    return result\n",
    "\n",
    "monadic_grade_up([33, 11, 44, 66, 22])  # base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "id": "bf8fad2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Sue', 'Sam', 'Joe'], dtype='<U3')"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       names←'Joe' 'Sue' 'Sam'\n",
    "#       ages←34 22 25\n",
    "#\n",
    "#       names[⍋ages]\n",
    "# ┌───┬───┬───┐\n",
    "# │Sue│Sam│Joe│\n",
    "# └───┴───┴───┘\n",
    "\n",
    "def dict_grade_up(keys, values):\n",
    "    temp_dict = {k:v for k, v in zip(keys, values)}\n",
    "    temp_list = sorted(temp_dict.items(), key=lambda x:x[1])\n",
    "    return np.array(\n",
    "        [pair[0] for pair in temp_list]\n",
    "    )\n",
    "\n",
    "names = np.array(['Joe', 'Sue', 'Sam'])\n",
    "ages = np.array([34, 22, 25])\n",
    "dict_grade_up(names, ages)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "251fc55f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 1, 3, 4, 0]"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍋ 'ABC' ⎕NULL ⍬ ¯3j4 'A'\n",
    "# 3 2 4 5 1\n",
    "\n",
    "def ordering(val):\n",
    "    if not np.size([val]):\n",
    "        return 1\n",
    "    elif val == None:\n",
    "        return 2\n",
    "    elif isinstance(val, complex):\n",
    "        return 3\n",
    "    else:\n",
    "        return 4 * len(val)\n",
    "    \n",
    "def grade_up_order(omega):\n",
    "    return monadic_grade_up(\n",
    "        [\n",
    "            ordering(i)\n",
    "            for i in omega\n",
    "        ]\n",
    "    )\n",
    "\n",
    "# base 0 numbering\n",
    "grade_up_order(\n",
    "    ['ABC', None, np.array([]), complex(-3, 4), 'A']\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f3e2a05",
   "metadata": {},
   "source": [
    "### Dyadic - Dyadic Grade Up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "9052fb5a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3, 5, 2, 4]"
      ]
     },
     "execution_count": 191,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Provide collating sequence for character data.\n",
    "#\n",
    "#       ⍋ 'Banana'\n",
    "# 1 2 4 6 3 5\n",
    "\n",
    "monadic_grade_up(\"Banana\")  # Base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "d11af4ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 2, 4, 0]"
      ]
     },
     "execution_count": 192,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'an' ⍋ 'Banana'\n",
    "# 2 4 6 3 5 1\n",
    "\n",
    "def dyadic_grade_up(alpha, omega):\n",
    "    result = []\n",
    "    for a in alpha:\n",
    "        last_idx = -1\n",
    "        for i in range(omega.count(a)):\n",
    "            try:\n",
    "                last_idx = omega.index(a, last_idx + 1)\n",
    "            except:\n",
    "                break\n",
    "            result.append(last_idx)\n",
    "\n",
    "    sorted_omega = sorted(omega)\n",
    "    prev = []\n",
    "    for val in sorted_omega:\n",
    "        if val in alpha:\n",
    "            continue\n",
    "        i = omega.index(val)\n",
    "        while i in prev:\n",
    "            i = omega.index(val, i+1)\n",
    "        result.append(i)\n",
    "        prev.append(i)\n",
    "\n",
    "    return result\n",
    "\n",
    "dyadic_grade_up(\"an\", \"Banana\")  # Base 0 numbering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b75c2136",
   "metadata": {},
   "source": [
    "## Grade Down (⍒)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5533b09",
   "metadata": {},
   "source": [
    "### Monadic - Grade Down"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "6dcd1931",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 2, 0, 4, 1])"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Indices which would select items in descending order.\n",
    "#\n",
    "#       ⍒ 33 11 44 66 22\n",
    "# 4 3 1 5 2\n",
    "\n",
    "def monadic_grade_down(omega):\n",
    "    grade_up = monadic_grade_up(omega[::-1])\n",
    "    last_index = len(omega) - 1 \n",
    "    return np.array(\n",
    "        [last_index - g for g in reversed(grade_up)]\n",
    "    )\n",
    "\n",
    "monadic_grade_down([33, 11, 44, 66, 22])  # base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "bd9635cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Joe', 'Sam', 'Sue'], dtype='<U3')"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       names←'Joe' 'Sue' 'Sam'\n",
    "#       ages←34 22 25\n",
    "#\n",
    "#       names[⍒ages]\n",
    "# ┌───┬───┬───┐\n",
    "# │Joe│Sam│Sue│\n",
    "# └───┴───┴───┘\n",
    "\n",
    "def dict_grade_down(keys, values):\n",
    "    return np.array(\n",
    "        [\n",
    "            i for i \n",
    "            in reversed(dict_grade_up(keys, values))\n",
    "        ]\n",
    "    )\n",
    "\n",
    "names = np.array(['Joe', 'Sue', 'Sam'])\n",
    "ages = np.array([34, 22, 25])\n",
    "dict_grade_down(names, ages)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4f790d2",
   "metadata": {},
   "source": [
    "### Dyadic - Dyadic Grade Down"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "id": "413fc1c7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 1, 3, 5, 0])"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Provide collating sequence for character data.\n",
    "\n",
    "#       ⍒ 'Banana'\n",
    "# 3 5 2 4 6 1\n",
    "\n",
    "monadic_grade_down(\"Banana\")  # Base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "8bc93476",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 1, 3, 5]"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'an' ⍒ 'Banana'\n",
    "# 1 3 5 2 4 6\n",
    "\n",
    "def dyadic_grade_down(alpha, omega):\n",
    "    return dyadic_grade_up(alpha, omega[::-1])\n",
    "\n",
    "dyadic_grade_down(\"an\", \"Banana\")  # Base 0 numbering"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7c538ab",
   "metadata": {},
   "source": [
    "-----------------------------------\n",
    "## Operators\n",
    "-----------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "705e03b0",
   "metadata": {},
   "source": [
    "## Diaeresis (¨)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6697147",
   "metadata": {},
   "source": [
    "### Monadic - Each (Map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "5869fe9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['1', '2', '3', 'A', '9'], dtype='<U21')"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⊃¨ 1 2 3 'ABC' (9 8 7)\n",
    "# 1 2 3 A 9\n",
    "\n",
    "result = []\n",
    "for item in [\n",
    "    i[0] for i in \n",
    "    [[[1, 2, 3]], \"ABC\", (9, 8, 7)]\n",
    "]:\n",
    "    try:\n",
    "        result.extend(item)\n",
    "    except TypeError:\n",
    "        result.append(item)\n",
    "        \n",
    "np.array(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "6a2d087d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 18]"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +/¨ (1 2 3 4)(5 6 7)\n",
    "# 10 18\n",
    "\n",
    "[\n",
    "    sum(arr) \n",
    "    for arr in \n",
    "    (np.array([1, 2, 3, 4]), np.array([5, 6, 7]))\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "id": "f4cc6231",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0], [2, 0, 0], [3, 4, 0], 'V  ']"
      ]
     },
     "execution_count": 199,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 ↑¨ 1 2 (3 4) 'V'\n",
    "# ┌─────┬─────┬─────┬───┐\n",
    "# │1 0 0│2 0 0│3 4 0│V  │\n",
    "# └─────┴─────┴─────┴───┘\n",
    "\n",
    "[\n",
    "    take(3, arr)\n",
    "    for arr in \n",
    "    np.array([\n",
    "            1, \n",
    "            2,\n",
    "            (3, 4),\n",
    "            \"V\"        \n",
    "        ],\n",
    "        dtype=object\n",
    "    )\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "f27f60aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 99), (2, 99), (3, 99)]"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 2 3 ,¨ 99\n",
    "# ┌────┬────┬────┐\n",
    "# │1 99│2 99│3 99│\n",
    "# └────┴────┴────┘\n",
    "\n",
    "[\n",
    "    catenate(val, 99)\n",
    "    for val in\n",
    "    np.array([\n",
    "        1,\n",
    "        2,\n",
    "        3\n",
    "    ])\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3207932b",
   "metadata": {},
   "source": [
    "## Tilde Diaeresis (⍨)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeb52c52",
   "metadata": {},
   "source": [
    "### Monadic - After a function  = Commute (Switch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "3b4206c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3])"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ⍴ 3     ⍝ ⍺ ⍴ ⍵\n",
    "# 3 3\n",
    "\n",
    "np.resize([3], [2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "7ba62264",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 2])"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 ⍴⍨ 3    ⍝ ⍵ ⍴ ⍺\n",
    "# 2 2 2\n",
    "\n",
    "def switch(func, alpha, omega):\n",
    "    if alpha is None:\n",
    "        alpha = omega\n",
    "    return func(omega, alpha)\n",
    "\n",
    "switch(np.resize, [3], [2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "bde0289e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 3, 3])"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍴⍨ 3      ⍝ ⍵ ⍴ ⍵\n",
    "# 3 3 3\n",
    "\n",
    "switch(np.resize, None, [3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e505d8b0",
   "metadata": {},
   "source": [
    "### Monadic - After some data = Constant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "a887c6fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mu'"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'mu'⍨ 'any' ⎕NULL   ⍝ Always returns its operand\n",
    "# mu\n",
    "\n",
    "def constant(const, array):\n",
    "    if np.array(array).ndim > 1:\n",
    "        return np.full(\n",
    "            shape = np.array(array).shape,\n",
    "            fill_value = const\n",
    "        )\n",
    "    else:\n",
    "        return const\n",
    "\n",
    "constant(\n",
    "    'mu', \n",
    "    ['any', None]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "d6a36f26",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mu'"
      ]
     },
     "execution_count": 205,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1E100 ('mu'⍨) 1j1\n",
    "# mu\n",
    "\n",
    "constant(\n",
    "    'mu', \n",
    "    [1E100, 'mu', complex(1, 1)]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "id": "4d02a804",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-1, -1],\n",
       "        [-1, -1],\n",
       "        [-1, -1]],\n",
       "\n",
       "       [[-1, -1],\n",
       "        [-1, -1],\n",
       "        [-1, -1]]])"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯1⍨¨ ⍳2 3\n",
    "# ¯1 ¯1 ¯1\n",
    "# ¯1 ¯1 ¯1\n",
    "\n",
    "constant(\n",
    "    -1, \n",
    "    index([2, 3])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3b738c1",
   "metadata": {},
   "source": [
    "## Star Diaeresis (⍣)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f50c2fd",
   "metadata": {},
   "source": [
    "### Dyadic - Power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "id": "6a7dd6f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[['A' 'B']\n",
      "  ['C' 'D']]\n",
      "\n",
      " [['E' 'F']\n",
      "  ['G' 'H']]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[array([[['A', 'B'],\n",
       "         ['C', 'D']],\n",
       " \n",
       "        [['E', 'F'],\n",
       "         ['G', 'H']]], dtype='<U1')]"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cube    ⍝ 3D array\n",
    "# AB\n",
    "# CD\n",
    "\n",
    "# EF\n",
    "# GH\n",
    "#       (↓⍣1) cube   ⍝ split once\n",
    "# ┌──┬──┐\n",
    "# │AB│CD│\n",
    "# ├──┼──┤\n",
    "# │EF│GH│\n",
    "# └──┴──┘\n",
    "\n",
    "cube = np.array(list('ABCDEFGH')).reshape((2, 2, 2))\n",
    "print(cube)\n",
    "np.array_split(cube, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "4188e9b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[['A', 'B'],\n",
       "         ['C', 'D']]], dtype='<U1'),\n",
       " array([[['E', 'F'],\n",
       "         ['G', 'H']]], dtype='<U1')]"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       (↓⍣2) cube   ⍝ split twice\n",
    "# ┌───────┬───────┐\n",
    "# │┌──┬──┐│┌──┬──┐│\n",
    "# ││AB│CD│││EF│GH││\n",
    "# │└──┴──┘│└──┴──┘│\n",
    "# └───────┴───────┘\n",
    "\n",
    "np.array_split(cube, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "26e093f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-459.40000000000003, -40.0, 32.0, 212.0]"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       f ← (32∘+)∘(×∘1.8)   ⍝ Fahrenheit from Celsius\n",
    "\n",
    "#       f ¯273 ¯40 0 100     ⍝ Fahrenheit\n",
    "# ¯459.4 ¯40 32 212\n",
    "\n",
    "def fahrenheit_from_celsius(c):\n",
    "    return c * 1.8 + 32\n",
    "\n",
    "[\n",
    "    fahrenheit_from_celsius(c) \n",
    "    for c in [-273, -40, 0, 100]\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "c6109b4c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-273.,  -40.,    0.,  100.])"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       c ← f⍣¯1             ⍝ Inverse: Celsius from Fahrenheit\n",
    "\n",
    "#       c ¯459.4 ¯40 32 212  ⍝ Celsius\n",
    "# ¯273 ¯40 0 100\n",
    "\n",
    "from pynverse import inversefunc\n",
    "\n",
    "inversefunc(fahrenheit_from_celsius, y_values=[-459.4, -40.0, 32.0, 212.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "473c9384",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.618033988749895"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       1 +∘÷⍣= 1            ⍝ fixpoint: golden mean\n",
    "# 1.61803\n",
    "\n",
    "(1 + 5 ** 0.5) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cfac91",
   "metadata": {},
   "source": [
    "## Dot (.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "195cf0fd",
   "metadata": {},
   "source": [
    "### Dyadic - Product"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "5773610d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inner Product f.g      \n",
    "\n",
    "#       1 2 3 +.× 4 5 6\n",
    "# 32\n",
    "\n",
    "np.dot(\n",
    "    [1, 2, 3], [4, 5, 6]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "75f0f62e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 ∧.= 3 3 3 3\n",
    "# 1\n",
    "\n",
    "int(all(\n",
    "    3 == o\n",
    "    for o in [3, 3, 3, 3]\n",
    "))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "83822460",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "matrix([[ 7, 10],\n",
       "        [15, 22]])"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "# 1 2\n",
    "# 3 4\n",
    "#       mat +.× mat   ⍝ matrix product\n",
    "#  7 10\n",
    "# 15 22\n",
    "\n",
    "mat = np.matrix(\"1 2;3 4\")\n",
    "print(mat)\n",
    "np.dot(mat, mat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "98f3b50f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4,  5,  6,  7],\n",
       "       [ 8, 10, 12, 14],\n",
       "       [12, 15, 18, 21]])"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Outer Product ∘.g\n",
    "\n",
    "#       1 2 3 ∘.× 4 5 6 7\n",
    "#  4  5  6  7\n",
    "#  8 10 12 14\n",
    "# 12 15 18 21\n",
    "\n",
    "np.outer(\n",
    "    [1, 2, 3], [4, 5, 6, 7]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6d3986e",
   "metadata": {},
   "source": [
    "## Jot (∘)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82ee34a2",
   "metadata": {},
   "source": [
    "### Dyadic - Beside and Bind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "f1375559",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([2, 1, 0]), array([3, 2, 1, 0]), array([4, 3, 2, 1, 0])]"
      ]
     },
     "execution_count": 216,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NB: ∘ is also used in outer product ∘.f - see Dot (.)\n",
    "\n",
    "# Beside\n",
    "\n",
    "#       ⌽∘⍳¨ 3 4 5\n",
    "# ┌─────┬───────┬─────────┐\n",
    "# │3 2 1│4 3 2 1│5 4 3 2 1│\n",
    "# └─────┴───────┴─────────┘\n",
    "\n",
    "[np.flip(index(i)) for i in [3, 4, 5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "7b203347",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([2, 0, 1]), array([3, 0, 1, 2]), array([4, 0, 1, 2, 3])]"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ¯1 ⌽∘⍳¨ 3 4 5\n",
    "# ┌─────┬───────┬─────────┐\n",
    "# │3 1 2│4 1 2 3│5 1 2 3 4│\n",
    "# └─────┴───────┴─────────┘\n",
    "\n",
    "[rotate(-1, index(i)) for i in [3, 4, 5]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "90bd7448",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1.61803398874989$"
      ],
      "text/plain": [
       "1.61803398874989"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       +∘÷/ 40⍴1    ⍝ continued fraction\n",
    "# 1.61803\n",
    "\n",
    "from sympy.ntheory.continued_fraction import continued_fraction_reduce\n",
    "from sympy import Float\n",
    "\n",
    "Float(continued_fraction_reduce(40 * [1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e2888ba",
   "metadata": {},
   "source": [
    "## Quad Equal (⌸)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b44ea2c",
   "metadata": {},
   "source": [
    "### Monadic - Key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "36b6c490",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', list([3])],\n",
       "       ['a', list([1, 1, 9])],\n",
       "       ['n', list([4, 5])]], dtype=object)"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Banana' {⍺ ⍵}⌸ 3 1 4 1 5 9\n",
    "# ┌─┬─────┐\n",
    "# │B│3    │\n",
    "# ├─┼─────┤\n",
    "# │a│1 1 9│\n",
    "# ├─┼─────┤\n",
    "# │n│4 5  │\n",
    "# └─┴─────┘\n",
    "\n",
    "from collections import defaultdict\n",
    "\n",
    "def key(alpha=None, omega=None, reduce_fx=None):\n",
    "    assert omega is not None\n",
    "    if alpha is None:\n",
    "        alpha = omega\n",
    "        omega = range(1, len(omega) + 1)\n",
    "    assert len(alpha) == len(omega)\n",
    "    \n",
    "    items = [i for i in zip(alpha, omega)]\n",
    "    result = defaultdict(list)\n",
    "    \n",
    "    for i in items:\n",
    "        a = i[0]\n",
    "        o = i[1]\n",
    "        result[a].append(o)\n",
    "    \n",
    "    if reduce_fx is not None:\n",
    "        for k, v in result.items():\n",
    "            result[k] = reduce_fx(v)\n",
    "            \n",
    "    return np.array(\n",
    "        list(result.items()), dtype=object\n",
    "    )\n",
    "\n",
    "key(\"Banana\", [3, 1, 4, 1, 5, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "efeabf9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', 3],\n",
       "       ['a', 11],\n",
       "       ['n', 9]], dtype=object)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Banana' {⍺,+/⍵}⌸ 3 1 4 1 5 9\n",
    "# B  3\n",
    "# a 11\n",
    "# n  9 \n",
    "\n",
    "key(\"Banana\", [3, 1, 4, 1, 5, 9], sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "006cd4b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', list([1])],\n",
       "       ['a', list([2, 4, 6])],\n",
       "       ['n', list([3, 5])]], dtype=object)"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Banana' {⍺ ⍵}⌸ 1 2 3 4 5 6\n",
    "# ┌─┬─────┐\n",
    "# │B│1    │\n",
    "# ├─┼─────┤\n",
    "# │a│2 4 6│\n",
    "# ├─┼─────┤\n",
    "# │n│3 5  │\n",
    "# └─┴─────┘\n",
    "\n",
    "key(\"Banana\", [1, 2, 3, 4, 5, 6])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "id": "ed5497b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['B', list([1])],\n",
       "       ['a', list([2, 4, 6])],\n",
       "       ['n', list([3, 5])]], dtype=object)"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       {⍺ ⍵}⌸ 'Banana'  ⍝ (same as above)\n",
    "# ┌─┬─────┐\n",
    "# │B│1    │\n",
    "# ├─┼─────┤\n",
    "# │a│2 4 6│\n",
    "# ├─┼─────┤\n",
    "# │n│3 5  │\n",
    "# └─┴─────┘\n",
    "\n",
    "key(None, \"Banana\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "423cf773",
   "metadata": {},
   "source": [
    "## Jot Diaeresis (⍤)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d793ef5",
   "metadata": {},
   "source": [
    "### Dyadic - (f⍤g): Atop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "d44c292a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.25"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       -⍤÷ 4      ⍝ (  f⍤g y) ≡  f   g y\n",
    "# ¯0.25\n",
    "\n",
    "def atop(alpha_operand, alpha_operation, omega_operation, omega_operand):\n",
    "    if alpha_operand is None:\n",
    "        alpha_operand = 1\n",
    "    \n",
    "    return alpha_operation(\n",
    "        omega_operation(\n",
    "            alpha_operand, \n",
    "            omega_operand\n",
    "        )\n",
    "    )\n",
    "\n",
    "atop(\n",
    "    None, np.negative, np.divide, 4\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "15d213a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.0"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       12 -⍤÷ 4   ⍝ (x f⍤g y) ≡ (f x g y)\n",
    "# ¯3\n",
    "\n",
    "atop(12, np.negative, np.divide, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "9fddef15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 1, 0, 1]"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 1 4 1 5 ~⍤∊ 1 2 3\n",
    "# 0 0 1 0 1\n",
    "\n",
    "atop([3, 1, 4, 1, 5], logic_not, membership, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1145073c",
   "metadata": {},
   "source": [
    "### Dyadic - (f⍤a):   Rank "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "77ea3c73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 1  2  3]\n",
      "  [ 4  5  6]]\n",
      "\n",
      " [[ 7  8  9]\n",
      "  [10 11 12]]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5,  6],\n",
       "       [ 7,  8,  9, 10, 11, 12]])"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cube    ⍝ 3D array\n",
    "#  1  2  3\n",
    "#  4  5  6\n",
    "\n",
    "#  7  8  9\n",
    "# 10 11 12\n",
    "\n",
    "#       (,⍤2) cube\n",
    "# 1 2 3  4  5  6\n",
    "# 7 8 9 10 11 12\n",
    "\n",
    "\n",
    "# defined in the \"General Functions\" at the top of this page and it is\n",
    "# defined here again for the purposes of keeping it close to the APL examples\n",
    "# that test it\n",
    "def rank(dim_idx, arr):\n",
    "    # if you ask for a rank higher than exists in this array\n",
    "    # just return the original array \n",
    "    # enclosed in a list for consistency\n",
    "    if dim_idx > arr.ndim - 1:\n",
    "        return list(enclose(arr))\n",
    "    \n",
    "    # reverse order to work with python indexing more easily\n",
    "    shape = list(reversed(arr.shape))\n",
    "    slices = shape[dim_idx:]\n",
    "    \n",
    "    # split into sub-arrays\n",
    "    get_splits = lambda arr, count: np.split(np.ravel(arr), count)\n",
    "    slice_count = np.multiply.reduce(slices)\n",
    "    splits = get_splits(arr, slice_count)\n",
    "    \n",
    "    # need to reshape arrays if looking for rank > 1\n",
    "    if dim_idx > 1:\n",
    "        shape.pop(dim_idx)\n",
    "        new_shape = list(reversed(shape))\n",
    "        splits = [\n",
    "            s.reshape(new_shape) \n",
    "            for s in splits\n",
    "        ]\n",
    "        \n",
    "    return splits\n",
    "\n",
    "cube = np.arange(1, 13).reshape((2, 2, 3))\n",
    "print(cube)   \n",
    "\n",
    "np.array([np.ravel(arr) for arr in rank(2, cube)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "74155fe8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 0]])"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       cmat    ⍝ character matrix\n",
    "# abc\n",
    "# zxy \n",
    "#\n",
    "#       (⍋⍤1) cmat    ⍝ grade-up by row  \n",
    "# 1 2 3 \n",
    "# 2 3 1\n",
    "\n",
    "cmat = np.array([list(\"abc\"), list(\"zxy\")])\n",
    "cmat\n",
    "\n",
    "# defined in the \"General Functions\" at the top of this page\n",
    "np.array([monadic_grade_up(list(arr)) for arr in rank(1, cmat)])  # base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "id": "6e90e63f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[11, 12, 13, 14],\n",
       "       [25, 26, 27, 28],\n",
       "       [39, 40, 41, 42]])"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       nmat     ⍝ numeric matrix\n",
    "# 1  2  3  4\n",
    "# 5  6  7  8\n",
    "# 9 10 11 12\n",
    "\n",
    "#       10 20 30 (+⍤0 1) nmat  ⍝ scalars plus vectors\n",
    "# 11 12 13 14 \n",
    "# 25 26 27 28 \n",
    "# 39 40 41 42\n",
    "\n",
    "nmat = np.arange(1, 13).reshape((3, 4))\n",
    "print(nmat)\n",
    "\n",
    "# defined in the \"General Functions\" at the top of this page\n",
    "alpha_ = rank(0, np.array([10, 20, 30]))\n",
    "omega_ = rank(1, nmat)\n",
    "np.array([a_ + o_ for a_, o_ in zip(alpha_, omega_)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eea883cf",
   "metadata": {},
   "source": [
    "## Circle Dieresis (⍥)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4c49250",
   "metadata": {},
   "source": [
    "### Dyadic - Over"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "cd32bc24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3.0"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       -⍥⌊ 3.6                 ⍝ Same as ∘ or ⍤ monadically\n",
    "# ¯3\n",
    "\n",
    "def over(alpha_operand, alpha_operation, omega_operation, omega_operand):\n",
    "    if alpha_operand is None:\n",
    "        omega = np.array(omega_operation(omega_operand))\n",
    "        return alpha_operation(omega)\n",
    "        \n",
    "    else:\n",
    "        alpha = np.array(omega_operation(alpha_operand))\n",
    "        omega = np.array(omega_operation(omega_operand))\n",
    "        \n",
    "        return alpha_operation(alpha, omega)\n",
    "\n",
    "over(None, np.negative, np.floor, 3.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "id": "dd737fb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       5.1 -⍥⌊ 3.6             ⍝ Applies ⌊ to both arguments\n",
    "# 2\n",
    "\n",
    "over(5.1, np.subtract, np.floor, 3.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "57cc5840",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Dyalog' ≡⍥⎕C 'DYALOG'  ⍝ Case-insensitive match\n",
    "# 1\n",
    "\n",
    "def case_insensitive_match(alpha, omega):\n",
    "    return int(\n",
    "        alpha.lower() == omega.lower()\n",
    "    )\n",
    "\n",
    "case_insensitive_match('Dyalog', 'DYALOG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "id": "ffe3731f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 232,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       'Dyalog' ≡⍥⎕C 'IBM'\n",
    "# 0\n",
    "\n",
    "case_insensitive_match('Dyalog', 'IBM')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7070b47d",
   "metadata": {},
   "source": [
    "## Quad Diamond (⌺)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0b2f621",
   "metadata": {},
   "source": [
    "### Dyadic - Stencil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "073afa40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1, 2]), array([2, 3, 4]), array([4, 5, 6]), array([6, 7, 8])]"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       {⊂⍵}⌺(⍪3 2) ⍳8\n",
    "# ┌─────┬─────┬─────┬─────┐\n",
    "# │0 1 2│2 3 4│4 5 6│6 7 8│\n",
    "# └─────┴─────┴─────┴─────┘\n",
    "\n",
    "def alpha_extraction(alpha, dims=1):\n",
    "    # extract elements of alpha\n",
    "    # either size & skip for 1d omegas\n",
    "    # or rows & cols for 2d omegas\n",
    "    try:\n",
    "        a0, a1 = alpha\n",
    "    except TypeError:\n",
    "        a0 = alpha\n",
    "        if dims == 1:\n",
    "            a1 = 1\n",
    "        else:\n",
    "            a1 = alpha  # same # rows and cols = square\n",
    "    return a0, a1\n",
    "\n",
    "\n",
    "def stencil_1d(alpha, omega):\n",
    "    size, skip = alpha_extraction(alpha, 1)\n",
    "    \n",
    "    # determine the basics of the slices we're looking for\n",
    "    positions = [i for i, j in enumerate(omega) if not i % skip]\n",
    "    side_len = (size-1)//2\n",
    "    last_idx = len(omega)-1\n",
    "\n",
    "    # iterate over each slice \"middle\" position\n",
    "    result = []\n",
    "    for pos in positions:\n",
    "        \n",
    "        # determine starting position and any 0-padding\n",
    "        start_padding = []\n",
    "        start = pos-side_len\n",
    "        if start < 0:\n",
    "            start_padding = abs(start) * [0]\n",
    "            start = 0\n",
    "\n",
    "        # determine ending position and any 0-padding\n",
    "        finish_padding = []\n",
    "        finish = pos + side_len\n",
    "        if finish > last_idx:\n",
    "            finish_padding = (abs(finish) - last_idx) * [0]\n",
    "            finish = len(omega)\n",
    "        while finish - start + len(start_padding) + len(finish_padding) < size:\n",
    "            finish += 1\n",
    "        \n",
    "        # make the slice, add to result\n",
    "        o = omega[start:finish]\n",
    "        if start_padding or finish_padding:\n",
    "            o = np.array(\n",
    "                [*start_padding, *o, *finish_padding]\n",
    "            )\n",
    "        result.append(o)\n",
    "        \n",
    "    return result\n",
    "\n",
    "        \n",
    "stencil_1d(\n",
    "    [3, 2], \n",
    "    np.arange(1, 9)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "f2e00be9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[[[ 0,  0,  0],\n",
       "         [ 0,  1,  2],\n",
       "         [ 0,  5,  6]],\n",
       "\n",
       "        [[ 0,  0,  0],\n",
       "         [ 1,  2,  3],\n",
       "         [ 5,  6,  7]],\n",
       "\n",
       "        [[ 0,  0,  0],\n",
       "         [ 2,  3,  4],\n",
       "         [ 6,  7,  8]],\n",
       "\n",
       "        [[ 0,  0,  0],\n",
       "         [ 3,  4,  0],\n",
       "         [ 7,  8,  0]]],\n",
       "\n",
       "\n",
       "       [[[ 0,  1,  2],\n",
       "         [ 0,  5,  6],\n",
       "         [ 0,  9, 10]],\n",
       "\n",
       "        [[ 1,  2,  3],\n",
       "         [ 5,  6,  7],\n",
       "         [ 9, 10, 11]],\n",
       "\n",
       "        [[ 2,  3,  4],\n",
       "         [ 6,  7,  8],\n",
       "         [10, 11, 12]],\n",
       "\n",
       "        [[ 3,  4,  0],\n",
       "         [ 7,  8,  0],\n",
       "         [11, 12,  0]]],\n",
       "\n",
       "\n",
       "       [[[ 0,  5,  6],\n",
       "         [ 0,  9, 10],\n",
       "         [ 0, 13, 14]],\n",
       "\n",
       "        [[ 5,  6,  7],\n",
       "         [ 9, 10, 11],\n",
       "         [13, 14, 15]],\n",
       "\n",
       "        [[ 6,  7,  8],\n",
       "         [10, 11, 12],\n",
       "         [14, 15, 16]],\n",
       "\n",
       "        [[ 7,  8,  0],\n",
       "         [11, 12,  0],\n",
       "         [15, 16,  0]]],\n",
       "\n",
       "\n",
       "       [[[ 0,  9, 10],\n",
       "         [ 0, 13, 14],\n",
       "         [ 0,  0,  0]],\n",
       "\n",
       "        [[ 9, 10, 11],\n",
       "         [13, 14, 15],\n",
       "         [ 0,  0,  0]],\n",
       "\n",
       "        [[10, 11, 12],\n",
       "         [14, 15, 16],\n",
       "         [ 0,  0,  0]],\n",
       "\n",
       "        [[11, 12,  0],\n",
       "         [15, 16,  0],\n",
       "         [ 0,  0,  0]]]])"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       mat\n",
    "#  1  2  3  4\n",
    "#  5  6  7  8\n",
    "#  9 10 11 12\n",
    "# 13 14 15 16\n",
    "\n",
    "#       ({⊂⍵}⌺3 3) mat\n",
    "# ┌───────┬────────┬────────┬───────┐\n",
    "# │0 0 0  │0 0 0   │0 0 0   │0 0 0  │\n",
    "# │0 1 2  │1 2 3   │2 3 4   │3 4 0  │\n",
    "# │0 5 6  │5 6 7   │6 7 8   │7 8 0  │\n",
    "# ├───────┼────────┼────────┼───────┤\n",
    "# │0 1  2 │1  2  3 │ 2  3  4│ 3  4 0│\n",
    "# │0 5  6 │5  6  7 │ 6  7  8│ 7  8 0│\n",
    "# │0 9 10 │9 10 11 │10 11 12│11 12 0│\n",
    "# ├───────┼────────┼────────┼───────┤\n",
    "# │0  5  6│ 5  6  7│ 6  7  8│ 7  8 0│\n",
    "# │0  9 10│ 9 10 11│10 11 12│11 12 0│\n",
    "# │0 13 14│13 14 15│14 15 16│15 16 0│\n",
    "# ├───────┼────────┼────────┼───────┤\n",
    "# │0  9 10│ 9 10 11│10 11 12│11 12 0│\n",
    "# │0 13 14│13 14 15│14 15 16│15 16 0│\n",
    "# │0  0  0│ 0  0  0│ 0  0  0│ 0  0 0│\n",
    "# └───────┴────────┴────────┴───────┘\n",
    "\n",
    "from skimage.util import view_as_windows\n",
    "\n",
    "\n",
    "mat = np.arange(1, 17).reshape((4, 4))\n",
    "print(mat)\n",
    "\n",
    "\n",
    "def stencil_2d(alpha, omega):\n",
    "    alpha_rows, alpha_cols = alpha_extraction(alpha, 2)\n",
    "    omega_rows = omega.shape[-1]\n",
    "    omega_cols = omega.shape[-2] \n",
    "    \n",
    "    try:\n",
    "        assert omega_rows + 1 >= alpha_cols\n",
    "        assert omega_cols + 1 >= alpha_rows\n",
    "    except AssertionError:\n",
    "        raise AssertionError(\"DOMAIN ERROR\")\n",
    "    except IndexError:\n",
    "        raise AssertionError(\"Must be 2-dimensional array\")\n",
    "        \n",
    "    # determine how much padding will be needed on the rows and columns    \n",
    "    vertical_padding = (alpha_rows - 1) // 2\n",
    "    horizontal_padding = (alpha_cols - 1) // 2\n",
    "    \n",
    "    # pad 0s as necessary onto omega\n",
    "    full_array = np.pad(\n",
    "        omega, \n",
    "        (\n",
    "            (vertical_padding, vertical_padding), \n",
    "            (horizontal_padding, horizontal_padding), \n",
    "        ), \n",
    "        'constant',\n",
    "        constant_values=0\n",
    "    )\n",
    "    \n",
    "    # slice into windows\n",
    "    windows = view_as_windows(full_array, alpha)\n",
    "    return windows\n",
    "\n",
    "\n",
    "stencil_2d(\n",
    "    [3, 3],\n",
    "    mat\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "id": "fa1204f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14, 24, 30, 22],\n",
       "       [33, 54, 63, 45],\n",
       "       [57, 90, 99, 69],\n",
       "       [46, 72, 78, 54]])"
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ({+/,⍵}⌺3 3) mat\n",
    "# 14 24 30 22\n",
    "# 33 54 63 45\n",
    "# 57 90 99 69\n",
    "# 46 72 78 54\n",
    "\n",
    "st2 = stencil_2d(\n",
    "        [3, 3],\n",
    "        mat\n",
    "    )\n",
    "\n",
    "result = []\n",
    "for row in range(st2.shape[0]):\n",
    "    for col in range(st2.shape[1]):\n",
    "        val = st2[row, col].sum()\n",
    "        result.append(val)\n",
    "        \n",
    "np.array(result).reshape(st2.shape[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3dcffeed",
   "metadata": {},
   "source": [
    "## At (@)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a390bc51",
   "metadata": {},
   "source": [
    "### Dyadic - At"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 236,
   "id": "265711fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 3, 0, 5]"
      ]
     },
     "execution_count": 236,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       (0@2 4) 1 2 3 4 5\n",
    "# 1 0 3 0 5\n",
    "\n",
    "def at(alpha, omega, arr):\n",
    "    result = []\n",
    "    for i, a in enumerate(arr):\n",
    "        if i in omega:\n",
    "            if callable(alpha):\n",
    "                result.append(alpha(a))\n",
    "            else:\n",
    "                result.append(alpha)\n",
    "        else:\n",
    "            result.append(a)\n",
    "    return result\n",
    "\n",
    "at(0, [1, 3], [1, 2, 3, 4, 5])  # base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "a9d8e211",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 20, 3, 40, 5]"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       10 (×@2 4) 1 2 3 4 5\n",
    "# 1 20 3 40 5\n",
    "\n",
    "def multiply_10(var):\n",
    "    return var * 10\n",
    "\n",
    "at(multiply_10, [1, 3], [1, 2, 3, 4, 5])  # base 0 numbering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "id": "9f322def",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 0.5, 3.0, 0.25, 5.0]"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       (÷@2 4) 1 2 3 4 5\n",
    "# 1 0.5 3 0.25 5\n",
    "\n",
    "at(np.reciprocal, [1, 3], [1.0, 2.0, 3.0, 4.0, 5.0])  # base 0 numbering and will not work with integers here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "7cd0783a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['*', 2, '*', 4, '*']"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       '*'@(2∘|) 1 2 3 4 5   ⍝ Boolean selection 1 0 1 0 1\n",
    "# * 2 * 4 *\n",
    "\n",
    "['*' if i % 2 else i for i in range(1, 6)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "52593816",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 2, 3, 4, 1]"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⌽@(2∘|) 1 2 3 4 5     ⍝ Reversal of sub-array 1 3 5\n",
    "# 5 2 3 4 1\n",
    "\n",
    "var_array = [1, 2, 3, 4, 5]\n",
    "rev_array = list(reversed(var_array))\n",
    "bool_array = [i % 2 for i in var_array]\n",
    "index_array = where(bool_array)\n",
    "final_array = [\n",
    "    var_array[i] if i not in index_array \n",
    "    else rev_array[i] \n",
    "    for i in range(len(var_array))\n",
    "]\n",
    "final_array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2631b0cd",
   "metadata": {},
   "source": [
    "## Quad Colon (⍠)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63d0f34f",
   "metadata": {},
   "source": [
    "### Dyadic - Variant"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "id": "34232efb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ABC'"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ('a' ⎕R 'x') 'ABC'           ⍝ 'a' replaced with 'x'\n",
    "# ABC\n",
    "\n",
    "'ABC'.replace('a', 'x')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "79835117",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xBC'"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ('a' ⎕R 'x' ⍠ 'IC' 1) 'ABC'  ⍝ .. Ignoring Case\n",
    "# xBC\n",
    "\n",
    "import re  # builtin regex library of Python\n",
    "ic = lambda x, y, z: re.compile(re.escape(x), re.IGNORECASE).sub(y, z)\n",
    "ic('a', 'x', 'ABC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "9dbffc94",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'xBC'"
      ]
     },
     "execution_count": 243,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       IgnCase ← ⍠ 'IC' 1\n",
    "\n",
    "#       'a' ⎕R 'x' IgnCase 'ABC'\n",
    "# xBC \n",
    "\n",
    "def IgnCase(alpha, omega):\n",
    "    result = re.compile(re.escape(alpha[0]), re.IGNORECASE)\n",
    "    return result.sub(alpha[1], omega)\n",
    "\n",
    "IgnCase(('a', 'x'), 'ABC')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3d9ab5f",
   "metadata": {},
   "source": [
    "------------------------------\n",
    "## Miscellaneous\n",
    "------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c101a84",
   "metadata": {},
   "source": [
    "## High Minus (¯)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "id": "838a340c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2, -2])"
      ]
     },
     "execution_count": 244,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Qualifier for negative number\n",
    "\n",
    "#       1 + ¯1 0 1 ¯3\n",
    "# 0 1 2 ¯2\n",
    "\n",
    "1 + np.array([-1, 0, 1, -3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "id": "a747198c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03"
      ]
     },
     "execution_count": 245,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3e¯2\n",
    "# 0.03\n",
    "\n",
    "3e-2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49f5bc2a",
   "metadata": {},
   "source": [
    "## Left Arrow (←)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffe0733f",
   "metadata": {},
   "source": [
    "### Assignment - Naming"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "103a9615",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 7])"
      ]
     },
     "execution_count": 246,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       V ← 5 6 7\n",
    "#       V\n",
    "# 5 6 7\n",
    "\n",
    "V = np.array([5, 6, 7])\n",
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "id": "80c1684a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, (5, 6))"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       (i(j k)) ← 4(5 6)\n",
    "#       (i(j k))\n",
    "# ┌─┬───┐\n",
    "# │4│5 6│\n",
    "# └─┴───┘\n",
    "\n",
    "i, (j, k) = 4, (5, 6)\n",
    "i, (j, k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "03f93133",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       sum ← +⌿\n",
    "#       sum 1 2 3 4\n",
    "# 10\n",
    "\n",
    "sum_ = sum\n",
    "sum_([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "id": "97475edd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       product ← {×/⍵}\n",
    "#       product 1 2 3 4\n",
    "# 24\n",
    "\n",
    "def multiply(omega):\n",
    "    return np.multiply.reduce(omega)\n",
    "\n",
    "product = multiply\n",
    "multiply([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "id": "c0537a72",
   "metadata": {},
   "outputs": [],
   "source": [
    "# inverse ← ⍣¯1\n",
    "\n",
    "from pynverse import inversefunc as inverse"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92899f89",
   "metadata": {},
   "source": [
    "### Assignment - Modification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "id": "cb1abb52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 7, 8])"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       V +← 1\n",
    "#       V\n",
    "# 6 7 8\n",
    "\n",
    "V += 1\n",
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "f26dbc01",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 0, 8])"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       V[2] ← 0\n",
    "#       V\n",
    "# 6 0 8\n",
    "\n",
    "V[1] = 0\n",
    "V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "95bba59f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 8])"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       (⊃V) ← 2\n",
    "#       V\n",
    "# 2 0 8\n",
    "\n",
    "V[0] = 2\n",
    "V"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb578a3b",
   "metadata": {},
   "source": [
    "## Zilde (⍬)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6b25451",
   "metadata": {},
   "source": [
    "### Niladic:  Empty Numeric Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "id": "100b8c95",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍬≡⍳0\n",
    "# 1\n",
    "\n",
    "# using .all()\n",
    "int(\n",
    "    (np.array([]) == np.arange(0)).all()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "5691a824",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍬≡0⍴0\n",
    "# 1\n",
    "\n",
    "int(\n",
    "    (np.array([]) == np.array([]).reshape((0))).all()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "edea2fa4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍬≡0 0⍴0\n",
    "# 0\n",
    "\n",
    "# using function\n",
    "# Tweaked from: https://stackoverflow.com/questions/43973991/check-if-two-numpy-arrays-are-identical\n",
    "def arrays_equal(a, b):\n",
    "    if a.shape != b.shape:\n",
    "        return 0\n",
    "    for ai, bi in zip(a.flat, b.flat):\n",
    "        if ai != bi:\n",
    "            return 0\n",
    "    return 1\n",
    "\n",
    "arrays_equal(\n",
    "    np.array([]), np.array([]).reshape((0, 0))\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "590c1193",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       ⍬≡''\n",
    "# 0\n",
    "\n",
    "# using np.size\n",
    "int(\n",
    "    (np.size(np.array([])) == np.size(np.array(\"\")))\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0928a4dc",
   "metadata": {},
   "source": [
    "## Hydrant (⍎)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed7b214f",
   "metadata": {},
   "source": [
    "### Monadic - Execute"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "896d1f30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "#       ⍎ '1+1'\n",
    "# 2\n",
    "\n",
    "exec('print(1+1)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "db717e80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "#       V ← 1 2 3\n",
    "#       ⍎ 'V'\n",
    "# 1 2 3 \n",
    "\n",
    "V = [1, 2, 3]\n",
    "exec('print(V)')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7838abac",
   "metadata": {},
   "source": [
    "## Thorn (⍕)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32b74e2e",
   "metadata": {},
   "source": [
    "### Monadic - Format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "e1ccdf83",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[4 5 6]'"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# NB: In the following examples space characters\n",
    "#     are represented by small dots: ···\n",
    "\n",
    "#       4 5 6          ⍝ numeric vector\n",
    "# 4 5 6\n",
    "#       ⍕ 4 5 6        ⍝ equivalent character vector\n",
    "# 4·5·6\n",
    "\n",
    "str(np.array([4, 5, 6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "e4e730d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "#       mat            ⍝ numeric matrix\n",
    "# 1 2 3\n",
    "# 4 5 6\n",
    "\n",
    "#       ⍕ mat          ⍝ equivalent character matrix\n",
    "# 1·2·3\n",
    "# 4·5·6\n",
    "\n",
    "mat = np.matrix(\"1 2 3;4 5 6\")\n",
    "print(mat)\n",
    "print()\n",
    "\n",
    "print(str(mat))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69fbe80e",
   "metadata": {},
   "source": [
    "### Dyadic - Format By Specification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "f74149d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'  3.12  0.00'"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Field-width and number of decimal places:\n",
    "\n",
    "#       6 2 ⍕ 3.125 0.002\n",
    "# ··3.13··0.00\n",
    "\n",
    "def num_format(num, char_total, dec_places):\n",
    "    if len(str(int(num))) + 1 + dec_places > char_total:\n",
    "        return \"*\" * char_total\n",
    "    fmt = \"{:.\" + str(dec_places) + \"f}\"\n",
    "    rounded_num = fmt.format(num)\n",
    "    result = rounded_num.rjust(char_total)\n",
    "    return result  \n",
    "\n",
    "\n",
    "def array_to_rounded_string(arr, char_total, dec_places):\n",
    "    arr_rounded = [\n",
    "        num_format(a, char_total, dec_places)\n",
    "        for a in np.ravel(arr)\n",
    "    ]\n",
    "    return \"\".join(arr_rounded)\n",
    "\n",
    "\n",
    "def format_by_specification(alpha, omega):\n",
    "    assert len(alpha) == 2\n",
    "    if isinstance(omega, np.matrix):\n",
    "        result = []\n",
    "        for o in omega:\n",
    "            result.append(\n",
    "                array_to_rounded_string(\n",
    "                    o,\n",
    "                    alpha[0],\n",
    "                    alpha[1],\n",
    "                )\n",
    "            )\n",
    "        result = \"\\n\".join(result)\n",
    "        \n",
    "    else:\n",
    "        result = array_to_rounded_string(\n",
    "                    omega,\n",
    "                    alpha[0],\n",
    "                    alpha[1],\n",
    "                )\n",
    "        result = \"\".join(result)\n",
    "        \n",
    "    return result \n",
    "    \n",
    "    \n",
    "format_by_specification([6, 2], [3.125, 0.002])\n",
    "# Note: Python's default rounding pattern is different from APL's\n",
    "# For more info: https://stackoverflow.com/questions/10825926/python-3-x-rounding-behavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "id": "988817b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1.00  2.00  3.00\n",
      "  4.00  5.00  6.00\n"
     ]
    }
   ],
   "source": [
    "#       6 2 ⍕ mat\n",
    "# ··1.00··2.00··3.00\n",
    "# ··4.00··5.00··6.00\n",
    "\n",
    "print(format_by_specification([6, 2], mat))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "id": "7e5771bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'******'"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       6 2 ⍕ 1234   ⍝ (field not wide enough)\n",
    "# ******\n",
    "\n",
    "format_by_specification([6, 2], [1234])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aee64b8",
   "metadata": {},
   "source": [
    "## Diamond (⋄)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51512b02",
   "metadata": {},
   "source": [
    "### Syntax:    Statement Separator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "id": "a9c7d679",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       Statements are evaluated sequentially\n",
    "#       from left to right.\n",
    "\n",
    "#       A←4 ⋄ A←A×3 ⋄ A÷2\n",
    "# 6\n",
    "\n",
    "A=4; A*=3; A/2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8eeb15b6",
   "metadata": {},
   "source": [
    "## Lamp (⍝)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "783fa216",
   "metadata": {},
   "source": [
    "### Syntax: Comment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "id": "330e2a67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Text to the right of ⍝ is ignored.\n",
    "\n",
    "#       2+3  ⍝ this is a comment\n",
    "# 5\n",
    "\n",
    "2+3  # this is a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0933478d",
   "metadata": {},
   "source": [
    "## Del (∇)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "id": "2327638b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Del Syntax:         dfn self-reference (recursion)\n",
    "\n",
    "#     fact←{             ⍝ Factorial ⍵.\n",
    "#         ⍵≤1: 1         ⍝ small ⍵: finished\n",
    "#         ⍵×∇ ⍵-1        ⍝ otherwise: recurse\n",
    "#      }\n",
    "#       fact 5\n",
    "# 120\n",
    "\n",
    "def fact(n):\n",
    "    if n<=1:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * fact(n - 1)  # recursion done via using the same name again\n",
    "fact(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "4c3728c8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Double-Del Syntax:  dop self-reference\n",
    "#\n",
    "#       pow←{                ⍝ power operator: apply ⍵⍵ times\n",
    "#           ⍵⍵=0:⍵           ⍝ ⍵⍵ is 0: finished\n",
    "#           ⍺⍺ ∇∇(⍵⍵-1)⍺⍺ ⍵  ⍝ otherwise: recurse\n",
    "#       }\n",
    "#\n",
    "#       incr←{1+⍵}      ⍝ define an increment function\n",
    "#       (incr pow 3) 5  ⍝ apply it 3 times to 5\n",
    "# 8\n",
    "\n",
    "\n",
    "# Understanding gathered from this StackOverflow response I received from Adám:\n",
    "#     https://stackoverflow.com/a/74587631/9885313\n",
    "\n",
    "# Python does not have a built-in way to create user-definied operators\n",
    "# The closest I found was this ActiveState recipe:\n",
    "#     https://code.activestate.com/recipes/384122/\n",
    "# Here, dunder methods of a class are used to create a pseudo-operator \n",
    "# that needs to instantiate 2 classes to get one answer. It is a neat trick\n",
    "# and a brilliant display of using Python's flexibility to your advantage\n",
    "# but I think the simplest and most straightforward method to achieve the goal here\n",
    "# would be to use a closure as follows:\n",
    "\n",
    "def Pow(fx):\n",
    "    def inner(count, val):\n",
    "        if count == 0:\n",
    "            return val\n",
    "        else:\n",
    "            result = fx(val)\n",
    "            return inner(\n",
    "                count-1,\n",
    "                result\n",
    "            )\n",
    "    return inner\n",
    "\n",
    "incr = lambda x: x+1\n",
    "pow = Pow(incr)\n",
    "pow(3, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9752e9fc",
   "metadata": {},
   "source": [
    "## Alpha (⍺)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fda09119",
   "metadata": {},
   "source": [
    "### Alpha Syntax:           Left argument of a dfn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "4f62d95b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 {⍺+1} 5\n",
    "# 3\n",
    "\n",
    "fx = lambda a, w: a+1\n",
    "fx(2, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2ddb8b9",
   "metadata": {},
   "source": [
    "### Double-Alpha Syntax:    Left Operand of a dop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "ffc83e3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 270,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 +{⍺ ⍺⍺ ⍵} 4\n",
    "# 7\n",
    "\n",
    "def add2(alpha, omega):\n",
    "    return alpha + omega\n",
    "\n",
    "fx = lambda a, func, w: func(a, w)\n",
    "fx(3, add2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "474f94e7",
   "metadata": {},
   "source": [
    "## Omega (⍵)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d012477",
   "metadata": {},
   "source": [
    "### Omega Syntax:           Right argument of a dfn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "82ee206c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       2 {⍵+1} 5\n",
    "# 6\n",
    "\n",
    "fx = lambda a, w: w+1\n",
    "fx(2, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f50d42a8",
   "metadata": {},
   "source": [
    "### Double-Omega Syntax:    Right operand of a dop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "4638f5c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#       3 +{⍺ ⍵⍵ ⍵}× 4\n",
    "# 12\n",
    "\n",
    "def add2(alpha, omega):\n",
    "    return alpha + omega\n",
    "\n",
    "def multiply2(alpha, omega):\n",
    "    return alpha * omega\n",
    "\n",
    "fx = lambda a, left_func, right_func, w: right_func(a, w)\n",
    "fx(3, add2, multiply2, 4)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}