notebooks/analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Array API Comparison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notebook dependencies and initial setup..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adjust the default figure size:\n",
    "plt.rcParams[\"figure.figsize\"] = (20,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the root project directory..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Determine the current working directory:\n",
    "dir = os.getcwd()\n",
    "\n",
    "# Walk the parent directories looking for a `package.json` file located in the root directory...\n",
    "child = ''\n",
    "while (child != dir):\n",
    "    spath = os.path.join(dir, 'package.json')\n",
    "    if (os.path.exists(spath)):\n",
    "        root_dir = dir\n",
    "        break\n",
    "    \n",
    "    child = dir\n",
    "    dir = os.path.dirname(dir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Resolve the directory containing data files..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = os.path.join(root_dir, 'data')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* * *\n",
    "\n",
    "## Overview"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following array libraries were initially analyzed:\n",
    "\n",
    "-   [**NumPy**][numpy]: serves as the reference API against which all other array libraries are compared.\n",
    "-   [**CuPy**][cupy]\n",
    "-   [**Dask.array**][dask-array]\n",
    "-   [**JAX**][jax]\n",
    "-   [**MXNet**][mxnet]\n",
    "-   [**PyTorch**][pytorch]\n",
    "-   [**rnumpy**][rnumpy]: an opinionated curation of NumPy APIs, serving as an exercise in evaluating what is most \"essential\" (i.e., the smallest set of building block functionality on which most array functionality can be built).\n",
    "-   [**PyData/Sparse**][pydata-sparse]\n",
    "-   [**Tensorflow**][tensorflow]\n",
    "\n",
    "The data from this analysis can be found in the \"join\" dataset below.\n",
    "\n",
    "From the initial array library list, the following array libraries were subsequently analyzed in order to determine relatively common APIs:\n",
    "\n",
    "-   [**NumPy**][numpy]\n",
    "-   [**CuPy**][cupy]\n",
    "-   [**Dask.array**][dask-array]\n",
    "-   [**JAX**][jax]\n",
    "-   [**MXNet**][mxnet]\n",
    "-   [**PyTorch**][pytorch]\n",
    "-   [**Tensorflow**][tensorflow]\n",
    "\n",
    "[**PyData/Sparse**][pydata-sparse] was omitted due to insufficient and relatively nascent API coverage. [**rnumpy**][rnumpy] was omitted due to its nature as an intellectual exercise exploring what a minimal API could look like, rather than a ubiquitous library having widespread usage.\n",
    "\n",
    "In order to understand array API usage by downstream libraries, the following downstream libraries were analyzed (for additional information, see the [Python API Record][python-api-record] tooling repository):\n",
    "\n",
    "-   [**Dask.array**][dask-array]\n",
    "-   [**Matplotlib**][matplotlib]\n",
    "-   [**pandas**][pandas]\n",
    "-   [**scikit-image**][scikit-image] (alias: `skimage`)\n",
    "-   [**xarray**][xarray]\n",
    "\n",
    "[cupy]: https://docs-cupy.chainer.org/en/stable/reference/comparison.html\n",
    "\n",
    "[dask-array]: https://docs.dask.org/en/latest/array-api.html\n",
    "\n",
    "[jax]: https://jax.readthedocs.io/en/latest/\n",
    "\n",
    "[mxnet]: https://numpy.mxnet.io/api/deepnumpy\n",
    "\n",
    "[numpy]: https://docs.scipy.org/doc/numpy\n",
    "\n",
    "[pydata-sparse]: https://github.com/pydata/sparse\n",
    "\n",
    "[pytorch]: https://pytorch.org/docs/stable/\n",
    "\n",
    "[rnumpy]: https://github.com/Quansight-Labs/rnumpy\n",
    "\n",
    "[tensorflow]: https://www.tensorflow.org/api_docs/python\n",
    "\n",
    "[matplotlib]: https://matplotlib.org/\n",
    "\n",
    "[pandas]: https://pandas.pydata.org/\n",
    "\n",
    "[scikit-image]: https://scikit-image.org/ \n",
    "\n",
    "[xarray]: https://xarray.pydata.org/en/latest/\n",
    "\n",
    "[python-api-record]: https://github.com/pydata-apis/python-api-record"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* * *\n",
    "\n",
    "## Datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook contains the following datasets..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Categories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a table mapping NumPy APIs to a usage \"category\"..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "CATEGORIES = pandas.read_csv(os.path.join(data_dir, 'raw', 'numpy_categories.csv')).fillna(value='(other)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows, which will inform us as to the number of NumPy APIs..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "765"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "NUM_APIS = len(CATEGORIES.index)\n",
    "NUM_APIS"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>category</th>\n",
       "      <th>subcategory</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.absolute</td>\n",
       "      <td>math</td>\n",
       "      <td>special</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.add</td>\n",
       "      <td>math</td>\n",
       "      <td>arithmetic</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.allclose</td>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>statistics</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             name    category subcategory\n",
       "0  numpy.absolute        math     special\n",
       "1       numpy.add        math  arithmetic\n",
       "2       numpy.all     logical     (other)\n",
       "3  numpy.allclose     logical     (other)\n",
       "4      numpy.amax  statistics     (other)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "CATEGORIES.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above table, the first column corresponds to the NumPy API (arranged in alphabetical order). The second column corresponds to a high-level cateogory (as inspired by categorization found in [**rnumpy**][rnumpy]). The third column corresponds to a subcategory of the respective value in the second column. The categories are as follows:\n",
    "\n",
    "-   `binary_ops`: APIs for performing bitwise operations\n",
    "-   `creation`: APIs for array creation\n",
    "-   `datetime`: APIs for manipulating dates and times\n",
    "-   `finance`: APIs for computing financial quantities\n",
    "-   `indexing`: APIs for array indexing\n",
    "-   `io`: APIs for loading and writing data\n",
    "-   `linalg`: APIs for performing linear algebra operations (e.g., dot product, matrix multiplication, etc.)\n",
    "-   `logical`: APIs for logical operations (e.g., element-wise comparisions)\n",
    "-   `manipulation`: APIs for array manipulation (e.g., reshaping and joining arrays)\n",
    "-   `math`: APIs for basic mathematical functions (e.g., element-wise elementary functions)\n",
    "-   `polynomials`: APIs for evaluating polynomials\n",
    "-   `random`: APIs for pseudorandom number generation\n",
    "-   `sets`: APIs for performing set operations (e.g., union, intersection, complement, etc.)\n",
    "-   `signal_processing`: APIs for performing signal processing (e.g., FFTs)\n",
    "-   `sorting`: APIs for sorting array elements\n",
    "-   `statistics`: APIs for computing statistics (e.g., reductions such as computing the mean, variance, and standard deviation)\n",
    "-    `string`: APIs for operating on strings\n",
    "-    `utilities`: general utilities (e.g., displaying an element's binary representation)\n",
    "-   `(other)`: APIs not categorized (or subcategorized)\n",
    "\n",
    "API categorization was manually compiled based on personal judgment and is undoubtedly imperfect.\n",
    "\n",
    "[rnumpy]: https://github.com/Quansight-Labs/rnumpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "CATEGORY_NAMES = [\n",
    "    '(other)',\n",
    "    'binary_ops',\n",
    "    'creation',\n",
    "    'datetime',\n",
    "    'finance',\n",
    "    'indexing',\n",
    "    'io',\n",
    "    'linalg',\n",
    "    'logical',\n",
    "    'manipulation',\n",
    "    'math',\n",
    "    'polynomials',\n",
    "    'random',\n",
    "    'sets',\n",
    "    'signal_processing',\n",
    "    'sorting',\n",
    "    'statistics',\n",
    "    'string',\n",
    "    'utilities'\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of the list of category names, we can define a subset of \"core\" categories (again, based on personal judgment)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "CORE_CATEGORY_NAMES = [\n",
    "    'creation',\n",
    "    'indexing',\n",
    "    'linalg',\n",
    "    'logical',\n",
    "    'manipulation',\n",
    "    'math',\n",
    "    'signal_processing', # mainly because of FFT\n",
    "    'sorting',\n",
    "    'statistics'\n",
    "]\n",
    "\n",
    "NON_CORE_CATEGORY_NAMES = np.setdiff1d(CATEGORY_NAMES, CORE_CATEGORY_NAMES).tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the category data above, we can determine the relative composition of the NumPy API..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th>subcategory</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>(other)</td>\n",
       "      <td>(other)</td>\n",
       "      <td>86</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>binary_ops</td>\n",
       "      <td>(other)</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td rowspan=\"3\" valign=\"top\">creation</td>\n",
       "      <td>(other)</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>existing_data</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>range</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>datetime</td>\n",
       "      <td>(other)</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>finance</td>\n",
       "      <td>(other)</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td rowspan=\"4\" valign=\"top\">indexing</td>\n",
       "      <td>(other)</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>searching</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sorting</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>io</td>\n",
       "      <td>(other)</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>(other)</td>\n",
       "      <td>39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "      <td>40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td rowspan=\"5\" valign=\"top\">manipulation</td>\n",
       "      <td>(other)</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>changing_shape</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>joining_arrays</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>moving_axes</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>tiling</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td rowspan=\"5\" valign=\"top\">math</td>\n",
       "      <td>arithmetic</td>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>complex</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>rounding</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>special</td>\n",
       "      <td>36</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>trig</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>polynomials</td>\n",
       "      <td>(other)</td>\n",
       "      <td>170</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>random</td>\n",
       "      <td>(other)</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sets</td>\n",
       "      <td>(other)</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td rowspan=\"3\" valign=\"top\">signal_processing</td>\n",
       "      <td>(other)</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>fft</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>window</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sorting</td>\n",
       "      <td>(other)</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td rowspan=\"2\" valign=\"top\">statistics</td>\n",
       "      <td>(other)</td>\n",
       "      <td>37</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>counting</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>string</td>\n",
       "      <td>(other)</td>\n",
       "      <td>51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>utilities</td>\n",
       "      <td>(other)</td>\n",
       "      <td>24</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                  name\n",
       "category          subcategory         \n",
       "(other)           (other)           86\n",
       "binary_ops        (other)            6\n",
       "creation          (other)           36\n",
       "                  existing_data     30\n",
       "                  range              7\n",
       "datetime          (other)            5\n",
       "finance           (other)           10\n",
       "indexing          (other)           10\n",
       "                  searching          3\n",
       "                  sorting            3\n",
       "                  statistics         5\n",
       "io                (other)            8\n",
       "linalg            (other)           39\n",
       "logical           (other)           40\n",
       "manipulation      (other)           11\n",
       "                  changing_shape    18\n",
       "                  joining_arrays    14\n",
       "                  moving_axes        8\n",
       "                  tiling             3\n",
       "math              arithmetic        21\n",
       "                  complex            7\n",
       "                  rounding          12\n",
       "                  special           36\n",
       "                  trig              19\n",
       "polynomials       (other)          170\n",
       "random            (other)            2\n",
       "sets              (other)            5\n",
       "signal_processing (other)            6\n",
       "                  fft               18\n",
       "                  window             5\n",
       "sorting           (other)            6\n",
       "statistics        (other)           37\n",
       "                  counting           4\n",
       "string            (other)           51\n",
       "utilities         (other)           24"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "category_breakdown = CATEGORIES.groupby(by=['category', 'subcategory']).count()\n",
    "category_breakdown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize the relative composition for top-level categories as follows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11afaaed0>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "category_count = CATEGORIES.loc[:,['name','category']].groupby(by='category').count().sort_values(by='name', ascending=True)\n",
    "category_count.plot.barh()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we omit functions which are not in \"core\" categories, we arrive at the following API frequency distribution..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>math</td>\n",
       "      <td>0.238693</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>creation</td>\n",
       "      <td>0.183417</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>manipulation</td>\n",
       "      <td>0.135678</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>0.103015</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>logical</td>\n",
       "      <td>0.100503</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>0.097990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>signal_processing</td>\n",
       "      <td>0.072864</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>indexing</td>\n",
       "      <td>0.052764</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sorting</td>\n",
       "      <td>0.015075</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       name\n",
       "category                   \n",
       "math               0.238693\n",
       "creation           0.183417\n",
       "manipulation       0.135678\n",
       "statistics         0.103015\n",
       "logical            0.100503\n",
       "linalg             0.097990\n",
       "signal_processing  0.072864\n",
       "indexing           0.052764\n",
       "sorting            0.015075"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compute the total number of non-\"core\" NumPy APIs:\n",
    "non_core_categories_num_apis = category_count.loc[NON_CORE_CATEGORY_NAMES,:].sum()\n",
    "\n",
    "# Create a DataFrame containing only NumPy APIs considered \"core\" and compute the empirical frequency distribution:\n",
    "core_category_distribution = category_count.drop(index=NON_CORE_CATEGORY_NAMES) / (NUM_APIS-non_core_categories_num_apis)\n",
    "core_category_distribution.sort_values(by='name', ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11b435f10>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "core_category_distribution.sort_values(by='name', ascending=True).plot.barh()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a table mapping NumPy `ndarray` methods to equivalent top-level NumPy APIs..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "METHODS_TO_FUNCTIONS = pandas.read_csv(os.path.join(data_dir, 'raw', 'numpy_methods_to_functions.csv')).fillna(value='-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(METHODS_TO_FUNCTIONS.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>function</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.ndarray</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.ndarray.T</td>\n",
       "      <td>numpy.transpose</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.ndarray.__abs__</td>\n",
       "      <td>numpy.absolute</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.ndarray.__add__</td>\n",
       "      <td>numpy.add</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.ndarray.__and__</td>\n",
       "      <td>numpy.bitwise_and</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>numpy.ndarray.__array__</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>numpy.ndarray.__array_wrap__</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>numpy.ndarray.__bool__</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>numpy.ndarray.__complex__</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>numpy.ndarray.__contains__</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         method           function\n",
       "0                 numpy.ndarray                  -\n",
       "1               numpy.ndarray.T    numpy.transpose\n",
       "2         numpy.ndarray.__abs__     numpy.absolute\n",
       "3         numpy.ndarray.__add__          numpy.add\n",
       "4         numpy.ndarray.__and__  numpy.bitwise_and\n",
       "5       numpy.ndarray.__array__                  -\n",
       "6  numpy.ndarray.__array_wrap__                  -\n",
       "7        numpy.ndarray.__bool__                  -\n",
       "8     numpy.ndarray.__complex__                  -\n",
       "9    numpy.ndarray.__contains__                  -"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "METHODS_TO_FUNCTIONS.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>method</th>\n",
       "      <th>function</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>111</td>\n",
       "      <td>numpy.ndarray.swapaxes</td>\n",
       "      <td>numpy.swapaxes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>112</td>\n",
       "      <td>numpy.ndarray.take</td>\n",
       "      <td>numpy.take</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>113</td>\n",
       "      <td>numpy.ndarray.tobytes</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>114</td>\n",
       "      <td>numpy.ndarray.tofile</td>\n",
       "      <td>numpy.save</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>115</td>\n",
       "      <td>numpy.ndarray.tolist</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>116</td>\n",
       "      <td>numpy.ndarray.tostring</td>\n",
       "      <td>numpy.array2string</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>117</td>\n",
       "      <td>numpy.ndarray.trace</td>\n",
       "      <td>numpy.trace</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>118</td>\n",
       "      <td>numpy.ndarray.transpose</td>\n",
       "      <td>numpy.transpose</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>119</td>\n",
       "      <td>numpy.ndarray.var</td>\n",
       "      <td>numpy.var</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>120</td>\n",
       "      <td>numpy.ndarray.view</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                      method            function\n",
       "111   numpy.ndarray.swapaxes      numpy.swapaxes\n",
       "112       numpy.ndarray.take          numpy.take\n",
       "113    numpy.ndarray.tobytes                   -\n",
       "114     numpy.ndarray.tofile          numpy.save\n",
       "115     numpy.ndarray.tolist                   -\n",
       "116   numpy.ndarray.tostring  numpy.array2string\n",
       "117      numpy.ndarray.trace         numpy.trace\n",
       "118  numpy.ndarray.transpose     numpy.transpose\n",
       "119        numpy.ndarray.var           numpy.var\n",
       "120       numpy.ndarray.view                   -"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "METHODS_TO_FUNCTIONS.tail(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Join"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load API data for each array library as a single table, using NumPy as the reference API..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "JOIN = pandas.read_csv(os.path.join(data_dir, 'join.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "765"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(JOIN.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>cupy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>jax</th>\n",
       "      <th>mxnet</th>\n",
       "      <th>pytorch</th>\n",
       "      <th>rnumpy</th>\n",
       "      <th>sparse</th>\n",
       "      <th>tensorflow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.absolute</td>\n",
       "      <td>absolute</td>\n",
       "      <td>NaN</td>\n",
       "      <td>absolute</td>\n",
       "      <td>absolute</td>\n",
       "      <td>abs</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>math.abs</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.add</td>\n",
       "      <td>add</td>\n",
       "      <td>NaN</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>NaN</td>\n",
       "      <td>math.add</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>all</td>\n",
       "      <td>all</td>\n",
       "      <td>alltrue</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>all</td>\n",
       "      <td>NaN</td>\n",
       "      <td>reduce_all</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>NaN</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>max</td>\n",
       "      <td>max</td>\n",
       "      <td>max</td>\n",
       "      <td>amax</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>math.reduce_max</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            numpy      cupy dask.array       jax     mxnet   pytorch  \\\n",
       "0  numpy.absolute  absolute        NaN  absolute  absolute       abs   \n",
       "1       numpy.add       add        NaN       add       add       add   \n",
       "2       numpy.all       all        all   alltrue       NaN       NaN   \n",
       "3  numpy.allclose  allclose   allclose  allclose       NaN  allclose   \n",
       "4      numpy.amax       max        max       max      amax       NaN   \n",
       "\n",
       "     rnumpy sparse       tensorflow  \n",
       "0       NaN    NaN         math.abs  \n",
       "1       add    NaN         math.add  \n",
       "2       all    NaN       reduce_all  \n",
       "3  allclose    NaN              NaN  \n",
       "4       NaN    NaN  math.reduce_max  "
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "JOIN.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the table above, the first column corresponds to the NumPy API (arranged in alphabetical order) and each subsequent column corresponds to an equivalent API in a respective array library. If an array library does not have an equivalent API, the row value for that array library is `NaN`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Intersection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a table containing the API intersection (i.e., APIs implemented in **all** compared array libraries)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "INTERSECTION = pandas.read_csv(os.path.join(data_dir, 'intersection.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(INTERSECTION.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>cupy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>jax</th>\n",
       "      <th>mxnet</th>\n",
       "      <th>pytorch</th>\n",
       "      <th>tensorflow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.angle</td>\n",
       "      <td>angle</td>\n",
       "      <td>angle</td>\n",
       "      <td>angle</td>\n",
       "      <td>angle</td>\n",
       "      <td>angle</td>\n",
       "      <td>math.angle</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.arange</td>\n",
       "      <td>arange</td>\n",
       "      <td>arange</td>\n",
       "      <td>arange</td>\n",
       "      <td>arange</td>\n",
       "      <td>range</td>\n",
       "      <td>range</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.arccos</td>\n",
       "      <td>arccos</td>\n",
       "      <td>arccos</td>\n",
       "      <td>arccos</td>\n",
       "      <td>arccos</td>\n",
       "      <td>acos</td>\n",
       "      <td>math.acos</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.arcsin</td>\n",
       "      <td>arcsin</td>\n",
       "      <td>arcsin</td>\n",
       "      <td>arcsin</td>\n",
       "      <td>arcsin</td>\n",
       "      <td>asin</td>\n",
       "      <td>math.asin</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.arctan</td>\n",
       "      <td>arctan</td>\n",
       "      <td>arctan</td>\n",
       "      <td>arctan</td>\n",
       "      <td>arctan</td>\n",
       "      <td>atan</td>\n",
       "      <td>math.atan</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          numpy    cupy dask.array     jax   mxnet pytorch  tensorflow\n",
       "0   numpy.angle   angle      angle   angle   angle   angle  math.angle\n",
       "1  numpy.arange  arange     arange  arange  arange   range       range\n",
       "2  numpy.arccos  arccos     arccos  arccos  arccos    acos   math.acos\n",
       "3  numpy.arcsin  arcsin     arcsin  arcsin  arcsin    asin   math.asin\n",
       "4  numpy.arctan  arctan     arctan  arctan  arctan    atan   math.atan"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "INTERSECTION.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the table above, the first column corresponds to the NumPy API (arranged in alphabetical order) and each subsequent column corresponds to an equivalent API in a respective array library.\n",
    "\n",
    "Using the API categorization data above, we can associate each NumPy API in the intersection with its respective category..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>category</th>\n",
       "      <th>subcategory</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.angle</td>\n",
       "      <td>math</td>\n",
       "      <td>complex</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.arange</td>\n",
       "      <td>creation</td>\n",
       "      <td>range</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.arccos</td>\n",
       "      <td>math</td>\n",
       "      <td>trig</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.arcsin</td>\n",
       "      <td>math</td>\n",
       "      <td>trig</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.arctan</td>\n",
       "      <td>math</td>\n",
       "      <td>trig</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           name  category subcategory\n",
       "0   numpy.angle      math     complex\n",
       "1  numpy.arange  creation       range\n",
       "2  numpy.arccos      math        trig\n",
       "3  numpy.arcsin      math        trig\n",
       "4  numpy.arctan      math        trig"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection_categories = pandas.merge(\n",
    "    INTERSECTION[['numpy']],\n",
    "    CATEGORIES[['name', 'category', 'subcategory']],\n",
    "    left_on='numpy',\n",
    "    right_on='name',\n",
    "    how='left'\n",
    ")\n",
    "intersection_categories.drop('numpy', axis=1, inplace=True)\n",
    "intersection_categories.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the previous table, we can compute the category composition of the intersection, which is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>math</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>creation</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>manipulation</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>indexing</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              name\n",
       "category          \n",
       "math            29\n",
       "linalg          11\n",
       "creation        10\n",
       "manipulation     6\n",
       "statistics       5\n",
       "indexing         3"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection_category_count = intersection_categories.loc[:,['name', 'category']].fillna(value='(other)').groupby(by='category').count().sort_values(by='name', ascending=False)\n",
    "intersection_category_count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From which we can compute the empirical distribution..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>math</td>\n",
       "      <td>0.453125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>0.171875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>creation</td>\n",
       "      <td>0.156250</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>manipulation</td>\n",
       "      <td>0.093750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>0.078125</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>indexing</td>\n",
       "      <td>0.046875</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  name\n",
       "category              \n",
       "math          0.453125\n",
       "linalg        0.171875\n",
       "creation      0.156250\n",
       "manipulation  0.093750\n",
       "statistics    0.078125\n",
       "indexing      0.046875"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "intersection_category_distribution = intersection_category_count / intersection_category_count.sum()\n",
    "intersection_category_distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "whereby\n",
    "\n",
    "-  `~50%` are basic element-wise mathematical functions, such as arithmetic and trigonometric functions\n",
    "-  `~25%` are array creation and manipulation functions\n",
    "-  `~15%` are linear algebra functions\n",
    "-  `~10%` are indexing and statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11b376d10>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "intersection_category_count.sort_values(by='name', ascending=True).plot.barh()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary\n",
    "\n",
    "Array libraries find the most agreement in providing APIs for (1) array creation and manipulation, (2) element-wise operations for evaluating elementary mathematical functions, (3) basic summary statistics, and (4) linear algebra operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complement (intersection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a table containing the API complement (i.e., APIs **not** included in the intersection above)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "COMPLEMENT = pandas.read_csv(os.path.join(data_dir, 'complement.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "701"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(COMPLEMENT.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>cupy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>jax</th>\n",
       "      <th>mxnet</th>\n",
       "      <th>pytorch</th>\n",
       "      <th>tensorflow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.absolute</td>\n",
       "      <td>absolute</td>\n",
       "      <td>NaN</td>\n",
       "      <td>absolute</td>\n",
       "      <td>absolute</td>\n",
       "      <td>abs</td>\n",
       "      <td>math.abs</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.add</td>\n",
       "      <td>add</td>\n",
       "      <td>NaN</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>math.add</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>all</td>\n",
       "      <td>all</td>\n",
       "      <td>alltrue</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>reduce_all</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>NaN</td>\n",
       "      <td>allclose</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>max</td>\n",
       "      <td>max</td>\n",
       "      <td>max</td>\n",
       "      <td>amax</td>\n",
       "      <td>NaN</td>\n",
       "      <td>math.reduce_max</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            numpy      cupy dask.array       jax     mxnet   pytorch  \\\n",
       "0  numpy.absolute  absolute        NaN  absolute  absolute       abs   \n",
       "1       numpy.add       add        NaN       add       add       add   \n",
       "2       numpy.all       all        all   alltrue       NaN       NaN   \n",
       "3  numpy.allclose  allclose   allclose  allclose       NaN  allclose   \n",
       "4      numpy.amax       max        max       max      amax       NaN   \n",
       "\n",
       "        tensorflow  \n",
       "0         math.abs  \n",
       "1         math.add  \n",
       "2       reduce_all  \n",
       "3              NaN  \n",
       "4  math.reduce_max  "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COMPLEMENT.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the table above, the first column corresponds to the NumPy API (arranged in alphabetical order) and each subsequent column corresponds to an equivalent API in a respective array library. If an array library does not have an equivalent API, the row value for that array library is `NaN`.\n",
    "\n",
    "Using the API categorization data above, we can associate each NumPy API in the complement with its respective category..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>category</th>\n",
       "      <th>subcategory</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.absolute</td>\n",
       "      <td>math</td>\n",
       "      <td>special</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.add</td>\n",
       "      <td>math</td>\n",
       "      <td>arithmetic</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.allclose</td>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>statistics</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             name    category subcategory\n",
       "0  numpy.absolute        math     special\n",
       "1       numpy.add        math  arithmetic\n",
       "2       numpy.all     logical     (other)\n",
       "3  numpy.allclose     logical     (other)\n",
       "4      numpy.amax  statistics     (other)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complement_categories = pandas.merge(\n",
    "    COMPLEMENT[['numpy']],\n",
    "    CATEGORIES[['name', 'category', 'subcategory']],\n",
    "    left_on='numpy',\n",
    "    right_on='name',\n",
    "    how='left'\n",
    ")\n",
    "complement_categories.drop('numpy', axis=1, inplace=True)\n",
    "complement_categories.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Common APIs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a table containing (relatively) common APIs (where \"common\" is defined as existing in **at least** `5` of the `7` compared array libraries; this dataset may be considered a weaker and more inclusive intersection)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "COMMON_APIS = pandas.read_csv(os.path.join(data_dir, 'common_apis.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "194"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(COMMON_APIS.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>cupy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>jax</th>\n",
       "      <th>mxnet</th>\n",
       "      <th>pytorch</th>\n",
       "      <th>tensorflow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.absolute</td>\n",
       "      <td>absolute</td>\n",
       "      <td>NaN</td>\n",
       "      <td>absolute</td>\n",
       "      <td>absolute</td>\n",
       "      <td>abs</td>\n",
       "      <td>math.abs</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.add</td>\n",
       "      <td>add</td>\n",
       "      <td>NaN</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>add</td>\n",
       "      <td>math.add</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>all</td>\n",
       "      <td>all</td>\n",
       "      <td>alltrue</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>reduce_all</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>allclose</td>\n",
       "      <td>NaN</td>\n",
       "      <td>allclose</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>max</td>\n",
       "      <td>max</td>\n",
       "      <td>max</td>\n",
       "      <td>amax</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            numpy      cupy dask.array       jax     mxnet   pytorch  \\\n",
       "0  numpy.absolute  absolute        NaN  absolute  absolute       abs   \n",
       "1       numpy.add       add        NaN       add       add       add   \n",
       "2       numpy.all       all        all   alltrue       NaN       NaN   \n",
       "3  numpy.allclose  allclose   allclose  allclose       NaN  allclose   \n",
       "4      numpy.amax       max        max       max      amax       NaN   \n",
       "\n",
       "   tensorflow  \n",
       "0    math.abs  \n",
       "1    math.add  \n",
       "2  reduce_all  \n",
       "3         NaN  \n",
       "4         NaN  "
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COMMON_APIS.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the table above, the first column corresponds to the NumPy API (arranged in alphabetical order) and each subsequent column corresponds to an equivalent API in a respective array library. If an array library does not have an equivalent API, the row value for that array library is `NaN`.\n",
    "\n",
    "Using the API categorization data above, we can associate each NumPy API in the list of common APIs with its respective category..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>category</th>\n",
       "      <th>subcategory</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.absolute</td>\n",
       "      <td>math</td>\n",
       "      <td>special</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.add</td>\n",
       "      <td>math</td>\n",
       "      <td>arithmetic</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.allclose</td>\n",
       "      <td>logical</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>statistics</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             name    category subcategory\n",
       "0  numpy.absolute        math     special\n",
       "1       numpy.add        math  arithmetic\n",
       "2       numpy.all     logical     (other)\n",
       "3  numpy.allclose     logical     (other)\n",
       "4      numpy.amax  statistics     (other)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "common_apis_categories = pandas.merge(\n",
    "    COMMON_APIS[['numpy']],\n",
    "    CATEGORIES[['name', 'category', 'subcategory']],\n",
    "    left_on='numpy',\n",
    "    right_on='name',\n",
    "    how='left'\n",
    ")\n",
    "common_apis_categories.drop('numpy', axis=1, inplace=True)\n",
    "common_apis_categories.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the previous table, we can compute the category composition of the list of common APIs, which is as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>math</td>\n",
       "      <td>66</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>23</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>manipulation</td>\n",
       "      <td>22</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>creation</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>logical</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>signal_processing</td>\n",
       "      <td>14</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>indexing</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>binary_ops</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>(other)</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>utilities</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sets</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sorting</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   name\n",
       "category               \n",
       "math                 66\n",
       "linalg               23\n",
       "manipulation         22\n",
       "creation             19\n",
       "logical              18\n",
       "statistics           16\n",
       "signal_processing    14\n",
       "indexing              7\n",
       "binary_ops            3\n",
       "(other)               2\n",
       "utilities             2\n",
       "sets                  1\n",
       "sorting               1"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "common_apis_category_count = common_apis_categories.loc[:,['name', 'category']].fillna(value='(other)').groupby(by='category').count().sort_values(by='name', ascending=False)\n",
    "common_apis_category_count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From which we can compute the empirical distribution..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>math</td>\n",
       "      <td>0.340206</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>0.118557</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>manipulation</td>\n",
       "      <td>0.113402</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>creation</td>\n",
       "      <td>0.097938</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>logical</td>\n",
       "      <td>0.092784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>0.082474</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>signal_processing</td>\n",
       "      <td>0.072165</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>indexing</td>\n",
       "      <td>0.036082</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>binary_ops</td>\n",
       "      <td>0.015464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>(other)</td>\n",
       "      <td>0.010309</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>utilities</td>\n",
       "      <td>0.010309</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sets</td>\n",
       "      <td>0.005155</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sorting</td>\n",
       "      <td>0.005155</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       name\n",
       "category                   \n",
       "math               0.340206\n",
       "linalg             0.118557\n",
       "manipulation       0.113402\n",
       "creation           0.097938\n",
       "logical            0.092784\n",
       "statistics         0.082474\n",
       "signal_processing  0.072165\n",
       "indexing           0.036082\n",
       "binary_ops         0.015464\n",
       "(other)            0.010309\n",
       "utilities          0.010309\n",
       "sets               0.005155\n",
       "sorting            0.005155"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "common_apis_category_distribution = common_apis_category_count / common_apis_category_count.sum()\n",
    "common_apis_category_distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x11c078a10>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "common_apis_category_count.sort_values(by='name', ascending=True).plot.barh()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Summary\n",
    "\n",
    "In addition to the categories discussed above in the `Intersection` section, array libraries find general agreement in providing APIs for (1) logical operations, (2) signal processing, and (3) indexing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complement (common APIs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a table containing the complement of the above common APIs..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "COMMON_COMPLEMENT = pandas.read_csv(os.path.join(data_dir, 'common_complement.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "571"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(COMMON_COMPLEMENT)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>cupy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>jax</th>\n",
       "      <th>mxnet</th>\n",
       "      <th>pytorch</th>\n",
       "      <th>tensorflow</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.append</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>append</td>\n",
       "      <td>append</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.apply_along_axis</td>\n",
       "      <td>NaN</td>\n",
       "      <td>apply_along_axis</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.apply_over_axes</td>\n",
       "      <td>NaN</td>\n",
       "      <td>apply_over_axes</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.argpartition</td>\n",
       "      <td>argpartition</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>argpartition</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.argwhere</td>\n",
       "      <td>NaN</td>\n",
       "      <td>argwhere</td>\n",
       "      <td>NaN</td>\n",
       "      <td>argwhere</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    numpy          cupy        dask.array     jax  \\\n",
       "0            numpy.append           NaN               NaN  append   \n",
       "1  numpy.apply_along_axis           NaN  apply_along_axis     NaN   \n",
       "2   numpy.apply_over_axes           NaN   apply_over_axes     NaN   \n",
       "3      numpy.argpartition  argpartition               NaN     NaN   \n",
       "4          numpy.argwhere           NaN          argwhere     NaN   \n",
       "\n",
       "          mxnet pytorch tensorflow  \n",
       "0        append     NaN        NaN  \n",
       "1           NaN     NaN        NaN  \n",
       "2           NaN     NaN        NaN  \n",
       "3  argpartition     NaN        NaN  \n",
       "4      argwhere     NaN        NaN  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COMMON_COMPLEMENT.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the table above, the first column corresponds to the NumPy API (arranged in alphabetical order) and each subsequent column corresponds to an equivalent API in a respective array library. If an array library does not have an equivalent API, the row value for that array library is `NaN`.\n",
    "\n",
    "Using the API categorization data above, we can associate each NumPy API in the complement with its respective category..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>name</th>\n",
       "      <th>category</th>\n",
       "      <th>subcategory</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.append</td>\n",
       "      <td>manipulation</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.apply_along_axis</td>\n",
       "      <td>utilities</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.apply_over_axes</td>\n",
       "      <td>utilities</td>\n",
       "      <td>(other)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.argpartition</td>\n",
       "      <td>indexing</td>\n",
       "      <td>sorting</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.argwhere</td>\n",
       "      <td>indexing</td>\n",
       "      <td>searching</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     name      category subcategory\n",
       "0            numpy.append  manipulation     (other)\n",
       "1  numpy.apply_along_axis     utilities     (other)\n",
       "2   numpy.apply_over_axes     utilities     (other)\n",
       "3      numpy.argpartition      indexing     sorting\n",
       "4          numpy.argwhere      indexing   searching"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "common_complement_categories = pandas.merge(\n",
    "    COMMON_COMPLEMENT[['numpy']],\n",
    "    CATEGORIES[['name', 'category', 'subcategory']],\n",
    "    left_on='numpy',\n",
    "    right_on='name',\n",
    "    how='left'\n",
    ")\n",
    "common_complement_categories.drop('numpy', axis=1, inplace=True)\n",
    "common_complement_categories.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Downstream Library Usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Downstream library usage was measured by running test suites for each respective downstream library and recording NumPy API calls. For further details, see the API record tooling [repository](https://github.com/pydata-apis/python-api-record).\n",
    "\n",
    "Load a table containing API usage data..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "API_RECORD = pandas.read_csv(os.path.join(data_dir, 'vendor', 'record.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2039"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(API_RECORD.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>function</th>\n",
       "      <th>count</th>\n",
       "      <th>library</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.array</td>\n",
       "      <td>2092</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.nan</td>\n",
       "      <td>1988</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.ndarray.shape</td>\n",
       "      <td>690</td>\n",
       "      <td>skimage</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.arange</td>\n",
       "      <td>680</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.random</td>\n",
       "      <td>587</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>numpy.array</td>\n",
       "      <td>552</td>\n",
       "      <td>skimage</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>numpy.ndarray.dtype</td>\n",
       "      <td>542</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>numpy.zeros</td>\n",
       "      <td>447</td>\n",
       "      <td>skimage</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>numpy.random.mtrand.RandomState.randn</td>\n",
       "      <td>409</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>numpy.int64</td>\n",
       "      <td>359</td>\n",
       "      <td>pandas</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                function  count  library\n",
       "0                            numpy.array   2092   pandas\n",
       "1                              numpy.nan   1988   pandas\n",
       "2                    numpy.ndarray.shape    690  skimage\n",
       "3                           numpy.arange    680   pandas\n",
       "4                           numpy.random    587   pandas\n",
       "5                            numpy.array    552  skimage\n",
       "6                    numpy.ndarray.dtype    542   pandas\n",
       "7                            numpy.zeros    447  skimage\n",
       "8  numpy.random.mtrand.RandomState.randn    409   pandas\n",
       "9                            numpy.int64    359   pandas"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "API_RECORD.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above table, the first column corresponds to the NumPy API (arranged in descending order according to line count), and the second column corresponds to the name of the downstream library."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* * *\n",
    "\n",
    "## Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ranking (intersection)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the API record data, we can rank each API in the API intersection according to its relative usage and based on the following algorithm:\n",
    "\n",
    "-   For each downstream library, compute the relative invocation frequency for each NumPy API based on the total number of NumPy API invocations for that library.\n",
    "-   For each downstream library, rank NumPy APIs by invocation frequency in descending order (i.e., an API with a greater invocation frequency should have a higher rank).\n",
    "-   Sort NumPy APIs according to the number of downstream libraries which invoked each respective API (i.e., an API which is invoked by more downstream libraries should have a higher rank). The assumption here is that more widely invoked APIs are more \"essential\"/foundational, cutting across domains, than APIs which are invoked by one or two domain-specific libraries.\n",
    "-   In the event of a tie, sort by the median rank across each downstream library (i.e., an API with a higher median rank should have a higher rank).\n",
    "-   In the event of a tie based on median rank, sort by rank variance (i.e., an API having a more \"consistent\" rank--a lower variance--should have a higher rank).\n",
    "\n",
    "The ranking data is available as a precomputed table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "INTERSECTION_RANKS = pandas.read_csv(os.path.join(data_dir, 'intersection_ranks.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(INTERSECTION_RANKS.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>matplotlib</th>\n",
       "      <th>pandas</th>\n",
       "      <th>skimage</th>\n",
       "      <th>xarray</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.array</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.arange</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.sum</td>\n",
       "      <td>3</td>\n",
       "      <td>11</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.reshape</td>\n",
       "      <td>5</td>\n",
       "      <td>7</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.zeros</td>\n",
       "      <td>9</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>numpy.ones</td>\n",
       "      <td>4</td>\n",
       "      <td>12</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>numpy.transpose</td>\n",
       "      <td>12</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>9</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>numpy.mean</td>\n",
       "      <td>6</td>\n",
       "      <td>15</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>numpy.linspace</td>\n",
       "      <td>18</td>\n",
       "      <td>3</td>\n",
       "      <td>16</td>\n",
       "      <td>11</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>numpy.concatenate</td>\n",
       "      <td>14</td>\n",
       "      <td>9</td>\n",
       "      <td>9</td>\n",
       "      <td>16</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               numpy dask.array matplotlib pandas skimage xarray\n",
       "0        numpy.array          1          1      1       1      2\n",
       "1       numpy.arange          2          2      2       5      1\n",
       "2          numpy.sum          3         11      4       3     10\n",
       "3      numpy.reshape          5          7      3       6      3\n",
       "4        numpy.zeros          9          4      5       2      6\n",
       "5         numpy.ones          4         12      7       4      5\n",
       "6    numpy.transpose         12          6      8       9      7\n",
       "7         numpy.mean          6         15      6       8      8\n",
       "8     numpy.linspace         18          3     16      11      4\n",
       "9  numpy.concatenate         14          9      9      16     13"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "INTERSECTION_RANKS.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>matplotlib</th>\n",
       "      <th>pandas</th>\n",
       "      <th>skimage</th>\n",
       "      <th>xarray</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>54</td>\n",
       "      <td>numpy.linalg.inv</td>\n",
       "      <td>-</td>\n",
       "      <td>39</td>\n",
       "      <td>-</td>\n",
       "      <td>35</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>55</td>\n",
       "      <td>numpy.linalg.svd</td>\n",
       "      <td>42</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>36</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>56</td>\n",
       "      <td>numpy.conj</td>\n",
       "      <td>60</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>41</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>57</td>\n",
       "      <td>numpy.flip</td>\n",
       "      <td>54</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>50</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>58</td>\n",
       "      <td>numpy.trunc</td>\n",
       "      <td>57</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>52</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>59</td>\n",
       "      <td>numpy.linalg.qr</td>\n",
       "      <td>41</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>60</td>\n",
       "      <td>numpy.matmul</td>\n",
       "      <td>43</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>61</td>\n",
       "      <td>numpy.linalg.solve</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>44</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>62</td>\n",
       "      <td>numpy.trace</td>\n",
       "      <td>61</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>63</td>\n",
       "      <td>numpy.linalg.cholesky</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    numpy dask.array matplotlib pandas skimage xarray\n",
       "54       numpy.linalg.inv          -         39      -      35      -\n",
       "55       numpy.linalg.svd         42          -      -      36      -\n",
       "56             numpy.conj         60          -      -      41      -\n",
       "57             numpy.flip         54          -      -      50      -\n",
       "58            numpy.trunc         57          -      -       -     52\n",
       "59        numpy.linalg.qr         41          -      -       -      -\n",
       "60           numpy.matmul         43          -      -       -      -\n",
       "61     numpy.linalg.solve          -          -      -      44      -\n",
       "62            numpy.trace         61          -      -       -      -\n",
       "63  numpy.linalg.cholesky          -          -      -       -      -"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "INTERSECTION_RANKS.tail(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "Based on the record data, the most commonly used NumPy APIs which are shared among **all** analyzed array libraries are those for (1) array creation (e.g., `zeros`, `ones`, etc.), (2) array manipulation (e.g., `reshape`), (3) element-wise evaluation of elementary mathematical functions (e.g., `sin`, `cos`, etc.), and (4) statistical reductions (e.g., `mean`, `var`, `std`, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ranking (common APIs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to ranking the APIs found in the intersection, as done above, we can rank each API in the list of common APIs according to relative usage. The ranking data is available as a precomputed table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "COMMON_APIS_RANKS = pandas.read_csv(os.path.join(data_dir, 'common_apis_ranks.csv'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Compute the number of rows..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "194"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(COMMON_APIS_RANKS.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preview table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>matplotlib</th>\n",
       "      <th>pandas</th>\n",
       "      <th>skimage</th>\n",
       "      <th>xarray</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>numpy.array</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>numpy.arange</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>numpy.asarray</td>\n",
       "      <td>26</td>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "      <td>12</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>numpy.reshape</td>\n",
       "      <td>6</td>\n",
       "      <td>12</td>\n",
       "      <td>6</td>\n",
       "      <td>8</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>numpy.all</td>\n",
       "      <td>4</td>\n",
       "      <td>17</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>numpy.ones</td>\n",
       "      <td>5</td>\n",
       "      <td>19</td>\n",
       "      <td>14</td>\n",
       "      <td>4</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>numpy.sum</td>\n",
       "      <td>3</td>\n",
       "      <td>18</td>\n",
       "      <td>8</td>\n",
       "      <td>3</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>numpy.zeros</td>\n",
       "      <td>15</td>\n",
       "      <td>5</td>\n",
       "      <td>9</td>\n",
       "      <td>2</td>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>8</td>\n",
       "      <td>numpy.amax</td>\n",
       "      <td>9</td>\n",
       "      <td>8</td>\n",
       "      <td>19</td>\n",
       "      <td>5</td>\n",
       "      <td>16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>9</td>\n",
       "      <td>numpy.mean</td>\n",
       "      <td>7</td>\n",
       "      <td>29</td>\n",
       "      <td>10</td>\n",
       "      <td>13</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           numpy dask.array matplotlib pandas skimage xarray\n",
       "0    numpy.array          1          1      1       1      2\n",
       "1   numpy.arange          2          2      2       7      1\n",
       "2  numpy.asarray         26          3      4      12      3\n",
       "3  numpy.reshape          6         12      6       8      4\n",
       "4      numpy.all          4         17      3       6      7\n",
       "5     numpy.ones          5         19     14       4      6\n",
       "6      numpy.sum          3         18      8       3     13\n",
       "7    numpy.zeros         15          5      9       2      9\n",
       "8     numpy.amax          9          8     19       5     16\n",
       "9     numpy.mean          7         29     10      13     11"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COMMON_APIS_RANKS.head(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>numpy</th>\n",
       "      <th>dask.array</th>\n",
       "      <th>matplotlib</th>\n",
       "      <th>pandas</th>\n",
       "      <th>skimage</th>\n",
       "      <th>xarray</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>184</td>\n",
       "      <td>numpy.linalg.qr</td>\n",
       "      <td>124</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>185</td>\n",
       "      <td>numpy.matmul</td>\n",
       "      <td>126</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>186</td>\n",
       "      <td>numpy.triu</td>\n",
       "      <td>130</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>187</td>\n",
       "      <td>numpy.negative</td>\n",
       "      <td>139</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>188</td>\n",
       "      <td>numpy.linalg.lstsq</td>\n",
       "      <td>155</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>189</td>\n",
       "      <td>numpy.trace</td>\n",
       "      <td>178</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>190</td>\n",
       "      <td>numpy.vdot</td>\n",
       "      <td>179</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>191</td>\n",
       "      <td>numpy.linalg.cholesky</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>192</td>\n",
       "      <td>numpy.linalg.matrix_power</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>193</td>\n",
       "      <td>numpy.linalg.slogdet</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "      <td>-</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         numpy dask.array matplotlib pandas skimage xarray\n",
       "184            numpy.linalg.qr        124          -      -       -      -\n",
       "185               numpy.matmul        126          -      -       -      -\n",
       "186                 numpy.triu        130          -      -       -      -\n",
       "187             numpy.negative        139          -      -       -      -\n",
       "188         numpy.linalg.lstsq        155          -      -       -      -\n",
       "189                numpy.trace        178          -      -       -      -\n",
       "190                 numpy.vdot        179          -      -       -      -\n",
       "191      numpy.linalg.cholesky          -          -      -       -      -\n",
       "192  numpy.linalg.matrix_power          -          -      -       -      -\n",
       "193       numpy.linalg.slogdet          -          -      -       -      -"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "COMMON_APIS_RANKS.tail(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "Based on the record data, the most commonly used NumPy APIs which are common among analyzed array libraries are those for (1) array creation (e.g., `zeros`, `ones`, etc.), (2) array manipulation (e.g., `reshape`), (3) element-wise evaluation of elementary mathematical functions (e.g., `sin`, `cos`, etc.), and (4) statistical reductions (e.g., `amax`, `amin`, `mean`, `var`, `std`, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Downstream API Usage Categories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load a precomputed table containing the API usage categories for the top `100` NumPy array APIs for each downstream library..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "LIB_TOP_100_CATEGORY_STATS = pandas.read_csv(os.path.join(data_dir, 'lib_top_100_category_stats.csv'), index_col='category')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "View table contents..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>dask.array</th>\n",
       "      <th>matplotlib</th>\n",
       "      <th>pandas</th>\n",
       "      <th>skimage</th>\n",
       "      <th>xarray</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>category</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>(other)</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>2</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>binary_ops</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>creation</td>\n",
       "      <td>11</td>\n",
       "      <td>18</td>\n",
       "      <td>17</td>\n",
       "      <td>19</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>datetime</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>indexing</td>\n",
       "      <td>6</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>io</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>linalg</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>logical</td>\n",
       "      <td>8</td>\n",
       "      <td>10</td>\n",
       "      <td>12</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>manipulation</td>\n",
       "      <td>6</td>\n",
       "      <td>19</td>\n",
       "      <td>10</td>\n",
       "      <td>19</td>\n",
       "      <td>11</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>math</td>\n",
       "      <td>32</td>\n",
       "      <td>25</td>\n",
       "      <td>26</td>\n",
       "      <td>23</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sets</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>signal_processing</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>sorting</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>statistics</td>\n",
       "      <td>15</td>\n",
       "      <td>6</td>\n",
       "      <td>14</td>\n",
       "      <td>10</td>\n",
       "      <td>17</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>utilities</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                   dask.array  matplotlib  pandas  skimage  xarray\n",
       "category                                                          \n",
       "(other)                     1           4       5        2       4\n",
       "binary_ops                  3           0       0        1       0\n",
       "creation                   11          18      17       19      15\n",
       "datetime                    0           0       0        0       1\n",
       "indexing                    6           5       6        7       6\n",
       "io                          0           0       0        1       0\n",
       "linalg                      4           3       2        5       4\n",
       "logical                     8          10      12        6       7\n",
       "manipulation                6          19      10       19      11\n",
       "math                       32          25      26       23      29\n",
       "sets                        1           1       2        1       1\n",
       "signal_processing          10           3       0        0       0\n",
       "sorting                     1           1       2        1       0\n",
       "statistics                 15           6      14       10      17\n",
       "utilities                   2           5       4        5       5"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "LIB_TOP_100_CATEGORY_STATS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "groups = LIB_TOP_100_CATEGORY_STATS.index.values\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "index = np.arange(len(groups))\n",
    "bar_width = 0.15\n",
    "\n",
    "rects1 = plt.bar(index-(1*bar_width), LIB_TOP_100_CATEGORY_STATS['dask.array'], bar_width, label='dask.array')\n",
    "rects2 = plt.bar(index-(0*bar_width), LIB_TOP_100_CATEGORY_STATS['matplotlib'], bar_width, label='matplotlib')\n",
    "rects3 = plt.bar(index+(1*bar_width), LIB_TOP_100_CATEGORY_STATS['pandas'], bar_width, label='pandas')\n",
    "rects4 = plt.bar(index+(2*bar_width), LIB_TOP_100_CATEGORY_STATS['skimage'], bar_width, label='skimage')\n",
    "rects5 = plt.bar(index+(3*bar_width), LIB_TOP_100_CATEGORY_STATS['xarray'], bar_width, label='xarray')\n",
    "\n",
    "plt.title('Array API Categories')\n",
    "plt.xlabel('Categories')\n",
    "plt.ylabel('Count')\n",
    "plt.xticks(index + bar_width, groups)\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Summary\n",
    "\n",
    "As shown in the chart, the top four most common categories for the top `100` NumPy APIs consumed by each downstream library are those for (1) element-wise evaluation of elementary mathematical functions, (2) array creation, (3) array manipulation, and (4) statistical reductions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}