Day23 - Numpy Array Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# **NumPy - Array Functions**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. **Creating NumPy Arrays:**\n",
    "   - You can create NumPy arrays using `np.random.random()`, `np.arange()`, and reshaping methods like `reshape()`. In your example, you created three NumPy arrays, `a1`, `a2`, and `a3`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[74. 98. 34.]\n",
      " [89. 62. 11.]\n",
      " [29. 87. 44.]]\n",
      "------------\n",
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "-------------\n",
      "[[12 13 14]\n",
      " [15 16 17]\n",
      " [18 19 20]\n",
      " [21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "# first we have to assume three numpy arrays\n",
    "a1 = np.random.random((3,3))\n",
    "a1 = np.round(a1*100)\n",
    "\n",
    "a2 = np.arange(12).reshape(3,4)\n",
    "\n",
    "a3 = np.arange(12,24).reshape(4,3)\n",
    "\n",
    "print(a1)\n",
    "print('------------')\n",
    "print(a2)\n",
    "print('-------------')\n",
    "print(a3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. **Maximum, Minimum, Sum, and Product:**\n",
    "   - You can find the maximum value in an array using `np.max()`.\n",
    "   - You can find the minimum value in an array using `np.min()`.\n",
    "   - You can calculate the sum of all elements in an array using `np.sum()`.\n",
    "   - You can calculate the product of all elements in an array using `np.prod()`.\n",
    "   - By specifying the `axis` parameter, you can find the maximum or minimum along columns (axis=0) or rows (axis=1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "528.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1661426069717568.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.prod(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([89., 98., 44.])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if we want seperate for columns and rows\n",
    "# axis -> 0 = columns , 1 = row\n",
    "\n",
    "np.max(a1,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([98., 89., 87.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(a1,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([29., 62., 11.])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.min(a1,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. **Mean, Median, Standard Deviation, and Variance:**\n",
    "   - You can calculate the mean of an array using `np.mean()`.\n",
    "   - You can find the median value in an array using `np.median()`.\n",
    "   - You can calculate the standard deviation of an array using `np.std()`.\n",
    "   - You can compute the variance of an array using `np.var()`.\n",
    "   - Similar to the previous case, you can specify the `axis` parameter for calculations along columns or rows.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "58.666666666666664"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.5"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(a2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28.85211334450987"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "832.4444444444446"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([74., 62., 44.])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for columns and rows\n",
    "np.median(a1,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([74., 87., 34.])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(a1,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. **Trigonometric Functions:**\n",
    "   - You can apply trigonometric functions to an array, such as sine (`np.sin()`) and cosine (`np.cos()`), which perform element-wise calculations on the input array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.98514626, -0.57338187,  0.52908269],\n",
       "       [ 0.86006941, -0.7391807 , -0.99999021],\n",
       "       [-0.66363388, -0.82181784,  0.01770193]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sin(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.17171734, -0.81928825, -0.84857027],\n",
       "       [ 0.51017704,  0.67350716,  0.0044257 ],\n",
       "       [-0.74805753,  0.56975033,  0.99984331]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cos(a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. **Dot Product:**\n",
    "   - The `np.dot()` function computes the dot product of two arrays, which is particularly useful for matrix multiplication. In your example, you multiplied `a2` and `a3` using `np.dot()` to obtain the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "------------\n",
      "[[12 13 14]\n",
      " [15 16 17]\n",
      " [18 19 20]\n",
      " [21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "print(a2)\n",
    "\n",
    "print('------------')\n",
    "\n",
    "print(a3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[114, 120, 126],\n",
       "       [378, 400, 422],\n",
       "       [642, 680, 718]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a2,a3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. **Logarithms and Exponents:**\n",
    "   - You can compute the natural logarithm of an array using `np.log()`.\n",
    "   - You can calculate the exponential of each element in an array using `np.exp()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.30406509, 4.58496748, 3.52636052],\n",
       "       [4.48863637, 4.12713439, 2.39789527],\n",
       "       [3.36729583, 4.46590812, 3.78418963]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(a1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.37338298e+32, 3.63797095e+42, 5.83461743e+14],\n",
       "       [4.48961282e+38, 8.43835667e+26, 5.98741417e+04],\n",
       "       [3.93133430e+12, 6.07603023e+37, 1.28516001e+19]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. **Rounding, Flooring, and Ceiling:**\n",
    "   - You can round the elements of an array to the nearest integer using `np.round()`.\n",
    "   - You can round down the elements to the nearest integer using `np.floor()`.\n",
    "   - You can round up the elements to the nearest integer using `np.ceil()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12.34714055 34.11903111 28.73639357]\n",
      " [97.69723411 52.68276927 61.09195526]]\n"
     ]
    }
   ],
   "source": [
    "a=np.random.random((2,3))*100\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12., 34., 29.],\n",
       "       [98., 53., 61.]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.round(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12., 34., 28.],\n",
       "       [97., 52., 61.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.floor(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[13., 35., 29.],\n",
       "       [98., 53., 62.]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ceil(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These NumPy functions and operations are essential tools for numerical and scientific computing in Python, providing a wide range of capabilities for data manipulation, analysis, and mathematical calculations.\n",
    "\n",
    "Check Out this for more NumPy Functions - https://numpy.org/doc/stable/reference/routines.math.html"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}