numeric-protocols.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Numeric ABCs and Protocols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.8.2 (default, Mar 11 2020, 00:28:52) \\n[Clang 11.0.0 (clang-1100.0.33.17)]'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import numbers\n",
    "import operator\n",
    "import typing\n",
    "import numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "abcs = [numbers.Complex, numbers.Real, numbers.Integral]\n",
    "protocols = [typing.SupportsComplex, typing.SupportsFloat, typing.SupportsInt,\n",
    "             typing.SupportsIndex]\n",
    "py_nums = [complex, float, int]\n",
    "converters = py_nums + [operator.index]\n",
    "np_nums = [numpy.complex64, numpy.float16, numpy.uint8]\n",
    "types = [t for pair in itertools.zip_longest(py_nums, np_nums) for t in pair]\n",
    "samples = [t(1) for t in types]\n",
    "ifaces = [t for pair in itertools.zip_longest(abcs, protocols, converters) for t in pair]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                |builtins |  numpy  |builtins |  numpy  |builtins |  numpy  |\n",
      "                | complex |complex64|  float  | float16 |   int   |  uint8  |\n",
      "-----------------------------------------------------------------------------\n",
      "         samples| (1+0j)  | (1+0j)  |   1.0   |   1.0   |    1    |    1    |\n",
      "-----------------------------------------------------------------------------\n",
      " numbers.Complex|    •    |    •    |    •    |    •    |    •    |    •    |\n",
      " SupportsComplex|         |    •    |         |         |         |         |\n",
      "         complex| (1+0j)  | (1+0j)  | (1+0j)  | (1+0j)  | (1+0j)  | (1+0j)  |\n",
      "-----------------------------------------------------------------------------\n",
      "    numbers.Real|         |         |    •    |    •    |    •    |    •    |\n",
      "   SupportsFloat|    •    |    •    |    •    |    •    |    •    |    •    |\n",
      "           float|TypeError|   1.0   |   1.0   |   1.0   |   1.0   |   1.0   |\n",
      "-----------------------------------------------------------------------------\n",
      "numbers.Integral|         |         |         |         |    •    |    •    |\n",
      "     SupportsInt|    •    |    •    |    •    |    •    |    •    |    •    |\n",
      "             int|TypeError|    1    |    1    |    1    |    1    |    1    |\n",
      "-----------------------------------------------------------------------------\n",
      "   SupportsIndex|         |         |         |         |    •    |    •    |\n",
      "           index|TypeError|TypeError|TypeError|TypeError|    1    |    1    |\n",
      "-----------------------------------------------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-8-daedfa318ff5>:31: ComplexWarning: Casting complex values to real discards the imaginary part\n",
      "  new = iface(o)\n"
     ]
    }
   ],
   "source": [
    "CWIDTH = 9\n",
    "BORDER = '-' * ((CWIDTH + 1) * 6 + 17)\n",
    "print(' ' * 16, end='')\n",
    "for t in types:\n",
    "    print(f'|{t.__module__:^{CWIDTH}}', end='')\n",
    "print('|')\n",
    "\n",
    "print(' ' * 16, end='')\n",
    "for t in types:\n",
    "    print(f'|{t.__name__:^{CWIDTH}}', end='')\n",
    "print('|\\n' + BORDER)\n",
    "\n",
    "print('samples'.rjust(16), end='')\n",
    "for o in samples:\n",
    "    print(f'|{o!r:^{CWIDTH}}', end='')           \n",
    "print('|\\n' + BORDER)\n",
    "\n",
    "\n",
    "for iface in ifaces:\n",
    "    if iface is None:\n",
    "        continue\n",
    "    # row heading\n",
    "    name = iface.__name__\n",
    "    if iface.__module__ == 'numbers':\n",
    "        name = 'numbers.' + name\n",
    "    print(f'{name:>16}', end='')\n",
    "    # cells\n",
    "    if iface in converters:\n",
    "        for o in samples:\n",
    "            try:\n",
    "                new = iface(o)\n",
    "            except TypeError as e:\n",
    "                new = e.__class__.__name__\n",
    "            print(f'|{new:^{CWIDTH}}', end='')           \n",
    "        print('|\\n' + BORDER)\n",
    "    else:\n",
    "        for o in samples:\n",
    "            mark = '\\N{BULLET}' if isinstance(o, iface) else ''\n",
    "            print(f'|{mark:^{CWIDTH}}', end='')           \n",
    "        print('|')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1+0j), (1+0j))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "py_complex = 1+0j\n",
    "np_complex = numpy.complex64(py_complex)\n",
    "py_complex, np_complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(complex, numpy.complex64)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(py_complex), type(np_complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import SupportsComplex, SupportsFloat, SupportsInt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, True)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(py_complex, SupportsComplex), isinstance(np_complex, SupportsComplex), "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1+0j), (1+0j))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "complex(py_complex), complex(np_complex)"
   ]
  },
  {
   "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.8.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}