nimd-testing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1dbb5ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b86b512",
   "metadata": {},
   "outputs": [],
   "source": [
    "digits='0123456789'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "fdc9178b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_type_size(t):\n",
    "    s=[i for i in t if i in digits]\n",
    "    return int(''.join(s))\n",
    "\n",
    "def get_simd_size(t):\n",
    "    return int(t.split('x')[-1])\n",
    "\n",
    "def get_simd_type(t):\n",
    "    return t.split('x')[0]\n",
    "\n",
    "def get_base_type(t):\n",
    "    s=[i for i in t if i not in digits+'x']\n",
    "    return (''.join(s))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e98a5bdd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def identify_retval_table(df):\n",
    "    return any('Vec' in str(c) for c in df.columns) and 'Ret' in df.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7a532474",
   "metadata": {},
   "outputs": [],
   "source": [
    "def identify_parameters_table(df):\n",
    "    t=df.iloc[0, 0]\n",
    "    if type(t)==str:\n",
    "        return t.startswith('a')\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8c854390",
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_binop(t):\n",
    "    return len([i for i in t.split(',') if i.strip()])>1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e601634f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_retvals_tables(url, ops, default):\n",
    "    ret={}\n",
    "    for op in ops:\n",
    "        tables=pd.read_html(url+op+'.html')\n",
    "        retval_tables=[t for t in tables if identify_retval_table(t)]\n",
    "        params=[t for t in tables if identify_parameters_table(t)]\n",
    "        binop=True\n",
    "        if params:\n",
    "            binop=is_binop(params[-1].iloc[0, 0])\n",
    "        retval_table=retval_tables[-1] if retval_tables else default(binop)\n",
    "        ret[op]=retval_table\n",
    "    return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "cb7ebbea",
   "metadata": {},
   "outputs": [],
   "source": [
    "types=pd.DataFrame([(\"uint\", \"uint8\", 16),\n",
    "(\"int\", \"int8\", 16),\n",
    "(\"uint\", \"uint16\", 8),\n",
    "(\"int\", \"int16\", 8),\n",
    "(\"uint\", \"uint32\", 4),\n",
    "(\"int\", \"int32\", 4),\n",
    "(\"uint\", \"uint64\", 2),\n",
    "(\"int\", \"int64\", 2),\n",
    "(\"float\", \"float32\", 4),\n",
    "(\"float\", \"float64\", 2),\n",
    "(\"uint\", \"uint8\", 32),\n",
    "(\"int\", \"int8\", 32),\n",
    "(\"uint\", \"uint16\", 16),\n",
    "(\"int\", \"int16\", 16),\n",
    "(\"uint\", \"uint32\", 8),\n",
    "(\"int\", \"int32\", 8),\n",
    "(\"uint\", \"uint64\", 4),\n",
    "(\"int\", \"int64\", 4),\n",
    "(\"float\", \"float32\", 8),\n",
    "(\"float\", \"float64\", 4),\n",
    "(\"uint\", \"uint8\", 64),\n",
    "(\"int\", \"int8\", 64),\n",
    "(\"uint\", \"uint16\", 32),\n",
    "(\"int\", \"int16\", 32),\n",
    "(\"uint\", \"uint32\", 16),\n",
    "(\"int\", \"int32\", 16),\n",
    "(\"uint\", \"uint64\", 8),\n",
    "(\"int\", \"int64\", 8),\n",
    "(\"float\", \"float32\", 16),\n",
    "(\"float\", \"float64\", 8),], columns=['base_type', 'size_type', 'size'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "912cd312",
   "metadata": {},
   "outputs": [],
   "source": [
    "types['width']=types.size_type.apply(get_type_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "78674ec0",
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_types=types.iloc[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "46ed1c4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "mask_types['base_type']='mask_'+mask_types['base_type']\n",
    "mask_types['size_type']='mask_'+mask_types['size_type']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5ae83859",
   "metadata": {},
   "outputs": [],
   "source": [
    "types=pd.concat([types, mask_types]).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "28b0fc8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "types['floating']=types.base_type.str.contains('float')\n",
    "types['mask']=types.base_type.str.contains('mask')\n",
    "\n",
    "types['simd_type']=types.size_type+'x'+types['size'].astype(str)\n",
    "\n",
    "types['int'] = types.base_type.str.contains('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d91c6f94",
   "metadata": {},
   "outputs": [],
   "source": [
    "def default_retval(ints=True, floating=True, mask=False, binop=True):\n",
    "    temp = types[types.floating==floating]\n",
    "    temp = temp[temp['int']==ints]\n",
    "    temp = temp[types['mask']==mask]\n",
    "    simd_types=temp.simd_type.drop_duplicates().values\n",
    "    if binop:\n",
    "        return pd.DataFrame({'Ret':simd_types, 'Vec1':simd_types, 'Vec2':simd_types})\n",
    "    return pd.DataFrame({'Ret':simd_types, 'Vec':simd_types})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "827f438f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#bitwise ops\n",
    "bitops_base_url='https://p12tic.github.io/libsimdpp/v2.2-dev/libsimdpp/w/bitwise/'\n",
    "bitops=[\n",
    "    'bit_and',\n",
    "    'bit_andnot',\n",
    "    'bit_or',\n",
    "    'bit_xor',\n",
    "    'bit_not'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4ddd3ec5",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_278259/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_278259/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_278259/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_278259/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_278259/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n"
     ]
    }
   ],
   "source": [
    "bitops_retvals=get_retvals_tables(bitops_base_url, bitops, default=lambda bo: default_retval(floating=False, binop=bo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6507e8ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "#floating ops\n",
    "floatops_base_url='https://p12tic.github.io/libsimdpp/v2.2-dev/libsimdpp/w/fp/'\n",
    "floatops=['add',\n",
    " 'sub',\n",
    " 'mul',\n",
    " 'div',\n",
    " 'fmadd',\n",
    " 'fmsub',\n",
    " 'neg',\n",
    " 'cmp_eq',\n",
    " 'cmp_neq',\n",
    " 'cmp_lt',\n",
    " 'cmp_gt',\n",
    " 'cmp_le',\n",
    " 'cmp_ge',\n",
    " 'abs',\n",
    " 'sign',\n",
    " 'min',\n",
    " 'max',\n",
    " 'isnan',\n",
    " 'isnan2',\n",
    " 'sqrt',\n",
    " 'rcp_e',\n",
    " 'rcp_rh',\n",
    " 'rsqrt_e',\n",
    " 'rsqrt_rh',\n",
    " 'reduce_add',\n",
    " 'reduce_mul',\n",
    " 'reduce_min',\n",
    " 'reduce_max']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "ab720af0",
   "metadata": {},
   "outputs": [],
   "source": [
    "floatops_retvals=get_retvals_tables(floatops_base_url, floatops, default=lambda bo: default_retval(False, binop=bo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "85226d66",
   "metadata": {},
   "outputs": [],
   "source": [
    "#int ops\n",
    "intops_base_url='https://p12tic.github.io/libsimdpp/v2.2-dev/libsimdpp/w/int/'\n",
    "intops=['add',\n",
    " 'sub',\n",
    " 'add_sat',\n",
    " 'sub_sat',\n",
    " 'mul_lo',\n",
    " 'mul_hi',\n",
    " 'mull',\n",
    " 'neg',\n",
    " 'cmp_eq',\n",
    " 'cmp_neq',\n",
    " 'cmp_lt',\n",
    " 'cmp_gt',\n",
    " 'cmp_le',\n",
    " 'cmp_ge',\n",
    " 'abs',\n",
    " 'avg',\n",
    " 'avg_trunc',\n",
    " 'min',\n",
    " 'max',\n",
    " 'shift_l',\n",
    " 'shift_r',\n",
    " 'reduce_add',\n",
    " 'reduce_mul',\n",
    " 'reduce_min',\n",
    " 'reduce_max',\n",
    " 'reduce_and',\n",
    " 'reduce_or']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "5749afe2",
   "metadata": {},
   "outputs": [],
   "source": [
    "intops_retvals=get_retvals_tables(intops_base_url, intops, default=lambda bo: default_retval(True, False, binop=bo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b8e49e0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ns=\"simdpp::\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "7d21d19c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def translate_type(t):\n",
    "    if t.endswith('_t'): t=t[:-2]\n",
    "    if t=='double': t='float64'\n",
    "    if t=='float': t='float32'\n",
    "    return t\n",
    "\n",
    "def derive_from_description(t):\n",
    "    words = t.split(' ')\n",
    "    ret = []\n",
    "    for w in words:\n",
    "        w = translate_type(w)\n",
    "        if w in types.base_type.unique() or w in types.size_type.unique() or w in types.simd_type.unique():\n",
    "            ret.append(w)\n",
    "        elif w=='mask':\n",
    "            ret+=types[types['mask']]['base_type'].tolist()\n",
    "    return ret\n",
    "\n",
    "def get_best_type_table(t, dd=True):\n",
    "    if dd:\n",
    "        t = derive_from_description(t)\n",
    "    else:\n",
    "        t=[t]\n",
    "    if len(t)==1:\n",
    "        t=t[0]\n",
    "        a = types[types.size_type==t]\n",
    "        b = types[types.simd_type==t]\n",
    "        c = types[types.base_type==t]\n",
    "        return sorted([a, b, c], key=lambda x: len(x))[-1]\n",
    "    else:\n",
    "        ret=[]\n",
    "        for ty in t:\n",
    "            ret.append(get_best_type_table(ty, False))\n",
    "        return pd.concat(ret)\n",
    "# def get_type_combinations(ts):\n",
    "    \n",
    "#     ts=[get_best_type_table(t) for t in ts]\n",
    "#     sizes=set(ts[0]['size'].values)\n",
    "#     for t in ts[1:]:\n",
    "#         sizes = sizes.intersection(set(t['size'].values))\n",
    "#     ts=[t[t['size'].isin(sizes)] for t in ts]\n",
    "#     import pdb; pdb.set_trace()\n",
    "#     for s in sizes:\n",
    "#         ret=[]\n",
    "#         for t in ts:\n",
    "#             ret.append(t[t['size']==s].iloc[0]['simd_type'])\n",
    "        \n",
    "#         yield ret\n",
    "\n",
    "def get_type_combinations(ts):\n",
    "#     import pdb; pdb.set_trace()\n",
    "    tables=[get_best_type_table(t) for t in ts]\n",
    "    unique_sizes=[t['size'].unique().tolist() for t in tables]\n",
    "    sizes=set(unique_sizes[0])\n",
    "    for s in unique_sizes[1:]:\n",
    "        sizes=sizes.intersection(set(s))\n",
    "#     sizes={i for j in () for i in j}\n",
    "    ts = [t.size_type.iloc[0] for t in tables]\n",
    "    tables = pd.concat(tables)\n",
    "    tables=tables[tables['size'].isin(sizes)]\n",
    "    for s in sizes:\n",
    "        y = [f\"{t}x{s}\" for t in ts]\n",
    "#         if \"int32x32\" in y:\n",
    "#             import pdb; pdb.set_trace()\n",
    "        yield y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ef6d9a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "def type_lookup(kt, k, vt):\n",
    "    return types[types[kt]==k][vt].iloc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "f54bef0d",
   "metadata": {},
   "outputs": [],
   "source": [
    "aliases={\n",
    "    'add':'`+`',\n",
    "    'sub':'`-`',\n",
    "    'neg':'`-`',\n",
    "    'mul':'`*`',\n",
    "    'div':'`/`',\n",
    "    'divide':'`/`',\n",
    "    'mull':'`*`',\n",
    "    'shift_l':'`<<`',\n",
    "    'shift_r':'`>>`',\n",
    "     'cmp_eq': '`==`',\n",
    "     'cmp_neq': '`~=`',\n",
    "     'cmp_lt': '`<`',\n",
    "     'cmp_gt': '`>`',\n",
    "     'cmp_le': '`<=`',\n",
    "     'cmp_ge': '`>=`',\n",
    "    'bit_and': '`&`',\n",
    "    'bit_andnot': '`&~`',\n",
    "    'bit_or': '`|`',\n",
    "    'bit_xor': '`^`',\n",
    "    'bit_not': '`~`',\n",
    "    'fmadd': '`*+`',\n",
    "    'fmsub': '`*-`',\n",
    "}\n",
    "\n",
    "special={\n",
    "    'fmadd': 'a * b + c',\n",
    "    'fmsub': 'a * b - c',\n",
    "    '`*+`': 'a * b + c',\n",
    "    '`*-`': 'a * b - c',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "eee65ada",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_numpy_res(op, a, b = None, c = None):\n",
    "    if op in special:\n",
    "        op = special[op]\n",
    "        return eval(op)\n",
    "    if op in aliases:\n",
    "        op=aliases[op]\n",
    "\n",
    "    op=op.replace('`', '')\n",
    "    if b is not None:\n",
    "        return eval(f\"a {op} b\")\n",
    "    try:\n",
    "        return eval(f\"np.{op}(a)\")\n",
    "    except:\n",
    "        try:\n",
    "            return eval(f\"{op} a\")\n",
    "        except:\n",
    "            return eval(f\"a.{op}()\")"
   ]
  },
  {
   "cell_type": "raw",
   "id": "072222e7",
   "metadata": {},
   "source": [
    "values_to_choose = {\"float\": [float(i) for i in range(100) if i]+[float(-i) for i in range(100) if i],\n",
    "    \"int\": [i for i in range(100) if i]+[-i for i in range(100) if i],\n",
    "    \"uint\": [i for i in range(100) if i]}\n",
    "def gen_bin_op(op, op_name, arg_type, ret_type, arg2_type=None):\n",
    "    if arg2_type is None: arg2_type=arg_type\n",
    "    size1 = type_lookup('simd_type', arg_type, 'size')\n",
    "    size2 = type_lookup('simd_type', arg2_type, 'size')\n",
    "    size_type1 = type_lookup('simd_type', arg_type, 'size_type')\n",
    "    size_type2 = type_lookup('simd_type', arg2_type, 'size_type')\n",
    "    arg1 = np.random.choice(values_to_choose[type_lookup('simd_type', arg_type, 'base_type')],  size1).astype(size_type1)\n",
    "    arg2 = np.random.choice(values_to_choose[type_lookup('simd_type', arg2_type, 'base_type')],  size2).astype(size_type2)\n",
    "    res = get_numpy_res(op, arg1, arg2).astype(size_type1).tolist()\n",
    "    arg1=[str(i) for i in arg1]\n",
    "    arg2=[str(i) for i in arg2]\n",
    "    simd_arg1 = arg1[:]\n",
    "    simd_arg1[0] = f'{size_type1}({simd_arg1[0]})'\n",
    "    simd_arg1 = f\"Vector({', '.join(simd_arg1)})\"\n",
    "    simd_arg2 = arg2[:]\n",
    "    simd_arg2[0] = f'{size_type2}({simd_arg2[0]})'\n",
    "    simd_arg2 = f\"Vector({', '.join(simd_arg2)})\"\n",
    "    return f'''\n",
    "test \"op: {op}, op_name: {op_name}, arg_type: {arg_type}, ret_type: {ret_type}, arg2_type: {arg2_type}\":###\n",
    "  check ({op}({simd_arg1}, {simd_arg2})).to_array == {res}###'''\n",
    "\n",
    "def gen_tri_op(op, op_name, arg_type, ret_type, arg2_type=None, arg3_type=None):\n",
    "    if arg2_type is None: arg2_type=arg_type\n",
    "    if arg3_type is None: arg3_type=arg2_type\n",
    "    size1 = type_lookup('simd_type', arg_type, 'size')\n",
    "    size2 = type_lookup('simd_type', arg2_type, 'size')\n",
    "    size3 = type_lookup('simd_type', arg3_type, 'size')\n",
    "    size_type1 = type_lookup('simd_type', arg_type, 'size_type')\n",
    "    size_type2 = type_lookup('simd_type', arg2_type, 'size_type')\n",
    "    size_type3 = type_lookup('simd_type', arg3_type, 'size_type')\n",
    "    arg1 = np.random.choice(values_to_choose[type_lookup('simd_type', arg_type, 'base_type')],  size1).astype(size_type1)\n",
    "    arg2 = np.random.choice(values_to_choose[type_lookup('simd_type', arg2_type, 'base_type')],  size2).astype(size_type2)\n",
    "    arg3 = np.random.choice(values_to_choose[type_lookup('simd_type', arg3_type, 'base_type')],  size3).astype(size_type3)\n",
    "    res = get_numpy_res(op, arg1, arg2, arg3).tolist()\n",
    "    arg1=[str(i) for i in arg1]\n",
    "    arg2=[str(i) for i in arg2]\n",
    "    arg3=[str(i) for i in arg3]\n",
    "    simd_arg1 = arg1[:]\n",
    "    simd_arg1[0] = f'{size_type1}({simd_arg1[0]})'\n",
    "    simd_arg1 = f\"Vector({', '.join(simd_arg1)})\"\n",
    "    simd_arg2 = arg2[:]\n",
    "    simd_arg2[0] = f'{size_type2}({simd_arg2[0]})'\n",
    "    simd_arg2 = f\"Vector({', '.join(simd_arg2)})\"\n",
    "    simd_arg3 = arg3[:]\n",
    "    simd_arg3[0] = f'{size_type3}({simd_arg3[0]})'\n",
    "    simd_arg3 = f\"Vector({', '.join(simd_arg3)})\"\n",
    "    return f'''\n",
    "test \"op: {op}, op_name: {op_name}, arg_type: {arg_type}, ret_type: {ret_type}, arg2_type: {arg2_type}, arg3_type: {arg3_type}\":###\n",
    "  check ({op}({simd_arg1}, {simd_arg2}, {simd_arg3})).to_array == {res}###'''\n",
    "\n",
    "def gen_uni_op(op, op_name, arg_type, ret_type):\n",
    "    size1 = type_lookup('simd_type', arg_type, 'size')\n",
    "    size_type1 = type_lookup('simd_type', arg_type, 'size_type')\n",
    "    arg1 = np.random.choice(values_to_choose[type_lookup('simd_type', arg_type, 'base_type')],  size1).astype(size_type1)\n",
    "    res = get_numpy_res(op, arg1).tolist()\n",
    "    arg1=[str(i) for i in arg1]\n",
    "    simd_arg1 = arg1[:]\n",
    "    simd_arg1[0] = f'{size_type1}({simd_arg1[0]})'\n",
    "    simd_arg1 = f\"Vector({', '.join(simd_arg1)})\"\n",
    "    return f'''\n",
    "test \"op: {op}, op_name: {op_name}, arg_type: {arg_type}, ret_type: {ret_type}\":###\n",
    "  check ({op}({simd_arg1})).to_array == {res}###'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e5b69369",
   "metadata": {},
   "outputs": [],
   "source": [
    "bad_types=['int8x32', 'int8x64', 'uint8x32', 'uint8x64', 'int16x32', 'int16x64', 'uint16x32', 'uint16x64']\n",
    "types=types[~types.simd_type.isin(bad_types)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "4fc25c5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_parser_type(s):\n",
    "    if 'mask' in s:\n",
    "        raise TypeError('no mask support')\n",
    "    return f\"{s[0]}{type_lookup('size_type', s, 'width')}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "e8a45ea5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_bin_op(op, op_name, arg_type, ret_type, arg2_type=None):\n",
    "    if arg2_type is None: arg2_type=arg_type\n",
    "    size1 = type_lookup('simd_type', arg_type, 'size')\n",
    "    size2 = type_lookup('simd_type', arg2_type, 'size')\n",
    "    size_type1 = type_lookup('simd_type', arg_type, 'size_type')\n",
    "    size_type2 = type_lookup('simd_type', arg2_type, 'size_type')\n",
    "    size_type_ret = type_lookup('simd_type', ret_type, 'size_type')\n",
    "    ret_width = type_lookup('simd_type', arg_type, 'width')\n",
    "    arg1 = np.random.randint(5, 10, size=size1).astype(size_type1)\n",
    "    arg2 = np.random.randint(1, 5, size=size2).astype(size_type2)\n",
    "    res = get_numpy_res(op, arg1, arg2).astype(size_type1).tolist()\n",
    "    res = [f\"{i}{get_parser_type(size_type_ret)}\" for i in res]\n",
    "    arg1=[str(i) for i in arg1]\n",
    "    arg2=[str(i) for i in arg2]\n",
    "    simd_arg1 = arg1[:]\n",
    "    simd_arg1[0] = f'{size_type1}({simd_arg1[0]})'\n",
    "    simd_arg1 = f\"Vector({', '.join(simd_arg1)})\"\n",
    "    simd_arg2 = arg2[:]\n",
    "    simd_arg2[0] = f'{size_type2}({simd_arg2[0]})'\n",
    "    simd_arg2 = f\"Vector({', '.join(simd_arg2)})\"\n",
    "    return f'''\n",
    "test \"op: {op}, op_name: {op_name}, arg_type: {arg_type}, ret_type: {ret_type}, arg2_type: {arg2_type}\":###\n",
    "  check compare(({op}({simd_arg1}, {simd_arg2})).to_seq, @[{', '.join(res)}])###'''\n",
    "\n",
    "def gen_tri_op(op, op_name, arg_type, ret_type, arg2_type=None, arg3_type=None):\n",
    "    if arg2_type is None: arg2_type=arg_type\n",
    "    if arg3_type is None: arg3_type=arg2_type\n",
    "    size1 = type_lookup('simd_type', arg_type, 'size')\n",
    "    size2 = type_lookup('simd_type', arg2_type, 'size')\n",
    "    size3 = type_lookup('simd_type', arg3_type, 'size')\n",
    "    size_type1 = type_lookup('simd_type', arg_type, 'size_type')\n",
    "    size_type2 = type_lookup('simd_type', arg2_type, 'size_type')\n",
    "    size_type3 = type_lookup('simd_type', arg3_type, 'size_type')\n",
    "    size_type_ret = type_lookup('simd_type', ret_type, 'size_type')\n",
    "    ret_width = type_lookup('simd_type', arg_type, 'width')\n",
    "    arg1 = np.random.randint(5, 10, size=size1).astype(size_type1)\n",
    "    arg2 = np.random.randint(1, 5, size=size2).astype(size_type2)\n",
    "    arg3 = np.random.randint(1, 5, size=size3).astype(size_type3)\n",
    "    res = get_numpy_res(op, arg1, arg2, arg3).tolist()\n",
    "\n",
    "    res = [f\"{i}{get_parser_type(size_type_ret)}\" for i in res]\n",
    "\n",
    "    arg1=[str(i) for i in arg1]\n",
    "    arg2=[str(i) for i in arg2]\n",
    "    arg3=[str(i) for i in arg3]\n",
    "    simd_arg1 = arg1[:]\n",
    "    simd_arg1[0] = f'{size_type1}({simd_arg1[0]})'\n",
    "    simd_arg1 = f\"Vector({', '.join(simd_arg1)})\"\n",
    "    simd_arg2 = arg2[:]\n",
    "    simd_arg2[0] = f'{size_type2}({simd_arg2[0]})'\n",
    "    simd_arg2 = f\"Vector({', '.join(simd_arg2)})\"\n",
    "    simd_arg3 = arg3[:]\n",
    "    simd_arg3[0] = f'{size_type3}({simd_arg3[0]})'\n",
    "    simd_arg3 = f\"Vector({', '.join(simd_arg3)})\"\n",
    "    return f'''\n",
    "test \"op: {op}, op_name: {op_name}, arg_type: {arg_type}, ret_type: {ret_type}, arg2_type: {arg2_type}, arg3_type: {arg3_type}\":###\n",
    "  check compare(({op}({simd_arg1}, {simd_arg2}, {simd_arg3})).to_seq, @[{', '.join(res)}])###'''\n",
    "\n",
    "def gen_uni_op(op, op_name, arg_type, ret_type):\n",
    "    size1 = type_lookup('simd_type', arg_type, 'size')\n",
    "    size_type1 = type_lookup('simd_type', arg_type, 'size_type')\n",
    "    size_type_ret = type_lookup('simd_type', ret_type, 'size_type')\n",
    "    ret_width = type_lookup('simd_type', arg_type, 'width')\n",
    "    arg1 = np.random.randint(1, 10, size=size1).astype(size_type1)\n",
    "    res = get_numpy_res(op, arg1).tolist()\n",
    "    res = [f\"{i}{get_parser_type(size_type_ret)}\" for i in res]\n",
    "    arg1=[str(i) for i in arg1]\n",
    "    simd_arg1 = arg1[:]\n",
    "    simd_arg1[0] = f'{size_type1}({simd_arg1[0]})'\n",
    "    simd_arg1 = f\"Vector({', '.join(simd_arg1)})\"\n",
    "    return f'''\n",
    "test \"op: {op}, op_name: {op_name}, arg_type: {arg_type}, ret_type: {ret_type}\":###\n",
    "  check compare(({op}({simd_arg1})).to_seq, @[{', '.join(res)}])###'''"
   ]
  },
  {
   "cell_type": "raw",
   "id": "fd36055b",
   "metadata": {},
   "source": [
    "print(gen_tri_op('fmadd', 'fmadd', 'float32x4', 'float32x4', 'float32x4'))\n",
    "\n",
    "print(gen_bin_op('`*`', 'add', 'float32x4', 'float32x4'))\n",
    "\n",
    "print(gen_uni_op('`~`', 'bit_not', 'uint64x4', 'uint64x4'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "a99f846f",
   "metadata": {},
   "outputs": [],
   "source": [
    "keywords={'div':'divide'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "df982758",
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_op(op):\n",
    "    if op in keywords:\n",
    "        return keywords[op]\n",
    "    return op"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "dea29322",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_op(op, retvals):\n",
    "#     import pdb; pdb.set_trace()\n",
    "    binop=retvals.shape[1]>2 and 'Vec3' not in retvals.columns\n",
    "    triop=retvals.shape[1]>3 and 'Vec3' in retvals.columns\n",
    "    if binop:\n",
    "        for i in range(len(retvals)):\n",
    "            temp=retvals.iloc[i]\n",
    "            for c in get_type_combinations([temp['Ret'], temp['Vec1'], temp['Vec2']]):\n",
    "                output(gen_bin_op(name_op(op), op, c[1], c[0], c[2]))\n",
    "                if op in aliases:\n",
    "                    output(gen_bin_op(aliases[op], op, c[1], c[0], c[2]))\n",
    "    elif triop:\n",
    "        for i in range(len(retvals)):\n",
    "            temp=retvals.iloc[i]\n",
    "            for c in get_type_combinations([temp['Ret'], temp['Vec1'], temp['Vec2'], temp['Vec3']]):\n",
    "                output(gen_tri_op(name_op(op), op, c[1], c[0], c[2], c[3]))\n",
    "                if op in aliases:\n",
    "                    output(gen_tri_op(aliases[op], op, c[1], c[0], c[2], c[3]))\n",
    "    else:\n",
    "        for i in range(len(retvals)):\n",
    "            temp=retvals.iloc[i].to_dict()\n",
    "            vec=[v for k,v in temp.items() if 'Vec' in k][0]\n",
    "            for c in get_type_combinations([temp['Ret'], vec]):\n",
    "                output(gen_uni_op(name_op(op), op, c[1], c[0]))\n",
    "                if op in aliases:\n",
    "                    output(gen_uni_op(aliases[op], op, c[1], c[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "cfa6e279",
   "metadata": {},
   "outputs": [],
   "source": [
    "size_types=types[types['mask']==False].size_type.unique()\n",
    "simd_types=types[types['mask']==False].simd_type.unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "735c0be3",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_conversions():\n",
    "    ret=[]\n",
    "    for t1 in simd_types:\n",
    "        for t2 in simd_types:\n",
    "            size1=get_simd_size(t1)\n",
    "            size2=get_simd_size(t2)\n",
    "            t=get_simd_type(t2)\n",
    "            if size1==size2:\n",
    "                if t1!=t2:\n",
    "                    output(\n",
    "                        f'proc to_{t}*(x: {t1}): {t2} {{.header: simd, importcpp: \"@.to_{t}()\".}}'\n",
    "                    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "36a28cb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_simd_types(s):\n",
    "#     import pdb; pdb.set_trace()\n",
    "    if not s['mask']:\n",
    "        gen_simd_type(s['base_type'], s['size_type'], s['size'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "b9121da9",
   "metadata": {},
   "outputs": [],
   "source": [
    "all_output=\"\"\n",
    "def output(s):\n",
    "    global all_output\n",
    "    all_output+=s+'\\n'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "8520059f",
   "metadata": {},
   "outputs": [],
   "source": [
    "gen_op('add', intops_retvals['add'])"
   ]
  },
  {
   "cell_type": "raw",
   "id": "6ea619fa",
   "metadata": {},
   "source": [
    "_=types.apply(gen_simd_types, axis=1)"
   ]
  },
  {
   "cell_type": "raw",
   "id": "c794918e",
   "metadata": {},
   "source": [
    "gen_conversions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "8570e8ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "for retvals in [floatops_retvals, intops_retvals]:#, bitops_retvals]:\n",
    "    for k, v in retvals.items():\n",
    "        try:\n",
    "            gen_op(k, v)\n",
    "        except (TypeError, SyntaxError, AttributeError, KeyError):\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8d55d06d",
   "metadata": {},
   "outputs": [],
   "source": [
    "delete = ['test', \"mull\", (\"*\", \"uint\"), 'round', 'ceil', 'trunc', 'floor', \"sign\"]\n",
    "def dedup(ls):\n",
    "    curr=[]\n",
    "    for l in ls:\n",
    "        l=l.replace('  check', \"discard\")\n",
    "        \n",
    "        if any(w in l if type(w)!=tuple else all(s in l for s in w) for w in delete):\n",
    "            continue\n",
    "        elif l not in curr:\n",
    "            curr.append(l)\n",
    "        elif \"###\" in l:\n",
    "            curr.append(l)\n",
    "    return curr\n",
    "\n",
    "\n",
    "with open('./tests/tests.nim', 'a+') as f:\n",
    "    f.write('''\n",
    "\n",
    "# To run these tests, simply execute `nimble test`.\n",
    "\n",
    "import unittest\n",
    "\n",
    "import nimd\n",
    "\n",
    "type INT_TYPE = uint8 or int8 or uint16 or int16 or uint32 or int32 or uint64 or int64\n",
    "type FLOAT_TYPE = float32 or float64\n",
    "proc `~=`[T: FLOAT_TYPE](a, b: T): bool =\n",
    "  ## Check if \"a\" and \"b\" are close.\n",
    "  ## We use a relative tolerance to compare the values.\n",
    "  result = abs(a - b) < 0.001\n",
    "\n",
    "proc `~=`[T: INT_TYPE](a, b: T): bool =\n",
    "  ## Check if \"a\" and \"b\" are close.\n",
    "  ## We use a relative tolerance to compare the values.\n",
    "  result = a==b\n",
    "\n",
    "proc `compare`[A, B](a: seq[A], b: seq[B]): bool =\n",
    "  #echo a\n",
    "  for i, _ in a:\n",
    "    if not (a[i]~=b[i]):\n",
    "      raise newException(CatchableError, $(a[i], b[i]))\n",
    "  return true\n",
    "''')\n",
    "    for l in dedup([i for i in all_output.split('\\n') if i.strip()]):\n",
    "        f.write(l)\n",
    "        f.write('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "dd3a52d7",
   "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>base_type</th>\n",
       "      <th>size_type</th>\n",
       "      <th>size</th>\n",
       "      <th>simd_type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>float</td>\n",
       "      <td>float64</td>\n",
       "      <td>2</td>\n",
       "      <td>float64x2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>float</td>\n",
       "      <td>float32</td>\n",
       "      <td>4</td>\n",
       "      <td>float32x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>float</td>\n",
       "      <td>float64</td>\n",
       "      <td>4</td>\n",
       "      <td>float64x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>float</td>\n",
       "      <td>float32</td>\n",
       "      <td>8</td>\n",
       "      <td>float32x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>29</th>\n",
       "      <td>float</td>\n",
       "      <td>float64</td>\n",
       "      <td>8</td>\n",
       "      <td>float64x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>28</th>\n",
       "      <td>float</td>\n",
       "      <td>float32</td>\n",
       "      <td>16</td>\n",
       "      <td>float32x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>int</td>\n",
       "      <td>int64</td>\n",
       "      <td>2</td>\n",
       "      <td>int64x2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>int</td>\n",
       "      <td>int32</td>\n",
       "      <td>4</td>\n",
       "      <td>int32x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>int</td>\n",
       "      <td>int64</td>\n",
       "      <td>4</td>\n",
       "      <td>int64x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>int</td>\n",
       "      <td>int16</td>\n",
       "      <td>8</td>\n",
       "      <td>int16x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>int</td>\n",
       "      <td>int32</td>\n",
       "      <td>8</td>\n",
       "      <td>int32x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>27</th>\n",
       "      <td>int</td>\n",
       "      <td>int64</td>\n",
       "      <td>8</td>\n",
       "      <td>int64x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>int</td>\n",
       "      <td>int8</td>\n",
       "      <td>16</td>\n",
       "      <td>int8x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>int</td>\n",
       "      <td>int16</td>\n",
       "      <td>16</td>\n",
       "      <td>int16x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25</th>\n",
       "      <td>int</td>\n",
       "      <td>int32</td>\n",
       "      <td>16</td>\n",
       "      <td>int32x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>39</th>\n",
       "      <td>mask_float</td>\n",
       "      <td>mask_float64</td>\n",
       "      <td>2</td>\n",
       "      <td>mask_float64x2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>38</th>\n",
       "      <td>mask_float</td>\n",
       "      <td>mask_float32</td>\n",
       "      <td>4</td>\n",
       "      <td>mask_float32x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>49</th>\n",
       "      <td>mask_float</td>\n",
       "      <td>mask_float64</td>\n",
       "      <td>4</td>\n",
       "      <td>mask_float64x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>48</th>\n",
       "      <td>mask_float</td>\n",
       "      <td>mask_float32</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_float32x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>59</th>\n",
       "      <td>mask_float</td>\n",
       "      <td>mask_float64</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_float64x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>58</th>\n",
       "      <td>mask_float</td>\n",
       "      <td>mask_float32</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_float32x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>37</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int64</td>\n",
       "      <td>2</td>\n",
       "      <td>mask_int64x2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>35</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int32</td>\n",
       "      <td>4</td>\n",
       "      <td>mask_int32x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>47</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int64</td>\n",
       "      <td>4</td>\n",
       "      <td>mask_int64x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>33</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int16</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_int16x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int32</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_int32x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>57</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int64</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_int64x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>31</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int8</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_int8x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>43</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int16</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_int16x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>55</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int32</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_int32x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>41</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int8</td>\n",
       "      <td>32</td>\n",
       "      <td>mask_int8x32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>53</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int16</td>\n",
       "      <td>32</td>\n",
       "      <td>mask_int16x32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>51</th>\n",
       "      <td>mask_int</td>\n",
       "      <td>mask_int8</td>\n",
       "      <td>64</td>\n",
       "      <td>mask_int8x64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>36</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint64</td>\n",
       "      <td>2</td>\n",
       "      <td>mask_uint64x2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>34</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint32</td>\n",
       "      <td>4</td>\n",
       "      <td>mask_uint32x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>46</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint64</td>\n",
       "      <td>4</td>\n",
       "      <td>mask_uint64x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>32</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint16</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_uint16x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>44</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint32</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_uint32x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>56</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint64</td>\n",
       "      <td>8</td>\n",
       "      <td>mask_uint64x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint8</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_uint8x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>42</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint16</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_uint16x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>54</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint32</td>\n",
       "      <td>16</td>\n",
       "      <td>mask_uint32x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>40</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint8</td>\n",
       "      <td>32</td>\n",
       "      <td>mask_uint8x32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>52</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint16</td>\n",
       "      <td>32</td>\n",
       "      <td>mask_uint16x32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>mask_uint</td>\n",
       "      <td>mask_uint8</td>\n",
       "      <td>64</td>\n",
       "      <td>mask_uint8x64</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint64</td>\n",
       "      <td>2</td>\n",
       "      <td>uint64x2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint32</td>\n",
       "      <td>4</td>\n",
       "      <td>uint32x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint64</td>\n",
       "      <td>4</td>\n",
       "      <td>uint64x4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint16</td>\n",
       "      <td>8</td>\n",
       "      <td>uint16x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint32</td>\n",
       "      <td>8</td>\n",
       "      <td>uint32x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint64</td>\n",
       "      <td>8</td>\n",
       "      <td>uint64x8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint8</td>\n",
       "      <td>16</td>\n",
       "      <td>uint8x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint16</td>\n",
       "      <td>16</td>\n",
       "      <td>uint16x16</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>24</th>\n",
       "      <td>uint</td>\n",
       "      <td>uint32</td>\n",
       "      <td>16</td>\n",
       "      <td>uint32x16</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     base_type     size_type  size        simd_type\n",
       "9        float       float64     2        float64x2\n",
       "8        float       float32     4        float32x4\n",
       "19       float       float64     4        float64x4\n",
       "18       float       float32     8        float32x8\n",
       "29       float       float64     8        float64x8\n",
       "28       float       float32    16       float32x16\n",
       "7          int         int64     2          int64x2\n",
       "5          int         int32     4          int32x4\n",
       "17         int         int64     4          int64x4\n",
       "3          int         int16     8          int16x8\n",
       "15         int         int32     8          int32x8\n",
       "27         int         int64     8          int64x8\n",
       "1          int          int8    16          int8x16\n",
       "13         int         int16    16         int16x16\n",
       "25         int         int32    16         int32x16\n",
       "39  mask_float  mask_float64     2   mask_float64x2\n",
       "38  mask_float  mask_float32     4   mask_float32x4\n",
       "49  mask_float  mask_float64     4   mask_float64x4\n",
       "48  mask_float  mask_float32     8   mask_float32x8\n",
       "59  mask_float  mask_float64     8   mask_float64x8\n",
       "58  mask_float  mask_float32    16  mask_float32x16\n",
       "37    mask_int    mask_int64     2     mask_int64x2\n",
       "35    mask_int    mask_int32     4     mask_int32x4\n",
       "47    mask_int    mask_int64     4     mask_int64x4\n",
       "33    mask_int    mask_int16     8     mask_int16x8\n",
       "45    mask_int    mask_int32     8     mask_int32x8\n",
       "57    mask_int    mask_int64     8     mask_int64x8\n",
       "31    mask_int     mask_int8    16     mask_int8x16\n",
       "43    mask_int    mask_int16    16    mask_int16x16\n",
       "55    mask_int    mask_int32    16    mask_int32x16\n",
       "41    mask_int     mask_int8    32     mask_int8x32\n",
       "53    mask_int    mask_int16    32    mask_int16x32\n",
       "51    mask_int     mask_int8    64     mask_int8x64\n",
       "36   mask_uint   mask_uint64     2    mask_uint64x2\n",
       "34   mask_uint   mask_uint32     4    mask_uint32x4\n",
       "46   mask_uint   mask_uint64     4    mask_uint64x4\n",
       "32   mask_uint   mask_uint16     8    mask_uint16x8\n",
       "44   mask_uint   mask_uint32     8    mask_uint32x8\n",
       "56   mask_uint   mask_uint64     8    mask_uint64x8\n",
       "30   mask_uint    mask_uint8    16    mask_uint8x16\n",
       "42   mask_uint   mask_uint16    16   mask_uint16x16\n",
       "54   mask_uint   mask_uint32    16   mask_uint32x16\n",
       "40   mask_uint    mask_uint8    32    mask_uint8x32\n",
       "52   mask_uint   mask_uint16    32   mask_uint16x32\n",
       "50   mask_uint    mask_uint8    64    mask_uint8x64\n",
       "6         uint        uint64     2         uint64x2\n",
       "4         uint        uint32     4         uint32x4\n",
       "16        uint        uint64     4         uint64x4\n",
       "2         uint        uint16     8         uint16x8\n",
       "14        uint        uint32     8         uint32x8\n",
       "26        uint        uint64     8         uint64x8\n",
       "0         uint         uint8    16         uint8x16\n",
       "12        uint        uint16    16        uint16x16\n",
       "24        uint        uint32    16        uint32x16"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "types[['base_type', 'size_type', 'size', 'simd_type']].sort_values(['base_type', 'size'])#.to_html().replace('\\n', '')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01865305",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac8b08e5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}