EC440_A2_FM_partitioning.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "EC440_A2-FM_partitioning.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "**VLSI CAD Assignment 2: FM ALGORITHM**\n",
        "<br>\n",
        "Submitted by: <br>\n",
        "\n",
        "\n",
        "1.   Adithi S Upadhya (191EC101)\n",
        "2.   Poorvi S.H.M (191EC229)\n",
        "\n"
      ],
      "metadata": {
        "id": "_ue6pwBCisdL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Partitioning with Fiduccia-Mattheyses\n",
        "Iterative graph partitioning heuristic <br>\n",
        "Similar to KL, but moves only a single vertex at a time <br>\n",
        "Operates in mulitple passes: <br>\n",
        "* unlock all the vertices\n",
        "* move one vertex at a time to improve the cut\n",
        "* roll back to the best configuration seen\n",
        "\n"
      ],
      "metadata": {
        "id": "OHyKtPDfVWB-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib as plt \n",
        "import random\n",
        "import networkx as nx"
      ],
      "metadata": {
        "id": "ltvF-m7UWLxK"
      },
      "execution_count": 1,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Input format:** Number of blocks N, Dimension of each of the blocks (width, height), Adjacency matrix which is a N X N matrix. Each element in the adjacency matrix (i, j) gives the number of interconnects running between them. <br>\n",
        "Example- <br>\n",
        "{6, {10, 5}, {8, 6}, {4, 13}, {10, 3}, {8, 4}, {4, 1}} where the first data 6 indicates the number of blocks, then each of the six pairs of data enclosed in the flower braces specify {width, height} of the individual block.\n",
        "\n",
        "The following 6X6 adjacency matrix gives the number of edges between the blocks.\n",
        "  \n",
        "{0 1 3 2 4 2<br>\n",
        " 1 0 3 1 2 1<br>\n",
        " 3 3 0 1 1 2<br>\n",
        " 2 1 1 0 2 3<br>\n",
        " 4 2 1 2 0 1<br>\n",
        " 2 1 2 3 1 0}<br>\n"
      ],
      "metadata": {
        "id": "z7P6GjUIQUK8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"\"\"The input format should be:\n",
        "{n, (w1, y1), (w2, h2), ......(wn, hn)}\n",
        "{m00 m01 m02....m0n\n",
        " m10 m11 m12....m1n\n",
        " ..................\n",
        " ..................\n",
        " mn0 mn1 mn2....mnn}\"\"\")\n",
        "filename = input(\"Enter input file name eg-input.txt: \")"
      ],
      "metadata": {
        "id": "k3USDsthdENa",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c62bee2-37ef-495c-f450-4ecfed72669f"
      },
      "execution_count": 2,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "The input format should be:\n",
            "{n, (w1, y1), (w2, h2), ......(wn, hn)}\n",
            "{m00 m01 m02....m0n\n",
            " m10 m11 m12....m1n\n",
            " ..................\n",
            " ..................\n",
            " mn0 mn1 mn2....mnn}\n",
            "Enter input file name eg-input.txt: input.txt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with open(filename, \"r\") as ip:\n",
        "    inp = [line.strip() for line in ip]\n",
        "\n",
        "# Removibg the '{}', n\n",
        "dim = inp[0]\n",
        "dim = dim.split(',') # The split() method splits a string into a list after breaking the given string by the specified separator.\n",
        "N = int(dim[0].split('{')[1])\n",
        "dim = dim[1:]\n",
        "dim[len(dim)-1] = dim[len(dim)-1].split('}')[0]\n",
        "\n",
        "# Getting the adjacency matrix\n",
        "adj = []\n",
        "for i in range(1, len(inp)):\n",
        "    adj.append(inp[i].split())\n",
        "    \n",
        "adj[0][0] = adj[0][0].split('{')[1]\n",
        "adj[N-1][N-1] = adj[N-1][N-1].split('}')[0]\n",
        "\n",
        "adj_matrix = []\n",
        "for a in adj:\n",
        "    l = []\n",
        "    for j in a:\n",
        "        l.append(int(j))\n",
        "    adj_matrix.append(list(l))\n",
        "        \n",
        "# Removing the '(' and ')'\n",
        "pts = []    # Stores all the points, x-coordinates in even position and y-coordinates in odd position\n",
        "for i in dim:\n",
        "    i = i.strip() #returns a copy of the string with both leading and trailing characters removed (based on the string argument passed). \n",
        "    i = i.strip('(')\n",
        "    i = i.strip(')')\n",
        "    pts.append(int(i))\n",
        "    \n",
        "# Storing the points in [(x1,y1), (x2,y2),....(xn,yn)]\n",
        "dim = []\n",
        "i=0\n",
        "while i!=len(pts):\n",
        "    dim.append((pts[i], pts[i+1]))\n",
        "    i += 2"
      ],
      "metadata": {
        "id": "Ssole3-ndFi3"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(N)\n",
        "print(dim)\n",
        "print(adj_matrix)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xTkwnwWee6dR",
        "outputId": "4b68d76e-453a-4a94-af9a-3e1acf0144eb"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6\n",
            "[(10, 5), (8, 6), (4, 13), (10, 3), (8, 4), (4, 1)]\n",
            "[[0, 1, 3, 2, 4, 2], [1, 0, 3, 1, 2, 1], [3, 3, 0, 1, 1, 2], [2, 1, 1, 0, 2, 3], [4, 2, 1, 2, 0, 1], [2, 1, 2, 3, 1, 0]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#N = 6\n",
        "#dim = [(10,5),(8,6),(4,13),(10,3),(8,4),(4,1)]\n",
        "#rows,cols = (N,N)\n",
        "#adj_matrix = [[0]*cols]*rows\n",
        "#adj_matrix = [[0, 1, 3, 2, 4, 2], [1, 0, 3, 1, 2, 1],[ 3, 3, 0, 1, 1, 2],[2, 1, 1, 0, 2, 3],[4, 2, 1, 2, 0, 1],[2, 1, 2, 3, 1, 0]]"
      ],
      "metadata": {
        "id": "1k_NEVShQMX1"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def random_partition(V):\n",
        "  random.shuffle(V)\n",
        "  cut = int(N/2)\n",
        "  A, B = np.sort(V[:cut]), np.sort(V[cut:])\n",
        "  print(A)\n",
        "  print(B)\n",
        "  #pairs = len(A)*len(B)\n",
        "  cut_size = 0\n",
        "  for i in A:\n",
        "    for j in B:\n",
        "      cut_size = cut_size + adj_matrix[i][j]\n",
        "  print(\"initial cut_size =\" + str(cut_size))\n",
        "  return A,B,cut_size"
      ],
      "metadata": {
        "id": "w4N5Z98hgT0M"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def area(A,dim):\n",
        "  area_A = 0\n",
        "  for i in A:\n",
        "    area_A = area_A + dim[i][0]*dim[i][1]\n",
        "  return area_A"
      ],
      "metadata": {
        "id": "nQvO8aDdgwhq"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def rf(area_A, area_B):\n",
        "  r = area_A / (area_A + area_B)\n",
        "  return r"
      ],
      "metadata": {
        "id": "hOMXrUVkhL3E"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def is_balanced(r, area_V, area_A, max_area):\n",
        "  # Balance criterion \n",
        "  # [r.area(v) - area_MAX(v)] <= area(A) <= [r.area(v) + area_MAX(v)]\n",
        "  LHS  = r*area_V - max_area \n",
        "  RHS = r*area_V + max_area\n",
        "  if (area_A >= LHS and area_A <=RHS):\n",
        "    return True\n",
        "  else :\n",
        "    return False "
      ],
      "metadata": {
        "id": "6_mHsbYihg_e"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_gain(A,B,c,adj_matrix): #partition A, B and block c \n",
        "  FS = 0 # FS(i) = number of nets that have i as the only cell in partition P containining i \n",
        "  TE = 0 # TE(i) = number of nets containing cell i and are entirely located in partition P containining i \n",
        "  if c in A:\n",
        "    pB = B\n",
        "    pA = A\n",
        "  else :\n",
        "    pB = A\n",
        "    pA = B\n",
        "  for j in pB: \n",
        "    if adj_matrix[c][j]!=0: \n",
        "      # block in partition B is connected to block c\n",
        "      # check if its connected to any other block in partition A\n",
        "      for i in pA:\n",
        "        if i!=c and adj_matrix[i][j] == 0:\n",
        "          FS = FS + 1\n",
        "  for i in pA:\n",
        "    if i!=c and adj_matrix[i][c]!=0:\n",
        "      TE = TE + 1\n",
        "  gain = FS - TE\n",
        "  return gain"
      ],
      "metadata": {
        "id": "2OQ2g9ekk-Zx"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def calculate_parameters(N, dim, adj_matrix):\n",
        "    V = list(range(N)) #listing all the vertices\n",
        "    # Dividing nodes into 2 random groups A and B \n",
        "    A,B,cut_size = random_partition(V)\n",
        "    # ratio factor r = [area(A)]/[area(A)+area(B)] where area(A), area(B) are the areas of the respective partitions \n",
        "    area_A = area(A,dim) \n",
        "    area_B = area(B,dim)\n",
        "    AREA = []\n",
        "    for i in range(len(dim)):\n",
        "      AREA.append(dim[i][0] * dim[i][1])\n",
        "    area_V = 0 \n",
        "    max_area = max(AREA)\n",
        "    area_V = area(V,dim)\n",
        "    r = rf(area_A, area_B)\n",
        "    return V,A,B,cut_size,area_A,area_B,area_V,max_area,r,AREA"
      ],
      "metadata": {
        "id": "1VFNSJVrvuct"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def FM1(N, dim, adj_matrix,V,A,B,cut_size,area_A,area_B,area_V,max_area,r,AREA,locked):\n",
        "  # Step 2: Calculate gains\n",
        "  # gain = FS - TE\n",
        "  gain = []\n",
        "  for i in V:\n",
        "    g = calculate_gain(A,B,i,adj_matrix)\n",
        "    gain.append(g)\n",
        "  # Step 3: find the base block, the one with max gain \n",
        "  sols = []\n",
        "  min_area = max(AREA)\n",
        "  temp = 0\n",
        "  for i in range(len(gain)):\n",
        "    if gain[i] == max(gain):\n",
        "      sols.append(i)\n",
        "  min = AREA[sols[0]]\n",
        "  exchange = sols[0]\n",
        "  for i in sols:\n",
        "    #check balance criterion for each \n",
        "    if i in A:\n",
        "      temp = area_A - AREA[i]\n",
        "    else:\n",
        "      temp = area_A + AREA[i]\n",
        "    if is_balanced(r, area_V, area_A, max_area) and temp <= min:\n",
        "      exchange = i\n",
        "      min = temp\n",
        "  locked.append(exchange)\n",
        "  if exchange in A:\n",
        "    A.remove(exchange)\n",
        "    B.append(exchange)\n",
        "  else:\n",
        "    A.append(exchange)\n",
        "    B.remove(exchange)\n",
        "  return gain[exchange]"
      ],
      "metadata": {
        "id": "N-5KqyE2XOHM"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def FM_partitioning(N,dim,adj_matrix):\n",
        "    V,a,b,cut_size,area_A,area_B,area_V,max_area,r,AREA = calculate_parameters(N, dim, adj_matrix)\n",
        "    # Step 1: Balance criterion to be satisfied\n",
        "    if is_balanced(r, area_V, area_A, max_area) == False:\n",
        "      while is_balanced(r, area_V, area_A, max_area) == False:\n",
        "        V,a,b,cut_size,area_A,area_B,area_V,max_area,r = calculate_parameters(N, dim, adj_matrix)\n",
        "    locked = []\n",
        "    iter_gain = []\n",
        "    A = a.tolist()\n",
        "    B = b.tolist()\n",
        "    while len(locked)!=N:\n",
        "      # update and run\n",
        "      g = FM1(N, dim, adj_matrix,V,A,B,cut_size,area_A,area_B,area_V,max_area,r,AREA,locked)\n",
        "      iter_gain.append(g)\n",
        "    gain_sum = []\n",
        "    l = 0\n",
        "    for i in range(len(iter_gain)):\n",
        "      l = l + iter_gain[i]\n",
        "      gain_sum.append(l)\n",
        "    # select max cummulative gain\n",
        "    minArea = max_area # initialising to high value\n",
        "    aA = area(a,dim)\n",
        "    aB = area(b,dim)\n",
        "    newA = a.tolist()\n",
        "    newB = b.tolist()\n",
        "    ans = 0\n",
        "    for i in range(len(gain_sum)):\n",
        "      if gain_sum[i] == max(gain_sum):\n",
        "        for j in range(i):\n",
        "          if j in a:\n",
        "            aA = aA - dim[j][0] * dim[j][1]\n",
        "          else:\n",
        "            aA = aA + dim[j][0] * dim[j][1]\n",
        "        if aA < minArea:\n",
        "          minArea = aA\n",
        "          ans = i\n",
        "    print(ans)\n",
        "    # final partitions\n",
        "    for i in range(ans+1):\n",
        "      if i in a:\n",
        "        newA.remove(i)\n",
        "        newB.append(i)\n",
        "      else:\n",
        "        newA.append(i)\n",
        "        newB.remove(i)\n",
        "    cut_size = 0\n",
        "    for i in newA:\n",
        "      for j in newB:\n",
        "        cut_size = cut_size + adj_matrix[i][j]\n",
        "    print(\"Final partition: A=\",newA,\"\", \"B=\", newB,\"\", \"cut size=\",cut_size)\n",
        "    return newA,newB,cut_size"
      ],
      "metadata": {
        "id": "Ac7XKsVzC5KI"
      },
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Running mulitple iterations to get the combination with minimum cut size and minimum ratio factor :"
      ],
      "metadata": {
        "id": "EAYmXvA-d1vt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fm_tuples = []\n",
        "run_time = N * (N-1)/2 \n",
        "i = 0\n",
        "while i!=run_time:\n",
        "  print(\"ITERATION #\", i)\n",
        "  newA,newB,cut_size = FM_partitioning(N,dim,adj_matrix)\n",
        "  new_areaA = area(newA,dim)\n",
        "  new_areaB = area(newB,dim)\n",
        "  new_rf = rf(new_areaA, new_areaB)\n",
        "  fm_tuples.append((cut_size,new_rf,newA,newB))\n",
        "  i = i+1\n",
        "res = min(fm_tuples)\n",
        "grp1 = res[2] \n",
        "grp2 = res[3]\n",
        "G = nx.Graph()\n",
        "for i in range(N):\n",
        "  for j in range(N):\n",
        "    if(adj_matrix[i][j]!=0):\n",
        "      G.add_edge(i,j)\n",
        "for n in G.nodes():\n",
        "  G.nodes[n]['color'] = 'b' if n in grp1 else 'g'\n",
        "colors = [node[1]['color'] for node in G.nodes(data=True)]\n",
        "nx.draw(G, with_labels=True, node_color=colors)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "VY-ATX51NTIq",
        "outputId": "190d5fe4-4327-41fc-874c-5a57b177c3be"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ITERATION # 0\n",
            "[0 2 3]\n",
            "[1 4 5]\n",
            "initial cut_size =19\n",
            "0\n",
            "Final partition: A= [2, 3]  B= [1, 4, 5, 0]  cut size= 17\n",
            "ITERATION # 1\n",
            "[0 2 3]\n",
            "[1 4 5]\n",
            "initial cut_size =19\n",
            "0\n",
            "Final partition: A= [2, 3]  B= [1, 4, 5, 0]  cut size= 17\n",
            "ITERATION # 2\n",
            "[3 4 5]\n",
            "[0 1 2]\n",
            "initial cut_size =16\n",
            "0\n",
            "Final partition: A= [3, 4, 5, 0]  B= [1, 2]  cut size= 12\n",
            "ITERATION # 3\n",
            "[0 1 5]\n",
            "[2 3 4]\n",
            "initial cut_size =21\n",
            "0\n",
            "Final partition: A= [1, 5]  B= [2, 3, 4, 0]  cut size= 15\n",
            "ITERATION # 4\n",
            "[0 3 4]\n",
            "[1 2 5]\n",
            "initial cut_size =15\n",
            "0\n",
            "Final partition: A= [3, 4]  B= [1, 2, 5, 0]  cut size= 15\n",
            "ITERATION # 5\n",
            "[0 2 3]\n",
            "[1 4 5]\n",
            "initial cut_size =19\n",
            "0\n",
            "Final partition: A= [2, 3]  B= [1, 4, 5, 0]  cut size= 17\n",
            "ITERATION # 6\n",
            "[0 1 3]\n",
            "[2 4 5]\n",
            "initial cut_size =21\n",
            "0\n",
            "Final partition: A= [1, 3]  B= [2, 4, 5, 0]  cut size= 15\n",
            "ITERATION # 7\n",
            "[1 2 5]\n",
            "[0 3 4]\n",
            "initial cut_size =15\n",
            "0\n",
            "Final partition: A= [1, 2, 5, 0]  B= [3, 4]  cut size= 15\n",
            "ITERATION # 8\n",
            "[0 4 5]\n",
            "[1 2 3]\n",
            "initial cut_size =17\n",
            "0\n",
            "Final partition: A= [4, 5]  B= [1, 2, 3, 0]  cut size= 17\n",
            "ITERATION # 9\n",
            "[0 4 5]\n",
            "[1 2 3]\n",
            "initial cut_size =17\n",
            "0\n",
            "Final partition: A= [4, 5]  B= [1, 2, 3, 0]  cut size= 17\n",
            "ITERATION # 10\n",
            "[1 2 5]\n",
            "[0 3 4]\n",
            "initial cut_size =15\n",
            "0\n",
            "Final partition: A= [1, 2, 5, 0]  B= [3, 4]  cut size= 15\n",
            "ITERATION # 11\n",
            "[1 2 3]\n",
            "[0 4 5]\n",
            "initial cut_size =17\n",
            "0\n",
            "Final partition: A= [1, 2, 3, 0]  B= [4, 5]  cut size= 17\n",
            "ITERATION # 12\n",
            "[0 1 2]\n",
            "[3 4 5]\n",
            "initial cut_size =16\n",
            "0\n",
            "Final partition: A= [1, 2]  B= [3, 4, 5, 0]  cut size= 12\n",
            "ITERATION # 13\n",
            "[0 2 5]\n",
            "[1 3 4]\n",
            "initial cut_size =17\n",
            "0\n",
            "Final partition: A= [2, 5]  B= [1, 3, 4, 0]  cut size= 15\n",
            "ITERATION # 14\n",
            "[0 3 5]\n",
            "[1 2 4]\n",
            "initial cut_size =16\n",
            "0\n",
            "Final partition: A= [3, 5]  B= [1, 2, 4, 0]  cut size= 12\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Combination with minimum cut size and ratio factor\", \"\\n\", \"Partition A = \", res[2], \" \", \"Partition B = \", res[3], \" \", \"cut size\", cut_size, \" \", \"ratio-factor\",new_rf)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CZIHKfuWdnLC",
        "outputId": "68325d53-b146-4243-fc32-2480cc9d30b8"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Combination with minimum cut size and ratio factor \n",
            " Partition A =  [3, 5]   Partition B =  [1, 2, 4, 0]   cut size 12   ratio-factor 0.1574074074074074\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Plotting the rectangular blocks according to the above partition:"
      ],
      "metadata": {
        "id": "OyU797uNeiPZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.patches import Rectangle\n",
        "# hardcoded for the current case\n",
        "#define Matplotlib figure and axis\n",
        "fig, ax = plt.subplots()\n",
        "ax.plot([0, 10],[0, 10], color = 'white', lw=0.1)\n",
        "#add rectangle to plot\n",
        "ax.add_patch(Rectangle((0, 0), 6, 8, edgecolor = 'red', fill = False, lw=3))\n",
        "ax.annotate(\"Block 1\", (3, 4), color='red', weight='bold', fontsize=8, ha='center', va='center')\n",
        "ax.add_patch(Rectangle((6, 0), 4, 8, edgecolor = 'red', fill = False, lw=3))\n",
        "ax.annotate(\"Block 4\", (8, 4), color='red', weight='bold', fontsize=8, ha='center', va='center')\n",
        "ax.add_patch(Rectangle((10, 0), 4, 13, edgecolor = 'red', fill = False, lw=3))\n",
        "ax.annotate(\"Block 2\", (12, 6.5), color='red', weight='bold', fontsize=8, ha='center', va='center')\n",
        "ax.add_patch(Rectangle((0, 8), 10, 5, edgecolor = 'red', fill = False, lw=3))\n",
        "ax.annotate(\"Block 0\", (5, 10.5), color='red', weight='bold', fontsize=8, ha='center', va='center')\n",
        "ax.add_patch(Rectangle((0, 13), 10, 3, edgecolor = 'black', fill = False, lw=3))\n",
        "ax.annotate(\"Block 3\", (5, 14.5), color='black', weight='bold', fontsize=8, ha='center', va='center')\n",
        "ax.add_patch(Rectangle((10, 13), 4, 1, edgecolor = 'black', fill = False, lw=3))\n",
        "ax.annotate(\"Block 5\", (12, 13.5), color='black', weight='bold', fontsize=8, ha='center', va='center')\n",
        "ax.add_patch(Rectangle((-0.1, -0.1), 14.15, 16.15, edgecolor = 'green', fill = False, lw=1.5, ls = '--'))\n",
        "#plt.legend()\n",
        "#display plot\n",
        "plt.show()    "
      ],
      "metadata": {
        "id": "oQHh4PffdD65",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "8dc81783-0edb-41a4-ccd6-72a43da5bffc"
      },
      "execution_count": 17,
      "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": "code",
      "source": [
        ""
      ],
      "metadata": {
        "id": "TAv5Cy6JeuI2"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}