Lab_1_Numpy_basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lab 1: Numpy basics.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyN90son5P27Y4AkkAzLRES8",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mirsazzathossain/CSE317-Lab/blob/main/Lab_1_Numpy_basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dy6WcZhSqIOk"
      },
      "source": [
        "# **Colab Notebooks**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aBYrfsG9q0GF"
      },
      "source": [
        "To run this tutorial entirely in Colab, click the Open in Colab badge at the very top of this page. Sign in with your google account and click on the '[ ]' sign at top of each code cell to run the code of that cell."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rvy7qgN8naaE"
      },
      "source": [
        "# **Python**\n",
        "Python is a high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p9O7jd5pnwRj"
      },
      "source": [
        "## if ... elif ... else"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qIAKZEGCn590"
      },
      "source": [
        "n = 3;\n",
        "if n >= 1 and n < 5:  \n",
        "  x = 1\n",
        "elif n != 0:\n",
        "  x = 1\n",
        "else: \n",
        "  x = 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rC1nfPKbod0_"
      },
      "source": [
        "## Loops\n",
        "We can loop over the elements of a list like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bLJOyQmtoigg"
      },
      "source": [
        "for i in range(10):\n",
        "  print(i, end=' ')\n",
        "\n",
        "print()\n",
        "\n",
        "animals = ['cat', 'dog', 'monkey']\n",
        "for animal in animals:\n",
        "    print(animal, end=' ')\n",
        "\n",
        "print()\n",
        "\n",
        "nums = [0, 1, 2, 3, 4]\n",
        "squares = []\n",
        "for x in nums:\n",
        "    squares.append(x ** 2)\n",
        "print(squares)   # Prints [0, 1, 4, 9, 16]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yJ2qP9atpG1u"
      },
      "source": [
        "If you want access to the index of each element within the body of a loop, use the built-in enumerate function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Cy2Xrz6CpIDM"
      },
      "source": [
        "animals = ['cat', 'dog', 'monkey']\n",
        "for idx, animal in enumerate(animals):\n",
        "    print('#%d: %s' % (idx + 1, animal))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "16ncA1qUpVTt"
      },
      "source": [
        "## Functions\n",
        "Python functions are defined using the `def` keyword. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "InEDKT1WpaW9"
      },
      "source": [
        "def sign(x):\n",
        "    if x > 0:\n",
        "        return 'positive'\n",
        "    elif x < 0:\n",
        "        return 'negative'\n",
        "    else:\n",
        "        return 'zero'\n",
        "\n",
        "print(sign(-1))\n",
        "print(sign(0))\n",
        "print(sign(1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "brgg-3z5prsO"
      },
      "source": [
        "We will often define functions to take optional keyword arguments, like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4Xm_ISpRptCv"
      },
      "source": [
        "def hello(name, loud=False):\n",
        "    if loud:\n",
        "        print('HELLO, %s!' % name.upper())\n",
        "    else:\n",
        "        print('Hello, %s' % name)\n",
        "\n",
        "hello('Bob') # Prints \"Hello, Bob\"\n",
        "hello('Fred', loud=True)  # Prints \"HELLO, FRED!\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DEgtZOzAqW4s"
      },
      "source": [
        "def sumdiff(x,y):\n",
        "    a = x + y;\n",
        "    b = x - y;\n",
        "\n",
        "    return a, b\n",
        "\n",
        "sum, diff = sumdiff(5, 3)\n",
        "print(sum, diff)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T_gXI0D12DdA"
      },
      "source": [
        "# **Numpy**\n",
        "Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays. To start working with numpy we always need to import the numpy package. Run the cell below to import numpy."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rC161lJVzykW"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SLstFTXf3dO3"
      },
      "source": [
        "## Array\n",
        "NumPy’s array class is called ndarray. We can initialize numpy arrays from nested Python lists, and access elements using square brackets:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kvXNpnmQ3d83"
      },
      "source": [
        "a = np.array([2, 3, 4])   # Create array(1D) from python list\n",
        "print(a[0])               # Access elements using square brackets\n",
        "\n",
        "a[0] = 1                  # Change an element of the array\n",
        "print(a)                  # Prints \"[1, 3, 4]\"\n",
        "\n",
        "\n",
        "b = np.array([[2, 3, 4], [5, 6, 7]])  # Create a 2D array\n",
        "print(b[0, 1])                        # Prints 3\n",
        "\n",
        "b[1, 1] = 1                           # Change an element of the array\n",
        "print(b[0, 0], b[0, 1], b[1, 0])      # Prints \"2 3 5\"\n",
        "\n",
        "c = np.array([(1.5, 2, 3), (4, 5, 6)])# Create a 2D float array\n",
        "print(c[0, 1])                        # Prints \"2.0\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "la0KkEgt5vfT"
      },
      "source": [
        "Some important attributes of an ndarray object are:\n",
        "\n",
        "\n",
        "*   **ndarray.ndim:** the number of axes (dimensions) of the array.\n",
        "*   **ndarray.shape:** the dimensions of the array. This is a tuple of integers indicating the size of the array in each dimension. For a matrix with n rows and m columns, shape will be (n,m). The length of the shape tuple is therefore the number of axes, ndim.\n",
        "*   **ndarray.size:** the total number of elements of the array. This is equal to the product of the elements of shape.\n",
        "*   **ndarray.dtype:** an object describing the type of the elements in the array. numpy.int32, numpy.int16, and numpy.float64 are some examples.\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SLZzLMzd5rGM"
      },
      "source": [
        "print(a.ndim)             # Prints \"1\"\n",
        "print(b.ndim)             # Prints \"2\"\n",
        "\n",
        "print(a.shape)            # Prints \"(3,)\"\n",
        "print(b.shape)            # Prints \"(2, 3)\"\n",
        "\n",
        "print(a.size)             # Prints \"3\"\n",
        "print(b.size)             # Prints \"6\"\n",
        "\n",
        "print(a.dtype)            # Prints \"int64\"\n",
        "print(c.dtype)            # Prints \"float64\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QKjD4MT8C8wp"
      },
      "source": [
        "Numpy also provides many functions to create arrays:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b1ZQECGpC-5Z"
      },
      "source": [
        "a = np.zeros((2,2))      # Create an array of all zeros\n",
        "print(a)                 # Prints \"[[ 0.  0.]\n",
        "                         #          [ 0.  0.]]\"\n",
        "\n",
        "b = np.ones((1,2))       # Create an array of all ones\n",
        "print(b)                 # Prints \"[[ 1.  1.]]\"\n",
        "\n",
        "c = np.full((2,2), 7)    # Create a constant array\n",
        "print(c)                 # Prints \"[[ 7.  7.]\n",
        "                         #          [ 7.  7.]]\"\n",
        "\n",
        "d = np.eye(2)            # Create a 2x2 identity matrix\n",
        "print(d)                 # Prints \"[[ 1.  0.]\n",
        "                         #          [ 0.  1.]]\"\n",
        "\n",
        "e = np.random.random((2,2))  # Create an array filled with random values\n",
        "print(e)                     # Might print \"[[ 0.91940167  0.08143941]\n",
        "                             #               [ 0.68744134  0.87236687]]\"\n",
        "\n",
        "f = np.arange(3)         # Create an array filed with 0 to 2\n",
        "print(f)                 # Prints \"[0 1 2]\"\n",
        "\n",
        "g = np.linspace(2, 10, 5)    # Return evenly spaced 5 numbers over interval 2-10\n",
        "print(g)                     # Prints [ 2.  4.  6.  8. 10.]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wNYXWTb7HGvv"
      },
      "source": [
        "## Array indexing, Slicing and Iterating\n",
        "One-dimensional arrays can be indexed, sliced and iterated over, much like lists and other Python sequences."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G3W98UNGLhZH"
      },
      "source": [
        "a = np.arange(10)**3     # In python \"**\" means power x**3 = x^3\n",
        "print(a)                 # Prints \"[0 1 8 27 64 125 216 343 512 729]\"\n",
        "\n",
        "print(a[2])              # Prints \"8\"\n",
        "print(a[2:5])            # Prints \"[8 27 64]\"\n",
        "print(a[:6])             # Prints \"[0 1 8 27 64 125]\"\n",
        "print(a[2:])             # Prints \"[8 27 64 125 216 343 512 729]\"\n",
        "print(a[::-1])           # Prints reversed array\n",
        "\n",
        "a[:6:2] = 1000           # From start to position 6 (exclusive) set every 2nd element to 1000\n",
        "print(a)                 # Prints \"[1000 1 1000 27 1000 125 216 343 512 729]\"\n",
        "\n",
        "# Iterating over array\n",
        "for element in a:\n",
        "  print(element**(1/3.))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6nL19eN0yj96"
      },
      "source": [
        "Multidimensional arrays can have one index per axis. These indices are given in a tuple separated by commas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7pVfrvdyyhxj"
      },
      "source": [
        "b = np.array([[ 0,  1,  2,  3],\n",
        "              [10, 11, 12, 13],\n",
        "              [20, 21, 22, 23],\n",
        "              [30, 31, 32, 33],\n",
        "              [40, 41, 42, 43]])\n",
        "\n",
        "print(b[2, 3])           # Prints \"23\"\n",
        "\n",
        "print(b[:, 1])           # Print second column of b\n",
        "print(b[:, 1:3])         # Print second and third column of b\n",
        "print(b[:2, 2])          # Print first 2 rows in the third column of b\n",
        "print(b[-2:, 1])         # Print last 2 rows in the second column of b\n",
        "print(b[1:4, 2])         # Print rows 2-4 in the third column of b\n",
        "\n",
        "print()\n",
        "\n",
        "print(b[3, :])           # Print fourth row of b\n",
        "print(b[1:3, :])         # Print second and third row of b\n",
        "print(b[2, :2])          # Print first 2 columns in the third row of b\n",
        "print(b[1, -2:])         # Print last 2 columns in the second row of b\n",
        "print(b[2, 1:4])         # Print columns 2-4 in the third row of b\n",
        "\n",
        "# Iterating over 2D array\n",
        "for row in b:\n",
        "  for col in row:\n",
        "    print(col, end=' ')\n",
        "  print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-M4BzVP952Q1"
      },
      "source": [
        "**Integer array indexing:** When you index into numpy arrays using slicing, the resulting array view will always be a subarray of the original array. In contrast, integer array indexing allows you to construct arbitrary arrays using the data from another array. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C9JcNvCv6GS3"
      },
      "source": [
        "a = np.array([[1,2], [3, 4], [5, 6]])\n",
        "\n",
        "print(a[[0, 1, 2], [0, 1, 0]])  # Prints \"[1 4 5]\"\n",
        "\n",
        "# The above example of integer array indexing is equivalent to this:\n",
        "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))  # Prints \"[1 4 5]\"\n",
        "\n",
        "# When using integer array indexing, you can reuse the same\n",
        "# element from the source array:\n",
        "print(a[[0, 0], [1, 1]])  # Prints \"[2 2]\"\n",
        "\n",
        "# Equivalent to the previous integer array indexing example\n",
        "print(np.array([a[0, 1], a[0, 1]]))  # Prints \"[2 2]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0jME0ARg6kKU"
      },
      "source": [
        "One useful trick with integer array indexing is selecting or mutating one element from each row of a matrix:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQhNP85H6hlP"
      },
      "source": [
        "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
        "\n",
        "# Create an array of indices\n",
        "b = np.array([0, 2, 0, 1])\n",
        "\n",
        "# Select one element from each row of a using the indices in b\n",
        "print(a[np.arange(4), b])  # Prints \"[1  6  7 11]\"\n",
        "\n",
        "# Mutate one element from each row of a using the indices in b\n",
        "a[np.arange(4), b] += 10\n",
        "\n",
        "print(a)  # prints \"array([[11,  2,  3],\n",
        "          #                [ 4,  5, 16],\n",
        "          #                [17,  8,  9],\n",
        "          #                [10, 21, 12]])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2Ls1JpLn7xCH"
      },
      "source": [
        "**Boolean array indexing:** Boolean array indexing lets you pick out arbitrary elements of an array. Frequently this type of indexing is used to select the elements of an array that satisfy some condition. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1XV_sFav7wqo"
      },
      "source": [
        "a = np.array([[1,2], [3, 4], [5, 6]])\n",
        "\n",
        "bool_idx = (a > 2)   # Find the elements of a that are bigger than 2;\n",
        "                     # this returns a numpy array of Booleans of the same\n",
        "                     # shape as a, where each slot of bool_idx tells\n",
        "                     # whether that element of a is > 2.\n",
        "\n",
        "print(bool_idx)      # Prints \"[[False False]\n",
        "                     #          [ True  True]\n",
        "                     #          [ True  True]]\"\n",
        "\n",
        "# We use boolean array indexing to construct a rank 1 array\n",
        "# consisting of the elements of a corresponding to the True values\n",
        "# of bool_idx\n",
        "print(a[bool_idx])   # Prints \"[3 4 5 6]\"\n",
        "\n",
        "# We can do all of the above in a single concise statement:\n",
        "print(a[a > 2])      # Prints \"[3 4 5 6]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L-o8BV11Oqmg"
      },
      "source": [
        "## Changing the shape of an array\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZD3A7OcwOvJo"
      },
      "source": [
        "a = np.floor(10 * np.random.random((3, 4)))\n",
        "print(a)\n",
        "\n",
        "print(a.ravel())      # prints the array, flattened\n",
        "print(a.reshape(6, 2))# prints the array with a modified shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M_UHoPjy8LhI"
      },
      "source": [
        "## Stacking together different arrays\n",
        "Several arrays can be stacked together along different axes:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aQhbQttm8jVf"
      },
      "source": [
        "# Create two random integer array\n",
        "# elements are in range of 1 to 10\n",
        "a = np.random.randint(low=1, high=10, size=(2,2))\n",
        "b = np.random.randint(low=1, high=10, size=(2,2))\n",
        "\n",
        "c = np.vstack((a, b))       # Vertically stack a and b\n",
        "print(c)                    # Will print vertically stacked array\n",
        "\n",
        "d = np.hstack((a, b))       # Horizontally stack a and b\n",
        "print(d)                    # Will print horizontally stacked array"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gcmnewhj-wu_"
      },
      "source": [
        "The function **column_stack** stacks 1D arrays as columns into a 2D array. It is equivalent to **hstack** only for 2D arrays:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "96WPKp3F-33H"
      },
      "source": [
        "# For 2D array\n",
        "a = np.random.randint(low=1, high=10, size=(2,2))\n",
        "b = np.random.randint(low=1, high=10, size=(2,2))\n",
        "\n",
        "c = np.column_stack((a, b))\n",
        "print(c)                     # Will print horizontally stacked array\n",
        "\n",
        "# For 1D array\n",
        "a = np.array([4., 2.])\n",
        "b = np.array([3., 8.])\n",
        "\n",
        "c = np.column_stack((a, b))  # returns a 2D array\n",
        "print(c)                     # Prints [[4. 3.]\n",
        "                             #         [2. 8.]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mz-o8RsLAbjo"
      },
      "source": [
        "On the other hand, the function **row_stack** is equivalent to **vstack** for any input arrays."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fsHEqAOAAgII"
      },
      "source": [
        "a = np.array([4., 2.])\n",
        "b = np.array([3., 8.])\n",
        "\n",
        "c = np.row_stack((a, b))     # returns a 2D array\n",
        "print(c)                     # Prints [[4. 3.]\n",
        "                             #         [2. 8.]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fUqa8i9pChLG"
      },
      "source": [
        "For higher dimentional array we can use **concatenate**. Here we need to pass an additional parameter name **axis**. **Concatenate** join a sequence of arrays along an existing axis. Insted of **vstack**, **hstack**, **column_stack** & **row_stack** we can always use **concatenate**.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JI4mFTV5Cglb"
      },
      "source": [
        "a = np.array([[1, 2], [3, 4]])\n",
        "b = np.array([[5, 6]])\n",
        "\n",
        "c = np.concatenate((a, b), axis=0)   # Same as vstack\n",
        "print(c)                             # Prints [[1 2]\n",
        "                                     #         [3 4]\n",
        "                                     #         [5 6]]   \n",
        "\n",
        "d = np.concatenate((a, b.T), axis=1) # Same as hstack\n",
        "print(d)                             # Prints [[1 2 5]\n",
        "                                     #         [3 4 6]]\n",
        "\n",
        "e = np.concatenate((a, b), axis=None)# Flatten the array\n",
        "print(e)                             # Prints [1 2 3 4 5 6]\n",
        "\n",
        "a = np.arange(3)                     # Creates array [0 1 2]\n",
        "b = np.arange(2, 5)                  # Creates array [2 3 4]\n",
        "f = np.concatenate([a, b])           # Concatenate\n",
        "print(f)                             # Prints [0 1 2 2 3 4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-qPp3Ox_FtD3"
      },
      "source": [
        "## Basic Operations\n",
        "Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R1NK-sf9GE_f"
      },
      "source": [
        "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
        "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
        "\n",
        "# Elementwise sum\n",
        "print(x + y)            # Operator overloading\n",
        "print(np.add(x, y))     # Function in numpy module\n",
        "\n",
        "# Elementwise difference\n",
        "print(x - y)            # Operator overloading\n",
        "print(np.subtract(x, y))# Function in numpy module\n",
        "\n",
        "# Elementwise product\n",
        "print(x * y)            # Operator overloading\n",
        "print(np.multiply(x, y))# Function in numpy module\n",
        "\n",
        "# Elementwise division\n",
        "print(x / y)            # Operator overloading\n",
        "print(np.divide(x, y))  # Function in numpy module\n",
        "\n",
        "# Elementwise power\n",
        "print(x**2)             # Operator overloading\n",
        "print(np.power(x, 2))   # Function in numpy module\n",
        "\n",
        "# Elementwise square root\n",
        "print(x**(1/2.))        # Operator overloading\n",
        "print(np.sqrt(x))       # Function in numpy module"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q6wmHlYZHwZr"
      },
      "source": [
        "**Universal function:** NumPy provides familiar mathematical functions such as sin, cos, and exp."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hICmMmaDH3sx"
      },
      "source": [
        "a = np.arange(3)\n",
        "print(np.exp(a))       # Exponential\n",
        "\n",
        "print(np.sin(a))       # Sine\n",
        "\n",
        "print(np.cos(a))       # Cosine"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wLUi67DTKpnx"
      },
      "source": [
        "Many unary operations, such as computing the sum of all the elements in the array, are implemented as methods of the ndarray class."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TAm2d2J2Krjw"
      },
      "source": [
        "a = np.random.randint(10, size=(2, 4))\n",
        "print(a)\n",
        "\n",
        "print(a.sum())         # Prints the sum of all elements\n",
        "print(a.min())         # Prints the minimum of all elements\n",
        "print(a.max())         # Prints the maximum of all elements"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u8j4PzraLhOG"
      },
      "source": [
        "By specifying the axis parameter you can apply an operation along the specified axis of an array:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VaC_nh0ZLjy-"
      },
      "source": [
        "b = np.array([[ 0,  1,  2,  3],\n",
        "              [ 4,  5,  6,  7],\n",
        "              [ 8,  9, 10, 11]])\n",
        "\n",
        "print(b.sum(axis=0))   # sum of each column\n",
        "print(b.min(axis=1))   # min of each row\n",
        "print(b.cumsum(axis=1))# cumulative sum along each row"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TpOD10pvNOhY"
      },
      "source": [
        "We use the `dot` function to compute inner products of vectors, to multiply a vector by a matrix, and to multiply matrices. `dot` is available both as a function in the numpy module and as an instance method of array objects:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UVKoPAHzNVK6"
      },
      "source": [
        "x = np.array([[1,2],[3,4]])\n",
        "y = np.array([[5,6],[7,8]])\n",
        "\n",
        "v = np.array([9,10])\n",
        "w = np.array([11, 12])\n",
        "\n",
        "# Inner product of vectors; both produce 219\n",
        "print(v.dot(w))\n",
        "print(np.dot(v, w))\n",
        "\n",
        "# Matrix / vector product; both produce the 1D array [29 67]\n",
        "print(x.dot(v))\n",
        "print(np.dot(x, v))\n",
        "\n",
        "# Matrix / matrix product; both produce the 2D array\n",
        "# [[19 22]\n",
        "#  [43 50]]\n",
        "print(x.dot(y))\n",
        "print(np.dot(x, y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uMD1m0pINlhC"
      },
      "source": [
        "To transpose a matrix, simply use the `T` attribute of an array object:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cP68hvYSNvDV"
      },
      "source": [
        "x = np.array([[1,2], [3,4]])\n",
        "print(x)               # Prints \"[[1 2]\n",
        "                       #          [3 4]]\"\n",
        "print(x.T)             # Prints \"[[1 3]\n",
        "                       #          [2 4]]\"\n",
        "\n",
        "# Note that taking the transpose of a rank 1 array does nothing:\n",
        "v = np.array([1,2,3])\n",
        "print(v)               # Prints \"[1 2 3]\"\n",
        "print(v.T)             # Prints \"[1 2 3]\""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TUNlmk39RLkW"
      },
      "source": [
        "# **Pillow**\n",
        "Pillow is the friendly PIL fork, a Python Imaging Library. This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fq2cxw-SSx3G"
      },
      "source": [
        "from PIL import Image\n",
        "from IPython.display import display # Needed to display the image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JuuW1HYcSnzI"
      },
      "source": [
        "##Image operations\n",
        "Pillow provides functions to work with images. For example, it has functions to read images from disk and cnvert into numpy arrays, to write numpy arrays to disk as images, and to resize images. Here is a simple example that showcases these functions:\n",
        "\n",
        "***Note:** Please upload the 'cat.jpg' file to colab from the sidebar before proceeding to next step.\n",
        "\n",
        "![cat.jpg](data:image/jpeg;base64,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)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J0UdqRiWRhr4"
      },
      "source": [
        "img = Image.open('cat.jpg')   # Load image from disk\n",
        "display(img)                  # Visualize the image\n",
        "width, height = img.size      # Gives image dimension\n",
        "print(width, height)\n",
        "\n",
        "img_data = np.asarray(img)    # Convert image to np array\n",
        "print(img_data.shape)         # The image has shape (340, 325, 3)\n",
        "\n",
        "img = Image.fromarray(img_data, mode='RGB') # Convert np array to PIL image\n",
        "display(img)\n",
        "\n",
        "# RGB image to Grayscale\n",
        "gray_img = img.convert(mode='L') # Mode 'L' is 8-bit pixels, black and white\n",
        "display(gray_img)\n",
        "\n",
        "gray_img = gray_img.resize((300, 300)) # Resize image\n",
        "display(gray_img)\n",
        "gray_img.save('gray_cat.jpg')          # Save image"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nQ4bq7HVgMoq"
      },
      "source": [
        "# **Matplotlib**\n",
        "Matplotlib is a plotting library. In this section give a brief introduction to the matplotlib.pyplot module, which provides a plotting system. Import `matplotlib.pyplot` to start working with plots."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2lmyGnqhg1ul"
      },
      "source": [
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "B8AwridPghrE"
      },
      "source": [
        "## Plotting\n",
        "The most important function in matplotlib is `plot`, which allows you to plot 2D data. Here is a simple example:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "9hKHoJIThRoQ",
        "outputId": "64c85212-45fb-4c9d-b75d-a67383c2cafa"
      },
      "source": [
        "x = np.arange(start = 0, stop = 3 * np.pi, step = 0.1)\n",
        "y = np.sin(x)\n",
        "\n",
        "# Plot the points using matplotlib\n",
        "plt.plot(x, y)\n",
        "plt.show()  # You must call plt.show() to make graphics appear."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k6f1Yf_KiMU8"
      },
      "source": [
        "With just a little bit of extra work we can easily plot multiple lines at once, and add a title, legend, and axis labels:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "XXFsmLy8iNrs",
        "outputId": "739dae36-70e1-4013-9353-906456029a4e"
      },
      "source": [
        "x = np.arange(start = 0, stop = 3 * np.pi, step = 0.1)\n",
        "y_sin = np.sin(x)\n",
        "y_cos = np.cos(x)\n",
        "\n",
        "# Plot the points using matplotlib\n",
        "plt.plot(x, y_sin)\n",
        "plt.plot(x, y_cos)\n",
        "plt.xlabel('x axis label')\n",
        "plt.ylabel('y axis label')\n",
        "plt.title('Sine and Cosine')\n",
        "plt.legend(['Sine', 'Cosine'])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AeUzFhjZiiNG"
      },
      "source": [
        "## Subplots\n",
        "We can plot different things in the same figure using the `subplot` function. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 281
        },
        "id": "TDR6ElJ4iq5B",
        "outputId": "4730455d-dee5-423d-e335-1dbdfe6cbbfd"
      },
      "source": [
        "x = np.arange(start = 0, stop = 3 * np.pi, step = 0.1)\n",
        "y_sin = np.sin(x)\n",
        "y_cos = np.cos(x)\n",
        "\n",
        "# Set up a subplot grid that has height 2 and width 1,\n",
        "# and set the first such subplot as active.\n",
        "plt.subplot(2, 1, 1)\n",
        "\n",
        "# Make the first plot\n",
        "plt.plot(x, y_sin)\n",
        "plt.title('Sine')\n",
        "\n",
        "# Set the second subplot as active, and make the second plot.\n",
        "plt.subplot(2, 1, 2)\n",
        "plt.plot(x, y_cos)\n",
        "plt.title('Cosine')\n",
        "\n",
        "# Show the figure.\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-YErPJp_jtnd"
      },
      "source": [
        "## Surface plot\n",
        "We can plot 3D surface using `plot_surface` function. Here is an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        },
        "id": "6U5LsDBJkJDo",
        "outputId": "9f7c6ac7-ed3a-4d20-f2d1-3b674f46a71c"
      },
      "source": [
        "X = np.arange(-2, 2, 0.25)\n",
        "Y = np.arange(-2, 2, 0.25)\n",
        "\n",
        "X, Y = np.meshgrid(X, Y)   # carefully check what x and y are\n",
        "\n",
        "Z = X*np.exp(-X**2-Y**2)  # what will be Z(1)\n",
        "\n",
        "fig = plt.figure()\n",
        "ax = plt.axes(projection='3d')\n",
        "\n",
        "ax.plot_surface(X, Y, Z,cmap='viridis', edgecolor='none')\n",
        "ax.set_title('Surface plot')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}