nimd.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1dbb5ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "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_277824/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_277824/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_277824/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_277824/456007972.py:4: UserWarning: Boolean Series key will be reindexed to match DataFrame index.\n",
      "  temp = temp[types['mask']==mask]\n",
      "/tmp/ipykernel_277824/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": "3c9acae7",
   "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": "2bed154d",
   "metadata": {},
   "outputs": [],
   "source": [
    "methods = {}\n",
    "not_namespaced={\"round\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "68ad9f60",
   "metadata": {},
   "outputs": [],
   "source": [
    "def form_op_cpp(op_name):\n",
    "    if op_name in methods:\n",
    "        return f\"@.{op_name}()\"\n",
    "    if op_name in not_namespaced:\n",
    "        return f\"{op_name}(@)\"\n",
    "    return f\"{ns}{op_name}(@)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "71ca2ca2",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_type_exists(t):\n",
    "    return t is None or t in simd_types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "e8a45ea5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_bin_op(op, op_name, arg_type, ret_type, arg2_type=None):\n",
    "    if not all((check_type_exists(arg_type), check_type_exists(ret_type), check_type_exists(arg2_type))): return \"\"\n",
    "    op_cpp = form_op_cpp(op_name)\n",
    "    if arg2_type is None:\n",
    "        return f'''proc {op}*(x, y: {arg_type}): {ret_type}  {{.header: simd, importcpp: \"{op_cpp}\"}}'''\n",
    "\n",
    "    return f'''proc {op}*(x: {arg_type}, y: {arg2_type}): {ret_type}  {{.header: simd, importcpp: \"{op_cpp}\"}}'''\n",
    "\n",
    "def gen_tri_op(op, op_name, arg_type, ret_type, arg2_type=None, arg3_type=None):\n",
    "    if not all((check_type_exists(arg_type), check_type_exists(ret_type), check_type_exists(arg2_type), check_type_exists(arg3_type))): return \"\"\n",
    "    op_cpp = form_op_cpp(op_name)\n",
    "    if arg2_type and arg3_type:\n",
    "        return f'''proc {op}*(x: {arg_type}, y: {arg2_type}, z: {arg3_type}): {ret_type}  {{.header: simd, importcpp: \"{op_cpp}\"}}'''\n",
    "    elif arg2 is not None and arg3_type is None:\n",
    "        return f'''proc {op}*(x: {arg_type}, y, z: {arg2_type}): {ret_type}  {{.header: simd, importcpp: \"{op_cpp}\"}}'''\n",
    "    else:\n",
    "        return f'''proc {op}*(x, y, z: {arg_type}): {ret_type}  {{.header: simd, importcpp: \"{op_cpp}\"}}'''\n",
    "\n",
    "\n",
    "def gen_uni_op(op, op_name, arg_type, ret_type):\n",
    "    if not all((check_type_exists(arg_type), check_type_exists(ret_type))): return \"\"\n",
    "    op_cpp = form_op_cpp(op_name)\n",
    "    return f'''proc {op}*(x: {arg_type}): {ret_type}  {{.header: simd, importcpp: \"{op_cpp}\"}}'''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "a99f846f",
   "metadata": {},
   "outputs": [],
   "source": [
    "keywords={'div':'divide'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b9b54df9",
   "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": 30,
   "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": 31,
   "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": 32,
   "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": 33,
   "id": "ede34718",
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_simd_type(base_type, size_type, size):\n",
    "    simd_type=size_type+'x'+str(size)\n",
    "    mask_simd_type=\"mask_\"+size_type+'x'+str(size)\n",
    "    args=', '.join(f'x{i}' for i in range(size))\n",
    "    output(f\"\"\"\n",
    "##############################################\n",
    "### BEGIN {base_type}, {size_type}, {size} ###\n",
    "##############################################\n",
    "    \n",
    "type {simd_type}* {{.header: simd, importcpp: \"{ns}{size_type}<{size}>\".}} = object\n",
    "type {mask_simd_type}* {{.header: simd, importcpp: \"{ns}mask_{size_type}<{size}>\".}} = object\n",
    "\n",
    "proc Vector*({args}: {size_type}): {simd_type} {{.header: simd, importcpp: \"{ns}make_{base_type}<{ns}{size_type}<{size}>>(@)\".}}\n",
    "proc splat_{simd_type}*(x: SIZE_TYPE): {simd_type} = Vector({', '.join([f'x.{size_type}' for _ in range(size)])})\n",
    "\n",
    "proc to_mask*(x: {simd_type}): {mask_simd_type} {{.header: simd, importcpp: \"@.to_mask()\".}}\n",
    "\n",
    "proc len*(x: {simd_type}): Natural = {size}\n",
    "{'NEWLINE'.join([f'proc extract_{i}*(x: {simd_type}): {size_type}  {{.header: simd, importcpp: \"{ns}extract<{i}, {size}>(@)\"}}' for i in range(size)])}\n",
    "\n",
    "proc `[]`*(x: {simd_type}, i: Natural): {size_type} =\n",
    "  assert 0 <= i and i < {size} ###\n",
    "  {''.join([\"if i == 0:###NEWLINE    return extract_0(x)###NEWLINE\"]+[f\"NEWLINE  elif i == {i}:###NEWLINE    return extract_{i}(x)###\" for i in range(1, size-1)]+[f\"NEWLINE  else:###NEWLINE    return extract_{size-1}(x)###NEWLINE\"])}\n",
    "  \n",
    "{'NEWLINE'.join([f'proc insert_{i}*(x: var {simd_type}, v: {size_type}): {simd_type} {{.header: simd, importcpp: \"{ns}insert<{i}, {size}>(@)\"}}' for i in range(size)])}\n",
    "proc `[]=`*(x: var {simd_type}, i: Natural, v: {size_type}) =\n",
    "  assert 0 <= i and i < {size} ###\n",
    "  {''.join([\"if i == 0:###NEWLINE    x=insert_0(x, v)###NEWLINE\"]+[f\"NEWLINE  elif i == {i}:###NEWLINE    x=insert_{i}(x, v)###\" for i in range(1, size-1)]+[f\"NEWLINE  else:###NEWLINE    x=insert_{size-1}(x, v)###NEWLINE\"])}\n",
    "  \n",
    "proc to_seq*(x: {simd_type}): seq[{size_type}] = @[{', '.join([f'x[{i}]' for i in range(size)])}]\n",
    "proc to_array*(x: {simd_type}): auto = [{', '.join([f'x[{i}]' for i in range(size)])}]\n",
    "proc `$`*(x: {simd_type}): string = \"{simd_type}\"& $(x.to_array)\n",
    "proc to_{simd_type}*(x: seq[SIZE_TYPE]): {simd_type} =\n",
    "  assert x.len == {size} ###\n",
    "  Vector({', '.join([f'x[{i}].{size_type}' for i in range(size)])})\n",
    "\n",
    "############################################\n",
    "### END {base_type}, {size_type}, {size} ###\n",
    "############################################\n",
    "\n",
    "    \"\"\".replace('NEWLINE', '\\n'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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": 35,
   "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": 36,
   "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": 37,
   "id": "7bd550b1",
   "metadata": {},
   "outputs": [],
   "source": [
    "_=types.apply(gen_simd_types, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "c097b3f2",
   "metadata": {},
   "outputs": [],
   "source": [
    "gen_conversions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8570e8ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "for retvals in [bitops_retvals, floatops_retvals, intops_retvals]:\n",
    "    for k, v in retvals.items():\n",
    "        if not isinstance(v, pd.DataFrame):\n",
    "            v = v.to_frame()\n",
    "        try:\n",
    "            gen_op(k, v)\n",
    "        except (ValueError,):\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "8d55d06d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dedup(ls):\n",
    "    curr=[]\n",
    "    for l in ls:\n",
    "        if l not in curr:\n",
    "            curr.append(l)\n",
    "        elif \"###\" in l:\n",
    "            curr.append(l)\n",
    "    return curr\n",
    "\n",
    "# dedup=lambda x: x\n",
    "with open('./src/nimd.nim', 'a+') as f:\n",
    "    f.write('''\n",
    "const simd = \"<simdpp/simd.h>\"\n",
    "\n",
    "'''+f\"type SIZE_TYPE = {' or '.join(size_types)}\\n\\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": 497,
   "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": 497,
     "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": "29c5496f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "148a1bdf",
   "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
}