dev/apply_contiguity_tests.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ebb5a4e2-6a5a-4f8f-872a-b1574fc033a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "853 µs ± 299 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import numba as nb\n",
    "import pandas as pd\n",
    "arr = np.random.randn(1000000,3)\n",
    "\n",
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True)\n",
    "def temporary(z):\n",
    "    return (z[0] + z[2])/ z[1]\n",
    "\n",
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True)\n",
    "def temporarysum(z):\n",
    "    return np.sum(z)\n",
    "    \n",
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True, parallel = True)\n",
    "def func_int_identifier_loop(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1))\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporarysum(Z[i, :])\n",
    "    return res\n",
    "\n",
    "%timeit func_int_identifier_loop(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "95aebc15-3c68-4798-a268-d40cc27baf90",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'nb' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;129m@nb\u001b[39m\u001b[38;5;241m.\u001b[39mnjit(cache\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, parallel\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, fastmath\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, forceinline\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, looplift\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, inline\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124malways\u001b[39m\u001b[38;5;124m'\u001b[39m, target_backend\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mhost\u001b[39m\u001b[38;5;124m'\u001b[39m, no_cfunc_wrapper\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, no_rewrites\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, nogil\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_opt_1\u001b[39m(x):\n\u001b[1;32m      3\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39msum(x)\n\u001b[1;32m      5\u001b[0m \u001b[38;5;129m@nb\u001b[39m\u001b[38;5;241m.\u001b[39mnjit((nb\u001b[38;5;241m.\u001b[39mfloat32[:, :], nb\u001b[38;5;241m.\u001b[39mfloat32[:], nb\u001b[38;5;241m.\u001b[39muint32), cache\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mFalse\u001b[39;00m, parallel\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, fastmath\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, forceinline\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, looplift\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, inline\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124malways\u001b[39m\u001b[38;5;124m'\u001b[39m, target_backend\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mhost\u001b[39m\u001b[38;5;124m'\u001b[39m, no_cfunc_wrapper\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, no_rewrites\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m, nogil\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)\n\u001b[1;32m      6\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt_1\u001b[39m(Z, z, k):\n",
      "\u001b[0;31mNameError\u001b[0m: name 'nb' is not defined"
     ]
    }
   ],
   "source": [
    "@nb.njit(cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
    "def ffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_opt_1(x):\n",
    "    return np.sum(x)\n",
    "\n",
    "@nb.njit((nb.float32[:, :], nb.float32[:], nb.uint32), cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
    "def ffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt_1(Z, z, k):\n",
    "    for i in nb.prange(k):\n",
    "        z[i] = ffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_opt_1(Z[i, :])\n",
    "\n",
    "@nb.njit(nb.float32[:](nb.float32[:, :]), cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
    "def ffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt(Z):\n",
    "    k = np.uint32(len(Z))\n",
    "    z = np.zeros(k, dtype=np.float32)\n",
    "    ffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt_1(Z, z, k)\n",
    "    return z\n",
    "arr=arr.astype(np.float32)\n",
    "ffagg_sumc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "74ea58cc-d119-4821-aa7b-cd98d447ccad",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'vectorized' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[3], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mvectorized\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'vectorized' is not defined"
     ]
    }
   ],
   "source": [
    "vectorized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f626f3e7-42ee-4d48-afcb-53084c808f4d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ndims 2 axis 0\n",
      "def vectorized(x):\n",
      "    return np.sum(x)\n",
      "agg_sumx vectorized\n",
      "@nb.njit(cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
      "def vectorized_opt(x):\n",
      "    return np.sum(x)\n",
      "agg_sumx vectorized_opt\n",
      "def ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_1(x):\n",
      "    return np.sum(x)\n",
      "\n",
      "def ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_loop_1(Z, z, k):\n",
      "    for i in nb.prange(k):\n",
      "        z[i] = ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_1(Z[i, :])\n",
      "\n",
      "def loop(Z):\n",
      "    k = Z.shape[0]\n",
      "    z = np.zeros(k, dtype=np.float32)\n",
      "    ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_loop_1(Z, z, k)\n",
      "    return z\n",
      "agg_sumx loop\n",
      "@nb.njit(cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
      "def ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_opt_1(x):\n",
      "    return np.sum(x)\n",
      "\n",
      "@nb.njit((nb.float32[:, :], nb.float32[:], nb.uint32), cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
      "def ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt_1(Z, z, k):\n",
      "    for i in nb.prange(k):\n",
      "        z[i] = ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_built__uloop_opt_1(Z[i, :])\n",
      "\n",
      "@nb.njit(nb.float32[:](nb.float32[:, :]), cache=False, parallel=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True, nogil=True)\n",
      "def loop_opt(Z):\n",
      "    k = np.uint32(len(Z))\n",
      "    z = np.zeros(k, dtype=np.float32)\n",
      "    ffagg_sumxc4a2d99bc28d236098a095277b7eb0718d6be068_loop_opt_1(Z, z, k)\n",
      "    return z\n",
      "agg_sumx uloop_opt\n",
      "<function DataFrame._with_fallback_wrap.<locals>._with_protects at 0x7f18b81b94e0>\n",
      "vectorized_opt {'original': <function agg_sumx at 0x7f192cc614e0>, 'vectorized': <function compile_tree.<locals>.wrapped at 0x7f18b81b9440>, 'vectorized_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8220>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "TA MERE -8.888674627162546 () (array([[ 0.57211619,  0.75898589,  0.32405189, ...,  0.18761876,\n",
      "        -1.61669749, -2.75110593],\n",
      "       [ 0.93259001,  0.05388398,  1.76399405, ..., -1.36388309,\n",
      "        -0.32423722,  0.09639028]]),) {}\n",
      "loop_opt {'original': <function agg_sumx at 0x7f192cc614e0>, 'vectorized': <function compile_tree.<locals>.wrapped at 0x7f18b81b9440>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "vectorized {'original': <function agg_sumx at 0x7f192cc614e0>, 'vectorized': <function compile_tree.<locals>.wrapped at 0x7f18b81b9440>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "TA MERE -8.888674627162565 () (array([[ 0.57211619,  0.75898589,  0.32405189, ...,  0.18761876,\n",
      "        -1.61669749, -2.75110593],\n",
      "       [ 0.93259001,  0.05388398,  1.76399405, ..., -1.36388309,\n",
      "        -0.32423722,  0.09639028]]),) {}\n",
      "loop {'original': <function agg_sumx at 0x7f192cc614e0>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "TA MERE [ 23.99669  -32.885365] (2,) (array([[ 0.57211619,  0.75898589,  0.32405189, ...,  0.18761876,\n",
      "        -1.61669749, -2.75110593],\n",
      "       [ 0.93259001,  0.05388398,  1.76399405, ..., -1.36388309,\n",
      "        -0.32423722,  0.09639028]]),) {}\n",
      "vectorized_opt {'original': <function agg_sumx at 0x7f192cc614e0>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "loop_opt {'original': <function agg_sumx at 0x7f192cc614e0>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "vectorized {'original': <function agg_sumx at 0x7f192cc614e0>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "loop {'original': <function agg_sumx at 0x7f192cc614e0>, 'loop': <function compile_tree.<locals>.wrapped at 0x7f18b81b80e0>, 'uloop_opt': <function compile_tree.<locals>.wrapped at 0x7f18b81b8a40>}\n",
      "TA MERE [ 23.99669   -32.885365   -6.6619873] (3,) (array([[ 0.57211619,  0.75898589,  0.32405189, ...,  0.18761876,\n",
      "        -1.61669749, -2.75110593],\n",
      "       [ 0.93259001,  0.05388398,  1.76399405, ..., -1.36388309,\n",
      "        -0.32423722,  0.09639028],\n",
      "       [-1.05617881, -0.67556698,  1.77288429, ...,  0.15030611,\n",
      "         1.65866808,  1.35832112]]),) {}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "           0\n",
       "0  23.996691\n",
       "1 -32.885365\n",
       "2  -6.661987"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import numba as nb\n",
    "import pandas as pd\n",
    "import pandopt as pdo\n",
    "df = pdo.DataFrame(np.random.randn(1000,3))\n",
    "\n",
    "def agg_sumx(x):\n",
    "    return np.sum(x)\n",
    "    \n",
    "df.apply(agg_sumx, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ef4ac9bb-044b-4c5f-aee4-096a6902b646",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'vectorized_opt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mvectorized_opt\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'vectorized_opt' is not defined"
     ]
    }
   ],
   "source": [
    "vectorized_opt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8afb7029-174d-47a4-8dd9-c1fee0c9bc99",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randn(10_0000_000,7).astype(np.float32)\n",
    "df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c33a546-7976-46f2-9f41-cfba33621e4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['_built_vectorized_opt'](arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c968e689-cb7d-410e-a488-889cf46d41e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['_built_uloop_opt_1'](arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fdc10eb-4818-46ce-ba38-df3df465e2e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit np.sum(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a667bbe0-4382-406c-a63a-b5aa9495391c",
   "metadata": {},
   "outputs": [],
   "source": [
    "for key, values in df._compiled_func['fidnvctagg_sumaxis03agg_sum'].items():\n",
    "    print(key)\n",
    "    %timeit values(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b77a898c-7a8e-4021-97a9-b50a46df0748",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.__class__._compiled_func['fidnvctagg_sumaxis03agg_sum']['original'](arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3798964d-c5e1-4438-9bea-981c548dd8e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['ffagg_sum88b33e4e12f75ac8bf792aebde41f1a090f3a612_vectorized'](arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c8abae0-aad7-4bc2-b39a-465be771b795",
   "metadata": {},
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6273b99a-e83b-4bce-8f6c-a24cfe59525e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['ffagg_sum88b33e4e12f75ac8bf792aebde41f1a090f3a612_uloop_opt_1'](arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfcd3332-1eab-49a6-af5e-66a49697b26c",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2f012314-fd0d-4da6-b08a-17826dbc1b30",
   "metadata": {},
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['ffagg_sum88b33e4e12f75ac8bf792aebde41f1a090f3a612_vectorized_opt_nb_compyled'](arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb4fdf43-4155-4647-b400-33b42e207950",
   "metadata": {},
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctagg_sumaxis03agg_sum']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07bea4fb-e6ea-4b5a-99b0-815a1b8a6787",
   "metadata": {},
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['ffagg_sum88b33e4e12f75ac8bf792aebde41f1a090f3a612_uloop_1_opt_nb_compyled'](x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9baddf8b-492e-4f7c-9489-7a8c1915ed7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctagg_sumaxis1Trueagg_sum']['ffagg_sum88b33e4e12f75ac8bf792aebde41f1a090f3a612_uloop_1_opt_nb_compyled'](arr)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66aefbd4-6b87-4a94-b0df-74b120d99dc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df._compiled_func['fidnvctsumaxis1Truesum']['ffsum88b33e4e12f75ac8bf792aebde41f1a090f3a612_vectorized'](df.to_numpy())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6505267-edda-4fb7-a9bf-2f5e73376026",
   "metadata": {},
   "outputs": [],
   "source": [
    "import hashlib\n",
    "from functools import reduce\n",
    "mapping={**{\"A\": 2, 'C':9}}\n",
    "hashlib.sha256(reduce(lambda x, y: x + y, mapping.keys()).encode('UTF-8')).digest()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb924ca-9ada-464d-91b8-39f42c954693",
   "metadata": {},
   "outputs": [],
   "source": [
    "import hashlib\n",
    "from functools import reduce\n",
    "hashlib.sha1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c36b1e1-9b9a-4893-aec7-654318e1976b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(nopython=True, nogil=True)\n",
    "def temporaryD(z):\n",
    "    return (z[0] + z[2])/ z[1]\n",
    "    \n",
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True, parallel = True)\n",
    "def func_int_identifier_loopD(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1))\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporaryD(Z[i, :])\n",
    "    return res\n",
    "\n",
    "%timeit func_int_identifier_loopD(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7895657c-001c-449c-9066-276046b1ff3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True, parallel = True)\n",
    "def temporaryE(z):\n",
    "    return (z[0] + z[2])/ z[1]\n",
    "    \n",
    "@nb.jit(nopython=True, nogil=True)\n",
    "def func_int_identifier_loopE(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1))\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporaryE(Z[i, :])\n",
    "    return res\n",
    "\n",
    "%timeit func_int_identifier_loopE(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95379b01-da07-4542-b9a0-1a91d4704850",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba import vectorize, float64\n",
    "\n",
    "@vectorize([float64(float64, float64, float64)])\n",
    "def vectorized_function(x, y, z):\n",
    "    return (x + z) / y\n",
    "\n",
    "%timeit vectorized_function(arr[:,0], arr[:,1], arr[:,2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03a3c04c-147b-416a-8f27-676a6236519c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numba as nb\n",
    "\n",
    "arr = np.random.randn(1000000,3)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d3c9c99-ded7-4dac-965b-e526d8048ec7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit np.sum(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03e696d9-48ff-42b4-b3f3-febe291844d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit np.sum(arr.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f1d60d3-aa7b-4ac4-b0da-f47c4e2c162a",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randn(1000000,3)\n",
    "x=arr.copy(order='F')\n",
    "%timeit np.sum(x.copy(order='F'))\n",
    "x=arr.copy(order='C')\n",
    "%timeit np.sum(x.copy(order='C'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d64b5104-c7f6-4f6c-9a4e-3106b58c7d2d",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randn(1000000,3)\n",
    "x=arr.copy(order='F')\n",
    "%timeit np.sum(x.copy(order='F'), axis = 1)\n",
    "x=arr.copy(order='C')\n",
    "%timeit np.sum(x.copy(order='C'), axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0878eefc-36d3-4b63-8246-8903c33f56cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(10):\n",
    "    arr = np.random.randn(int(10**k),5)\n",
    "    \n",
    "    x=arr.copy(order='C')\n",
    "    %timeit np.sum(x, axis = 1)\n",
    "    x=arr.copy(order='C')\n",
    "    %timeit np.sum(x.copy(order='F'), axis = 1)\n",
    "    \n",
    "    \n",
    "    x=arr.copy(order='F')\n",
    "    %timeit np.sum(x, axis = 0)\n",
    "    x=arr.copy(order='F')\n",
    "    %timeit np.sum(x.copy(order='C'), axis = 0)\n",
    "    \n",
    "    print()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac0f710a-96e8-40e5-bcfd-dbbd57a5a119",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randn(int(10**1),3)\n",
    "\n",
    "x=arr.copy(order='C')\n",
    "func_int_identifier_loop(x.T.copy(order='F'))\n",
    "#func_int_identifier_loop(x.copy(order='F'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81e7e313-1dfc-46cc-83c7-abaff038ecf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "204960d3-234d-4468-bc19-b0c2767dc11b",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum(x, axis=1).reshape(-1,1) - func_int_identifier_loop(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79b1d65d-519f-4830-98f0-f9f0d904c6ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "func_int_identifier_loop(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05ac1564-f669-46da-8882-2ac46dfb54fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(nopython=True, fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_rewrites=True, nogil=True, parallel=True)\n",
    "def temporarysum(z):\n",
    "    return np.sum(z)\n",
    "    \n",
    "@nb.jit(nopython=True, nogil=True, parallel = True, fastmath=True, looplift=True, inline='always', target_backend='host', no_rewrites=True)\n",
    "def func_int_identifier_loop(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1))\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporarysum(Z[i, :])\n",
    "    return res\n",
    "\n",
    "@nb.jit(nopython=True, nogil=True, parallel = True, fastmath=True, looplift=True, inline='always', target_backend='host', no_rewrites=True)\n",
    "def func_int_identifier_loop_dtype(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1), dtype=np.float32)\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporarysum(Z[i, :])\n",
    "    return res\n",
    "\n",
    "@nb.jit(nopython=True, nogil=True, parallel = True, fastmath=True, looplift=True, inline='always', target_backend='host', no_rewrites=True)\n",
    "def func_int_identifier_loop_empty(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.empty((n, 1), dtype=np.float32)\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporarysum(Z[i, :])\n",
    "    return res\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "@nb.jit(nb.float32[:](nb.float32[:,:], nb.float32[:,:]), nopython=True, nogil=True, parallel = True,fastmath=True, looplift=True, target_backend='host', inline='always')\n",
    "def func_int_identifier_loopK(Z, res):\n",
    "    n = Z.shape[0]\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporarysum(Z[i, :])\n",
    "    return res[:n, 0]\n",
    "\n",
    "arr = np.random.randn(10_00_000,5)\n",
    "resF = np.zeros(tuple(s * 2 for s in arr.shape)).astype(np.float32).copy(order='F')\n",
    "resC = resF.copy(order='F')\n",
    "\n",
    "print('division of column over F-contiguous array')\n",
    "x=arr.astype(np.float32).copy(order='F')\n",
    "print('numba base', end=' ')\n",
    "%timeit func_int_identifier_loop(x)\n",
    "print('numba type initialized returned array', end=' ')\n",
    "%timeit func_int_identifier_loop_dtype(x)\n",
    "print('numba type initialized returned empty array', end=' ')\n",
    "%timeit func_int_identifier_loop_empty(x)\n",
    "print('numpy sum', end=' ')\n",
    "%timeit np.sum(x, axis=1)\n",
    "print('numpy copied for contiguity', end='')\n",
    "%timeit np.sum(x.copy(order='F'), axis=1)\n",
    "print('numba giving an output array F-contiguous', end=' ')\n",
    "%timeit func_int_identifier_loopK(x, resF)\n",
    "print('numba giving an output array C-contiguous', end=' ')\n",
    "%timeit func_int_identifier_loopK(x, resC)\n",
    "\n",
    "print()\n",
    "print('division of column over C-contiguous array')\n",
    "x=arr.astype(np.float32).copy(order='C')\n",
    "print('numba base', end=' ')\n",
    "%timeit func_int_identifier_loop(x)\n",
    "print('numba type initialized returned array', end=' ')\n",
    "%timeit func_int_identifier_loop_dtype(x)\n",
    "print('numba type initialized returned empty array', end=' ')\n",
    "%timeit func_int_identifier_loop_empty(x)\n",
    "print('numpy sum', end=' ')\n",
    "%timeit np.sum(x, axis=1)\n",
    "print('numpy copied for contiguity', end=' ')\n",
    "%timeit np.sum(x.copy(order='F'), axis=1)\n",
    "print('numba giving an output array F-contiguous', end=' ')\n",
    "%timeit func_int_identifier_loopK(x, resF)\n",
    "print('numba giving an output array C-contiguous', end=' ')\n",
    "%timeit func_int_identifier_loopK(x, resC)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a19ae2f-2ac4-4325-9301-f4fb3b8bfbac",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9f684a77-1645-44ec-a454-ec91042ea1bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numba as nb\n",
    "\n",
    "@nb.guvectorize([(nb.float32[:, :], nb.float32[:])], '(n,k)->(n)', nopython=True)\n",
    "def summatrix(computed_matrix, result_array):\n",
    "    for i in range(computed_matrix.shape[0]):\n",
    "        sum_ = 0.0\n",
    "        for j in nb.prange(computed_matrix.shape[1]):\n",
    "            sum_ += computed_matrix[i, j]\n",
    "        result_array[i] = sum_\n",
    "        \n",
    "%timeit summatrix(x)\n",
    "%timeit np.sum(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b07b1e39-fe37-4ae3-93dc-2dcc349a6e24",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import numba as nb\n",
    "\n",
    "@nb.vectorize#([(nb.float32[:])], '(n)->()', nopython=True)\n",
    "def sumarray(computed_array):\n",
    "    result_value = 0.0\n",
    "    for i in range(computed_array.shape[0]):\n",
    "        result_value += computed_array[i]\n",
    "    return result_value\n",
    "\n",
    "@nb.jit(nb.float32[:](nb.float32[:,:], nb.float32[:,:]), nopython=True)\n",
    "def summatrix(computed_matrix, result_array):\n",
    "    for i in range(computed_matrix.shape[0]):\n",
    "        result_array[i] = sumarray(computed_matrix[i, :])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e5aa53f-66dd-4889-afbc-2fadb8d7415d",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.guvectorize([(nb.float32[:], nb.float32)], '(n)->()')\n",
    "def sumarray(computed_array, result_value):\n",
    "    for i in range(computed_array.shape[0]):\n",
    "        result_value += computed_array[i]\n",
    "\n",
    "@nb.guvectorize([(nb.float32[:,:], nb.float32[:,:])], '(n,k)->(n,)')\n",
    "def summatrix(computed_matrix, result_array):\n",
    "    for i in nb.prange(computed_matrix.shape[0]):\n",
    "        sumarray(computed_matrix[i, :], result_array[i])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7dc6d10-b9de-456a-9b41-1b771204a086",
   "metadata": {},
   "outputs": [],
   "source": [
    "x[tuple((0, None))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c73e28f-f95e-471c-a700-fde1e851b3db",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# @nb.guvectorize((nb.float32[:,:], nb.float32[:,:]))\n",
    "@nb.guvectorize([(nb.float32[:,:], nb.float32[:,:])], '(n,k)->(n)')\n",
    "def func_int_identifier_loopQQK(Z, res):\n",
    "    n, k = Z.shape\n",
    "    for j in nb.prange(n):\n",
    "        res[i, 0] = temporarysum(Z[i, j])\n",
    "    # return res[:n, 0]\n",
    "\n",
    "arr = np.random.randn(10_00_000,5)\n",
    "resF = np.zeros(tuple(s * 2 for s in arr.shape)).astype(np.float32).copy(order='F')\n",
    "resC = resF.copy(order='F')\n",
    "x = arr.astype(np.float32).copy(order='F')\n",
    "print('numba giving an output array C-contiguous', end=' ')\n",
    "\n",
    "func_int_identifier_loopQQK(x, resC[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1edf9b2-9935-49ed-b3c1-9dff04b2e8a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "x_c=arr.astype(np.float32).copy(order='C')\n",
    "x_f=arr.astype(np.float32).copy(order='F')\n",
    "\n",
    "df = pd.DataFrame(x_c)\n",
    "df2= pd.DataFrame(x_f)\n",
    "\n",
    "\n",
    "# print('division of DataFrame creates over :')\n",
    "\n",
    "# %timeit df+df2\n",
    "# %timeit df.to_numpy()+df.to_numpy()\n",
    "# %timeit df.to_numpy().copy(order='C')+df2.to_numpy().copy(order='C')\n",
    "# %timeit df2.to_numpy()+df2.to_numpy()\n",
    "# %timeit df.to_numpy().copy(order='F')+df2.to_numpy().copy(order='F')\n",
    "# %timeit x_c+x_f\n",
    "# %timeit x_c+x_c\n",
    "# %timeit x_f+x_f\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4e3edc5-78f4-470f-8506-8ebef678f27b",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(nb.float32[::,:](nb.float32[:,:], nb.float32[:,:], nb.float32[:,:]), nopython=True, nogil=True, parallel = True,fastmath=True, looplift=True, target_backend='host', inline='always')\n",
    "def msum(A, B, res):\n",
    "    n, k = A.shape\n",
    "    for j in nb.prange(k):\n",
    "        for i in nb.prange(n):\n",
    "            res[i, j] = A[i, j] + B[i, j]\n",
    "    return res[:n, :k]\n",
    "\n",
    "\n",
    "arr = np.random.randn(10_000_000,3)\n",
    "\n",
    "resF = np.empty(tuple(s * 2 for s in arr.shape), dtype=np.float32)\n",
    "\n",
    "x_c=arr.astype(np.float32).copy(order='C')\n",
    "x_c1=arr.astype(np.float32).copy(order='C')\n",
    "x_f=arr.astype(np.float32).copy(order='F')\n",
    "x_f1=arr.astype(np.float32).copy(order='F')\n",
    "\n",
    "df = pd.DataFrame(x_c)\n",
    "df1b = pd.DataFrame(x_c1)\n",
    "df2= pd.DataFrame(x_f)\n",
    "\n",
    "print('division of DataFrame creates over arrays with same contiguity', end=' ')\n",
    "%timeit df+df1b\n",
    "print('division of DataFrame creates over same arrays copies with different contiguity', end=' ')\n",
    "%timeit df+df2\n",
    "print('division underlying numpy of DataFrame creates with same C-contiguity', end=' ')\n",
    "%timeit df.to_numpy()+df1b.to_numpy()\n",
    "print('division underlying numpy of DataFrame creates with different contiguity', end=' ')\n",
    "%timeit df.to_numpy()+df2.to_numpy()\n",
    "print('division underlying numpy of DataFrame creates with different contiguity copied in C order', end=' ')\n",
    "%timeit df.to_numpy().copy(order='C')+df2.to_numpy().copy(order='C')\n",
    "print('division underlying numpy of DataFrame creates with same F-contiguity', end=' ')\n",
    "%timeit df2.to_numpy()+df2.to_numpy()\n",
    "print('division underlying numpy of DataFrame creates with different contiguity copied in F order', end=' ')\n",
    "%timeit df.to_numpy().copy(order='F')+df2.to_numpy().copy(order='F')\n",
    "print('division of numpy array with himself', end=' ')\n",
    "%timeit x_c+x_c\n",
    "print('division of raw numpy arrays with different contiguity', end=' ')\n",
    "%timeit x_c+x_f\n",
    "print('division of raw numpy arrays with same C-contiguity', end=' ')\n",
    "%timeit x_c+x_c1\n",
    "print('division of raw numpy arrays with same F-contiguity', end=' ')\n",
    "%timeit x_f+x_f\n",
    "print('using numba mdivision over to numpy of same contiguity df')\n",
    "%timeit msum(df.to_numpy(), df1b.to_numpy(), resF)\n",
    "print('using numba mdivision over to numpy of different contiguity df')\n",
    "%timeit msum(df.to_numpy(), df2.to_numpy(), resF)\n",
    "print('using numba mdivision same array')\n",
    "%timeit msum(x_c, x_c, resF)\n",
    "print('using numba mdivision same contiguityt array')\n",
    "%timeit msum(x_c, x_c1, resF)\n",
    "print('using numba mdivision different contiguityt array')\n",
    "%timeit msum(x_c, x_f, resF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8ba876b7-9717-4e71-9003-93b49d46c39d",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(nb.float32[::,:](nb.float32[:,:], nb.float32[:,:], nb.float32[:,:]), nopython=True, nogil=True, parallel = True,fastmath=True, looplift=True, target_backend='host', inline='always')\n",
    "def msum(A, B, res):\n",
    "    n, k = A.shape\n",
    "    for j in nb.prange(k):\n",
    "        for i in nb.prange(n):\n",
    "            res[i, j] = A[i, j] / B[i, j]\n",
    "    return res[:n, :k]\n",
    "\n",
    "\n",
    "arr = np.random.randn(10_000_000,5)\n",
    "\n",
    "resF = np.empty(tuple(s * 2 for s in arr.shape), dtype=np.float32)\n",
    "\n",
    "x_c=arr.astype(np.float32).copy(order='C')\n",
    "x_c1=arr.astype(np.float32).copy(order='C')\n",
    "x_f=arr.astype(np.float32).copy(order='F')\n",
    "x_f1=arr.astype(np.float32).copy(order='F')\n",
    "\n",
    "df = pd.DataFrame(x_c)\n",
    "df1b = pd.DataFrame(x_c1)\n",
    "df2= pd.DataFrame(x_f)\n",
    "df2b= pd.DataFrame(x_f1)\n",
    "\n",
    "print('division of DataFrame creates over arrays with same C-contiguity', end=' ')\n",
    "%timeit df/df1b\n",
    "print('division of DataFrame creates over arrays with same F-contiguity', end=' ')\n",
    "%timeit df2/df2b\n",
    "print('division of DataFrame creates over same arrays copies with different contiguity', end=' ')\n",
    "%timeit df/df2\n",
    "print('division underlying numpy of DataFrame creates with same C-contiguity', end=' ')\n",
    "%timeit df.to_numpy()/df1b.to_numpy()\n",
    "print('division underlying numpy of DataFrame creates with different contiguity', end=' ')\n",
    "%timeit df.to_numpy()/df2.to_numpy()\n",
    "print('division underlying numpy of DataFrame creates with different contiguity copied in C order', end=' ')\n",
    "%timeit df.to_numpy().copy(order='C')/df2b.to_numpy().copy(order='C')\n",
    "print('division underlying numpy of DataFrame creates with same F-contiguity', end=' ')\n",
    "%timeit df2.to_numpy()/df2b.to_numpy()\n",
    "print('division underlying numpy of DataFrame creates with different contiguity copied in F order', end=' ')\n",
    "%timeit df.to_numpy().copy(order='F')/df2b.to_numpy().copy(order='F')\n",
    "print('division of numpy array with himself', end=' ')\n",
    "%timeit x_c/x_c\n",
    "print('division of raw numpy arrays with different contiguity', end=' ')\n",
    "%timeit x_c/x_f\n",
    "print('division of raw numpy arrays with same C-contiguity', end=' ')\n",
    "%timeit x_c/x_c1\n",
    "print('division of raw numpy arrays with same F-contiguity', end=' ')\n",
    "%timeit x_f/x_f\n",
    "print('using numba mdivision over to numpy of same contiguity df')\n",
    "%timeit msum(df.to_numpy(), df1b.to_numpy(), resF)\n",
    "print('using numba mdivision over to numpy of different contiguity df')\n",
    "%timeit msum(df.to_numpy(), df2.to_numpy(), resF)\n",
    "print('using numba mdivision same array')\n",
    "%timeit msum(x_c, x_c, resF)\n",
    "print('using numba mdivision same contiguityt array')\n",
    "%timeit msum(x_c, x_c1, resF)\n",
    "print('using numba mdivision different contiguityt array')\n",
    "%timeit msum(x_c, x_f, resF)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d7074e-2545-4037-a229-27469162d989",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(nb.float32[::,:](nb.float32[:,:], nb.float32[:,:], nb.float32[:,:]), nopython=True, nogil=True, parallel = True,fastmath=True, looplift=True, target_backend='host', inline='always')\n",
    "def msum(A, B, res):\n",
    "    n, k = A.shape\n",
    "    for j in nb.prange(k):\n",
    "        for i in nb.prange(n):\n",
    "            res[i, j] = A[i, j] / B[i, j]\n",
    "    return res[:n, :k]\n",
    "\n",
    "\n",
    "arr = np.random.randn(10_000_000,5)\n",
    "\n",
    "resF = np.empty(tuple(s * 2 for s in arr.shape), dtype=np.float32)\n",
    "\n",
    "x_c=arr.astype(np.float32).copy(order='F')\n",
    "\n",
    "df = pd.DataFrame(x_c)\n",
    "\n",
    "%timeit df / df.shift()\n",
    "%timeit x_c[1:] / x_c[:-1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe2fc12d-ef85-4d74-a7bb-b0e01c372196",
   "metadata": {},
   "outputs": [],
   "source": [
    "x_c.flags.c_contiguous"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0e52cef7-801f-4001-a8ce-f772aba93bc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "for k in range(7,8):\n",
    "    arr = np.random.randn(int(10**k),3)\n",
    "\n",
    "    print()\n",
    "    print(f'k={k}')\n",
    "    print('C-contiguous')\n",
    "    x=arr.copy(order='C')\n",
    "    print('numpy')\n",
    "    %timeit np.sum(x, axis=1)\n",
    "    print('numba')\n",
    "    %timeit func_int_identifier_loop(x)\n",
    "\n",
    "    print()\n",
    "    print('F-contiguous')\n",
    "    x=arr.copy(order='F')\n",
    "    print('numpy')\n",
    "    %timeit np.sum(x, axis=1)\n",
    "    print('numba')\n",
    "    %timeit func_int_identifier_loop(x)\n",
    "\n",
    "    print()\n",
    "    print('C contigous with conversion')\n",
    "    x=arr.copy(order='C')\n",
    "    print('numpy')\n",
    "    %timeit np.sum(x.copy(order='F'), axis=1)\n",
    "    print('numba')\n",
    "    %timeit func_int_identifier_loop(x.copy(order='F'))\n",
    "\n",
    "    print()\n",
    "    print()\n",
    "    print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "60dac167-6e6d-4bf5-b339-3d856ccdcaef",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(3, 10):\n",
    "    arr = np.random.randn(int(10**k),3)\n",
    "    \n",
    "    x=arr.copy(order='C')\n",
    "    %timeit func_int_identifier_loop(x)\n",
    "    x=arr.copy(order='F')\n",
    "    %timeit func_int_identifier_loop(x)\n",
    "    # x=arr.copy(order='F')\n",
    "    # %timeit func_int_identifier_loop(x.copy(order='C'))\n",
    "\n",
    "    # print()\n",
    "    \n",
    "    # x=arr.copy(order='F')\n",
    "    # %timeit func_int_identifier_loop(x)\n",
    "    # x=arr.copy(order='F')\n",
    "    # %timeit func_int_identifier_loop(x.copy(order='C'))\n",
    "    \n",
    "    # print()\n",
    "    # print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1ed512e-808f-42d5-9635-0dd04be204c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(10):\n",
    "    arr = np.random.randn(int(10**k),3)\n",
    "    \n",
    "    x=arr.copy(order='C')\n",
    "    %timeit func_int_identifier_loopD(x.copy(order='C'), axis = 1)\n",
    "    x=arr.copy(order='C')\n",
    "    %timeit func_int_identifier_loopD(x.copy(order='C').copy(order='F'), axis = 1)\n",
    "    \n",
    "    \n",
    "    x=arr.copy(order='F')\n",
    "    %timeit func_int_identifier_loopD(x.copy(order='F'), axis = 0)\n",
    "    x=arr.copy(order='F')\n",
    "    %timeit func_int_identifier_loopD(x.copy(order='F').copy(order='C'), axis = 0)\n",
    "    \n",
    "    print()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6d018d8-6ba9-423e-85c7-aed8454891ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in range(10):\n",
    "    arr = np.random.randn(int(10**k),3)\n",
    "    \n",
    "    x=arr.copy(order='C')\n",
    "    %timeit func_int_identifier_loop(x.copy(order='C'), axis = 1)\n",
    "    x=arr.copy(order='C')\n",
    "    %timeit func_int_identifier_loop(x.copy(order='C').copy(order='F'), axis = 1)\n",
    "    \n",
    "    \n",
    "    x=arr.copy(order='F')\n",
    "    %timeit func_int_identifier_loop(x.copy(order='F'), axis = 0)\n",
    "    x=arr.copy(order='F')\n",
    "    %timeit func_int_identifier_loop(x.copy(order='F').copy(order='C'), axis = 0)\n",
    "    \n",
    "    print()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37f99bdb-06a5-4c7f-9a10-e6c0abe9f034",
   "metadata": {},
   "outputs": [],
   "source": [
    "# import numpy as np\n",
    "\n",
    "# %timeit x = np.zeros((1_000_000_000, 4), dtype = np.float32)\n",
    "# %timeit x = np.empty((1_000_000_000, 4), dtype = np.float32)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc6cc7af-ee38-4707-a277-ff54141fb80c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1991fb31-30c6-442b-b3d5-13177ea45ae4",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randn(1000000,3)\n",
    "\n",
    "x=arr.copy(order='F')\n",
    "%timeit np.sum(x.copy(order='F'), axis = 0)\n",
    "x=arr.copy(order='F')\n",
    "%timeit np.sum(x.copy(order='F').copy(order='C'), axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ea8626f-1fd1-4b41-8893-31306b5179e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.random.randn(1000000,3)\n",
    "x=arr.copy(order='F')\n",
    "%timeit np.sum(x.copy(order='F'), axis = 0)\n",
    "x=arr.copy(order='C')\n",
    "%timeit np.sum(x.copy(order='C'), axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f33e37aa-abd3-4bd8-851c-6d0aa12b41e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numba import guvectorize, float64\n",
    "\n",
    "@guvectorize([(float64[:], float64[:])], '(n)->(n)', target='cpu')\n",
    "def guvectorized_function(x, out):\n",
    "    for i in range(x.shape[0]):\n",
    "        out[i] = (x[i] + x[i]) / x[i]  \n",
    "\n",
    "guvectorized_function\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "407bee39-6d7e-4534-9a0d-21f6af999774",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True, parallel = True)\n",
    "def temporaryE(z):\n",
    "    return (z[0] + z[2])/ z[1]\n",
    "    \n",
    "@nb.jit(nopython=True, nogil=True)\n",
    "def func_int_identifier_loopE(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1))\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporaryE(Z[i, :])\n",
    "    return res\n",
    "\n",
    "%timeit func_int_identifier_loopE(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee97a2ac-3d7a-4291-bea2-11ad2137be02",
   "metadata": {},
   "outputs": [],
   "source": [
    "@nb.jit(fastmath=True, forceinline=True, looplift=True, inline='always', target_backend='host', no_cfunc_wrapper=True, no_rewrites=True ,nopython=True, nogil=True, parallel = True)\n",
    "def temporaryE(z):\n",
    "    return (z[0] + z[2])/ z[1]\n",
    "    \n",
    "@nb.guvectorize\n",
    "def func_int_identifier_loopE(Z):\n",
    "    n = Z.shape[0]\n",
    "    res = np.zeros((n, 1))\n",
    "    for i in nb.prange(n):\n",
    "        res[i, 0] = temporaryE(Z[i, :])\n",
    "    return res\n",
    "\n",
    "%timeit func_int_identifier_loopE(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4de61c1-a8d3-47df-b3cc-bab31ad35bb5",
   "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.12.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}