1_Finding_Distance.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding Distance (numpy or pandas ?)\n",
    "\n",
    "The first task for our super hero (Python) is as follows:\n",
    "A bunch of villains spread all over the city, our super hero has the locations (x, y) of all the villains. He has to calculate the distance of each villain from his head quaters (0,0). What super power (NumPy or Pandas) serves the best in this situation?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Lets load the super powers\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import time as time  # time module to calcualate computation time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#generate villain locations\n",
    "import random as rd\n",
    "villains_x = [rd.uniform(0,1000) for i in range(1000000)]\n",
    "villains_y = [rd.uniform(0,1000) for i in range(1000000)]\n",
    "villains   = [i for i in zip(villains_x,villains_y)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function to calculate distance using numpy without vectorization\n",
    "def dist_numpy_wov(v_np):\n",
    "    dist   = []\n",
    "    #calculating distance\n",
    "    for i in range(len(v_np[:,0])):\n",
    "        dist.append(v_np[i,0]**2+v_np[i,1]**2)    \n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function to calculate distance using numpy with vectorization\n",
    "def dist_numpy_wv(v_np):\n",
    "    #calculating distance using vectorization in numpy\n",
    "    dist   =  np.sum(np.square(v_np),axis=1)    \n",
    "    return dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Function to calculate distance using pandas\n",
    "def dist_pandas(v_df):\n",
    "    dist = []\n",
    "    #calculating distance\n",
    "    for i in range(len(v_df['x'])):\n",
    "        dist.append(v_df.loc[i,'x']**2 + v_df.loc[i,'y']**2)  \n",
    "    return dist   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy without vectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time take by numpy without vectorization 4.024132\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Calculating distances \n",
    "villains   = np.array(villains)\n",
    "dist       = dist_numpy_wov(villains)\n",
    "\n",
    "end_time   = time.time()\n",
    "print (\"Time take by numpy without vectorization {0:1.6f}\".format(end_time-start_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time take by numpy without vectorization 81.982560\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Calculating distances \n",
    "villains_df   = pd.DataFrame(villains, columns = [\"x\", \"y\"])\n",
    "dist          = dist_pandas(villains_df)\n",
    "\n",
    "end_time   = time.time()\n",
    "print (\"Time take by numpy without vectorization {0:1.6f}\".format(end_time-start_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy with vectorization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time take by numpy with vectorization 0.135962\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "#Calculating distances \n",
    "villains   = np.array(villains)\n",
    "dist       = dist_numpy_wv(villains)\n",
    "\n",
    "end_time   = time.time()\n",
    "print (\"Time take by numpy with vectorization {0:1.6f}\".format(end_time-start_time))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "It was pretty clear from the above results that NumPy with vectorization is the one which takes much lesser time. Pandas on the other hand is very bad at distance calculating. The reason boils down to the indexing. Indexing series object is much slower than indexing numpy arrays. Check this site (https://penandpants.com/2014/09/05/performance-of-pandas-series-vs-numpy-arrays/) for explanation on the same. Anyway our super hero (python) should use numpy with vectorization to find the distances of super villains from the head quaters.\n",
    "\n",
    "\n",
    "\n",
    "## Winner for finding_distance:   NumPy with vectorization\n",
    "\n",
    "\n",
    "\n",
    "Thanks..!!!\n",
    "Have a nice day..!!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}