Numpy_for_Vector_and_Matrices.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "SAAuZCrwKNKm",
        "qHaGGeyRSwUi"
      ],
      "authorship_tag": "ABX9TyMZ1/RlSG0QATUpqZXVW7RB",
      "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/izzul31/Python-Labs/blob/main/Numpy_for_Vector_and_Matrices.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Introduction and Resources"
      ],
      "metadata": {
        "id": "6IefdS9lwg5I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The contents of this Numpy guide is mainly resourced from https://jakevdp.github.io/PythonDataScienceHandbook/index.html Chapter 2: Introduction to Numpy\n",
        "\n",
        "There is also an easier guide that is specific to our course here: https://github.com/rojaAchary/vectors_arrays_matrices/tree/main\n"
      ],
      "metadata": {
        "id": "D_DwRP3hwDdB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "np.array?"
      ],
      "metadata": {
        "id": "hoRevICqZenR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A good tips to learn is to ask for help on the syntax or functions. So use \"?\" after the line to see the documentation.\n",
        "\n",
        "The main beginner guide is in their website with examples: https://numpy.org/doc/stable/user/absolute_beginners.html"
      ],
      "metadata": {
        "id": "_AIgm_9AZxzd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Numpy"
      ],
      "metadata": {
        "id": "7afPtOksyMVG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "NumPy is the fundamental package for scientific computing with Python.\n",
        "\n",
        "Website: https://www.numpy.org\n",
        "Documentation: https://numpy.org/doc\n",
        "Mailing list: https://mail.python.org/mailman/listinfo/numpy-discussion\n",
        "Source code: https://github.com/numpy/numpy\n",
        "Contributing: https://www.numpy.org/devdocs/dev/index.html\n",
        "Bug reports: https://github.com/numpy/numpy/issues\n",
        "Report a security vulnerability: https://tidelift.com/docs/security\n",
        "\n",
        "It provides:\n",
        "\n",
        "a powerful N-dimensional array object;\n",
        "sophisticated (broadcasting) functions;\n",
        "tools for integrating C/C++ and Fortran code;\n",
        "useful **linear algebra**, Fourier transform, and random number capabilities\n",
        "\n",
        "From: https://github.com/numpy/numpy"
      ],
      "metadata": {
        "id": "5PzLhXcPyT-9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Numpy must first be imported if you do not have the package installed.\n",
        "To check the installed packages type"
      ],
      "metadata": {
        "id": "HwzwyG4Y6R00"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%pip list"
      ],
      "metadata": {
        "id": "lClBYLWt6rX_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "This will be one of the most used command in your Machine Learning development"
      ],
      "metadata": {
        "id": "4p31wL659eEI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np"
      ],
      "metadata": {
        "id": "UK0GlErC9t90"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "Then you can simply type **np** when you want to call the package. For every Jupyter Notebook, you only need to include and run the import statement once and you can use the imported package for the rest of the same notebook. (ref: https://www.studocu.com/en-au/document/university-of-sydney/statistical-modelling-for-business/python-language-companion-to-introduction-to-applied-linear-algebravectorsmatricesand-least-squares/64115357)"
      ],
      "metadata": {
        "id": "bFstjr9FnvD5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Three ways to make a row vector\n",
        "Using list in python\n",
        "\n",
        "Using Numpy array\n",
        "\n",
        "Using Numpy matrix"
      ],
      "metadata": {
        "id": "SAAuZCrwKNKm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x1 = [1, 3, 2]\n",
        "x2 = np.array([1,2,3])\n",
        "x3 = np.matrix([1, 2, 3])\n",
        "\n",
        "display(x1)\n",
        "display(x2)\n",
        "display(x3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 186
        },
        "id": "BWVhUEEiRgjG",
        "outputId": "c8d4c062-8c33-487f-add5-ef2eef9bd151"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "[1, 3, 2]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "matrix([[1, 2, 3]])"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The above is a row vector.\n",
        "Now declare a column vector"
      ],
      "metadata": {
        "id": "zriFVx3xR1dn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x4 = [[1], [3], [2]]\n",
        "x5 = np.array([[1], [3], [2]] )\n",
        "x6 = np.matrix([[1], [3], [2]] )\n",
        "\n",
        "display(x4)\n",
        "display(x5)\n",
        "display(x6)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 253
        },
        "id": "xSdodb74SFsU",
        "outputId": "c32d5623-c877-43d6-ec73-8931ceee12b2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "[[1], [3], [2]]"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[1],\n",
              "       [3],\n",
              "       [2]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "matrix([[1],\n",
              "        [3],\n",
              "        [2]])"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "eL4QuuX4SQVh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating a matrix and making sub-matrices\n",
        "\n",
        "Let's create a matrix A (4 by 4) and create sub-metrices from A."
      ],
      "metadata": {
        "id": "qHaGGeyRSwUi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define a 4x4 matrix\n",
        "A = np.array([[1,3,2],[5,6,7],[8,3,1],[4,3,7]])\n",
        "\n",
        "# Remember that indexing starts at 0 to n-1\n",
        "\n",
        "A1 = A[1,2]  # this gives the 2nd row, 3rd column value\n",
        "A2 = A[1,:]  # access the entire 2nd row\n",
        "A3 = A[:,2]  # access the entire 3rd column\n",
        "\n",
        "xp = A[1,0:2]\n",
        "\n",
        "display(A)\n",
        "display(A1)\n",
        "display(A2)\n",
        "display(A3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 418
        },
        "id": "_99gUWS0TOoL",
        "outputId": "9c5645ff-1954-4dda-ac14-bb7ee6896ace"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[1, 3, 2],\n",
              "       [5, 6, 7],\n",
              "       [8, 3, 1],\n",
              "       [4, 3, 7]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([5, 6, 7])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([2, 7, 1, 7])"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# More complicated 4x4 matrix\n",
        "B = np.array([[1,7,9,2],[2,3,3,4],[5,0,2,6],[6,1,5,5]])\n",
        "\n",
        "B1 = B[1:3,1] #  extract 2nd and 3rd row of column 2\n",
        "B2 = B[3,1:]  #  extract 2nd through last column of row 4\n",
        "\n",
        "B3 = B[:-1,1:4]  # extract matrix of 2nd-4th columns and first to next to last rows\n",
        "\n",
        "B4 = ( B[0,1:4], B[0:3,2].T ) # extract 2nd-4th column of first row and put it on top of 3rd column, 1st-3rd row transposed\n",
        "\n",
        "display(B)\n",
        "display(B1)\n",
        "display(B2)\n",
        "display(B3)\n",
        "display(B4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 715
        },
        "id": "mTcThTC5TqS1",
        "outputId": "35a253dc-19b7-45b8-9ee8-12a35e7ada36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[1, 7, 9, 2],\n",
              "       [2, 3, 3, 4],\n",
              "       [5, 0, 2, 6],\n",
              "       [6, 1, 5, 5]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([3, 0])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([1, 5, 5])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[7, 9, 2],\n",
              "       [3, 3, 4],\n",
              "       [0, 2, 6]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "(array([7, 9, 2]), array([9, 3, 2]))"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "_rfXVerFVtYi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Creating different types of metrices"
      ],
      "metadata": {
        "id": "SCdM1asxZOHH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Zeros Matrix"
      ],
      "metadata": {
        "id": "kyC2mTPIa9s4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "zeros_matrix = np.zeros((4, 4))\n",
        "print(zeros_matrix)"
      ],
      "metadata": {
        "collapsed": true,
        "id": "iUoAcf-1bD39"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Identity Matrix"
      ],
      "metadata": {
        "id": "gUdilis6bez2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "identity_matrix = np.identity(4)\n",
        "print(identity_matrix)"
      ],
      "metadata": {
        "id": "z5MBR7dbbqP3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create Random Matrix:\n",
        "\n",
        "containing Integers and Random Numbers, determining it's size."
      ],
      "metadata": {
        "id": "QpuPw8cCdh3z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "randomint_matrix = np.random.randint(10, size=(5, 5))\n",
        "\n",
        "random_matrix = np.random.rand(10, size=(4, 4))"
      ],
      "metadata": {
        "id": "FKWif-ctdeqo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Matrix Operations: Transpose, ..."
      ],
      "metadata": {
        "id": "XstUXKoXWJDK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To transpose a matrix the \".T\" is used"
      ],
      "metadata": {
        "id": "1BEV5e26WT8-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "C = np.random.randint(10, size=(4, 4))  # Two-dimensional array/matrix size 4 by 4\n",
        "\n",
        "C1 = C.T  # transpose\n",
        "\n",
        "display(C)\n",
        "display(C1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 666
        },
        "id": "ebOh0flGWbda",
        "outputId": "697836ca-67e1-4a0c-ebe1-ee56497bcd31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[3, 7, 3, 6],\n",
              "       [8, 7, 5, 7],\n",
              "       [3, 8, 7, 2],\n",
              "       [6, 1, 8, 3]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[3, 8, 3, 6],\n",
              "       [7, 7, 8, 1],\n",
              "       [3, 5, 7, 8],\n",
              "       [6, 7, 2, 3]])"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "To add matrices the \"+\" is used"
      ],
      "metadata": {
        "id": "93mbyu16XHzi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "D = C+B  # transpose\n",
        "\n",
        "display(C)\n",
        "display(B)\n",
        "display(D)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "309FwfJYX2GS",
        "outputId": "19e582fe-e510-4cf6-bccd-74a116e73f7a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[3, 7, 3, 6],\n",
              "       [8, 7, 5, 7],\n",
              "       [3, 8, 7, 2],\n",
              "       [6, 1, 8, 3]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[1, 7, 9, 2],\n",
              "       [2, 3, 3, 4],\n",
              "       [5, 0, 2, 6],\n",
              "       [6, 1, 5, 5]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[ 4, 14, 12,  8],\n",
              "       [10, 10,  8, 11],\n",
              "       [ 8,  8,  9,  8],\n",
              "       [12,  2, 13,  8]])"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To multiply matrices the \"*\" is used"
      ],
      "metadata": {
        "id": "gMNKZNjZZEgY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "E = C*B  # transpose\n",
        "\n",
        "display(C)\n",
        "display(B)\n",
        "display(E)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 996
        },
        "id": "2yuyHeyaY5hq",
        "outputId": "bdc7efa7-562a-499a-da0c-7cbf603ea8c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[3, 7, 3, 6],\n",
              "       [8, 7, 5, 7],\n",
              "       [3, 8, 7, 2],\n",
              "       [6, 1, 8, 3]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[1, 7, 9, 2],\n",
              "       [2, 3, 3, 4],\n",
              "       [5, 0, 2, 6],\n",
              "       [6, 1, 5, 5]])"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "array([[ 3, 49, 27, 12],\n",
              "       [16, 21, 15, 28],\n",
              "       [15,  0, 14, 12],\n",
              "       [36,  1, 40, 15]])"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To look into the elements you can"
      ],
      "metadata": {
        "id": "xjk8_TYoYOrF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "Dlarge = [(D>10)]\n",
        "\n",
        "display(Dlarge)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 368
        },
        "id": "17oPEhpcYOTb",
        "outputId": "9b1e5760-1a09-42eb-bced-bc00bf144f97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "[array([[False,  True,  True, False],\n",
              "        [False, False, False,  True],\n",
              "        [False, False, False, False],\n",
              "        [ True, False,  True, False]])]"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prompt: count the number of true in Dlarge\n",
        "\n",
        "import numpy as np\n",
        "count = np.sum(Dlarge[0])\n",
        "print(count)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7NwziOuiYmVp",
        "outputId": "89be0799-24aa-4656-e953-36945c3ee25d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5\n"
          ]
        }
      ]
    }
  ]
}