EE21B066_Assignment 4_APL.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6e3d333c",
   "metadata": {},
   "source": [
    "### TOPOLOGICAL SORTING :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fab9c44c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import pandas as pd\n",
    "def combinational_ckt(filename):\n",
    "    f=open(filename,'r')\n",
    "    lis=[]\n",
    "    for each in f:\n",
    "        lis.append(each.split())\n",
    "    f.close()\n",
    "    return lis\n",
    "def ip(filename):\n",
    "    f=open(filename,'r')\n",
    "    ip_nodes=[]\n",
    "    inp=[]\n",
    "    for each in f:\n",
    "        if ip_nodes==[]:\n",
    "            ip_nodes=list(each.split()).copy()\n",
    "        else :\n",
    "            inp.append(list(map(int,each.split())))\n",
    "    return ip_nodes,inp\n",
    "def unique(list):\n",
    "    uni=[]\n",
    "    for i in list:\n",
    "        if i not in uni:\n",
    "            uni.append(i)\n",
    "    return uni\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3a46019",
   "metadata": {},
   "source": [
    "- combinational_ckt function is used to read the netlist and returning a list contains each line as a sublist and sublist contains the elements which are obtained ny splitting the line by spaces.\n",
    "- ip function is used to read the input files and assigning input nodes and input values for different instants\n",
    "- unique function is used to remove the duplicates in list and returns the list of distinct elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "id": "a2dc820f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#creating a DAG\n",
    "def toposorting(net_filename,input_filename):\n",
    "    g=nx.DiGraph()\n",
    "    #net=combinational_ckt(\"parity.net\")\n",
    "    net=combinational_ckt(net_filename)\n",
    "    #print(net)\n",
    "#EDGES\n",
    "    edges=[]\n",
    "    for i in range(len(net)):\n",
    "        edges.append((net[i][2],net[i][-1]))\n",
    "        if net[i][3]!=net[i][-1] :edges.append((net[i][3],net[i][-1]))\n",
    "    #print(edges)\n",
    "#NODES\n",
    "    nodes=[]\n",
    "    for i in range(len(net)):\n",
    "        if net[i][2] not in nodes:\n",
    "            nodes.append(net[i][2])\n",
    "        if net[i][3] not in nodes:\n",
    "            nodes.append(net[i][3])\n",
    "        if net[i][-1] not in nodes:\n",
    "            nodes.append(net[i][-1])\n",
    "    #print(nodes)\n",
    "#OUTPUTNODES\n",
    "    output_nodes=[net[i][-1] for i in range(len(net))]\n",
    "    #print(output_nodes)\n",
    "#PRIMARY NODES\n",
    "    primary_nodes=[i for i in nodes if i not in output_nodes]\n",
    "#   print(primary_nodes)\n",
    "#NODES NUMBERING\n",
    "    nod_dict={}\n",
    "    for i in range(len(net)):\n",
    "        nod_dict[net[i][-1]]=net[i][1]\n",
    "    for i in primary_nodes:\n",
    "        nod_dict[i]='PI'\n",
    "#   print(nod_dict)\n",
    "#CONSTRUCTING GRAPH\n",
    "    g.add_edges_from(edges)\n",
    "    nx.set_node_attributes(g,nod_dict,name=\"gateType\")\n",
    " #   print(g.nodes(data=True))\n",
    "#TOPOLOGICAL SORT\n",
    "    try :\n",
    "        topo_nodes=list(nx.topological_sort(g))\n",
    "    except : \n",
    "        topo_nodes=[]\n",
    "        print('Graph contains a cycle or graph changed during iteration')\n",
    "        return\n",
    "#print(topo_nodes)\n",
    "#ORDER OF TOPONODES\n",
    "    topo_dict={}\n",
    "    for i in range(len(topo_nodes)):\n",
    "        topo_dict[topo_nodes[i]]=i\n",
    "#print(topo_dict)\n",
    "    topo_net=[]\n",
    "    for i in range(len(topo_nodes)):\n",
    "        for j in range(len(net)):\n",
    "            if topo_nodes[i]==net[j][-1] : topo_net.append(net[j])\n",
    "    ip_nodes,inp=ip(input_filename)\n",
    "#print(topo_net)\n",
    "    out=[]\n",
    "    for i in inp:\n",
    "        output_list=[0 for i in range(len(topo_dict))]\n",
    "        pi_dict={}\n",
    "        for j in range(len(ip_nodes)):\n",
    "            pi_dict[ip_nodes[j]]=i[j]\n",
    "        for key in pi_dict :\n",
    "            output_list[topo_dict[key]]=pi_dict[key]\n",
    "        for j in range(len(topo_net)):\n",
    "            if topo_net[j][1]=='and2': \n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]] and output_list[topo_dict[topo_net[j][3]]]\n",
    "            if topo_net[j][1]=='or2': \n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]] or output_list[topo_dict[topo_net[j][3]]]\n",
    "            if topo_net[j][1]=='nand2': \n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]] and output_list[topo_dict[topo_net[j][3]]]\n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][-1]]]^1\n",
    "            if topo_net[j][1]=='nor2': \n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]] or output_list[topo_dict[topo_net[j][3]]]\n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][-1]]]^1\n",
    "            if topo_net[j][1]=='xor2': \n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]]^output_list[topo_dict[topo_net[j][3]]]\n",
    "            if topo_net[j][1]=='xnor2': \n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]]^output_list[topo_dict[topo_net[j][3]]]\n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][-1]]]^1\n",
    "            if topo_net[j][1]=='inv':\n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]]^1\n",
    "            if topo_net[j][1]=='buf':\n",
    "                output_list[topo_dict[topo_net[j][-1]]]=output_list[topo_dict[topo_net[j][2]]]\n",
    "        out.append(output_list)\n",
    "    return out,topo_nodes\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7792611c",
   "metadata": {},
   "source": [
    "- Firstly we create a directional graph as in the presentation pdf.\n",
    "- Edges are created by connecting the third element to the last and if net has one more input, forth element to the last element.\n",
    "- nodes are the combination of input nodes (ususally third and forth element) and last element of each list.\n",
    "- output nodes are the last element of each list.\n",
    "- primary nodes are the nodes other than output nodes\n",
    "- As mentioned in the pdf, I created the graph g and found top_nodes i.e., topological sort of the given nodes using topological_sort function\n",
    "- Topo_dict is created numbering the topo_nodes such that element corresponding to the topo_list can easily be accessed.\n",
    "- I have arranged the net in the order that output of elements are in topological order\n",
    "- So that we can easily solve the circuit using a for loop on the topo_net and we can find every output of the gate and stored in the output_list.\n",
    "- For every input of the inputs file, corresponding output_list appends to the out which is the final output list for the given input vectors.\n",
    "- If there is any error in the inputs, error meaasge is printed.\n",
    "- To avoid error when we are calling the function, I used excpetion handling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "id": "353c6403",
   "metadata": {},
   "outputs": [],
   "source": [
    "try: out,topo_nodes=toposorting('c17.net','c17.inputs')\n",
    "except : print(\"ERROR\") # tot avoid error when unpacking the out and topo_nodes\n",
    "if type(out)==list:\n",
    "    out.insert(0,topo_nodes)\n",
    "# displaying data\n",
    "#for i in out:\n",
    "#    p=' '.join(list(map(str,[x for x in i])))\n",
    "#   print(p)\n",
    "#SORTING THE COLUMNS OF OUT\n",
    "out_dict={}\n",
    "for i in range(len(out[0])):\n",
    "    out_dict[out[0][i]]=[out[k][i] for k in range(1,len(inp)+1)]\n",
    "#print(out_dict)\n",
    "s_or=sorted(topo_nodes) #sorted order of topo_nodes\n",
    "#print(s_or)\n",
    "sorted_out={s:out_dict[s] for s in s_or}\n",
    "#print(sorted_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5e1c0de",
   "metadata": {},
   "source": [
    "- out_dict is constructed such that we can easily sort the columns correpeonding to 'out' using keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "id": "6a46a511",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   N1  N2  N22  N23  N3  N6  N7  n_0  n_1  n_2  n_3\n",
      "0   0   1    1    1   0   0   0    1    1    1    0\n",
      "1   0   0    0    0   1   0   0    1    1    1    1\n",
      "2   1   0    0    0   0   0   0    1    1    1    1\n",
      "3   0   0    0    0   1   1   1    1    0    1    1\n",
      "4   1   1    1    0   1   1   1    0    0    1    1\n"
     ]
    }
   ],
   "source": [
    "topo_df=pd.DataFrame(sorted_out)\n",
    "print(topo_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "id": "9cd6f6fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "topo_df.to_excel('topo_output_file_c17.xlsx','w')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a052ba33",
   "metadata": {},
   "source": [
    "- I used pandas to create a dataframe feeding the sorted dictionary, such that the nodes are in alphabetic order.\n",
    "- Created an excel file of the dataframe using to_excel function of pandas.\n",
    "- I used writing mode such that if there is no file in the directory with the filename given, it creates a new file with data or else it relaces the data of the file with this data.\n",
    "- You may get error if the file is open."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46078737",
   "metadata": {},
   "source": [
    "### EVENT DRIVEN EVALUATION :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "id": "e880b41e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def event_driven(net_filename,input_filename):\n",
    "    g=nx.DiGraph()\n",
    "    #net=combinational_ckt(\"parity.net\")\n",
    "    net=combinational_ckt(net_filename)\n",
    "    #print(net)\n",
    "#EDGES\n",
    "    edges=[]\n",
    "    for i in range(len(net)):\n",
    "        edges.append((net[i][2],net[i][-1]))\n",
    "        if net[i][3]!=net[i][-1] :edges.append((net[i][3],net[i][-1]))\n",
    "    #print(edges)\n",
    "#NODES\n",
    "    nodes=[]\n",
    "    for i in range(len(net)):\n",
    "        if net[i][2] not in nodes:\n",
    "            nodes.append(net[i][2])\n",
    "        if net[i][-2] not in nodes:\n",
    "            nodes.append(net[i][3])\n",
    "        if net[i][-1] not in nodes:\n",
    "            nodes.append(net[i][-1])\n",
    "    #print(nodes)\n",
    "#OUTPUTNODES\n",
    "    output_nodes=[net[i][-1] for i in range(len(net))]\n",
    "    #print(output_nodes)\n",
    "#PRIMARY NODES\n",
    "    primary_nodes=[i for i in nodes if i not in output_nodes]\n",
    "    #print(primary_nodes)\n",
    "    nod_dict={}\n",
    "    for i in range(len(net)):\n",
    "        nod_dict[net[i][-1]]=net[i][1]\n",
    "    for i in primary_nodes:\n",
    "        nod_dict[i]='PI'\n",
    "#CONSTRUCTING GRAPH\n",
    "    g.add_edges_from(edges)\n",
    "    nx.set_node_attributes(g,nod_dict,name=\"gateType\")\n",
    "    if list(nx.simple_cycles(g))!=[]: #step*\n",
    "        print(\"Graph contains a cycle or graph changed during iteration\")\n",
    "        return\n",
    "    #print(g)\n",
    "#INPUTS\n",
    "    ip_nodes,inp=ip(input_filename)\n",
    "    for i in output_nodes:\n",
    "        for each in list(g.successors(i)):\n",
    "            if each in ip_nodes:\n",
    "                print(\"error\")\n",
    "                return\n",
    "    q_dict={}\n",
    "    for i in range(len(nodes)):\n",
    "        q_dict[nodes[i]]=i\n",
    "    #print(q_dict)\n",
    "    #step1\n",
    "    q_upd=[]\n",
    "    update1=['x' for i in range(len(nodes))]\n",
    "    q_upd.append(update1)\n",
    "    op=[]\n",
    "    for i in inp:\n",
    "        flag=0\n",
    "        qu=ip_nodes.copy() #step2\n",
    "        pi_dict={} #dictionary of input nodes corresponding to its values of the input vector\n",
    "        for j in range(len(ip_nodes)):\n",
    "            pi_dict[ip_nodes[j]]=i[j]\n",
    "        while qu!=[]:\n",
    "            flag+=1\n",
    "            if op==[]:\n",
    "                if flag==1:\n",
    "                    for j in range(len(i)):\n",
    "                        suc=[]\n",
    "                        u=q_upd[-1].copy()\n",
    "                        suc=list(g.successors(qu[0]))\n",
    "                        u[q_dict[qu[0]]]=pi_dict[qu[0]]\n",
    "                        q_upd.append(u)#step 3\n",
    "                        for each in suc:qu.append(each)#step4  \n",
    "                        qu.pop(0) \n",
    "                if q_upd[-1][q_dict[qu[0]]]=='x':\n",
    "                    suc=[]\n",
    "                    u=q_upd[-1].copy()\n",
    "                    suc=list(g.successors(qu[0]))\n",
    "                    for each in suc:\n",
    "                        qu.append(each)\n",
    "                    gate=g.nodes[qu[0]]['gateType'] #gate type of qu[0]\n",
    "                    pred=list(g.predecessors(qu[0]))#inputs to the gate type\n",
    "                    if type(q_upd[-1][q_dict[pred[0]]])!=int or type(q_upd[-1][q_dict[pred[-1]]])!=int: #step 5\n",
    "                        qu.pop(0)\n",
    "                        continue\n",
    "                    if gate=='and2': #step 6\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] and q_upd[-1][q_dict[pred[1]]]\n",
    "                    if gate=='or2':\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] or q_upd[-1][q_dict[pred[1]]]\n",
    "                    if gate=='xor2':\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]^q_upd[-1][q_dict[pred[1]]]\n",
    "                    if gate=='nor2':\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] or q_upd[-1][q_dict[pred[1]]]\n",
    "                    if gate=='nand2':\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] and q_upd[-1][q_dict[pred[1]]]\n",
    "                        u[q_dict[qu[0]]]=u[q_dict[qu[0]]]^1\n",
    "                    if gate=='xnor2':\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]^q_upd[-1][q_dict[pred[1]]]\n",
    "                        u[q_dict[qu[0]]]=u[q_dict[qu[0]]]^1\n",
    "                    if gate==\"inv\":\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]^1\n",
    "                    if gate==\"buf\":\n",
    "                        u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]\n",
    "                        #break\n",
    "                       # k+=1\n",
    "                    q_upd.append(u)   #step 7\n",
    "               # q.pop(0)\n",
    "            else:\n",
    "                if flag==1 :\n",
    "                    j=0\n",
    "                    while j<len(i):  #step 8\n",
    "                        suc=[]\n",
    "                        u=q_upd[-1].copy()\n",
    "                        u[q_dict[qu[0]]]=pi_dict[qu[0]]\n",
    "                        q_upd.append(u)     \n",
    "                        if q_upd[-1][q_dict[qu[0]]]!=q_upd[-2][q_dict[qu[0]]] : \n",
    "                            suc=list(g.successors(qu[0]))\n",
    "                        for each in suc:qu.append(each)\n",
    "                        qu.pop(0)\n",
    "                        j+=1\n",
    "                qu=unique(qu) #step 9\n",
    "                u=q_upd[-1].copy()\n",
    "                gate=g.nodes[qu[0]]['gateType'] #gate type of qu[0]\n",
    "                pred=list(g.predecessors(qu[0])) #inputs to the gate type\n",
    "                if gate=='and2': #step6\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] and q_upd[-1][q_dict[pred[1]]]\n",
    "                if gate=='or2':\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] or q_upd[-1][q_dict[pred[1]]]\n",
    "                if gate=='xor2':\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]^q_upd[-1][q_dict[pred[1]]]\n",
    "                if gate=='nor2':\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] or q_upd[-1][q_dict[pred[1]]]\n",
    "                if gate=='nand2':\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]] and q_upd[-1][q_dict[pred[1]]]\n",
    "                    u[q_dict[qu[0]]]=u[q_dict[qu[0]]]^1\n",
    "                if gate=='xnor2':\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]^q_upd[-1][q_dict[pred[1]]]\n",
    "                    u[q_dict[qu[0]]]=u[q_dict[qu[0]]]^1\n",
    "                if gate==\"inv\":\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]^1\n",
    "                if gate==\"buf\":\n",
    "                    u[q_dict[qu[0]]]=q_upd[-1][q_dict[pred[0]]]\n",
    "                q_upd.append(u)\n",
    "                suc=[]\n",
    "                if q_upd[-1][q_dict[qu[0]]]!=q_upd[-2][q_dict[qu[0]]] : suc=list(g.successors(qu[0]))#step 10\n",
    "                for each in suc: qu.append(each)\n",
    "            qu.pop(0)\n",
    "        op.append(q_upd[-1])  #step o        \n",
    "    return op,nodes\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da08c294",
   "metadata": {},
   "source": [
    "- Constructing the graph is same as presentations.\n",
    "- q_upd is the state table of nodes.\n",
    "- op is the final output list of all input vectors.\n",
    "- q_dict is used for the numbering of the nodes.\n",
    "- qu is the queue of nodes to be executed.\n",
    "- u is the update need to be appended to the q_upd when required.\n",
    "- In event driven evaluation, for the first input vector we need to find the outputs of every node.\n",
    "- From the second input vector, if there is change in the value of the primary inputs, we need to find the successors of the node corresponding to that primary input until the last successor or it gets stopped at any node where there is no change in it's value with respect to it's previous value.\n",
    "- step*: nx.simple_cycles(g) find out the cycles in graph. if there is a cycle it is not an empty list so, it throws an error and returns. if there is no cycle it proceeds.\n",
    "- step1:firstly we will make every value of the node in the update1 to be'x' and append it to the q_upd.\n",
    "- step 2: for the first input vector, add all the elements of the input vector to the qu and create pi_dict whish is the dictionary of primary input nodes corresponding to its values of the input vector.\n",
    "- step 3: update the every change in the primary input node values one by one to the q_upd\n",
    "- step 4: add all the successors of the primary input nodes to the qu and pop out the primary input nodes correspondingly.\n",
    "- step 5:if the inputs qu[0] are not integers, pop it out and continue with the remaining elements in qu.\n",
    "- step 6: find the gate type of qu[0] and inputs and execute the q[0] gate.Append it's successors too and step 5 will be repeated.\n",
    "- step 7: update the q_upd and pop the first element.it will get repeated until qu becones empty.After that qu.is updated with new set of inputs.\n",
    "- step o :after the first input vector is done, now the last element of q_upd no more conatins 'x' and it contains the output of the first element. So, it is appened to op\n",
    "- step 8: now we will check every primary input with the value corresponding to the q_up[-1]. If there is a change it's values are updated and it's successors will be added to the and append the update and pop the first element.\n",
    "- step 9: As every input is updated in q_upd, we can take distinct elements of qu and execute them. This is done using unique() function and repeat step 5\n",
    "- step 10: after calculating the qu[0] , update the q_upd, If it's value in q_upd[-1] and q_upd[-2] are not equal it's successors are added and pop the first element of qu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 412,
   "id": "45fad313",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "try:\n",
    "    op,nodes=event_driven('parity.net','parity.inputs')   \n",
    "except :print(\"error\")\n",
    "\n",
    "op.insert(0,nodes)\n",
    "o_dict={}\n",
    "for i in range(len(op[0])):\n",
    "    o_dict[op[0][i]]=[op[k][i] for k in range(1,len(inp)+1)]\n",
    "#print(o_dict)\n",
    "s_or=sorted(nodes)\n",
    "#print(s_or)\n",
    "sorted_out_event={s:o_dict[s] for s in s_or}\n",
    "#print(sorted_out_event)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "id": "68ffcf77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   a  b  c  d  dummy_0  dummy_1  dummy_2  dummy_3  dummy_4  e  ...  n_2  n_3  \\\n",
      "0  0  1  0  0        0        0        0        0        0  0  ...    0    0   \n",
      "1  0  0  1  0        0        1        0        0        1  0  ...    1    1   \n",
      "2  1  0  0  0        0        0        0        1        0  0  ...    0    1   \n",
      "3  0  0  1  1        1        1        0        1        0  1  ...    1    1   \n",
      "4  1  1  1  1        1        0        1        1        0  1  ...    0    1   \n",
      "\n",
      "   n_4  n_5  n_6  n_7  n_8  o  p  q  \n",
      "0    0    1    1    1    0  1  1  1  \n",
      "1    0    1    0    0    1  1  1  0  \n",
      "2    1    1    1    1    0  0  0  1  \n",
      "3    0    0    1    0    0  1  1  0  \n",
      "4    1    0    1    0    1  0  1  1  \n",
      "\n",
      "[5 rows x 31 columns]\n"
     ]
    }
   ],
   "source": [
    "event_df=pd.DataFrame(sorted_out_event)\n",
    "print(event_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "id": "4ed0bde5",
   "metadata": {},
   "outputs": [],
   "source": [
    "event_df.to_excel('event_driven_output_file_parity.xlsx','w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "id": "b318f472",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "302 µs ± 13.2 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n",
      "488 µs ± 16.9 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit toposorting('c17.net','c17.inputs')\n",
    "%timeit event_driven('c17.net','c17.inputs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "id": "03585cbc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.71 ms ± 58.2 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "6.64 ms ± 128 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit toposorting('c8.net','c8.inputs')\n",
    "%timeit event_driven('c8.net','c8.inputs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "id": "13d3c154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24.2 ms ± 3.13 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)\n",
      "3.81 s ± 207 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit toposorting('c432.net','c432.inputs')\n",
    "%timeit event_driven('c432.net','c432.inputs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "id": "0e519646",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "796 µs ± 51.1 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n",
      "1.44 ms ± 182 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit toposorting('parity.net','parity.inputs')\n",
    "%timeit event_driven('parity.net','parity.inputs')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c8d2132",
   "metadata": {},
   "source": [
    "- As observed, topo_sorting is nore efficient than event_driven because time taken by event_driven is very large compared to topo_sorting.\n",
    "- As the no. of gates in a netlist increasing, the time taken by both the evaluations increasing.\n",
    "- Event_driven evaluation is completely dependent no. of gates involved with the changes in the input"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c31b7e2c",
   "metadata": {},
   "source": [
    "###### NOTE:\n",
    "- First import the libraries which u require.\n",
    "- Run the user defined function before you use it in some other cell."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "135997c0",
   "metadata": {},
   "source": [
    "- This is an .ipynb file, which we can run in Jupyter notebook or Jupyter lab.\n",
    "- In Jupyter lab, we need to upload this document to the workspace and start editting and running.\n",
    "- In jupyter notebook, which is a local host of our pc, we need to know where the file is located, opening this file is same as we do in file manager.\n",
    "- To open in jupyter notebook, first we need to unzip the file i.e., extract all the files from it and open the ipynb file."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}