Numpy-Performance_optimization2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0fc8880b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1f2bacaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard deviation using for loop: 0.2887271915863127\n"
     ]
    }
   ],
   "source": [
    "# Create a large NumPy array with 1 million elements\n",
    "large_array = np.random.rand(1_000_000)\n",
    "\n",
    "# Function to calculate the standard deviation using a for loop\n",
    "def std_dev_using_loop(array):\n",
    "    mean = np.mean(array)\n",
    "    variance = 0.0\n",
    "    for element in array:\n",
    "        variance += (element - mean) ** 2\n",
    "    variance /= len(array)\n",
    "    return np.sqrt(variance)\n",
    "\n",
    "# Calculate the standard deviation using the for loop\n",
    "std_loop = std_dev_using_loop(large_array)\n",
    "print(\"Standard deviation using for loop:\", std_loop)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "93248fb4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Standard deviation using NumPy's built-in function: 0.2887271915863172\n"
     ]
    }
   ],
   "source": [
    "# Optimize the standard deviation calculation using NumPy's built-in function\n",
    "std_numpy = np.std(large_array)\n",
    "print(\"Standard deviation using NumPy's built-in function:\", std_numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b4f5b9f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transposed array using for loop (first 5x5 block):\n",
      " [[0.23903337 0.19007353 0.85859229 0.28750725 0.35557048]\n",
      " [0.98251248 0.90925071 0.1161072  0.13561969 0.74814477]\n",
      " [0.43103037 0.72191547 0.30839426 0.3684516  0.48460447]\n",
      " [0.37271006 0.03125132 0.43701681 0.03482462 0.26708755]\n",
      " [0.16753644 0.50204953 0.03975582 0.51152274 0.97186594]]\n"
     ]
    }
   ],
   "source": [
    "# Create a large 2D NumPy array with shape (1000, 1000)\n",
    "large_array = np.random.rand(1000, 1000)\n",
    "\n",
    "# Function to transpose a 2D array using nested for loops\n",
    "def transpose_using_loops(array):\n",
    "    rows, cols = array.shape\n",
    "    transposed_array = np.zeros((cols, rows))\n",
    "    for i in range(rows):\n",
    "        for j in range(cols):\n",
    "            transposed_array[j, i] = array[i, j]\n",
    "    return transposed_array\n",
    "\n",
    "# Transpose the array using the nested for loops\n",
    "transposed_loop = transpose_using_loops(large_array)\n",
    "print(\"Transposed array using for loop (first 5x5 block):\\n\", transposed_loop[:5, :5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a3d62b0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Transposed array using NumPy's transpose() function (first 5x5 block):\n",
      " [[0.23903337 0.19007353 0.85859229 0.28750725 0.35557048]\n",
      " [0.98251248 0.90925071 0.1161072  0.13561969 0.74814477]\n",
      " [0.43103037 0.72191547 0.30839426 0.3684516  0.48460447]\n",
      " [0.37271006 0.03125132 0.43701681 0.03482462 0.26708755]\n",
      " [0.16753644 0.50204953 0.03975582 0.51152274 0.97186594]]\n"
     ]
    }
   ],
   "source": [
    "# Optimize the transposition using NumPy's transpose() function\n",
    "transposed_numpy = np.transpose(large_array)\n",
    "print(\"Transposed array using NumPy's transpose() function (first 5x5 block):\\n\", transposed_numpy[:5, :5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cf3e7cc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise multiplication using for loop (first 5x5 block):\n",
      " [[0.22136729 0.10063924 0.30866945 0.34007099 0.26016479]\n",
      " [0.32494352 0.00306148 0.49284438 0.02764902 0.05744921]\n",
      " [0.22614241 0.17308528 0.16583555 0.07813882 0.02567455]\n",
      " [0.01512018 0.06191294 0.50053005 0.34182763 0.19508571]\n",
      " [0.07593631 0.12350505 0.09011245 0.06890292 0.43955031]]\n"
     ]
    }
   ],
   "source": [
    "# Create 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 element-wise multiplication using nested for loops\n",
    "def elementwise_multiplication_using_loops(arr1, arr2):\n",
    "    rows, cols = arr1.shape\n",
    "    result = np.zeros((rows, cols))\n",
    "    for i in range(rows):\n",
    "        for j in range(cols):\n",
    "            result[i, j] = arr1[i, j] * arr2[i, j]\n",
    "    return result\n",
    "\n",
    "# Compute the element-wise multiplication using the nested for loops\n",
    "result_loop = elementwise_multiplication_using_loops(array1, array2)\n",
    "print(\"Element-wise multiplication using for loop (first 5x5 block):\\n\", result_loop[:5, :5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cd664cd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Element-wise multiplication using vectorized operations (first 5x5 block):\n",
      " [[0.22136729 0.10063924 0.30866945 0.34007099 0.26016479]\n",
      " [0.32494352 0.00306148 0.49284438 0.02764902 0.05744921]\n",
      " [0.22614241 0.17308528 0.16583555 0.07813882 0.02567455]\n",
      " [0.01512018 0.06191294 0.50053005 0.34182763 0.19508571]\n",
      " [0.07593631 0.12350505 0.09011245 0.06890292 0.43955031]]\n"
     ]
    }
   ],
   "source": [
    "# Optimize the element-wise multiplication using NumPy's vectorized operations\n",
    "result_vectorized = array1 * array2\n",
    "print(\"Element-wise multiplication using vectorized operations (first 5x5 block):\\n\", result_vectorized[:5, :5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "2e82b7ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum using nested for loops: 500355.56749845983\n",
      "Sum using NumPy's built-in function: 500355.5674984588\n"
     ]
    }
   ],
   "source": [
    "# Create a large 3D NumPy array with shape (100, 100, 100)\n",
    "large_array = np.random.rand(100, 100, 100)\n",
    "\n",
    "# Function to compute the sum of all elements using nested for loops\n",
    "def sum_using_loops(array):\n",
    "    total_sum = 0.0\n",
    "    for i in range(array.shape[0]):\n",
    "        for j in range(array.shape[1]):\n",
    "            for k in range(array.shape[2]):\n",
    "                total_sum += array[i, j, k]\n",
    "    return total_sum\n",
    "\n",
    "# Compute the sum using the nested for loops\n",
    "sum_loop = sum_using_loops(large_array)\n",
    "print(\"Sum using nested for loops:\", sum_loop)\n",
    "\n",
    "# Optimize the sum computation 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": 9,
   "id": "ff22c021",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum element using for loop: 999994\n",
      "Maximum element using NumPy: 999994\n"
     ]
    }
   ],
   "source": [
    "# Generate a large NumPy array with random integers\n",
    "large_array = np.random.randint(1, 1000000, size=1000000)\n",
    "\n",
    "# Function to find the maximum element using a for loop\n",
    "def find_max_with_loop(arr):\n",
    "    max_element = arr[0]\n",
    "    for element in arr:\n",
    "        if element > max_element:\n",
    "            max_element = element\n",
    "    return max_element\n",
    "\n",
    "# Find the maximum element using the for loop method\n",
    "max_with_loop = find_max_with_loop(large_array)\n",
    "\n",
    "# Find the maximum element using NumPy's built-in function\n",
    "max_with_numpy = np.max(large_array)\n",
    "\n",
    "# Display the results\n",
    "print(f\"Maximum element using for loop: {max_with_loop}\")\n",
    "print(f\"Maximum element using NumPy: {max_with_numpy}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ca03631a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 10 results using for loop:\n",
      "[2.06493506 0.2        1.17928903 0.36486486 0.27272727 7.66666667\n",
      " 2.38132296 6.18300654 0.83351709 1.38330171]\n",
      "First 10 results using NumPy:\n",
      "[2.06493506 0.2        1.17928903 0.36486486 0.27272727 7.66666667\n",
      " 2.38132296 6.18300654 0.83351709 1.38330171]\n"
     ]
    }
   ],
   "source": [
    "# Generate two large 1D NumPy arrays with random integers\n",
    "array1 = np.random.randint(1, 1000, size=1000000)\n",
    "array2 = np.random.randint(1, 1000, size=1000000)\n",
    "\n",
    "# Function to compute element-wise division using a for loop\n",
    "def element_wise_division_with_loop(arr1, arr2):\n",
    "    result = np.empty_like(arr1, dtype=float)\n",
    "    for i in range(len(arr1)):\n",
    "        result[i] = arr1[i] / arr2[i]\n",
    "    return result\n",
    "\n",
    "# Compute element-wise division using the for loop method\n",
    "result_with_loop = element_wise_division_with_loop(array1, array2)\n",
    "\n",
    "# Compute element-wise division using NumPy's vectorized operations\n",
    "result_with_numpy = array1 / array2\n",
    "\n",
    "# Display first 10 results to verify\n",
    "print(\"First 10 results using for loop:\")\n",
    "print(result_with_loop[:10])\n",
    "\n",
    "print(\"First 10 results using NumPy:\")\n",
    "print(result_with_numpy[:10])"
   ]
  }
 ],
 "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
}