Numpy-Performance_optimization.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3899070d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5b20a131",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum using for loop: 499767.56993624166\n",
      "Sum using NumPy's built-in function: 499767.5699362222\n"
     ]
    }
   ],
   "source": [
    "# Create a large 1D array with 1 million elements\n",
    "large_array = np.random.rand(1_000_000)\n",
    "\n",
    "# Function to calculate the sum using a for loop\n",
    "def sum_using_loop(array):\n",
    "    total = 0.0\n",
    "    for element in array:\n",
    "        total += element\n",
    "    return total\n",
    "\n",
    "# Calculate the sum using the for loop\n",
    "sum_loop = sum_using_loop(large_array)\n",
    "print(\"Sum using for loop:\", sum_loop)\n",
    "\n",
    "# Optimize the sum calculation using NumPy's built-in function\n",
    "sum_numpy = np.sum(large_array)\n",
    "print(\"Sum using NumPy's built-in function:\", sum_numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a7614103",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum using for loop (first 10 elements): [0.43522632 0.59381731 0.68383718 1.28241075 1.19722884 1.17870847\n",
      " 1.69564047 0.19936264 0.81946195 0.77812151]\n",
      "Sum using vectorized operations (first 10 elements): [0.43522632 0.59381731 0.68383718 1.28241075 1.19722884 1.17870847\n",
      " 1.69564047 0.19936264 0.81946195 0.77812151]\n"
     ]
    }
   ],
   "source": [
    "# Generate two large NumPy arrays with 1 million elements each\n",
    "array1 = np.random.rand(1_000_000)\n",
    "array2 = np.random.rand(1_000_000)\n",
    "\n",
    "# Function to perform element-wise addition using a for loop\n",
    "def add_using_loop(arr1, arr2):\n",
    "    result = np.zeros_like(arr1)\n",
    "    for i in range(len(arr1)):\n",
    "        result[i] = arr1[i] + arr2[i]\n",
    "    return result\n",
    "\n",
    "# Perform element-wise addition using the for loop\n",
    "sum_loop = add_using_loop(array1, array2)\n",
    "print(\"Sum using for loop (first 10 elements):\", sum_loop[:10])\n",
    "\n",
    "# Optimize the element-wise addition using vectorized operations\n",
    "sum_vectorized = array1 + array2\n",
    "print(\"Sum using vectorized operations (first 10 elements):\", sum_vectorized[:10])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e7cc94a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate two large 2D NumPy arrays with shape (1000, 1000)\n",
    "array1 = np.random.rand(1000, 1000)\n",
    "array2 = np.random.rand(1000, 1000)\n",
    "\n",
    "# Function to compute the dot product using nested for loops\n",
    "def dot_product_using_loops(arr1, arr2):\n",
    "    result = np.zeros((arr1.shape[0], arr2.shape[1]))\n",
    "    for i in range(arr1.shape[0]):\n",
    "        for j in range(arr2.shape[1]):\n",
    "            for k in range(arr1.shape[1]):\n",
    "                result[i, j] += arr1[i, k] * arr2[k, j]\n",
    "    return result\n",
    "\n",
    "# Compute the dot product using the nested for loops\n",
    "dot_product_loops = dot_product_using_loops(array1, array2)\n",
    "print(\"Dot product using nested for loops (first 5x5 block):\\n\", dot_product_loops[:5, :5])\n",
    "\n",
    "# this code definitely needs optimization\n",
    "# run time exceeded\n",
    "# thus, no output can be seen below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "549a7067",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dot product using NumPy's dot() function (first 5x5 block):\n",
      " [[250.8138586  248.70854944 243.35743054 244.35043007 239.15266257]\n",
      " [264.1999249  269.19131998 253.73015006 261.53807159 252.60448587]\n",
      " [249.33952654 249.42554133 239.72634485 247.58071302 241.42249836]\n",
      " [252.64998888 256.8086697  251.3359215  254.31203747 246.319851  ]\n",
      " [262.95907622 265.70352936 261.24357996 259.32753179 253.28896622]]\n"
     ]
    }
   ],
   "source": [
    "# Optimize the dot product computation using NumPy's dot() function\n",
    "dot_product_numpy = np.dot(array1, array2)\n",
    "print(\"Dot product using NumPy's dot() function (first 5x5 block):\\n\", dot_product_numpy[:5, :5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7ba0365e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Row-wise mean using for loop (first 10 rows): [0.46470359 0.50512447 0.4599706  0.46464672 0.49996935 0.44899845\n",
      " 0.53276454 0.53147782 0.49924803 0.47391731]\n",
      "Row-wise mean using vectorized operations (first 10 rows): [0.46470359 0.50512447 0.4599706  0.46464672 0.49996935 0.44899845\n",
      " 0.53276454 0.53147782 0.49924803 0.47391731]\n"
     ]
    }
   ],
   "source": [
    "# Create a large 2D NumPy array with shape (10000, 100)\n",
    "large_array = np.random.rand(10000, 100)\n",
    "\n",
    "# Function to calculate the row-wise mean using a for loop\n",
    "def row_wise_mean_using_loop(array):\n",
    "    row_means = np.zeros(array.shape[0])\n",
    "    for i in range(array.shape[0]):\n",
    "        row_means[i] = np.mean(array[i, :])\n",
    "    return row_means\n",
    "\n",
    "# Calculate the row-wise mean using the for loop\n",
    "mean_loop = row_wise_mean_using_loop(large_array)\n",
    "print(\"Row-wise mean using for loop (first 10 rows):\", mean_loop[:10])\n",
    "\n",
    "# Optimize the row-wise mean calculation using vectorized operations\n",
    "mean_vectorized = np.mean(large_array, axis=1)\n",
    "print(\"Row-wise mean using vectorized operations (first 10 rows):\", mean_vectorized[:10])\n"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}