From 4d646d911b6c4a053bc3445a576d434032182f59 Mon Sep 17 00:00:00 2001 From: Yukta03 <72689246+Yukta03@users.noreply.github.com> Date: Sat, 5 Dec 2020 21:06:35 +0530 Subject: [PATCH 1/6] Create Lab Programs --- Yukta Dadhich (C2)-170418/Lab Programs | 1 + 1 file changed, 1 insertion(+) create mode 100644 Yukta Dadhich (C2)-170418/Lab Programs diff --git a/Yukta Dadhich (C2)-170418/Lab Programs b/Yukta Dadhich (C2)-170418/Lab Programs new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Lab Programs @@ -0,0 +1 @@ + From ae6f135d5add1d57a924c7f2f45a398830c4d634 Mon Sep 17 00:00:00 2001 From: Yukta03 <72689246+Yukta03@users.noreply.github.com> Date: Sat, 5 Dec 2020 21:12:17 +0530 Subject: [PATCH 2/6] Add files via upload --- Yukta Dadhich (C2)-170418/BFS and DFS.ipynb | 66 +++++ .../Back Prpogation.ipynb | 145 +++++++++++ ...rectional associative memory network.ipynb | 155 ++++++++++++ .../Depth Limited Search.ipynb | 78 ++++++ Yukta Dadhich (C2)-170418/Hopfield.ipynb | 151 +++++++++++ .../Iterative Deepening Search.ipynb | 90 +++++++ .../MP Neuron(AND,OR,AND-NOT).ipynb | 238 ++++++++++++++++++ Yukta Dadhich (C2)-170418/Madaline.ipynb | 117 +++++++++ Yukta Dadhich (C2)-170418/Water Jug.ipynb | 134 ++++++++++ 9 files changed, 1174 insertions(+) create mode 100644 Yukta Dadhich (C2)-170418/BFS and DFS.ipynb create mode 100644 Yukta Dadhich (C2)-170418/Back Prpogation.ipynb create mode 100644 Yukta Dadhich (C2)-170418/Bidirectional associative memory network.ipynb create mode 100644 Yukta Dadhich (C2)-170418/Depth Limited Search.ipynb create mode 100644 Yukta Dadhich (C2)-170418/Hopfield.ipynb create mode 100644 Yukta Dadhich (C2)-170418/Iterative Deepening Search.ipynb create mode 100644 Yukta Dadhich (C2)-170418/MP Neuron(AND,OR,AND-NOT).ipynb create mode 100644 Yukta Dadhich (C2)-170418/Madaline.ipynb create mode 100644 Yukta Dadhich (C2)-170418/Water Jug.ipynb diff --git a/Yukta Dadhich (C2)-170418/BFS and DFS.ipynb b/Yukta Dadhich (C2)-170418/BFS and DFS.ipynb new file mode 100644 index 0000000..cad3627 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/BFS and DFS.ipynb @@ -0,0 +1,66 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the number you want to search-5\n", + "[1, 2, 3, 5]\n" + ] + } + ], + "source": [ + "def bfs(graph,start,search):\n", + " explored = []\n", + " queue = [start]\n", + " found = 1\n", + " while found:\n", + " node = queue.pop(0)\n", + " if(node == search):\n", + " found = 0\n", + " if node not in explored:\n", + " explored.append(node)\n", + " neighbours = graph[node]\n", + " for neighbour in neighbours:\n", + " queue.append(neighbour)\n", + " print(explored)\n", + "\n", + "search = int(input(\"enter the number you want to search-\"))\n", + "graph = {1: [2, 3, 5],\n", + " 2: [1,4, 5],\n", + " 3: [1, 6, 7],\n", + " 4: [2],\n", + " 5: [1, 2,4],\n", + " 6: [3],\n", + " 7: [3]}\n", + "bfs(graph,1,search)\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Back Prpogation.ipynb b/Yukta Dadhich (C2)-170418/Back Prpogation.ipynb new file mode 100644 index 0000000..ee227a1 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Back Prpogation.ipynb @@ -0,0 +1,145 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter X1: 0\n", + "0.0\n", + "Enter X2: 1\n", + "1.0\n", + "Enter bias 1: 1\n", + "Enter bias 2: 1\n", + "Enter bias 3: 1\n", + "Enter alpha: 0.25\n", + "Enter target: 1\n", + "phase 1\n", + "zin1= 0.19999999999999998\n", + "z1= 0.549833997312478\n", + "fzin1= 0.24751657271185995\n", + "zin2= 0.9\n", + "z2= 0.7109495026250039\n", + "fzin2= 0.2055003073422635\n", + "yin= 0.09102854918749159\n", + "y= 0.5227414361305817\n", + "fyin= 0.24948282708271868\n", + "phase 2\n", + "dell1= 0.11906781576358075\n", + "delta_w11= 0.01636688327313882\n", + "delta_w21= 0.021162801098940833\n", + "dellin1= 0.0476271263054323\n", + "dellin2= 0.011906781576358076\n", + "delta1= 0.011788503071235473\n", + "delta2= 0.002446847273398785\n", + "delta_w01= 0.029766953940895187\n", + "phase 3\n", + "delta_v11= 0.0\n", + "delta_v12= 0.0\n", + "delta_v21= 0.0029471257678088682\n", + "delta_v22= 0.0006117118183496963\n", + "delta_v01= 0.0029471257678088682\n", + "delta_v02= 0.0006117118183496963\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x1 = float(input(\"Enter X1: \"))\n", + "print(x1) \n", + "x2 = float(input(\"Enter X2: \")) \n", + "print(x2) \n", + "b1 = float(input(\"Enter bias 1: \"))\n", + "b2 = float(input(\"Enter bias 2: \"))\n", + "b3 = float(input(\"Enter bias 3: \"))\n", + "alpha = float(input(\"Enter alpha: \"))\n", + "t = float(input(\"Enter target: \"))\n", + "\n", + "a = [0.6,0.3,-0.1,-0.3,0.4,0.5,0.4,0.1,-0.2]\n", + "print('phase 1') \n", + "zin1 = float(b1*a[1]+x1*a[0]+x2*a[2])\n", + "print('zin1=',zin1)\n", + "zp1 = 1/(1+np.exp(-zin1))\n", + "print('z1=',zp1)\n", + "fzin1= zp1*(1-zp1)\n", + "print('fzin1=',fzin1)\n", + "\n", + "zin2= float(a[3]*x1+a[4]*x2+a[5]*b2)\n", + "print('zin2=',zin2)\n", + "zp2 = 1/(1+np.exp(-zin2))\n", + "print('z2=',zp2)\n", + "fzin2= zp2*(1-zp2)\n", + "print('fzin2=',fzin2)\n", + "\n", + "yin=float(zp1*a[6]+zp2*a[7]+b3*a[8])\n", + "print('yin=',yin)\n", + "y = 1/(1+np.exp(-yin))\n", + "print('y=',y)\n", + "fyin= y*(1-y)\n", + "print('fyin=',fyin)\n", + "\n", + "print('phase 2')\n", + "dell1=(t-y)*fyin\n", + "print('dell1=',dell1)\n", + "delta_w11=alpha*dell1*zp1\n", + "print('delta_w11=',delta_w11)\n", + "delta_w21=alpha*dell1*zp2\n", + "print('delta_w21=',delta_w21)\n", + "\n", + "dellin1=dell1*a[6]\n", + "print('dellin1=',dellin1)\n", + "dellin2 = dell1*a[7]\n", + "print('dellin2=',dellin2)\n", + "\n", + "delta1=dellin1*fzin1\n", + "print('delta1=',delta1)\n", + "delta2=dellin2*fzin2\n", + "print('delta2=',delta2)\n", + "delta_w01=alpha*dell1\n", + "print('delta_w01=',delta_w01)\n", + "\n", + "print('phase 3')\n", + "delta_v11=alpha*delta1*x1\n", + "print('delta_v11=',delta_v11)\n", + "delta_v12=alpha*delta2*x1\n", + "print('delta_v12=',delta_v12)\n", + "delta_v21=alpha*delta1*x2\n", + "print('delta_v21=',delta_v21)\n", + "delta_v22=alpha*delta2*x2\n", + "print('delta_v22=',delta_v22)\n", + "\n", + "delta_v01 = alpha*delta1\n", + "print('delta_v01=',delta_v01)\n", + "delta_v02 = alpha*delta2\n", + "print('delta_v02=',delta_v02)\n", + "\n", + "\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Bidirectional associative memory network.ipynb b/Yukta Dadhich (C2)-170418/Bidirectional associative memory network.ipynb new file mode 100644 index 0000000..5ec077b --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Bidirectional associative memory network.ipynb @@ -0,0 +1,155 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The Weight Matrix is:\n", + "\n", + "[[ 0 2]\n", + " [ 0 2]\n", + " [ 0 2]\n", + " [ 2 0]\n", + " [-2 0]\n", + " [ 2 0]\n", + " [ 2 0]\n", + " [-2 0]\n", + " [ 2 0]\n", + " [ 2 0]\n", + " [ 0 2]\n", + " [ 2 0]]\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\yukta\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:26: RuntimeWarning: overflow encountered in long_scalars\n", + "C:\\Users\\yukta\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:28: RuntimeWarning: overflow encountered in long_scalars\n", + "C:\\Users\\yukta\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:30: RuntimeWarning: overflow encountered in long_scalars\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x1=np.array([[1,1,1,-1,1,-1,-1,1,-1,-1,1,-1]])\n", + "x2=np.array([[1,1,1,1,-1,1,1,-1,1,1,1,1]])\n", + "x3=np.array([[1,1,1,-1,1,-1,-1,1,-1,1,1,1]])\n", + "t1 = np.array([[-1],[1]])\n", + "t2 = np.array([[1],[1]])\n", + "w1=np.zeros((12,2),dtype=int)\n", + "w2=np.zeros((12,2),dtype=int)\n", + "w=np.zeros((12,2),dtype=int)\n", + "i=0\n", + "while(i!=12):\n", + " w1[i][0]=x1[0][i]*t1[0][0]\n", + " w1[i][1]=x1[0][i]*t1[1][0]\n", + " w2[i][0]=x2[0][i]*t2[0][0]\n", + " w2[i][1]=x2[0][i]*t2[1][0]\n", + " i=i+1\n", + " w=w1+w2 \n", + "print('The Weight Matrix is:\\n')\n", + "print(w)\n", + "Yin11=Yin12=Yin21=Yin22=Yin31=Yin32=0\n", + "y1=0\n", + "y2=0\n", + "i=0\n", + "while(i!=12):\n", + " Yin11=Yin11+(x1[0][i]*w[i][0])\n", + " Yin12=Yin12+(x1[0][i]*w[i][1])\n", + " Yin21=Yin21+(x2[0][i]*w[i][0])\n", + " Yin22=Yin22+(x2[0][i]*w[i][1])\n", + " Yin31=Yin31+(x3[0][i]*w[i][0])\n", + " Yin32=Yin32+(x3[0][i]*w[i][1])\n", + "i=i+1\n", + "if(Yin11>0):\n", + " Yin11=1\n", + "else:\n", + " Yin11=-1\n", + "if(Yin12>0):\n", + " Yin12=1\n", + "else:\n", + " Yin12=-1 \n", + "if(Yin21>0):\n", + " Yin21=1\n", + "else:\n", + " Yin21=-1\n", + "if(Yin22>0):\n", + " Yin22=1\n", + "else:\n", + " Yin22=-1\n", + "if(Yin31>0):\n", + " Yin31=1\n", + "else:\n", + " Yin31=-1\n", + "if(Yin32>0):\n", + " Yin32=1\n", + "else:\n", + " Yin32=-1\n", + "\n", + "if((Yin11==-1) and (Yin12==1)):\n", + " print('Pattern T is recognized for Y-Layer')\n", + "else:\n", + " print('Pattern T is not recognized for Y-Layer') \n", + "if((Yin21==1) and (Yin22==1)):\n", + " print('Pattern O is recognized for Y-Layer')\n", + "else:\n", + " print('Pattern O is not recognized for Y-Layer')\n", + "\n", + "i=0\n", + "Xin1=np.zeros((12,1),dtype=int)\n", + "Xin2=np.zeros((12,1),dtype=int)\n", + "while(i!=12):\n", + " Xin1[i][0]=Xin1[i][0]+((Yin11*w[i][0])+(Yin12*w[i][1])) \n", + "if(Xin1[i][0]>0):\n", + " Xin1[i][0]=1\n", + "else:\n", + " Xin1[i][0]=-1\n", + " Xin2[i][0]=Xin2[i][0]+((Yin21*w[i][0])+(Yin22*w[i][1]))\n", + "if(Xin2[i][0]>0):\n", + " Xin2[i][0]=1\n", + "else:\n", + " Xin2[i][0]=-1\n", + "i=i+1\n", + "Xin1=Xin1.T\n", + "Xin2=Xin2.T\n", + "print('\\n')\n", + "if((Xin1==x1).all()):\n", + " print('Pattern T is recognized for X-Layer')\n", + "else:\n", + " print('Pattern T is not recognized for X-Layer') \n", + "if((Xin2==x2).all()):\n", + " print('Pattern O is recognized for X-Layer')\n", + "else:\n", + " print('Pattern O is not recognized for X-Layer')\n", + " print('Testing of I \\n Values for I are:', Yin31 ,'\\t',Yin32)\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Depth Limited Search.ipynb b/Yukta Dadhich (C2)-170418/Depth Limited Search.ipynb new file mode 100644 index 0000000..5260c79 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Depth Limited Search.ipynb @@ -0,0 +1,78 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the node to be searched4\n", + "enter the depth2\n", + "Target is NOT reachable from source within max depth\n" + ] + } + ], + "source": [ + "from collections import defaultdict \n", + "class Graph: \n", + " def __init__(self,vertices): \n", + " self.V = vertices \n", + " self.graph = defaultdict(list) \n", + " def addEdge(self,u,v): \n", + " self.graph[u].append(v) \n", + " def DLS(self,src,target,maxDepth): \n", + " if src == target : return True \n", + " if maxDepth <= 0 : return False \n", + " for i in self.graph[src]: \n", + " if(self.DLS(i,target,maxDepth-1)): \n", + " return True\n", + " return False \n", + " def IDDFS(self,src, target, maxDepth): \n", + " for i in range(maxDepth): \n", + " if (self.DLS(src, target, i)): \n", + " return True\n", + " return False\n", + "g = Graph (7); \n", + "g.addEdge(0, 1) \n", + "g.addEdge(0, 2) \n", + "g.addEdge(1, 3) \n", + "g.addEdge(1, 4) \n", + "g.addEdge(2, 5) \n", + "g.addEdge(2, 6) \n", + "target = int(input(\"enter the node to be searched\"));\n", + "maxDepth = int(input(\"enter the depth\"));\n", + "src = 0 \n", + "if g.IDDFS(src, target, maxDepth) == True: \n", + " print (\"Target is reachable from source \" +\n", + " \"within max depth\") \n", + "else : \n", + " print (\"Target is NOT reachable from source \" +\n", + " \"within max depth\")\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Hopfield.ipynb b/Yukta Dadhich (C2)-170418/Hopfield.ipynb new file mode 100644 index 0000000..508f697 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Hopfield.ipynb @@ -0,0 +1,151 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Weight Matrix:\n", + "\n", + "[ 3. -1. 1. 3. 1.]\n", + "[-1. 3. 1. -1. 1.]\n", + "[1. 1. 3. 1. 3.]\n", + "[ 3. -1. 1. 3. 1.]\n", + "[1. 1. 3. 1. 3.]\n", + "\n", + "\n", + "Weight Matrix with no self connection:\n", + "\n", + "[ 0. -1. 1. 3. 1.]\n", + "[-1. 0. 1. -1. 1.]\n", + "[1. 1. 0. 1. 3.]\n", + "[ 3. -1. 1. 0. 1.]\n", + "[1. 1. 3. 1. 0.]\n", + "\n", + "\n", + "Energy Calculations for pattern [1,1,1,1,1]: [-10.]\n", + "\n", + "\n", + "Energy Calculations for pattern [1,-1,-1,1,-1]: [-6.]\n", + "\n", + "\n", + "Energy Calculations for pattern [-1,1,-1,1,-1]: [-10.]\n", + "\n", + "\n", + "TESTING PHASE\n", + "\n", + "Pattern [1,1,1,-1,1] Recognized \n", + "\n", + "Pattern [1,-1,-1,-1,-1] Recognized \n", + "\n", + "Pattern [1,1,-1,-1,-1] Recognized \n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1,1,1,1],[1,-1,-1,1,-1],[-1,1,-1,-1,-1]])\n", + "x1=np.transpose(x)\n", + "t1=np.array([[1,1,1,-1,1]])\n", + "t2=np.array([[1,-1,-1,-1,-1]])\n", + "t3=np.array([[1,1,-1,-1,-1]])\n", + "w=np.zeros((5,5))\n", + "i=0\n", + "j=0\n", + "k=0\n", + "for i in range(len(x1)):\n", + " for j in range(len(x[0])):\n", + " for k in range(len(x)):\n", + " w[i][j] += x1[i][k] * x[k][j]\n", + "print('Weight Matrix:\\n')\n", + "for r in w:\n", + " print(r)\n", + "print('\\n\\nWeight Matrix with no self connection:\\n')\n", + "i=0\n", + "j=0\n", + "for i in range(int(5)):\n", + " for j in range(int(5)):\n", + " if(i==j):\n", + " w[i][j]=0\n", + "for r in w:\n", + " print(r) \n", + "E1=0\n", + "E2=0\n", + "E3=0\n", + "x11= x[0].reshape(5,1)\n", + "x12=x[1].reshape(5,1)\n", + "x13=x[2].reshape(5,1)\n", + "E1= -0.5 * np.matmul(x[0],np.matmul(w,x11))\n", + "print('\\n\\nEnergy Calculations for pattern [1,1,1,1,1]:',E1)\n", + "\n", + "E2= -0.5 * np.matmul(x[1],np.matmul(w,x12))\n", + "print('\\n\\nEnergy Calculations for pattern [1,-1,-1,1,-1]:',E2)\n", + "\n", + "E3= -0.5 * np.matmul(x[2],np.matmul(w,x13))\n", + "print('\\n\\nEnergy Calculations for pattern [-1,1,-1,1,-1]:',E3)\n", + "\n", + "print('\\n\\nTESTING PHASE')\n", + "w_dash=np.transpose(w)\n", + "Yin1=t1[0][3]+ np.matmul(x[0],w_dash[3])\n", + "if(Yin1>0):\n", + " t1[0][3]=1\n", + "else:\n", + " t1[0][3]=-1\n", + "if((t1==x).any()):\n", + " print('\\nPattern [1,1,1,-1,1] Recognized ')\n", + "else:\n", + " print('\\nPattern [1,1,1,-1,1] not Recognized ') \n", + "Yin2=t2[0][3]+ np.matmul(x[1],w_dash[3])\n", + "if(Yin2>0):\n", + " t2[0][3]=1\n", + "else:\n", + " t2[0][3]=-1\n", + "if((t2==x).any()):\n", + " print('\\nPattern [1,-1,-1,-1,-1] Recognized ')\n", + "else:\n", + " print('\\nPattern [1,-1,-1,-1,-1] not Recognized ') \n", + "Yin3=t3[0][0]+ np.matmul(x[2],w_dash[0])\n", + "if(Yin3>0):\n", + " t3[0][0]=1\n", + "else:\n", + " t3[0][0]=-1\n", + "if((t3==x).any()):\n", + " print('\\nPattern [1,1,-1,-1,-1] Recognized ')\n", + "else:\n", + " print('\\nPattern [1,1,-1,-1,-1] not Recognized ')\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Iterative Deepening Search.ipynb b/Yukta Dadhich (C2)-170418/Iterative Deepening Search.ipynb new file mode 100644 index 0000000..a937cbb --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Iterative Deepening Search.ipynb @@ -0,0 +1,90 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the node to be searched4\n", + "enter the depth2\n", + "Target is reachable from source within max depth : \n", + "3\n" + ] + } + ], + "source": [ + "from collections import defaultdict \n", + "\n", + "class Graph: \n", + " \n", + " def __init__(self,vertices): \n", + " \n", + " self.V = vertices \n", + " self.graph = defaultdict(list) \n", + " def addEdge(self,u,v): \n", + " self.graph[u].append(v) \n", + " \n", + " def DLS(self,src,target,maxDepth): \n", + " if src == target : return True \n", + " if maxDepth <= 0 : return False \n", + " \n", + " for i in self.graph[src]: \n", + " if(self.DLS(i,target,maxDepth-1)): \n", + " return True\n", + " return False \n", + " def IDDFS(self,src, target, maxDepth): \n", + " for i in range(maxDepth): \n", + " if (self.DLS(src, target, i)): \n", + " return True\n", + " return False\n", + " \n", + "\n", + "g = Graph (7); \n", + "g.addEdge(0, 1) \n", + "g.addEdge(0, 2) \n", + "g.addEdge(1, 3) \n", + "g.addEdge(1, 4) \n", + "g.addEdge(2, 5) \n", + "g.addEdge(2, 6) \n", + " \n", + "target = int(input(\"enter the node to be searched\"));\n", + "maxDepth = int(input(\"enter the depth\"));\n", + "src = 0\n", + "found = 1\n", + "while(found):\n", + " if g.IDDFS(src, target, maxDepth) == True:\n", + " print (\"Target is reachable from source \" +\n", + " \"within max depth : \")\n", + " print(maxDepth)\n", + " found = 0\n", + " else :\n", + " maxDepth = maxDepth +1\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/MP Neuron(AND,OR,AND-NOT).ipynb b/Yukta Dadhich (C2)-170418/MP Neuron(AND,OR,AND-NOT).ipynb new file mode 100644 index 0000000..2957646 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/MP Neuron(AND,OR,AND-NOT).ipynb @@ -0,0 +1,238 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MP Neuron for Logic Gates (AND,OR,AND-NOT)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 2\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 2\n" + ] + } + ], + "source": [ + "#AND\n", + "\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[0],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " \t#print(yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1\n", + " i=i+1\n", + " else:\n", + " \ty[i]=0\n", + " \ti=i+1\n", + " \n", + " if (y==t).all():\n", + " \tprint(\"MODEL IS TRAINED \")\n", + " \tprint(\"\\nOutput : \\n\",y)\n", + " \tprint(\"\\nweights : \",w,\"\\n\")\n", + " \tprint(\"theta : \",theta)\n", + " \tfound=1\n", + " else:\n", + " \t print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " \tw1=int(input(\"Enter Weight : \"))\n", + " \tw=np.append(w,w1)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [1.]\n", + " [1.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "#OR\n", + "\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[1],[1],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1\n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " #print(\"y\",y)\n", + " #print(\"t\",t)\n", + " if(y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " \tprint(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : -1\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[0.]\n", + " [1.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [ 1. -1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[0],[1],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " \t#print(yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1\n", + " i=i+1\n", + " \telse:\n", + " y[i]=0\n", + " i=i+1\n", + " #print(\"y\",y)\n", + " #print(\"t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else: \n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n", + "\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Madaline.ipynb b/Yukta Dadhich (C2)-170418/Madaline.ipynb new file mode 100644 index 0000000..b03f524 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Madaline.ipynb @@ -0,0 +1,117 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter new theta2\n", + "enter new alpha3\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "The final weight matrix is \n", + "[[3]\n", + " [3]]\n", + "The final output is:\n", + "[[ 1.]\n", + " [ 1.]\n", + " [ 1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[1],[1],[1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"enter new theta\"))\n", + "alpha=float(input(\"enter new alpha\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " \n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all():\n", + " found=1\n", + "print(\"The final weight matrix is \")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Yukta Dadhich (C2)-170418/Water Jug.ipynb b/Yukta Dadhich (C2)-170418/Water Jug.ipynb new file mode 100644 index 0000000..d901310 --- /dev/null +++ b/Yukta Dadhich (C2)-170418/Water Jug.ipynb @@ -0,0 +1,134 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter the capacity of first jug: 5\n", + "Enter the capacity of second jug: 7\n", + "In which jug to be filled :2\n", + "How much to be filled: 2\n", + "JUG1\tJUG2\n", + "0\t0\n", + "5\t0\n", + "0\t5\n", + "5\t5\n", + "3\t7\n", + "0\t3\n", + "5\t3\n", + "1\t7\n", + "0\t1\n", + "5\t1\n", + "0\t6\n", + "5\t6\n", + "4\t7\n", + "0\t4\n", + "5\t4\n", + "2\t7\n", + "0\t2\n" + ] + } + ], + "source": [ + "n1=int(input(\"Enter the capacity of first jug: \"))\n", + "n2=int(input(\"Enter the capacity of second jug: \"))\n", + "n3=int(input(\"In which jug to be filled :\"))\n", + "n4=int(input(\"How much to be filled: \"))\n", + "class Waterjug:\n", + " def __init__(self,am,bm,a,b,g):\n", + " self.a_max = am;\n", + " self.b_max = bm;\n", + " self.a = a;\n", + " self.b = b;\n", + " self.goal = g;\n", + " def fillA(self):\n", + " self.a = self.a_max;\n", + " print ('(', self.a, ',',self.b, ')')\n", + " def fillB(self):\n", + " self.b = self.b_max;\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def emptyA(self):\n", + " self.a = 0;\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def emptyB(self):\n", + " self.b = 0;\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def transferAtoB(self):\n", + " while (True):\n", + " self.a = self.a - 1\n", + " self.b = self.b + 1\n", + " if (self.a == 0 or self.b == self.b_max):\n", + " break\n", + " print ('(', self.a, ',', self.b, ')')\n", + " def main(self):\n", + " while (True):\n", + " if (self.a == self.goal or self.b == self.goal):\n", + " break\n", + " if (self.a == 0):\n", + " self.fillA()\n", + " elif (self.a > 0 and self.b != self.b_max):\n", + " self.transferAtoB()\n", + " elif (self.a > 0 and self.b == self.b_max):\n", + " self.emptyB()\n", + "def pour(jug1, jug2):\n", + " max1, max2, fill = n1, n2, n4 \n", + " print(\"%d\\t%d\" % (jug1, jug2))\n", + " if jug2 is fill:\n", + " return \n", + " elif jug2 is max2:\n", + " pour(0, jug1)\n", + " elif jug1 != 0 and jug2 is 0: \n", + " pour(0, jug1)\n", + " elif jug1 is fill: \n", + " pour(jug1, 0)\n", + " elif jug1 < max1: \n", + " pour(max1, jug2)\n", + " elif jug1 < (max2-jug2): \n", + " pour(0, (jug1+jug2))\n", + " else: \n", + " pour(jug1-(max2-jug2), (max2-jug2)+jug2) \n", + "print(\"JUG1\\tJUG2\")\n", + "if(n3==2):\n", + " pour(0, 0)\n", + "elif(n3==1):\n", + " print ('(', '0',',', '0', ')')\n", + " waterjug=Waterjug(n1,n2,0,0,n4);\n", + " waterjug.main();\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 04edba280f61854034c39a0dc0c64db0be5b4ba9 Mon Sep 17 00:00:00 2001 From: Yukta03 <72689246+Yukta03@users.noreply.github.com> Date: Sun, 6 Dec 2020 00:17:01 +0530 Subject: [PATCH 3/6] Create PYTHON LIBRARIES --- PYTHON LIBRARIES | 79 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) create mode 100644 PYTHON LIBRARIES diff --git a/PYTHON LIBRARIES b/PYTHON LIBRARIES new file mode 100644 index 0000000..ec158af --- /dev/null +++ b/PYTHON LIBRARIES @@ -0,0 +1,79 @@ +TensorFlow + +TensorFlow works like a computational library for writing new algorithms that involve a large number of tensor operations, since neural networks can be easily expressed as computational graphs they can be implemented using TensorFlow as a series of operations on Tensors. Plus, tensors are N-dimensional matrices which represent your data. +Features of TensorFlow:- +Flexible +Open Source +Easily Trainable +Responsive Construct + +Numpy + +Numpy is considered as one of the most popular machine learning library in Python. TensorFlow and other libraries uses Numpy internally for performing multiple operations on Tensors. Array interface is the best and the most important feature of Numpy. +Features of Numpy:- +Interactive +Mathematics +Intuitive + +Panda +Pandas is a machine learning library in Python that provides data structures of high-level and a wide variety of tools for analysis. One of the great feature of this library is the ability to translate complex operations with data using one or two commands. Pandas have so many inbuilt methods for grouping, combining data, and filtering, as well as time-series functionality. + +Features of Panda:- +Re-indexing +Iteration +Sorting +Aggregations +Concatenations +Visualizations + +PyTorch + + +PyTorch is the largest machine learning library that allow developers to perform tensor computations wan ith acceleration of GPU, creates dynamic computational graphs, and calculate gradients automatically. Other than this, PyTorch offers rich APIs for solving application issues related to neural networks. +Features of PyTorch:- +Hybrid Front-End +Distributed Training +Libraries And Tools + +SciPy + +SciPy is a machine learning library for application developers and engineers. However, you still need to know the difference between SciPy library and SciPy stack. SciPy library contains modules for optimization, linear algebra, integration, and statistics. +Features of SciPy:- +Optimization, +Numerical integration +Submodules + +Keras + + +Keras is considered as one of the coolest machine learning libraries in Python. It provides an easier mechanism to express neural networks. Keras also provides some of the best utilities for compiling models, processing data-sets, visualization of graphs, and much more. + +Features of Keras:- + +Runs smoothly (CPU and GPU) +Modular +Expressive +Flexible +Easy debugging +Supports neural network models (fully connected, convolutional, pooling, recurrent, embedding) + +Steps to install any new library:- +Using the Jupyter notebook and want to install a package with pip and conda +Install a package with pip +import sys +!{sys.executable} -m pip install numpy +Install a package with conda +import sys +!conda install --yes --prefix {sys.prefix} numpy + + + +Import NumPy and Check Version +The command to import numpy is +import numpy as np +Above code renames the Numpy namespace to np. This permits us to prefix Numpy function, methods, and attributes with " np " instead of typing " numpy." It is the standard shortcut you will find in the numpy literature +To check your installed version of Numpy use the command +print (np.__version__) + + + From 70a4c9cc856b1ba00e6f4b8dfe32d51288d32353 Mon Sep 17 00:00:00 2001 From: Yukta03 <72689246+Yukta03@users.noreply.github.com> Date: Sun, 6 Dec 2020 00:25:35 +0530 Subject: [PATCH 4/6] Add files via upload --- Data structures and their Operations.ipynb | 117 +++++++ ...on of various enviornments in python.ipynb | 51 +++ Numpy for Matrix Operations.ipynb | 114 +++++++ OPERATORS.ipynb | 169 ++++++++++ Plotting the Equations.ipynb | 232 ++++++++++++++ Single Layer Perceptron(AND,ANDNOT,OR) .ipynb | 296 ++++++++++++++++++ 6 files changed, 979 insertions(+) create mode 100644 Data structures and their Operations.ipynb create mode 100644 Installation of various enviornments in python.ipynb create mode 100644 Numpy for Matrix Operations.ipynb create mode 100644 OPERATORS.ipynb create mode 100644 Plotting the Equations.ipynb create mode 100644 Single Layer Perceptron(AND,ANDNOT,OR) .ipynb diff --git a/Data structures and their Operations.ipynb b/Data structures and their Operations.ipynb new file mode 100644 index 0000000..a15dd23 --- /dev/null +++ b/Data structures and their Operations.ipynb @@ -0,0 +1,117 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 'ananya', 2]\n", + "[1, 'ananya', 2, 'MODY UNIVERSITY']\n", + "[1, 'ananya', 2]\n" + ] + } + ], + "source": [ + "list = [1, \"ananya\", 1+1]\n", + "print(list)\n", + "list[1]\n", + "list.append(\"MODY UNIVERSITY\")\n", + "print(list)\n", + "list.pop()\n", + "print(list)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1: 'a', 2: 'b'}\n", + "dict_keys([1, 2])\n", + "dict_values(['a', 'b'])\n", + "0 1 a\n", + "1 2 b\n", + "1 a\n", + "2 b\n", + "True\n", + "{2: 'b'}\n", + "False\n" + ] + } + ], + "source": [ + "dictionary = { 1:'a', 2:'b'}\n", + "print(dictionary)\n", + "print(dictionary.keys())\n", + "print(dictionary.values())\n", + "for index, value in enumerate(dictionary): \n", + " print (index, value , dictionary[value])\n", + "for i in dictionary:\n", + " print (\"%d %s\" %(i, dictionary[i]))\n", + "print(1 in dictionary)\n", + "del dictionary[1]\n", + "print(dictionary)\n", + "print(1 in dictionary)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 'ananya', 3)\n", + "ananya\n", + "{1, 2, 3, 4, 5, 6, 7, 8, 9}\n", + "set = {1, 2, 3, 4, 5, 6, 7, 8, 9}\n" + ] + } + ], + "source": [ + "tuple = (1,\"ananya\", 1+2)\n", + "print(tuple)\n", + "print(tuple[1])\n", + "tuple[2]\n", + "\n", + "set = set()\n", + "for i in range(1,10):\n", + " set.add(i)\n", + "print(set)\n", + "print(\"set =\",set)\n", + "\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Installation of various enviornments in python.ipynb b/Installation of various enviornments in python.ipynb new file mode 100644 index 0000000..8372292 --- /dev/null +++ b/Installation of various enviornments in python.ipynb @@ -0,0 +1,51 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Aim:Learning about the tools and installation of various environment in python.\n", + "Jupyter Notebook\n", + "Project Jupyter exists to develop open-source software, open-standards, and services for interactive computing across dozens of programming languages.\n", + "The Jupyter Notebook is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. Uses include: data cleaning and transformation, numerical simulation, statistical modeling, data visualization, machine learning, and much more.\n", + "Functions:\n", + "Language of choice\n", + "Share Notebooks\n", + "Interactive Output\n", + "Big Data integration\n", + "\n", + "Installing Jupyter using Anaconda:-\n", + "For new users, we highly recommend installing Anaconda. Anaconda conveniently installs Python, the Jupyter Notebook, and other commonly used packages for scientific computing and data science.\n", + "Use the following installation steps:\n", + "Download Anaconda. We recommend downloading Anaconda’s latest Python 3 version (currently Python 3.5).\n", + "Install the version of Anaconda which you downloaded, following the instructions on the download page.\n", + "Once you have installed Jupyter Notebook. To run the notebook:\n", + "Click on launch jupyter notebook after starting Anaconda\n", + "\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Numpy for Matrix Operations.ipynb b/Numpy for Matrix Operations.ipynb new file mode 100644 index 0000000..2d95497 --- /dev/null +++ b/Numpy for Matrix Operations.ipynb @@ -0,0 +1,114 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[10, 11, 4],\n", + " [ 4, 6, 8],\n", + " [ 5, 2, 1]])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "x = np.array([[8,6,3],[2,3,4],[0,0,0]])\n", + "y = np.array([[2,5,1],[2,3,4],[5,2,1]])\n", + "x + y" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[43 64 35]\n", + " [30 27 18]\n", + " [ 0 0 0]]\n" + ] + } + ], + "source": [ + "c=x.dot(y)\n", + "print(c)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[4. , 1.2, 3. ],\n", + " [1. , 1. , 1. ],\n", + " [0. , 0. , 0. ]])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x / y" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0, 1, 0],\n", + " [0, 0, 0],\n", + " [0, 0, 0]], dtype=int32)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x % y" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/OPERATORS.ipynb b/OPERATORS.ipynb new file mode 100644 index 0000000..c3f155f --- /dev/null +++ b/OPERATORS.ipynb @@ -0,0 +1,169 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Assignment Operations\n", + "11\n", + "18\n", + "126\n", + "18.0\n", + "2.0\n", + "2\n", + "14\n", + "Arithmetic Operations\n", + "16\n", + "8\n", + "48\n", + "3.0\n", + "3\n", + "0\n", + "20736\n", + "Bitwise Operations\n", + "0\n", + "14\n", + "-11\n", + "14\n", + "2\n", + "40\n", + "Logical Operations\n", + "False\n", + "True\n", + "False\n", + "Relational Operations\n", + "False\n", + "True\n", + "False\n", + "True\n", + "False\n", + "True\n", + "Identity Operators\n", + "False\n", + "False\n", + "False\n", + "Membership Operator\n", + "False\n", + "True\n" + ] + } + ], + "source": [ + "#ASSIGNMENT OPERATORS\n", + "a=7\n", + "b=4\n", + "c=9\n", + "print(\"Assignment Operations\")\n", + "c=a+b\n", + "print(c)\n", + "c += a \n", + "print(c)\n", + "c *= a \n", + "print(c)\n", + "c /= a \n", + "print(c)\n", + "c //= a \n", + "print(c)\n", + "c = 2\n", + "c %= a \n", + "print(c)\n", + "c *= a \n", + "print(c)\n", + "\n", + "#ARITHMETIC OPERATORS\n", + "x=12\n", + "y=4\n", + "print(\"Arithmetic Operations\")\n", + "print(x+y)\n", + "print(x-y)\n", + "print(x*y)\n", + "print(x/y) \n", + "print(x//y) \n", + "print(x%y) \n", + "print(x**y) \n", + "\n", + "#BITWISE OPERATOR\n", + "a = 10\n", + "b = 4\n", + "print(\"Bitwise Operations\")\n", + "print(a & b) \n", + "print(a | b) \n", + "print(~a) \n", + "print(a ^ b) \n", + "print(a >> 2) \n", + "print(a << 2) \n", + "\n", + "#LOGICAL OPERATORS\n", + "a = True\n", + "b = False \n", + "print(\"Logical Operations\")\n", + "print(a and b) \n", + "print(a or b) \n", + "print(not a) \n", + "\n", + "#RELATIONAL OPERATORS\n", + "x=5\n", + "y=10\n", + "print(\"Relational Operations\")\n", + "print(x>y)\n", + "print(x=y)\n", + "print(x<=y)\n", + " \n", + "\n", + "\n", + "#SPECIAL OPERATORS\n", + "a1 = 3\n", + "b1 = 3\n", + "a2 = 'Sky'\n", + "b2 = 'Pink'\n", + "a3 = [1,2,3] \n", + "b3 = [1,2,3] \n", + " \n", + "print(\"Identity Operators\") \n", + "print(a1 is not b1) \n", + " \n", + " \n", + "print(a2 is b2) \n", + " \n", + "# Output is False, since lists are mutable. \n", + "print(a3 is b3) \n", + "\n", + "def Membership(x):\n", + " print(\"Membership Operator\")\n", + " print('A'not in x)\n", + " print(\"red\" in x)\n", + "Membership(\"Applesarered\")\n", + " " + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Plotting the Equations.ipynb b/Plotting the Equations.ipynb new file mode 100644 index 0000000..2523a7e --- /dev/null +++ b/Plotting the Equations.ipynb @@ -0,0 +1,232 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#y={1 x<10 0 else \n", + "import matplotlib.pyplot as plt\n", + "x=[num for num in range(0,20)]\n", + "y=[]\n", + "for i in x:\n", + " if i>=10:\n", + " y.append(1)\n", + " else:\n", + " y.append(0)\n", + "plt.plot(x,y)\n", + "plt.xlabel(\"x axis\")\n", + "plt.ylabel(\"y axis\")\n", + "plt.title(\"y=1 if x>=10 else y=0\")\n", + "plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#y=eax for different values of a.\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "num=[num for num in range(0,10)]\n", + "a=2 #constant value\n", + "x=np.array(num)*2\n", + "y=np.exp(x)\n", + "plt.plot(x,y)\n", + "plt.xlabel(\"x axis\")\n", + "plt.ylabel(\"y axis\")\n", + "plt.title(\"y=e**ax\")\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#y=7x2+3x+10 for 2≤x≤5\n", + "import matplotlib.pyplot as plt\n", + "x=[x for x in range(2,6)]\n", + "y=[]\n", + "for i in x:\n", + " y.append(7*pow(i,2)+3*i+10)\n", + "plt.plot(x,y)\n", + "plt.xlabel('x axis')\n", + "plt.ylabel('y axis')\n", + "plt.title('y=7x^2+3x+10')\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#y=11+e-x\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "x=[x for x in range(0,20)]\n", + "p=np.array(x)\n", + "p=1+np.exp(-p)\n", + "y=1/p\n", + "plt.plot(x,y)\n", + "plt.xlabel('x axis')\n", + "plt.ylabel('y axis')\n", + "plt.show()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "5. y=1-e-ax1+e-ax for different values of a.\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "num=[num for num in range(0,21)]\n", + "num=np.array(num)\n", + "a=2\n", + "p=1-np.exp(-num*a)\n", + "q=1+np.exp(-num*a)\n", + "y=p/q\n", + "plt.plot(num,y)\n", + "plt.xlabel('x axis')\n", + "plt.ylabel('y axis')\n", + "plt.show()\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "in_array : [0. 0.28559933 0.57119866 0.856798 1.14239733 1.42799666\n", + " 1.71359599 1.99919533 2.28479466 2.57039399 2.85599332 3.14159265]\n", + "\n", + "out_array : [ 0.00000000e+00 5.87252986e-01 1.28532195e+00 2.30812304e+00\n", + " 4.37938913e+00 1.39103055e+01 -1.39103055e+01 -4.37938913e+00\n", + " -2.30812304e+00 -1.28532195e+00 -5.87252986e-01 -2.44929360e-16]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#y=tan hx \n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "in_array = np.linspace(0, np.pi, 12)\n", + "h=2\n", + "out_array =h*np.tan(in_array)\n", + "print(\"in_array : \", in_array)\n", + "print(\"\\nout_array : \", out_array)\n", + "# red for numpy.tan()\n", + "plt.plot(in_array, out_array, color='red', marker=\"o\")\n", + "plt.title(\"numpy.tan()\")\n", + "plt.xlabel(\"X\")\n", + "plt.ylabel(\"Y\")\n", + "plt.show()\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Single Layer Perceptron(AND,ANDNOT,OR) .ipynb b/Single Layer Perceptron(AND,ANDNOT,OR) .ipynb new file mode 100644 index 0000000..b066d81 --- /dev/null +++ b/Single Layer Perceptron(AND,ANDNOT,OR) .ipynb @@ -0,0 +1,296 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter new theta:0.2\n", + "Enter new alpha:1\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "The final weight matrix is:\n", + "[[1]\n", + " [1]]\n", + "The final output is:\n", + "[[ 1.]\n", + " [ 1.]\n", + " [ 1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[1],[1],[1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"Enter new theta:\"))\n", + "alpha=float(input(\"Enter new alpha:\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all(): \n", + " found=1\n", + "print(\"The final weight matrix is:\")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter new theta:0.2\n", + "Enter new alpha:1\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[ 0.]\n", + " [-1.]\n", + " [ 0.]\n", + " [ 0.]]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[ 0.]\n", + " [-1.]\n", + " [-1.]\n", + " [ 1.]]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "The final weight matrix is \n", + "[[ 1]\n", + " [-1]]\n", + "The final output is:\n", + "[[-1.]\n", + " [ 1.]\n", + " [-1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[-1],[1],[-1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"Enter new theta:\"))\n", + "alpha=float(input(\"Enter new alpha:\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all():\n", + " found=1\n", + "print(\"The final weight matrix is \")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter new theta0.2\n", + "enter new alpha1\n", + "MODEL IS NOT TRAINED\n", + "The value of output is\n", + "[[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "NO UPDATION REQUIRED\n", + "[-1.]\n", + "NO UPDATION REQUIRED\n", + "[1.]\n", + "The final weight matrix is \n", + "[[1]\n", + " [1]]\n", + "The final output is:\n", + "[[ 1.]\n", + " [ 1.]\n", + " [ 1.]\n", + " [-1.]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "x=np.array([[1,1],[1,-1],[-1,1],[-1,-1]])\n", + "t=np.array([[1],[1],[1],[-1]])\n", + "w=np.array([[0],[0]])\n", + "b=0\n", + "theta=float(input(\"enter new theta\"))\n", + "alpha=float(input(\"enter new alpha\"))\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " yin=x[i][0]*w[0]+x[i][1]*w[1]\n", + " yin = yin+b\n", + " if(yin>theta):\n", + " y[i] = 1\n", + " elif(yin<=theta and yin>=-theta):\n", + " y[i]=0\n", + " else:\n", + " y[i]=-1\n", + " if (y[i]==t[i]):\n", + " print(\"NO UPDATION REQUIRED\")\n", + " print(y[i])\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " print(\"The value of output is\")\n", + " print(y)\n", + " w[0]=w[0]+alpha*x[i][0]*t[i]\n", + " w[1]=w[1]+alpha*x[i][1]*t[i]\n", + " b = b+alpha*t[i]\n", + " if(i<3):\n", + " i=i+1\n", + " else:\n", + " i=0\n", + " if(y==t).all():\n", + " found=1\n", + "print(\"The final weight matrix is \")\n", + "print(w)\n", + "print(\"The final output is:\")\n", + "print(y)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From dbede8c7d0083a28b3923a34cb23086ef0cd8bdf Mon Sep 17 00:00:00 2001 From: Yukta03 <72689246+Yukta03@users.noreply.github.com> Date: Sun, 6 Dec 2020 00:48:12 +0530 Subject: [PATCH 5/6] Add files via upload --- MP Neuron(AND,OR,AND-NOT) (1).ipynb | 318 ++++++++++++++++++++++++++++ 1 file changed, 318 insertions(+) create mode 100644 MP Neuron(AND,OR,AND-NOT) (1).ipynb diff --git a/MP Neuron(AND,OR,AND-NOT) (1).ipynb b/MP Neuron(AND,OR,AND-NOT) (1).ipynb new file mode 100644 index 0000000..b30eef0 --- /dev/null +++ b/MP Neuron(AND,OR,AND-NOT) (1).ipynb @@ -0,0 +1,318 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# MP Neuron for Logic Gates (AND,OR,AND-NOT)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 2\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 2\n" + ] + } + ], + "source": [ + "#AND\n", + "\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[0],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " \t#print(yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1\n", + " i=i+1\n", + " else:\n", + " \ty[i]=0\n", + " \ti=i+1\n", + " \n", + " if (y==t).all():\n", + " \tprint(\"MODEL IS TRAINED \")\n", + " \tprint(\"\\nOutput : \\n\",y)\n", + " \tprint(\"\\nweights : \",w,\"\\n\")\n", + " \tprint(\"theta : \",theta)\n", + " \tfound=1\n", + " else:\n", + " \t print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " \tw1=int(input(\"Enter Weight : \"))\n", + " \tw=np.append(w,w1)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [1.]\n", + " [1.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "#OR\n", + "\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[1],[1],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1\n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " #print(\"y\",y)\n", + " #print(\"t\",t)\n", + " if(y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " \tprint(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : -1\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[0.]\n", + " [1.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [ 1. -1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "#NAND\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[0],[1],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " \t#print(yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1\n", + " i=i+1\n", + " \telse:\n", + " y[i]=0\n", + " i=i+1\n", + " #print(\"y\",y)\n", + " #print(\"t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else: \n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 0]\n", + "y [[0.]\n", + " [0.]]\n", + "t [[1]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 0\n", + "Enter Weight : -1\n", + "[[ 0]\n", + " [-1]]\n", + "y [[1.]\n", + " [0.]]\n", + "t [[1]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]]\n", + "\n", + "weights : -1 \n", + "\n", + "theta : 0\n" + ] + } + ], + "source": [ + "#NOT\n", + "\n", + "import numpy as np\n", + "x=np.array([[0],[1]])\n", + "t=np.array([[1],[0]])\n", + "w=np.array([0])\n", + "theta=1\n", + "yin=np.zeros(shape=(2,1))\n", + "y=np.zeros(shape=(2,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(yin)\n", + " while(i<2):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " \n", + " \t#if(i==4):\n", + " \t#break\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"y\",y)\n", + " print(\"t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(1)):\n", + " w=int(input(\"Enter Weight : \"))\n", + "\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 5c868ba9ec5ebeab814ae356053d7934c5f6290a Mon Sep 17 00:00:00 2001 From: Yukta03 <72689246+Yukta03@users.noreply.github.com> Date: Sun, 6 Dec 2020 09:09:09 +0530 Subject: [PATCH 6/6] Add files via upload --- Linear Separability.ipynb | 98 ++++++ Numpy Neuron(AND,OR,NOT,NAND).ipynb | 456 +++++++++++++++++++++++++++ Use of matplotlib.ipynb | 461 ++++++++++++++++++++++++++++ 3 files changed, 1015 insertions(+) create mode 100644 Linear Separability.ipynb create mode 100644 Numpy Neuron(AND,OR,NOT,NAND).ipynb create mode 100644 Use of matplotlib.ipynb diff --git a/Linear Separability.ipynb b/Linear Separability.ipynb new file mode 100644 index 0000000..56ba978 --- /dev/null +++ b/Linear Separability.ipynb @@ -0,0 +1,98 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#for OR\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt \n", + "x = np.array([0,1])\n", + "y = np.array([0,1])\n", + "plt.scatter(x,y,c='red')\n", + "x = np.array([1,0])\n", + "y = np.array([0,1])\n", + "plt.scatter(x,y,c=\"blue\")\n", + "plt.xlabel('Input 1')\n", + "plt.ylabel('Input 2')\n", + "w=-1\n", + "b=1.5\n", + "x = np.linspace(0,1.5)\n", + "plt.plot(x,w*x+b,c='black')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#FOR ALL\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "x = np.array([0,1,0])\n", + "y = np.array([0,0,1])\n", + "plt.scatter(x,y,c='red')\n", + "plt.scatter(1,1,c=\"blue\")\n", + "plt.xlabel('Input 1')\n", + "plt.ylabel('Input 2')\n", + "w=-1\n", + "b=1.5\n", + "x = np.linspace(0,1.5)\n", + "plt.plot(x,w*x+b,c='black')\n", + "plt.show()\n" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Numpy Neuron(AND,OR,NOT,NAND).ipynb b/Numpy Neuron(AND,OR,NOT,NAND).ipynb new file mode 100644 index 0000000..857b506 --- /dev/null +++ b/Numpy Neuron(AND,OR,NOT,NAND).ipynb @@ -0,0 +1,456 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 2\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "Y is initiallised [2. 1. 1. 0.]\n", + "Calculated y [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 2\n" + ] + } + ], + "source": [ + "#AND\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[0],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[0]\n", + " [1]\n", + " [0]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : -1\n", + "Y is initiallised [ 0. 1. -1. 0.]\n", + "Calculated y [[0.]\n", + " [1.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[0]\n", + " [1]\n", + " [0]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[0.]\n", + " [1.]\n", + " [0.]\n", + " [0.]]\n", + "\n", + "weights : [ 1. -1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "#NAND\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[0],[1],[0],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[0]\n", + " [0]\n", + " [0]\n", + " [1]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 0\n", + "Enter Weight : -1\n", + "Enter Weight : -1\n", + "Y is initiallised [-2. -1. -1. 0.]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [1.]]\n", + "Expected Target t [[0]\n", + " [0]\n", + " [0]\n", + " [1]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[0.]\n", + " [0.]\n", + " [0.]\n", + " [1.]]\n", + "\n", + "weights : [-1. -1.] \n", + "\n", + "theta : 0\n" + ] + } + ], + "source": [ + "#NOR\n", + "\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[0],[0],[0],[1]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 0]\n", + "y [[0.]\n", + " [0.]]\n", + "t [[1]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 0\n", + "Enter Weight : -1\n", + "[[ 0]\n", + " [-1]]\n", + "y [[1.]\n", + " [0.]]\n", + "t [[1]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [0.]]\n", + "\n", + "weights : -1 \n", + "\n", + "theta : 0\n" + ] + } + ], + "source": [ + "#NOT\n", + "import numpy as np\n", + "x=np.array([[0],[1]])\n", + "t=np.array([[1],[0]])\n", + "w=np.array([0])\n", + "theta=1\n", + "yin=np.zeros(shape=(2,1))\n", + "y=np.zeros(shape=(2,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(yin)\n", + " while(i<2):\n", + "\t if yin[i]>=theta:\n", + "\t y[i]=1 \n", + "\t i=i+1\n", + "\n", + "\t#if(i==4):\n", + "\t#break\n", + "\t else:\n", + "\t y[i]=0\n", + "\t i=i+1\n", + " print(\"y\",y)\n", + " print(\"t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + "\t print(\"MODEL IS NOT TRAINED\")\n", + "\t w=np.zeros(shape=(0,0))\n", + "\t theta=int(input(\"Enter New Theta : \"))\n", + "\t for k in range(int(1)):\n", + "\t w=int(input(\"Enter Weight : \"))\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Y is initiallised [[0]\n", + " [0]\n", + " [0]\n", + " [0]]\n", + "Calculated y [[0.]\n", + " [0.]\n", + " [0.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "MODEL IS NOT TRAINED\n", + "Enter New Theta : 1\n", + "Enter Weight : 1\n", + "Enter Weight : 1\n", + "Y is initiallised [2. 1. 1. 0.]\n", + "Calculated y [[1.]\n", + " [1.]\n", + " [1.]\n", + " [0.]]\n", + "Expected Target t [[1]\n", + " [1]\n", + " [1]\n", + " [0]]\n", + "MODEL IS TRAINED \n", + "\n", + "Output : \n", + " [[1.]\n", + " [1.]\n", + " [1.]\n", + " [0.]]\n", + "\n", + "weights : [1. 1.] \n", + "\n", + "theta : 1\n" + ] + } + ], + "source": [ + "#OR\n", + "import numpy as np\n", + "x=np.array([[1,1],[1,0],[0,1],[0,0]])\n", + "t=np.array([[1],[1],[1],[0]])\n", + "w=np.array([[0],[0]])\n", + "theta=1\n", + "yin=np.zeros(shape=(4,1))\n", + "y=np.zeros(shape=(4,1))\n", + "yin=np.dot(x,w)\n", + "i=0\n", + "found=0\n", + "while(found==0):\n", + " i=0\n", + " yin=np.dot(x,w)\n", + " print(\"Y is initiallised\",yin)\n", + " while(i<4):\n", + " if yin[i]>=theta:\n", + " y[i]=1 \n", + " i=i+1\n", + " else:\n", + " y[i]=0\n", + " i=i+1\n", + " print(\"Calculated y\",y)\n", + " print(\"Expected Target t\",t)\n", + " if (y==t).all():\n", + " print(\"MODEL IS TRAINED \")\n", + " print(\"\\nOutput : \\n\",y)\n", + " print(\"\\nweights : \",w,\"\\n\")\n", + " print(\"theta : \",theta)\n", + " found=1\n", + " else:\n", + " print(\"MODEL IS NOT TRAINED\")\n", + " w=np.zeros(shape=(0,0))\n", + " theta=int(input(\"Enter New Theta : \"))\n", + " for k in range(int(2)):\n", + " w1=int(input(\"Enter Weight : \"))\n", + " w=np.append(w,w1)" + ] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Use of matplotlib.ipynb b/Use of matplotlib.ipynb new file mode 100644 index 0000000..6276aa2 --- /dev/null +++ b/Use of matplotlib.ipynb @@ -0,0 +1,461 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "\n", + "#plotting to our canvas\n", + "plt.plot([1,2,3],[4,5,1])\n", + "#showing what a plotted\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "[,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "plt.plot([1,2,3,4],[1,4,9,16],'r1',label='line1') #draw red dots \n", + "plt.plot([1,2,3,4],[1,2,3,4],linewidth=5,label='line2') #thickness of line\n", + "plt.plot([5,6,7,8,9],[5,6,7,8,9],'ro-',label='line3') #points will b like o\n", + "plt.plot([5,6,7,8,9],[6,6,6,6,6],color='red',linestyle=\"-\",marker='o',markersize='5',markerfacecolor='g') \n", + "#[xmin,xmax,ymin,ymax]\n", + "plt.axis([0,10,0,20])\n", + "plt.show()\n", + "\n", + "t=np.arange(0,5,.2)\n", + "plt.plot(t,t,'r--',t,t**2,'bo',t,t**4,'c^') #c is the color and ^ is the shape" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x=[5,2,7]\n", + "y=[2,16,4]\n", + "plt.plot(x,y) #plt.plot(x,y,linewidth=5,color='red')\n", + "plt.title('Info')\n", + "plt.ylabel('Y axis')\n", + "plt.xlabel('X axis')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x=[5,8,10]\n", + "y=[12,16,6]\n", + "x2=[6,9,11]\n", + "y2=[6,15,7]\n", + "plt.plot(x,y,'g',label='line one',linewidth=5)\n", + "plt.plot(x2,y2,'c',label='line two',linewidth=5)\n", + "plt.title(\"Epic Info\")\n", + "plt.ylabel('Y axis')\n", + "plt.xlabel('X axis')\n", + "plt.legend() #give the labels\n", + "plt.grid(True,color='k')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# bargraph: compare two entities\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.bar([0.25,1.25,2.25,3.25,4.25],[50,40,70,80,20],label=\"BMW\",width=.3)\n", + "plt.bar([.75,1.75,2.75,3.75,4.75],[80,20,20,50,60],label=\"Audi\",color='c',width=.5)\n", + "plt.legend()\n", + "plt.xlabel('Days')\n", + "plt.ylabel('Distance (kms)')\n", + "plt.title('Information')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# histogram: show distribution and used to plot frequency" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "population_age=[44,22,77,44,22,99,55,22,77,99,44,22,77,55,55]\n", + "bins= np.arange(1,100) #we give the range of x axis and it automatically taake y axis\n", + "plt.hist(population_age,bins,histtype='bar',rwidth=0.8)\n", + "plt.xlabel('age grp')\n", + "plt.ylabel('Number of people')\n", + "plt.title('Histogram')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# scatter plot: plot points " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x=[1,1.5,2,2.5,3,3.5,3.6]\n", + "y=[7.5,8,8.5,9,9.5,10,10.5]\n", + "\n", + "x1=[8,8.5,9,9.5,10,10.5,11]\n", + "y1=[3,3.5,3.7,4,4.5,5,5.2]\n", + "\n", + "plt.scatter(x,y,label='high income low saving',color='r')\n", + "plt.scatter(x1,y1,label='low income high saving',color='b')\n", + "plt.xlabel('saving*100')\n", + "plt.ylabel('income*1000')\n", + "plt.title('Scatter Plot')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# area plot" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl8VPXZ///XNVlIIIQEsod9CUsWlgKiKCIoRYW03NUqFK0rsRVFrYptb0vcqv1pbbX8KnpbRKpCEVwSERGhgoCAEJawhbApJIEkQBYSsn++f8wQQ0gghMycJHM9H488mMw5M+eao/m852zXEWMMSiml3JfN6gKUUkpZS4NAKaXcnAaBUkq5OQ0CpZRycxoESinl5jQIlFLKzWkQKHWJRORrEbmvCd5ntIgcbYqalLocGgTKLYhIooi8Z3UdjSUi80TkeavrUK2TBoFSSrk5DQLVqojITBHJEJFCEUkTkbEiMh74A3CbiJwWke2Oee8WkT2OeQ+KSEKt9/qZiGwTkQIROeB4n9rLCxeRHSLyeD31HBaR34vIbhE5JSLviIhPPfP2d+x2yhORXSIS73h+GvAr4ElH/cmXt5aUOpen1QUo1VREpC8wHRhmjMkUke6AhzHmgIj8GehtjJla4yXZwATgIDAKWCYi3xljUkRkODAfuAVYCYQD7WstrzvwJfCKMeatC5T2K+CnQBGQDPyv46fme3k5ps0FxgFXA5+KyFBjzFsichVw1BhzzuuUagq6RaBak0qgDTBARLyMMYeNMQfqm9kYs9QYc8DYrcY+qF/jmHwvMNcYs8IYU2WMyTDG7K3x8gHA18Csi4QAwGxjzBFjzEngBWByHfOMAPyAl4wxZcaYVcBn9cyrVJPSIFCthjFmP/AIkAhki8hCEYmob34RuVFENojISRHJA24CghyTuwD1hgj2b/kZwOIGlHakxuPvgbpqigCOGGOqas0b2YD3V+qyaBCoVsUY84Ex5mqgG2CAv5ydVHM+EWkDLAFeAUKNMQHA54A4ZjkC9LrAohKBXOADEfG4SFldajzuCmTWMU8m0EVEbLXmzairfqWakgaBajVEpK+IjHEM8iXAGey7iwCOA91rDLTe2Hcj5QAVInIj9n3zZ/0LuNtxsNkmIpEi0q/G9HLgVqAd8O9aA3htD4pIZxHpiP2g9X/qmGcj9mMIT4qIl4iMBiYCC2vU37MBq0GpS6ZBoFqTNsBL2L+pHwNCsA+8AB86/j0hIinGmELgYWARcAqYAiSdfSNjzCbgbuBvQD6wGvtWBjXmKQP+x7GcuRcIgw+wH3846Pg573oAx3vFAzc66v8ncGeN4xL/wn7sI09EPmnIylCqoURvTKOU84jIYeA+Y8xXVteiVH10i0AppdycBoFSSrk53TWklFJuTrcIlFLKzbWIFhNBQUGme/fuVpehlFItypYtW3KNMcEXm69FBEH37t3ZvHmz1WUopVSLIiLfN2Q+3TWklFJuToNAKaXcnAaBUkq5uRZxjEAp5T7Ky8s5evQoJSUlVpfSYvj4+NC5c2e8vLwa9XoNAqVUs3L06FHat29P9+7dEZGLv8DNGWM4ceIER48epUePHo16D901pJRqVkpKSujUqZOGQAOJCJ06dbqsLSgNAqVUs6MhcGkud31pECillJvTIFBKqYsYPXp0k1/UmpSUxEsvvXTBecrLy5t0mfXRg8VKKWWB+Ph44uPj65xWUFBAZmYmfn5+dO7c2em1aBAopZqlr+Vrpy9jtBl93nNFRUX88pe/5OjRo1RWVvL000+fM/3LL79k1qxZlJaW0qtXL9555x38/PzYsmULjz32GKdPnyYoKIh58+YRHh7O6NGjGTRoEJs2baKgoIC5c+cyfPhw5s2bx+bNm5k9ezZ33XUX/v7+bNy4kczMTKZPn87YsWNp27Ytv/3tb1m9ejU9evSgqqqKe+65h1tuuaVJ14PuGlJKqRq++OILIiIi2L59Ozt37mT8+PHV03Jzc3n++ef56quvSElJYejQobz66quUl5fz0EMPsXjxYrZs2cI999zDH//4x+rXFRUVsX79ev75z39yzz33nLfM8vJy9u3bxz/+8Q/++te/Mnv2bACWLVvG4cOHSU1N5e233+bbb791ymfWLQKllKohNjaWxx9/nJkzZzJhwgSuueaa6mkbNmxg9+7djBw5EoCysjKuvPJK0tLS2LlzJzfccAMAlZWVhIeHV79u8uTJAIwaNYqCggLy8vKqX5+WlkZ+fj4jR47EZrPRs2dPTp48CcB3333Hrbfeis1mIywsjOuuu84pn1mDQCmlaoiKimLLli18/vnn/P73v2fcuHHV04wx3HDDDSxYsOCc16SmphIdHV3vN/bap3cWFRWRlZVFXl4ehYWFAHh7e5+znJr/OpvuGlJKqRoyMzNp27YtU6dO5fHHHyclJaV62ogRI1i3bh379+8HoLi4mH379tG3b19ycnKqg6C8vJxdu3ZVv+4///kPYD++4OvrS1ZWVoMuABs2bBhLliyhqqqK48eP8/XXXzfhJ/2RbhEopZqlug7kukJqaipPPPEENpsNLy8v3njjDR5//HEAgoODmTdvHpMnT6a0tBSA559/nqioKBYvXszDDz9Mfn4+FRUVPPLII0RHRwPQrl07hgwZQn5+Pn/6058aXMtNN93Etm3biImJISoqiiuuuIIOHTo0+WduEfcsHjp0qNEb06jm5OTJk3z++eekpaUxdepU+vbta3VJrcaePXvo37+/1WU0iaKiIsaMGcODDz7IgAEDLvn1YWFhBAQE4Ofnx4kTJxg+fDjr1q0jLCzsvHnrWm8issUYM/Riy9EtAqUaaN++fSQlJZGUlMT69euprKwE7N8Ir732WhISEvjFL35xzr5e5Z6KiorIzMys3jq4HBMmTCAvL4+ysjKefvrpOkPgcmkQKFWPyspK1q1bR1JSEsnJyezbt6/eeVevXs3q1asJDg7mrrvuYtq0afTu3duF1armoGYAnPXmm29e1ns667hATRoEStVQUFDAF198QVJSEsuWLas+ja+hcnJyePnll3nllVcYM2YMCQkJ/PznP290n3jVMhQXF5OZmVl9WmhLo0Gg3N6hQ4dITk4mKSmJNWvWNEl/F2MMK1euZOXKlYSGhnLPPfdw//33N7pfvGqeWnoAnOW000dFpIuI/FdE9ojILhGZ4Xg+UUQyRGSb4+cmZ9WgVF2qqqrYsGEDf/jDH4iNjaVnz57MmDGDlStXOqXJ1/Hjx3nxxRfp1asX48eP5+OPP77s/cbKWmfOnOHAgQPs3r27xYcAOHeLoAL4nTEmRUTaA1tEZIVj2t+MMa84cdlKnaOoqIgVK1aQlJTE0qVLyc7OdnkNxhiWL1/O8uXLiYiI4N577+W+++6ja9euLq9FNc6ZM2fIzMzk1KlTVpfSpJy2RWCMyTLGpDgeFwJ7gEhnLU+p2jIyMpgzZw4333wzQUFBTJo0iXfeeceSEKgtMzOT5557jh49ejBhwgSSk5Orz0JSzc/ZLYBdu3adFwIffPDBOReHzZgxo/pq4ZbCJccIRKQ7MBjYCIwEpovIncBm7FsN58WriEwDpgH6jUk1WEpKSvVZPjWvCG2uqqqqWLp0KUuXLqVLly7cd9993HvvvURG6nem5uDMmTNkZWVd8KSBhQsXctNNN+Hj4wPAa6+95qrymozTLygTET9gNfCCMeYjEQkFcgEDPAeEG2POb8dXg15QpupTUlLCqlWrSE5O5rPPPuPo0aNWl3TZPDw8mDBhAgkJCfz0pz/FZnOvTjBnL4wSF5w2aUaPrvP5d955h7///e+cOXOGmJgYZs6cycsvv8zu3bspKSlh7NixJCQksHDhQl577TW6detGQEAAc+bMIT4+nvnz51NcXMyMGTMYOHAgO3bsICQkhFdeeQUfHx927drF888/j6+vLwMHDmT9+vXVbShqCgsLa/D9CC7ngjKn/h8mIl7AEuB9Y8xHAMaY48aYSmNMFfB/wHBn1qBan+zsbObOncukSZMICgri5ptvZs6cOa0iBMB+/cKnn37KTTfdRK9evfjzn//MsWPHrC7LLZSUlLBixQrmzp3Lm2++yQcffIDNZuOLL77gN7/5DfPnz2fBggWkpKSQnp7O7bffTnBwMHPmzGHOnDnnvd+RI0e49dZbWbRoEe3bt2fVqlUAPPvsszz11FPMnTu3WQS903YNib3d3r+APcaYV2s8H26MyXL8OgnY6awaVOuxc+fO6lM8N23aRFVVldUlucThw4f54x//SGJiIvHx8TzwwAOMHTtWb+7exEpKSsjKyuLEiROsWLGCvXv3cueddwJQWlpKx44d+eqrr/j444+prKwkNzeXQ4cO0adPnwu+b0RERHX7kX79+pGVlUVhYSHFxcUMHDgQgPHjx7N27VrnfsCLcOYxgpHAHUCqiGxzPPcHYLKIDMK+a+gwkODEGlQLVV5ezurVq0lOTiY5OZlDhw5ZXZKlysvLWbJkCUuWLKF3797cf//93H333QQHB1tdWotWWlpaHQA1Wz/ffPPNTJ8+vXq+jIwMpk+fzrvvvou/vz+JiYnVTecupOaFhDabjcrKSpe1lr4UzjxraK0xRowxccaYQY6fz40xdxhjYh3Px9fYOlBu7uTJk7z//vvcdtttBAcHc8MNN/D666+7fQjUtn//fmbOnEnnzp2ZPHmyS1oQtFY7d+4kNzf3nMF52LBhrFq1qvoAcX5+PseOHcPX17e6+VvN+w60bduWoqKiBi/T39+ftm3bkpqaCthbU1tNryxWlkpPT69u5LZu3To9hfISlJWVsXDhQhYuXEjfvn2ZNm0ad911Fx07drS6tCZR34Hcy1FaWsqxY8eqB/+6vp337NmTBx54gOnTp2OMwdPTkyeffJKoqChuu+02IiMjiYuLq55/0qRJzJgxg6CgoDqPE9Tl6aef5oUXXsDX15chQ4bg5+fXZJ+xMbQNtXKps43czu7ySUtLs7qkVsXHx4dbbrmFhIQErr76aqvLaRRntKEuKysjKyvrvG//VikuLqZt27YAzJs3j9zc3Op7HtTkqrOGdItAOV1BQQHLly+vbuR24sQJq0tqtUpKSnjvvfd47733iI6OZtq0adx5550EBARYXZolmlsAnLV27VrmzZtXfW/jWbNmWVqPbhEopzh8+HD1t/7Vq1dTVlZmdUluy9fXl9tuu42EhARGjBhhdTkX1RRbBGVlZRw7doycnJxmFQCXSrcIVItijGHTpk3VV/WePRCmrHfmzBnmzZvHvHnziIuLIyEhgalTp+Lv7291aU2utQSAq2kQqEYrLi5mxYoVJCcns3TpUr3oqQXYsWMHDz74IE8++SSTJ08mISGBoUMv+oWx2SsvL+fYsWNkZ2drADSCBoG6JJmZmdW7fFauXHlOsy3VchQVFfH222/z9ttvM2TIEBISEpgyZYrlZ69cqrMBkJOT4zYXGTqDBoG6qK1bt57TyE2/cbUuKSkpJCQk8Pjjj/OrX/2KhIQEBg0aZHVZF6QB0LSsb3Khmp3S0lKWLVvGb3/7W7p27cqQIUNITExky5YtGgKtWGFhIXPmzGHw4MFcccUVvPPOOxQXF1td1jnKy8s5evQoqampHD9+vFmHQHx8fJ03rbnnngv22LREq98iSExMJCMjw+oyWoycnBxWrlzJ6dOnrS5FWWjTpk1s2rSJRx99lDvuuIOEhARiYmIsq6eioqL6GEBzHvzPutCFkXPnznVhJQ3T6oPgww8/ZPfu3VaXoVSLlJ+fz+zZs5k9ezYjR44kISGBW2+9tbr3vlPVaKznCXR2/DSlzd99d95z8+fPx9vbm9tvv51XX32V9PR03njjDTZt2kRycjJXX30177zzDsYYrr76ah566CEARo0axZQpU9iwYQOPPPJI9fuVlJTwxBNPMGbMGCZNmsSoUaNYs2YNW7Zs4a233iIgIIADBw7Qr18/nnvuOUSEdevW8be//Y2QkBBGjBjBwYMH+eyzz5r40/9Idw0ppRpk3bp13HnnnURGRvLoo4+yd+9epy3Lyns6Dx48mG3b7H0y9+zZQ3FxMRUVFWzfvp2uXbvyj3/8gzfeeIP333+f3bt3V/d6OnPmDL169WLevHnVx1iKi4t57LHHGD9+PJMmTTpvWWlpaTz22GMsWrSIzMxMtm/fTmlpKX/+85957bXX+Oijj8jJyXH6Z9YgUEpdkpMnT/L3v/+d/v37M3r0aBYsWNBkFwzm5eWRl5dn6XUo/fv3Z8+ePRQVFeHl5UVsbCy7d+9m69at+Pn58ZOf/ITAwEA8PT0ZP348W7duBew3FBozZsw57/X4448zceJEbr755jqXFR0dTWhoKDabjaioKDIzMzl8+DCRkZHVd6mbPHmycz8wGgRKqcuwevVqpkyZQmRkJE888QTp6emNep/8/HyeeeYZunfvTn5+vqXNBz09PYmIiCA5OZm4uDgGDx7Mli1byMjIICwsrN7XeXt74+Hhcc5zcXFxrF+/vt6TLLy9vasfn21TbQUNAqXUZcvNzeWVV16hb9++XH/99Xz44YeUl5df9HUFBQU899xz9OjRg8TERPLz811Q7cUNHjyY9957j8GDBzNo0CCWLFlCVFQUsbGxpKSkkJeXR2VlJcuXL2fIkCH1vs8DDzxAhw4d+Mtf/tLgZXfr1o2MjAwyMzMB6ryFZVNr9QeLlVKuY4xh5cqVrFy5ktDQUO6++26mTZtGjx49zpmvsLCQ119/nVdffbXeG8PXdSDXVQYNGsTcuXOJi4vD19eXNm3aMGjQIIKCgnjwwQd54IEHMMYwcuRIrr322gu+1+9+9zueffZZXn/9dR5++OGLLtvHx4eZM2fy8MMPExIS4pIusq2+6Vx0dLSeNaSUhUSEcePGkZCQwHXXXccbb7zBX//613q70C5btoygoCAXV9m8nG1THRoayosvvkifPn149NFHL/gabTqnlGq2jDEsX76c5cuXY7PZWsR1AFb75JNPqk8XHTZsGAkJzr2jrwaBUsplNAQaZsqUKUyZMuWS2lBfDj1YrJRSbk6DQCml3JwGgVJKuTkNAqWUcnMaBEop1QAJCQmNPhV9xowZFBYWNnFFTUfPGlJKKSd77bXXrC7hgjQIlFLN0rBhw5y+jO/quHo5MzOThx9+mJiYGNLS0ujatSvPPPPMOfO89NJL7N69m5KSEsaOHUtCQgKbNm3iww8/5OWXXwZg48aNLF68mJdffpn4+Hjmz59PcXExM2bMYODAgezYsYOQkBBeeeUVfHx82LVrF88//zy+vr4MHDiQ9evXs3r1aqevA9BdQ0opdZ7vv/+eSZMmsWDBAtq1a8eHH354zvTf/OY3zJ8/nwULFpCSkkJ6ejrDhg3j0KFDnDp1CoDk5GQmTpx43nsfOXKEW2+9lUWLFtG+fXtWrVoFwLPPPstTTz3F3LlzsdlcOzRrECilVC2hoaEMHDgQgBtvvJHt27efM/2rr75i6tSpTJ06lYMHD3Lo0CFEhJtuuolly5ZRWFhIamoqV1111XnvHRERQd++fQHo168fWVlZFBYWUlxcXL3M8ePHO/kTnkt3DSmlVC1S4+5otX/PyMjgvffe491338Xf35/ExERKS0sBmDhxIo899hje3t6MHTsWT8/zh1gvL6/qx2dbT1vd881pWwQi0kVE/isie0Rkl4jMcDzfUURWiEi6499AZ9WglFKNcezYMXbs2AHA8uXLq7+pAxQVFeHr64ufnx8nTpzg22+/rZ4WHBxMUFAQc+fOZcKECQ1enr+/P23btq2+Ic+XX37ZRJ+kYZy5RVAB/M4YkyIi7YEtIrICuAtYaYx5SUSeAp4CZjqxDqVUC1TXgVxX6dGjB0uXLuXFF1+kS5cu3HLLLXzzzTcAREVFERUVxW233UZkZCRxcXHnvPbGG28kLy+Pnj17XtIyn376aV544QV8fX0ZMmQIfn5+TfZ5LsZpQWCMyQKyHI8LRWQPEAn8DBjtmO1d4Gs0CJRSzYiI8Pvf//6c5958883qx4mJifW+dtu2bfz85z8/57mkpCQAAgICzrnRzB133FH9uGfPnixYsACAefPmnddS2plccoxARLoDg4GNQKgjJDDGZIlISD2vmQZMA+jatasrylRKqctyxx134OvryyOPPHLJr127di3z5s2jsrKS8PBwZs2a5YQK6+b0IBARP2AJ8IgxpqD2QZj6GGPeAt4C+41pnFehUkr9KCIiotG3h/z3v//d6OWOGzeOcePGNfr1l8Opp4+KiBf2EHjfGPOR4+njIhLumB4OZDuzBqVUy6L3LLh0l3vWkTPPGhLgX8AeY8yrNSYlAb92PP418KmzalBKtTz79++noqLC6jJaDGMMJ06cwMfHp9Hv4cxdQyOBO4BUEdnmeO4PwEvAIhG5F/gBuNWJNSilWpjExEQSExPp3bu3y6+wbW7Kysoa1KzOx8fnsu5k5syzhtYC9R0QGOus5SqlWrZTp04xY8YMq8toFmbOnMlLL73k9OW4d9wqpZTSIFBKKXenvYaUqoevry/hQUFEBAYS0a4d4V5eRAARFRVEFBcTkZ9PqZcXfwkK4j8bNujZLqrF0iBQbqdNmzaEBwdXD/AR3t6EixBRXk7EmTNEFBQQnpNDYEEBHDli/7mAD/bt43979eLZkBAWbdhgeQMxpS6VBoFqNby9vQkLDiYiIIAIPz8i2rSxD/AVFfYBPj+fiBMn6JiXB0eP2n+ayIADB1h44ABP9+rFM8HBLN64UQNBtRgaBKrZ8/T0tA/wgYH2Ad7H59wBvqCAiJMn6XTyJJKRARkZltUafeAAiw4cILVPH57p1ImPNBBUC6BBoCzj4eFBaFAQER07EtG+vf0bvM1GRGWlfYAvLCTi5EmCc3ORrCzIyrK65AaLTU9ncXo626OieCYwkE82bdJAUM2WBoFqcjabjZCaA7yPz48DfElJ9QAfkpuL7fhxOH7c6pKdZuC+fXwEbI2K4pmAAD7dtMnqkpQ6jwaBajARIbhTJyI6dbIP8L6+9gG+qurHAf7UKUJzcvDIzoZsbSN11uB9+/gESOnXj0R/f5I1EFQzokGgqvn7+zOiTx86+/oS7uFhH+BLS6sH+LCcHDxzcyE31+pSW6whe/eSBHzXvz+J7drx+ebNVpeklAaBu+sWGcnEXr2IP32aa1NT8d6yxeqS3MKwPXtYCmyMjibR15cvNBCUhTQI3IyIMHzAACYGBRGfmUlserqlZ9m4uyt27WIZsCE6mlk+PnypQawsoEHgBtq2bcv1MTHEe3tzc1oaYbt2WV2SqmXErl0sB9bHxDDL25uvUlKsLkm5EQ2CVioiLIwJffoQf+YMY1NT8dGDky3CVTt3sgJYGxvLLE9PVm3danVJyg1oELQig/r2JT4sjInHj/OTvXuRY8esLkk10tWpqawE1sTFMctm4+tt2y76GqUaS4OgBWvTpg3XxcQQ37YtE/bvp0taGqSlWV2WakKjduzgv8DXAwcyC1izfbvVJalWSIOghQkOCuLmfv2YWFbGuF278NODi25h9PbtrAZWDRrErKoq1u7YYXVJqhXRIGgBBvTqRXznzkw8cYIRu3ZhW7vW6pKURcZs28YY4KvBg5lVUcH61FSrS1KtgAZBM+Tp6cmo2Fji27dn4qFD9DxwAA4csLos1Yxcv3Ur1wNfDhnCrLIyNuzcaXVJqgXTIGgmAgMCuHHAACYaw427dtFBzxZRDTAuJYVxwBc/+QmzSkrYpKcGq0bQILBQ727diO/enYl5eVy9cyee69dbXZJqocZv2cJ44POhQ5lVVMTmPXusLkm1IBoELuTh4cGV0dFMDAgg/sgR+h06BN9/b3VZqhW5afNmbgI+GzaMWYWFpOzda3VJqgXQIHCy9u3b89PoaCbabNy8Zw+d9GwP5QITvvuOCUDS8OEkFhSwVQNBXYAGgRN0jYxkYs+exBcVMTo1Fe8NG6wuSbmp+E2bmAh8Onw4iXl5bN+3z+qSVDOkQdAERIRhjkZuEzMzGaiN3FQzIsDPN23iZ8DHV1xB4smTpKanW12WakY0CBrJ19fX3sitTRsmaCM31QII8D8bNzIJWDJiBM/k5rJz/36ry1LNgAbBJQgPDWVCVBQTS0q4PjUV3+++s7okpS6ZALds2MAvgA+vvJJnsrPZrdepuDUNgosYGBVFfHg4E7OzGbpnD9KK76+r3IsAv/z2W24RYdGVV/LM8ePsPXjQ6rKUBTQIavH29ua62Fji27Vjwv79dN23D/QAm2rFbMZw+7ff8ksRFl51Fc9mZZF26JDVZSkX0iAAgjp1sjdyq6jgpzt3aiM35ZZsxjBl/Xpus9lYcNVVPJuZSfrhw1aXpVzAaUEgInOBCUC2MSbG8VwicD+Q45jtD8aYz51Vw4X079mT+C5dmHjyJFfu3Ilt3TorylCq2fGoqmLq+vVMttl4f+RInjt6lP164WOr5swtgnnAbGB+ref/Zox5xYnLrZOnpyfXxMQw0d+f+MOH6XXwIOj+UKXq5VFVxZ3r1jHFw4P3Ro7kuSNHOPjDD1aXpZzAaUFgjFkjIt2d9f4N9fMBA/jfDh24cdcuAvQuT0pdMs/KSu5at46pHh68e/XVPH/4MIePHrW6LNWEbBYsc7qI7BCRuSISWN9MIjJNRDaLyOacnJz6ZruoF3bvZvK33xJQUNDo91BK2QPh3rVr2XfsGG9dcw3dIiOtLkk1EVcHwRtAL2AQkAX8tb4ZjTFvGWOGGmOGBgcHu6o+pdRFeFVUcP8335B+/DhzrrmGLhERVpekLpNLg8AYc9wYU2mMqQL+DxjuyuUrpZqOV0UFCd98w/6cHP55zTV0Dg+3uiTVSC4NAhGp+X/KJEBvq6RUC+ddXs5vvvmG/SdOMHvUKCLDwqwuSV0ipwWBiCwAvgX6ishREbkX+P9EJFVEdgDXAY86a/lKKddqU1bGg2vWcODkSV4fNYrw0FCrS1INdNGzhkRkOvC+MebUpbyxMWZyHU//61LeQynV8rQpK+OhNWu4v00b3hw1ipf27uVYdrbVZakLaMgWQRjwnYgsEpHxIiLOLkop1fL5lJYyY80aDhYU8Oq11xKqJ300WxfdIjDG/K+aMY2IAAAQ0klEQVSIPA2MA+4GZovIIuBfxhhtWaiUuiDfkhIeXb2aBF9fPhw5kkKbFWett0w/6djRJctp0AVlxhgjIseAY0AFEAgsFpEVxpgnnVmgUqp1aHvmDL/WVi6X5qqrXLKYhhwjeBj4NZALvA08YYwpFxEbkA5oECilVAvWkC2CIOB/jDHndJ0yxlSJyATnlKWUUspVGnKM4E8XmLanactRSinlanrURiml3JwGgVJKuTkNAqWUcnMaBEop5eY0CJRSys1pECillJvTIFBKKTenQaCUUm5Og0AppdycBoFSSrm5BnUfVUqdryowkKI+fajStsrKScojIwlywXI0CJRqgKqAAPLi4tg3YADr+/Th027dWNOpk9VlqVZuZpcuvOSC5WgQKFWL8fcnLy6O9AED+LZPH5K6deO/QUEYvTmfaqU0CJRbM+3bkx8by/7oaL7t04fk7t35Sgd95WY0CJTbMO3aURAby4HoaDZERZHcrRvLQ0J00FduT4NAtUqmbVsKHYP+xqgolnbrxrKQECr1wK5S59EgUC2e8fXldEwMh6Kj2dSnD5/16MHnISGUe3hYXZpSLYIGgWpRjI8PRdHRHIqJ4bs+fVjaowdLQ0Mp1UFfqUbTIFDNlvH2pjg6msMxMWzu04fPe/bk07AwHfSVamIaBKpZMF5eFEdH80N0NJujoljWsyefhIdzRgd9pZxOg0C5nPHy4kz//vwQE8OWqCiW9+zJJ2FhFHp5WV2aUm5Jg0A5lfH0pKRfP47ExJDiGPQ/joggXwd9pZoNDQLVZIyHB6V9+3IkJoatffvyZa9efBQRwSkd9JVq1pwWBCIyF5gAZBtjYhzPdQT+A3QHDgO/NMacclYNynmMzUZpVBQZsbFs7duXFT17siQykhPe3laXppS6RM7cIpgHzAbm13juKWClMeYlEXnK8ftMJ9agmoCx2Sjr3ZuM2Fi29+3Lil69WBwZSU6bNlaXppRqAk4LAmPMGhHpXuvpnwGjHY/fBb5Gg6BZMSKU9+5NpmPQ/6pnT5Z06UKWDvpKtVquPkYQaozJAjDGZIlISH0zisg0YBpA165dXVSeezEilPfsSVZMDDv69WNl794s7tyZDB8fq0tTqtUTINjDizDjSUiZJyFFQlCe0DHbEJhhCDhcweBrbPA759fSbA8WG2PeAt4CGDp0qLG4nFahvEcPjsXGsqNfP1b16sXiLl34wdfX6rKUalUE6OThSRhehJZ5EFzkQVAedMyBjplVBByupEN6Oe3TyvEoKwfK632vtv2qXFKzq4PguIiEO7YGwoFsFy/fbZR368bx2FhS+/Xjv717s6RLFw62bWt1WUq1aB3PDvDlHgQX2QjOl3MH+P0V+O8tw6OkAqiwutwGc3UQJAG/Bl5y/Pupi5ffKlV06cLx2Fh29u/P1716sbhrV/a3a2d1WUq1GIEenoTiSWi5JyHFNoLyhU65EJhZReD39gG+fVoZXqdb1gDfUM48fXQB9gPDQSJyFJiFPQAWici9wA/Arc5afmtVERlJTmwsu/r35+s+fVjSpQt7/fysLkupZqmDhweheBFW4Ulwsf0bfKdcCMyqIuCHSgL2V+C/pxyvwtY5wDeUM88amlzPpLHOWmZrUxkRQU5sLLv792d1794s6dqVXe3bW12WUpbzs3kQLl6EVngQcsaDoHwh6AQEZFUR+EMVHQ6U02FvOd6nKoFKq8tt9prtwWJ3UxkWRm5sLHsGDGBNr1581K0b2/39rS5LKZdqZ7MRJl6EVnoScsaD4AKh0wkIzDIEHnF8g08rp02uDvBNSYPAAlUhIeTGxbG3f3++6d2bj7t1Y0uHDlaXpZTT+NYc4EvsA3zQCQg8bgj8oZIOByrosLccn+wqoNTxo1xFg8DJqoKCOBEXR9qAAax1DPqbAgKsLkupJtFGhDCbN2FVnoSU2AgusNHpJHQ8bgg4UknAgUr808pom6kDfHOmQdCEqjp25GRcHPsGDGBd79580q0b6zt2tLospS6ZtwihNi/HAO9B8OkfB/jAI1UEHKygw75y2v5QiQ7wLZ8GQSNVBQRwKi6O9Oho1vXuzafdu/ONDvqqmfOsOcCXOgb4U9Dp7AB/qNI+wB+uQEwZUGZ1ycoFNAgawHToQF5cHOn9+7O+Tx+Sunfnv0FBVpelVDUPINTDi1DjRWipB0GnhaBT9nYFHY/aB3j/9HL89usAr86nQVCLad+e/Lg49g8YwLeOQX9lUBBGxOrSlBuyASEeXoQZL4LLPAg5baNTHnQ6br+atcPhCjrsq8AvvRxb5YXbFShVH7cOAuPnR0FsLAcGDODbqCg+696d5cHBOugrpzvbcCzUeNrbFZy2EZQndMo2BGaa6n40fvvK8SjXAV45l9sEgWnblsK4OA4MGMBGx6D/RXAwlTab1aWpVuRsw7HQsw3Him0EnbJfzfpjw7EK2u8rw6NEB3jVPLT6IJj3yCN84ufH5yEhlHt4WF2OasE61u5Hkyd0dAzwgd9X4p9egX9aGZ7F7t2uQLU8rT4IXh44kN3FxVaXoZqxAEc/mtByT0LO2Af4oFz71awB31cQsL+C9mnaj0a1Xq0+CJT78rd5ECo1Go4V/NhwLPCHKjrst/ej8crXdgXKvWkQqBbHz+ZBmHja2xUUexB0tl1B1o/tCvz3ltHmpA7wSjWEBoFqNtrW0XAs6OSPDcfO9qNpk3N2gNerWZVqChoEyul8xEaYzT7Ah5Z4EFRo/wbf8bix94Q/WIn/3jJ8j2k/GqWsoEGgGs1bhDCbF2FVXvaGY4U2+zf4mv1o9pbjm6H9aJRqzjQI1Hm8RAjzcOyiKfWoHuA7Zp8d4O0dJdv9UIm9VYG2K1CqJdMgcCOeIoTYvAgz9gE+pNBG0CkIdPSj6XDQ3q6g3SHtR6OUO9EgaAU8sPejOdtwLPi02C92Og6BGZUEHqrEf1857Q5WYKvUAV4pdS4NgmbMhr0fTZjxJKTMk5Aie8vgjtmGjhmGgMMVdEivoN1+7UejlGo8DQILCBDk4UmY8bI3HCvysHeUzIaOGY5+NPsdDcfKdIBXSjmXBkET6+ThSRj2AT6oyEZwntApx9Fw7PtK/PfbL3byKNF2BUqp5kGDoIECHQN8SLmHveFY/o8DfOD3lfgfqKB9Whlep3WAV0q1LG4fBB1sHvarWc/2o8l3tAzOMnT4wd5wzH+PNhxTSrVerT4IhpT60q/Yk6B8+9WsAWcbjh2wNxzzPqX9aJRS7q3VB8FDD5yheLe2oVZKqfro7bmUUsrNaRAopZSb0yBQSik3Z8kxAhE5DBRiP0pbYYwZakUdSimlrD1YfJ0xJtfC5SullEJ3DSmllNuzKggM8KWIbBGRaXXNICLTRGSziGzOyclxcXlKKeU+rAqCkcaYIcCNwIMiMqr2DMaYt4wxQ40xQ4ODg11foVJKuQlLgsAYk+n4Nxv4GBhuRR1KKaUsCAIRaSci7c8+BsYBO11dh1JKKTsrzhoKBT4WkbPL/8AY84UFdSillMKCIDDGHAQGunq5Siml6qanjyqllJvTIFBKKTenQaCUUm5Og0AppdycBoFSSrk5DQKllHJzGgRKKeXmNAiUUsrNaRAopZSb0yBQSik3p0GglFJuToNAKaXcnAaBUkq5OQ0CpZRycxoESinl5jQIlFLKzWkQKKWUm9MgUEopN6dBoJRSbk6DQCml3JwGgVJKuTkNAqWUcnMaBEop5eY0CJRSys1pECillJvTIFBKKTenQaCUUm5Og0AppdycBoFSSrk5DQKllHJzlgSBiIwXkTQR2S8iT1lRg1JKKTuXB4GIeAD/P3AjMACYLCIDXF2HUkopO08Lljkc2G+MOQggIguBnwG7nbGwdtHtsPnoHjClVMvTpnMblyzHiiCIBI7U+P0ocEXtmURkGjDN8etpEUlr5PKCgNxGvtaZtK5Lo3VdGq3r0jTPulKAhy6rtm4NmcmKIJA6njPnPWHMW8Bbl70wkc3GmKGX+z5NTeu6NFrXpdG6Lk1zrQtcU5sV+0yOAl1q/N4ZyLSgDqWUUlgTBN8BfUSkh4h4A7cDSRbUoZRSCgt2DRljKkRkOrAc8ADmGmN2OXGRl717yUm0rkujdV0arevSNNe6wAW1iTHn7Z5XSinlRvS8SqWUcnMaBEop5eZaRRCIyFwRyRaRnfVMFxF53dHSYoeIDGkmdY0WkXwR2eb4+ZOL6uoiIv8VkT0isktEZtQxj8vXWQPrcvk6ExEfEdkkItsddT1TxzxtROQ/jvW1UUS6N5O67hKRnBrr6z5n11Vj2R4islVEPqtjmsvXVwPrsmR9ichhEUl1LHNzHdOd+/dojGnxP8AoYAiws57pNwHLsF/DMALY2EzqGg18ZsH6CgeGOB63B/YBA6xeZw2sy+XrzLEO/ByPvYCNwIha8/wWmON4fDvwn2ZS113AbFf/P+ZY9mPAB3X997JifTWwLkvWF3AYCLrAdKf+PbaKLQJjzBrg5AVm+Rkw39htAAJEJLwZ1GUJY0yWMSbF8bgQ2IP9iu+aXL7OGliXyznWwWnHr16On9pnWfwMeNfxeDEwVkTqunjS1XVZQkQ6AzcDb9czi8vXVwPraq6c+vfYKoKgAepqa2H5AONwpWPTfpmIRLt64Y5N8sHYv03WZOk6u0BdYME6c+xO2AZkAyuMMfWuL2NMBZAPdGoGdQH8wrE7YbGIdKljujP8HXgSqKpnuiXrqwF1gTXrywBfisgWsbfXqc2pf4/uEgQNamthgRSgmzFmIPAP4BNXLlxE/IAlwCPGmILak+t4iUvW2UXqsmSdGWMqjTGDsF8JP1xEYmrNYsn6akBdyUB3Y0wc8BU/fgt3GhGZAGQbY7ZcaLY6nnPq+mpgXS5fXw4jjTFDsHdlflBERtWa7tT15S5B0CzbWhhjCs5u2htjPge8RCTIFcsWES/sg+37xpiP6pjFknV2sbqsXGeOZeYBXwPja02qXl8i4gl0wIW7BeuryxhzwhhT6vj1/4CfuKCckUC8iBwGFgJjROS9WvNYsb4uWpdF6wtjTKbj32zgY+xdmmty6t+juwRBEnCn48j7CCDfGJNldVEiEnZ2v6iIDMf+3+OEC5YrwL+APcaYV+uZzeXrrCF1WbHORCRYRAIcj32B64G9tWZLAn7teHwLsMo4jvJZWVet/cjx2I+7OJUx5vfGmM7GmO7YDwSvMsZMrTWby9dXQ+qyYn2JSDsRaX/2MTAOqH2moVP/Hq3oPtrkRGQB9rNJgkTkKDAL+4EzjDFzgM+xH3XfDxQDdzeTum4BfiMiFcAZ4HZn/zE4jATuAFId+5cB/gB0rVGbFeusIXVZsc7CgXfFflMlG7DIGPOZiDwLbDbGJGEPsH+LyH7s32xvd3JNDa3rYRGJByocdd3lgrrq1AzWV0PqsmJ9hQIfO77feAIfGGO+EJEHwDV/j9piQiml3Jy77BpSSilVDw0CpZRycxoESinl5jQIlFLKzWkQKKWUm9MgUEopN6dBoJRSbk6DQKlGEJFhjsZkPo4rQ3fV0edHqRZBLyhTqpFE5HnAB/AFjhpjXrS4JKUaRYNAqUYSEW/gO6AEuMoYU2lxSUo1iu4aUqrxOgJ+2O+m5mNxLUo1mm4RKNVIIpKEvZ1xDyDcGDPd4pKUapRW0X1UKVcTkTuBCmPMB47un+tFZIwxZpXVtSl1qXSLQCml3JweI1BKKTenQaCUUm5Og0AppdycBoFSSrk5DQKllHJzGgRKKeXmNAiUUsrN/T/wO/fkpnx8KgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "days=[1,2,3,4,5]\n", + "sleeping=[6,7,8,9,10]\n", + "eating=[2,3,4,3,2]\n", + "working=[7,8,7,2,2]\n", + "playing=[8,5,7,8,13]\n", + "\n", + "plt.plot([],[],color='m',label=\"sleeping\",linewidth=5) #[][]show 2d array\n", + "plt.plot([],[],color='c',label=\"eating\",linewidth=5)\n", + "plt.plot([],[],color='r',label=\"working\",linewidth=5)\n", + "plt.plot([],[],color='k',label=\"playing\",linewidth=5)\n", + "\n", + "plt.stackplot(days,sleeping,eating,working,playing,colors=['m','c','r','k'])\n", + "\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.title('stack plot')\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "days=[1,2,3,4,5]\n", + "sleeping=[6,7,8,9,10]\n", + "eating=[2,3,4,3,2]\n", + "working=[7,8,7,2,2]\n", + "playing=[8,5,7,8,13]\n", + "slices=[7,2,2,13]\n", + "activities=['sleeping','eating','working','playing']\n", + "cols=['c','m','r','b']\n", + "\n", + "plt.pie(slices,labels=activities,colors=cols,startangle=90,shadow=True,explode=(0,0.1,0,0),autopct='%1.1f%%')\n", + "\n", + "plt.title('Pie Plot')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiple plots" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def f(t):\n", + " return np.exp(-t) * np.cos(2*np.pi*t)\n", + "t1=np.arange(0.0,5.0,0.1)\n", + "t2=np.arange(0.0,5.0,0.02)\n", + "plt.subplot(211) #first one show that there are 2 plots , second show that the plot are represented row wise or coloumn wise,third one show that \n", + "#this is first/second plot\n", + "plt.plot(t1,f(t1),'bo',t2,f(t2))\n", + "plt.subplot(212)\n", + "plt.plot(t2,np.cos(2*np.pi*t2))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def f(t):\n", + " return np.exp(-t) * np.cos(2*np.pi*t)\n", + "t1=np.arange(0.0,5.0,0.1)\n", + "t2=np.arange(0.0,5.0,0.02)\n", + "plt.subplot(222) #first one show that there are 2 plots , second show that the plot are represented rowise,third one show that \n", + "#this is first/second plot\n", + "plt.plot(t1,f(t1),'bo',t2,f(t2))\n", + "plt.subplot(221)\n", + "plt.plot(t2,np.cos(2*np.pi*t2))\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#compute the x and y coordinates for points on a sine curve\n", + "x=np.arange(0,3*np.pi,0.1)\n", + "y=np.sin(x)\n", + "#plot the points using matplotlib\n", + "plt.plot(x,y)\n", + "plt.show() " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}