Part 7: numpy_exercise.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "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.6.8"
    },
    "colab": {
      "name": "Part 7: numpy_exercise.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gulabpatel/Python_Tutorials/blob/master/Part_7_numpy_exercise.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0U-in5NXlAyr"
      },
      "source": [
        "General Instructions:\n",
        "- By array, I mean numpy array\n",
        "- By matrix, I mean a numpy array of 2 dimensions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "37hSpnsCkFAO"
      },
      "source": [
        "### 1\n",
        "Write a function to create and return an integer array of shape (5, 2) from a range between 100 to 200 (including 100, excluding 200) such that the difference between consecutive elements is 10."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YL23bzkVkFAP",
        "outputId": "2fab88e9-cd99-4f9c-aecf-f2de11ad937d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "import numpy as np\n",
        "def create_integer_array():\n",
        "  ### Your Code Here\n",
        "  a = np.arange(100,200,10)\n",
        "  a = a.reshape(5,2)\n",
        "  return a\n",
        "\n",
        "create_integer_array()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[100, 110],\n",
              "       [120, 130],\n",
              "       [140, 150],\n",
              "       [160, 170],\n",
              "       [180, 190]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zYjrAoJBkFAV"
      },
      "source": [
        "### 2\n",
        "Given a numpy array ```a```, of shape ```(m, n)``` m>=3, n>=3. Write a function to return an array consisting of the elements in 3rd column of ```a``` <br>\n",
        "Eg., Suppose\n",
        "``` \n",
        "a = [[1 2 3]\n",
        "     [4 5 6]\n",
        "     [7 8 9]]    \n",
        "```\n",
        "Then \n",
        "```\n",
        "column_3(a) -> [3 6 9]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qGBr5qQckFAX",
        "outputId": "95652960-579f-4509-9b68-829b35624761",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "import numpy as np\n",
        "from numpy.random import rand\n",
        "def column_3(a):\n",
        "  ### Your Code here\n",
        "  a = np.random.rand(m,n)\n",
        "  col3 = []\n",
        "  for i in range(m):\n",
        "    col3.append(a[i][2])\n",
        "  print(a)\n",
        "  return col3\n",
        "m=int(input(\"Enter the number of rows but greater than 2 \"))\n",
        "n=int(input(\"Enter the number of columns but greater than 2 \"))\n",
        "a = np.random.rand(m,n)\n",
        "column_3(a)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the number of rows but greater than 2 4\n",
            "Enter the number of columns but greater than 2 4\n",
            "[[0.16433577 0.74088436 0.16437681 0.09053237]\n",
            " [0.70709402 0.17574114 0.67397814 0.02694078]\n",
            " [0.24278107 0.41380844 0.59138165 0.76193985]\n",
            " [0.68546103 0.18555026 0.78629829 0.71292271]]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.16437680909839802,\n",
              " 0.6739781434734942,\n",
              " 0.5913816510265227,\n",
              " 0.7862982854264287]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DikElEA9kFAb"
      },
      "source": [
        "### 3\n",
        "Write a function which does the following. Given a numpy array $a$ of shape (m, n), index $i$ and an array $b$ of shape (m, ). Replace the $i_{th}$ column of $a$ with the array $b$  \n",
        "Eg., Suppose\n",
        "```\n",
        "a = [[1 2 3]\n",
        "     [4 5 6]\n",
        "     [7 8 9]]\n",
        "b = [30, 60, 90]\n",
        "\n",
        "```    \n",
        "Then,\n",
        "```\n",
        "replace_col(a, 2, b) -> [[1 2 30]\n",
        "                         [4 5 60]\n",
        "                         [7 8 90]]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0uKhiFAHkFAd",
        "outputId": "f607af55-19ff-4619-8573-cdfae01cdfa0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def replace_col(a, i, b):\n",
        "  ### Your Code Here\n",
        "  print(\"Matrix before replacing row by b: \")\n",
        "  print(a)\n",
        "  print(b)\n",
        "  for j in range(m):\n",
        "    a[j][i] = b[j]\n",
        "  print(\"Matrix after replacement: \")\n",
        "  return a\n",
        "\n",
        "m = int(input(\"Enter the number of rows but greater than 2 \"))\n",
        "n = int(input(\"Enter the number of columns but greater than 2 \"))\n",
        "i = int(input(\"Enter the column you want to change \"))\n",
        "\n",
        "a = [] \n",
        "print(\"Enter the entries of matix row-wise: \")  \n",
        "for i in range(m):\t\t \n",
        "\tc = [] \n",
        "\tfor j in range(n):\t \n",
        "\t\tc.append(int(input())) \n",
        "\ta.append(c) \n",
        " \n",
        "\n",
        "print(\"enter the row matrix: \")\n",
        "b =[] \n",
        "for i in range(m):\t\t \t\n",
        "\t\tb.append(int(input())) \n",
        "  \n",
        "#for i in range(m): \n",
        "#\tfor j in range(n): \n",
        "#\t\tprint(matrix[i][j], end = \" \") \n",
        "#\tprint()\n",
        "replace_col(a, i, b)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the number of rows but greater than 2 3\n",
            "Enter the number of columns but greater than 2 3\n",
            "Enter the column you want to change 1\n",
            "Enter the entries of matix row-wise: \n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "enter the row matrix: \n",
            "10\n",
            "20\n",
            "30\n",
            "Matrix before replacing row by b: \n",
            "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]\n",
            "[10, 20, 30]\n",
            "Matrix after replacement: \n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1, 2, 10], [4, 5, 20], [7, 8, 30]]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kiBrW4BekFAs"
      },
      "source": [
        "### 4\n",
        "Write a function which does the following. Given a numpy array $a$ of shape (m, n) and indices $i$, $j$. Return a numpy array which swaps the columns $i$ and $j$ of $a$\n",
        "Eg., Suppose\n",
        "```\n",
        "a = [[1 2 3]\n",
        "     [4 5 6]\n",
        "     [7 8 9]]\n",
        "\n",
        "swap_cols(a, 0, 2) -> [[3 2 1]\n",
        "                       [6 5 4]\n",
        "                       [9 8 7]]\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SHreztV0kFAt",
        "outputId": "0c4d81d2-cf60-46f9-adc5-65e5892b951d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def swap_cols(a, i, j):\n",
        "  ### Your Code Here\n",
        "  t = 0\n",
        "  for k in range(len(a)):\n",
        "    t = a[k][i]\n",
        "    a[k][i] = a[k][j]\n",
        "    a[k][j] =t\n",
        "  return a\n",
        "\n",
        "a = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "swap_cols(a,0,2)"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3, 2, 1],\n",
              "       [6, 5, 4],\n",
              "       [9, 8, 7]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zcmziMV3ol55"
      },
      "source": [
        "## 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jMeJeFXzosUu"
      },
      "source": [
        "There are various equivalent ways to define the determinant of a square matrix A, i.e. one with the same number of rows and columns. Perhaps the simplest way to express the determinant is by considering the elements in the top row and the respective minors; starting at the left, multiply the element by the minor, then subtract the product of the next element and its minor, and alternate adding and subtracting such products until all elements in the top row have been exhausted. For example, here is the result for a 4 × 4 matrix: <br>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kHt2BOQpo5k3"
      },
      "source": [
        "###5.1 Minor\n",
        "Write a function that does the following. \n",
        "Given a square matrix $A$ and an index $i$, find and return the sub-matrix that is the minor corresponding to element at index $i$ of the first row of $A$"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cgDuw57DowWl",
        "outputId": "51624349-a096-42b2-fba0-6ad7cc58c1ad",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def minor(A, i):\n",
        "  ### Write your code here\n",
        "  if(np.size(A)==1):\n",
        "    return A\n",
        "  else:\n",
        "    return np.delete(np.delete(A,i,axis=1),0,axis=0)\n",
        "\n",
        "A = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
        "minor(A, 1)"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4, 6],\n",
              "       [7, 9]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iD0m17LHpMF6"
      },
      "source": [
        "###5.2\n",
        "Given a square matrix $A$, write a function that computes and return the determinant using the formula given above and the helper function that you have defined called ```minor```. <br>\n",
        "(Do not use the functions to compute determinant which numpy provides built in)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Pd5AIYHpY7K",
        "outputId": "b3153071-c498-481c-e33a-559a50250466",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def determinant(A):\n",
        "  ### Write your code here\n",
        "  detmat = 0\n",
        "  if np.size(A) == 1:\n",
        "    return A[0][0]\n",
        "  \n",
        "  elif np.size(A) == 4:\n",
        "    return A[0][0]*A[1][1]-A[1][0]*A[0][1]\n",
        "\n",
        "  else:\n",
        "    for i in range(A.shape[0]):\n",
        "      detmat+=((-1)**i)*A[0][i]*determinant(minor(A,i))\n",
        "  #print(A)  \n",
        "  return detmat\n",
        "##Given matrix is\n",
        "a = np.array([[2,0,0,0],[0,6,0,8],[9,0,11,12],[0,0,15,16]])\n",
        "determinant(a)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "-48"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JW-LTXol-FUO"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}