18. Quiz 3 .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": "C_of Quiz 3.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "cells": [
    {
      "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"
      },
      "source": [
        "import numpy as np\n",
        "def create_integer_array():\n",
        "  arr=np.empty([5,2],dtype='int')\n",
        "  p=range(100,200,10)\n",
        "  c=-1\n",
        "  for i in range(0,5):\n",
        "    for j in range(0,2):\n",
        "      c+=1\n",
        "      arr[i][j]=p[c] \n",
        "  return(arr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "source": [
        "def column_3(a):\n",
        "  return(a[:,2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "source": [
        "def replace_col(a, i, b):\n",
        "  a[:,i]=b\n",
        "  return(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "source": [
        "def swap_cols(a, i, j):\n",
        "  b=[]\n",
        "  b=a[:,i]\n",
        "  a[:,i]=a[:,j]\n",
        "  a[:,j]=b\n",
        "  return a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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",
        "<img src = \"https://drive.google.com/uc?id=1TTljfFZAnOvqgAOiOrv6r4DDRROD-Vph\"> <br>\n",
        "\n",
        "Also, for a 2x2 matrix, this is the formula - <br>\n",
        "<img src = \"https://drive.google.com/uc?id=1H3aFpr1guevWjz4F-XRUQ9eP5TfjVLwu\"> <br>"
      ]
    },
    {
      "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"
      },
      "source": [
        "def minor(A,i):\n",
        "  m=[]\n",
        "  c=A.shape\n",
        "  for j in range(1,c[1]):\n",
        "    l=[]\n",
        "    for k in range(0,c[0]):\n",
        "      if(k!=i):\n",
        "        l.append(A[j][k])\n",
        "    m.append(l)\n",
        "  return(np.array(m))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "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"
      },
      "source": [
        "def determinant(A):\n",
        "    n=len(A)\n",
        "    t=[0]*n\n",
        "    total=1 \n",
        "    d=1\n",
        "    for i in range(0,n): \n",
        "        index=i\n",
        "        while(A[index][i]==0 and index<n): \n",
        "            index+=1\n",
        "        if(index==n):\n",
        "            continue\n",
        "        if(index!=i): \n",
        "            for j in range(0,n): \n",
        "                A[index][j],A[i][j]=A[i][j],A[index][j]   \n",
        "            d=d*int(pow(-1,index-i)) \n",
        "        for j in range(0,n): \n",
        "            t[j]=A[i][j]\n",
        "        for j in range(i+1,n): \n",
        "            m=t[i]\n",
        "            y=A[j][i]\n",
        "            for k in range(0,n):\n",
        "                A[j][k]=(m*A[j][k])-(y*t[k]) \n",
        "            total=total*m\n",
        "    for i in range(0,n): \n",
        "         d=d*A[i][i]\n",
        "    d=int(d/total)\n",
        "    return(d)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EeJEzPfs_K_4"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}