From 78784b374b2d1a9be66eb4ad41470409e2bd4dfa Mon Sep 17 00:00:00 2001
From: Thomas Stephen Lee
Date: Mon, 7 Sep 2015 17:46:06 +0530
Subject: add/update books

---
 .../ch10.ipynb                                     | 331 +++++++++
 .../ch11.ipynb                                     | 469 +++++++++++++
 .../ch12.ipynb                                     |  91 +++
 .../ch13.ipynb                                     | 104 +++
 .../ch14.ipynb                                     | 106 +++
 .../ch17.ipynb                                     | 769 +++++++++++++++++++++
 .../ch19.ipynb                                     | 106 +++
 .../ch2.ipynb                                      | 533 ++++++++++++++
 .../ch21.ipynb                                     | 476 +++++++++++++
 .../ch3.ipynb                                      | 543 +++++++++++++++
 .../ch4.ipynb                                      | 338 +++++++++
 .../ch5.ipynb                                      | 416 +++++++++++
 .../ch6.ipynb                                      | 466 +++++++++++++
 .../ch8.ipynb                                      | 178 +++++
 .../ch9.ipynb                                      | 478 +++++++++++++
 .../screenshots/EbbyNo.png                         | Bin 0 -> 87873 bytes
 .../screenshots/comparision_of_models.png          | Bin 0 -> 20065 bytes
 .../screenshots/multiplexing.png                   | Bin 0 -> 77998 bytes
 18 files changed, 5404 insertions(+)
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png
 create mode 100755 Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png

(limited to 'Wireless_Communications_and_Networking_by_V._Garg')

diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb
new file mode 100755
index 00000000..b47575f1
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch10.ipynb
@@ -0,0 +1,331 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:52a8123efdb6330b1c01d828fbdcc37a6411e5ce1469de2c94b22a16e7b4d8c8"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 10: Antennas, Diversity and Link Analysis"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.1, Page 292"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "D=10000;  #in metres\n",
+      "TxEIRP=30;  #Effective Isotropic Radiated Power(EIRP)dBW\n",
+      "lamda=0.2;  #in metres\n",
+      "Pt=10;  #Transmitted power in dBW\n",
+      "Gt=20; #transmitter gain in dBi\n",
+      "Gr=3;  #receiver gain in dBi\n",
+      "Lo=6;#total system lossses in dB\n",
+      "Nf=5;  #noise figure in dB\n",
+      "BW=1.25; #mHz\n",
+      "k=1.38*10**-23;  #Boltzmann constant\n",
+      "T=290;  #temperature in degree kelvin\n",
+      "\n",
+      "#Calculations\n",
+      "Lp=20*math.log10(lamda/(4*math.pi*D));   #free space loss\n",
+      "Pr=Lp+Pt+Gt+Gr-Lo;# received power in dBW\n",
+      "No=10*math.log10(k*T);  #Noise density in dBW\n",
+      "NO=No+30;  #factor of '30' to convert from dBW to dBm\n",
+      "Pn=Nf+10*math.log10(BW*10**6)+NO;# noise signal power in dBm\n",
+      "SNR=(Pr+30)-Pn;\n",
+      "\n",
+      "#Results\n",
+      "print 'The received signal power is %d dBm'%(round(Pr+30)); #factor of '30' to convert from dBW to dBm\n",
+      "print 'SNR is %d dB'%SNR"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The received signal power is -59 dBm\n",
+        "SNR is 49 dB\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.2, Page 293"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "#As we have to use data from Eg 10.1, \n",
+      "D=10000;  # in metres\n",
+      "TxEIRP=30;  #Effective Isotropic Radiated Power(EIRP)dBW\n",
+      "lamda=0.2;  #in metres\n",
+      "Pt=10;  #trasmitted power in dBW\n",
+      "Gt=20; #transmitter gain in dBi\n",
+      "Gr=3;  #receiver gain in dBi\n",
+      "Lo=6;#total system lossses in dB\n",
+      "Nf=5;  #noise figure in dB\n",
+      "BW=1.25; #mHz\n",
+      "k=1.38*10**-23;  #Boltzmann constant\n",
+      "T=290;  #temperature in degree kelvin\n",
+      "#additional data given in this eg\n",
+      "hr=40.; #height of receiver in metre\n",
+      "ht=2; #trasmittter antenna height in metres\n",
+      "\n",
+      "#Calculations\n",
+      "Lp=20*math.log10(hr*ht/D**2);\n",
+      "Pr=Lp+Pt+Gt+Gr-Lo;# received power in dBW\n",
+      "No=10*math.log10(k*T);  #Noise density in dBW\n",
+      "NO=No+30;  #factor of '30' to convert from dBW to dBm\n",
+      "Pn=Nf+10*math.log10(BW*10**6)+NO;# noise signal power in dBm\n",
+      "SNR=(Pr+30)-Pn;\n",
+      "\n",
+      "#Result\n",
+      "print 'The received signal power is %d dBm'%(round(Pr+30)); #factor of '30' to convert from dBW to dBm\n",
+      "print 'SNR is %d dB'%SNR"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The received signal power is -65 dBm\n",
+        "SNR is 43 dB\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.3, Page 299"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Pin=12.;  #Input power in watts\n",
+      "Ploss=3;  #resistive losses in Watts\n",
+      "D=5;  #Directivity\n",
+      "\n",
+      "#Calculations\n",
+      "Eff=(Pin-Ploss)/Pin;\n",
+      "G=Eff*D;\n",
+      "\n",
+      "#Results\n",
+      "print 'Gain of the antenna is %.2f dB = %.2f'%(10*math.log10(G),G);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Gain of the antenna is 5.74 dB = 3.75\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.4, Page 299"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "G=12.; #Gain of antenna in dBi\n",
+      "\n",
+      "#Calculations\n",
+      "Theta=101.5/10**(G/10);\n",
+      "\n",
+      "#Result\n",
+      "print 'The 3-dB beam width of a linear element antenna is %.1f degrees'%Theta"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The 3-dB beam width of a linear element antenna is 6.4 degrees\n"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.5, Page 299"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "N=12; #number of turns\n",
+      "fr=1.8; #frequency in GHz\n",
+      "\n",
+      "#Calculations\n",
+      "lamda=3*10**8/(fr*10**9);\n",
+      "DH=lamda/math.pi;# diameter of helix in milli-meters\n",
+      "S=lamda/4;#turn spacing in millimetres\n",
+      "L=N*S;\n",
+      "G=15*N*S*(DH*math.pi)**2/lamda**3;\n",
+      "Theta=52*lamda/(math.pi*DH)*math.sqrt(lamda/(N*S));\n",
+      "\n",
+      "#Results\n",
+      "print 'The optimim diameter is %d mm'%(DH*1000);\n",
+      "print 'Spacing is  %.1f mm'%(S*1000);\n",
+      "print 'Total Length of antenna is %d mm'%(L*1000);\n",
+      "print 'The antenna gain is %.1f dBi'%(10*math.log10(G));\n",
+      "print 'The BeamWidth of antenna is %d degrees'%Theta"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The optimim diameter is 53 mm\n",
+        "Spacing is  41.7 mm\n",
+        "Total Length of antenna is 500 mm\n",
+        "The antenna gain is 16.5 dBi\n",
+        "The BeamWidth of antenna is 30 degrees\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.6, Page 305"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "E0=1000.; #average SNR\n",
+      "Eg=10; #threshold value for SNR\n",
+      "M=3;  #3-Branch Combiner\n",
+      "e=2.71828; #Euler's number\n",
+      "\n",
+      "#Calculations&Results\n",
+      "x=Eg/E0;\n",
+      "P3=(1-e**(-x))**M; #Considering 3-branch selection combiner\n",
+      "print 'By considering 3-branch selection combiner technique, probability comes to be %.e'%P3;\n",
+      "P1=(1-e**(-x));#M=1;\n",
+      "print ' BY not considering diversity technique, probability comes to be %.e'%P1;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "By considering 3-branch selection combiner technique, probability comes to be 1e-06\n",
+        " BY not considering diversity technique, probability comes to be 1e-02\n"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 10.7, Page 312"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "SR=3.84; #spreading rate in Mcps\n",
+      "\n",
+      "#Calculations\n",
+      "ChipDur=1./(SR*10**6);\n",
+      "Speed=3*10**8;\n",
+      "Dd=ChipDur*Speed;\n",
+      "\n",
+      "#Result\n",
+      "print 'Minimum delay distance to successfully resolve the multipath components and operate the Rake receiver is %d m'%Dd"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Minimum delay distance to successfully resolve the multipath components and operate the Rake receiver is 78 m\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb
new file mode 100755
index 00000000..9cc0698a
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch11.ipynb
@@ -0,0 +1,469 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:a9273e79f8d5c3c028c517c94bebc1e2c1c9a292aef113298724eb86d1685f66"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 11: Spread Spectrum (SS) and CDMA Systems"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.1, Page 322"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "CR1=1.2288; #Mcps(Clock rate 1)\n",
+      "CR2=5.;#Mcps(Clock rate 2)\n",
+      "R1=9.6; #Information rate in Kbps for CR1\n",
+      "PG2=256;  #Processing Gain for CR2\n",
+      "\n",
+      "#Calculations\n",
+      "PG1=10*math.log10(CR1*10**3/9.6);#Processing Gain for CR1\n",
+      "R2=CR2*10**3/PG2;#information rate in Kbps for CR2\n",
+      "\n",
+      "#Results\n",
+      "print 'The processing gain for clock rate 1.2288Mcps is %d dB'%PG1\n",
+      "print 'Improvemrnt in information rate is %.2f Kbps'%(R2-R1);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The processing gain for clock rate 1.2288Mcps is 21 dB\n",
+        "Improvemrnt in information rate is 9.93 Kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.2, Page 326"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "#From figure 11.5 we get resultant demodulated signal at a mobile;\n",
+      "Rx=[[1,1,1,1,-3,1],[1,-3,1,1,1,1],[1,-3,1,1,1,-3],[1,-3,1,1,1,1],[-1,3,3,-1,3,-1]];#Resultant demodulated signal at mobile\n",
+      "\n",
+      "#from Figure 11.4 \n",
+      "c1=[[-1,-1,-1,-1,1,1],[1,-1,1,1,-1,-1],[1,-1,1,-1,-1,-1],[-1,1,1,1,-1,1],[1,-1,-1,1,-1,1]];\n",
+      "c2=[[1,1,-1,1,1,-1],[-1,1,-1,1,-1,-1],[-1,-1,1,1,1,-1],[1,1,-1,-1,1,-1],[1,-1,-1,-1,-1,-1]];\n",
+      "c3=[[-1,-1,1,-1,1,-1],[-1,-1,-1,1,1,1],[-1,1,1,-1,-1,1],[-1,1,-1,-1,-1,-1],[1,1,1,-1,1,1]];\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#t={[1  2 3 4 5 6];[7 8 9 10 11 12];[13 14 15 16 17 18];[19 20 21 22 23 24];[25 26 27 28 29 30]};\n",
+      "#for Mobile 1\n",
+      "for i in range(0,5):\n",
+      "    Demod1=c1[i][0]*Rx[i][0]+c1[i][1]*Rx[i][1]+c1[i][2]*Rx[i][2]+c1[i][3]*Rx[i][3]+c1[i][4]*Rx[i][4]-1\n",
+      "    if(Demod1<0):\n",
+      "        B1=1;\n",
+      "    else:\n",
+      "        B1=0;\n",
+      "\n",
+      "#for mobile 2\n",
+      "for i in range(0,5):\n",
+      "    Demod2=c2[i][0]*Rx[i][0]+c2[i][1]*Rx[i][1]+c2[i][2]*Rx[i][2]+c2[i][3]*Rx[i][3]+c2[i][4]*Rx[i][4]+1;\n",
+      "    if(Demod2<0):\n",
+      "        B2=1;\n",
+      "    else:\n",
+      "        B2=0;\n",
+      "\n",
+      "#for mobile 3\n",
+      "for i in range(0,5):\n",
+      "    Demod3=c3[i][0]*Rx[i][0]+c3[i][1]*Rx[i][1]+c3[i][2]*Rx[i][2]+c3[i][3]*Rx[i][3]+c3[i][4]*Rx[i][4]-1;\n",
+      "    if(Demod3<0):\n",
+      "        B3=1;\n",
+      "    else:\n",
+      "        B3=0;\n",
+      "\n",
+      "print \"Value of integration at end of bit period for mobile1\",Demod1\n",
+      "print \"Value of integration at end of bit period for mobile2\",Demod2\n",
+      "print \"Value of integration at end of bit period for mobile3\",Demod3\n",
+      "print \"The  recovered signal at mobile 1 is \",B1\n",
+      "print \"The  recovered signal at mobile 2 is \",B2\n",
+      "print \"The  recovered signal at mobile 3 is \",B3\n",
+      "print \"In all cases, Recovered signal is negated value of transmitted signal\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Value of integration at end of bit period for mobile1 -12\n",
+        "Value of integration at end of bit period for mobile2 -8\n",
+        "Value of integration at end of bit period for mobile3 8\n",
+        "The  recovered signal at mobile 1 is  1\n",
+        "The  recovered signal at mobile 2 is  1\n",
+        "The  recovered signal at mobile 3 is  0\n",
+        "In all cases, Recovered signal is negated value of transmitted signal\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.3, Page 332"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "BW=100; #in MHz\n",
+      "Fspac=10;  #frequency spacing in kHz\n",
+      "\n",
+      "#Calculations\n",
+      "FreqTones=BW*10**3/Fspac;\n",
+      "Chips=math.log(FreqTones,2);\n",
+      "\n",
+      "#Result\n",
+      "print 'Minimum number of chips required are %d chips'%Chips"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Minimum number of chips required are 13 chips\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.4, Page 332"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "R=120; #transmission rate in kbps\n",
+      "Hop=2000; #per second\n",
+      "Spectrum=10; #in MHz\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#For 32-FSK\n",
+      "Bits_sym=math.log(32,2);\n",
+      "SR=R/Bits_sym;\n",
+      "print 'Bits per symbol are %d'%Bits_sym\n",
+      "print 'Hops per second are 2000 and Symbol rate is %d kbps'%SR\n",
+      "Sym_hop=SR*10**3/Hop;\n",
+      "Min_BW=Sym_hop*SR;\n",
+      "Nonoverlap_hop=Spectrum*10**3/Min_BW;\n",
+      "print 'Symbols transmitted per hop are %d'%Sym_hop;\n",
+      "print 'Number of non-Overlapping hop frequencies are %d'%(round(Nonoverlap_hop))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Bits per symbol are 5\n",
+        "Hops per second are 2000 and Symbol rate is 24 kbps\n",
+        "Symbols transmitted per hop are 12\n",
+        "Number of non-Overlapping hop frequencies are 35\n"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.5, Page 332"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "R=200;#input data rate in bps\n",
+      "Fhop=200;#per second\n",
+      "k=1;#Multipication_Factor\n",
+      "\n",
+      "#Calculations&Results\n",
+      "# We have 32-FSK modulation scheme\n",
+      "Bits_sym=math.log(32,2);\n",
+      "Rs=Fhop/Bits_sym;\n",
+      "print 'There are 200 hops per second and Symbol rate is %d symbols per sec'%Rs;  \n",
+      "\n",
+      "SDur=1/Rs;\n",
+      "L=Fhop/Rs;\n",
+      "CDur=SDur/L;\n",
+      "Separation=1/CDur;\n",
+      "M=2**Bits_sym;\n",
+      "Hop_BW=k*M*Fhop*L;\n",
+      "Gp=M*k*L; \n",
+      "\n",
+      "\n",
+      "print ' Minimum separation between frequency tones should be %d Hz'%Separation;\n",
+      "print ' Number of different frequency tones produced by a frequency synthesizer are %d'%M;\n",
+      "print ' Processing Gain is %d'%Gp;\n",
+      "print 'Hopping bandwidth is %d kHz'%(Hop_BW/1000);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "There are 200 hops per second and Symbol rate is 40 symbols per sec\n",
+        " Minimum separation between frequency tones should be 200 Hz\n",
+        " Number of different frequency tones produced by a frequency synthesizer are 32\n",
+        " Processing Gain is 160\n",
+        "Hopping bandwidth is 32 kHz\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.6, Page 342"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "M1=[1,0,0,1,1];\n",
+      "\n",
+      "Rx1=[[1,1,1,1,-3,1],[1,-3,1,1,1,1],[1,-3,1,1,1,-3],[1,-3,1,1,1,1],[-1,3,3,-1,3,-1],[1,-1,-1,0,0,0]];#Resultant demodulated signal at mobile(Z(t)) from path1\n",
+      "Rx2=[[-1,-1,1,1,1,1],[-3,1,1,-3,1,1],[1,1,1,-3,1,1],[1,-3,1,-3,1,1],[1,1,-1,3,3,-1],[3,1,-1,0,0,0]];#Resultant demodulated signal at mobile(Z(t-2Tc)) from path2\n",
+      "Rx=Rx1+Rx2; #since,Z(t)=z(t)+Z(t-2Tc)\n",
+      "\n",
+      "#from Figure 11.13 (d) & Figure 11.14\n",
+      "c1=[[-1,-1,-1,-1,1,1],[1,-1,1,1,-1,-1],[1,-1,1,-1,-1,-1],[-1,1,1,1,-1,1],[1,-1,-1,1,-1,1]];\n",
+      "c2=[[-1,1,-1,-1,-1,-1],[1,1,1,-1,1,1],[-1,-1,1,-1,1,-1],[-1,-1,-1,1,1,1],[-1,1,1,-1,-1,1],[-1,1,0,0,0,0]];\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#case-1:Z(t)*C1(t);\n",
+      "for i in range(0,5):\n",
+      "    Demod_1=c1[i][0]*Rx[i][0]+c1[i][1]*Rx[i][1]+c1[i][2]*Rx[i][2]+c1[i][3]*Rx[i][3]+c1[i][4]*Rx[i][4]+c1[i][5]*Rx[i][5];\n",
+      "    if(Demod_1<0):\n",
+      "        B1=1;\n",
+      "    else:\n",
+      "        B1=0;\n",
+      "\n",
+      "#case-2:Z(t)*C1(t-2Tc);\n",
+      "for j in range(0,5):\n",
+      "    Demod_2=c2[j][2]*Rx[j][2]+c2[j][3]*Rx[j][3]+c2[j][4]*Rx[j][4]+c2[j][5]*Rx[j][5]+c2[j+1][0]*Rx[j+1][0]+c2[j+1][1]*Rx[j+1][1]-10\n",
+      "    if(Demod_2<0):\n",
+      "        B2=1;\n",
+      "    else:\n",
+      "        B2=0;\n",
+      "\n",
+      "print \"case-1:z(t)*c1(t)\";\n",
+      "print \"Value of integration at end of bit period for mobile(case-1)\",Demod_1\n",
+      "print \"The recovered signal at mobile(case-1) is \",B1\n",
+      "print \"Actual bit values are\",M1\n",
+      "print \"Recovered and actual values are not matching\",\n",
+      "\n",
+      "print \"\\n\\ncase-2:z(t)*c1(t-2Tc)\"\n",
+      "print \"Value of integration at end of bit period for mobile(case-2)\",Demod_2\n",
+      "print \"The recovered signal at mobile(case-2) is \",B2\n",
+      "print \"Actual bit values are\",M1\n",
+      "print \"Recovered and actual values are not matching\",\n",
+      "\n",
+      "#case3-Sum of path1 and path2\n",
+      "print \"\\n\\ncase-3:Sum of path1 & path2 integrator\"\n",
+      "Demod_3=Demod_1+Demod_2;\n",
+      "print \"Sum of integrator outputs(rake receiver output)\",Demod_3\n",
+      "\n",
+      "for k in range(0,5):\n",
+      "    if(Demod_3<0):\n",
+      "        B3=1;\n",
+      "    else:\n",
+      "        B3=0;\n",
+      "        \n",
+      "print \"Detected bit value \",B3\n",
+      "print \"Actual bit values are\",M1\n",
+      "print \"Recovered and actual values are matching\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "case-1:z(t)*c1(t)\n",
+        "Value of integration at end of bit period for mobile(case-1) -12\n",
+        "The recovered signal at mobile(case-1) is  1\n",
+        "Actual bit values are [1, 0, 0, 1, 1]\n",
+        "Recovered and actual values are not matching \n",
+        "\n",
+        "case-2:z(t)*c1(t-2Tc)\n",
+        "Value of integration at end of bit period for mobile(case-2) -12\n",
+        "The recovered signal at mobile(case-2) is  1\n",
+        "Actual bit values are [1, 0, 0, 1, 1]\n",
+        "Recovered and actual values are not matching \n",
+        "\n",
+        "case-3:Sum of path1 & path2 integrator\n",
+        "Sum of integrator outputs(rake receiver output) -24\n",
+        "Detected bit value  1\n",
+        "Actual bit values are [1, 0, 0, 1, 1]\n",
+        "Recovered and actual values are matching\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.7, Page 360"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Prm=-97;#the signal strength from the base stations in  dBm\n",
+      "#The constant ( K ) is the part of the broadcast message that is sent to the mobile by the base station on the paging channel.\n",
+      "K=-73; #dB\n",
+      "P2=18; #power as directed by BS (dBm)\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Ptm=K-Prm;\n",
+      "print 'The mobile transmitter power be set as a first approximation of %d dBm'%Ptm\n",
+      "Pwr_Redu=Ptm-P2;#power reduction\n",
+      "print 'Power reduction = %d dBm'%Pwr_Redu\n",
+      "Time=6*1.25;\n",
+      "print 'Time required by mobile station to make changes as directed by base station is %.1f msec'%Time\n",
+      " "
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The mobile transmitter power be set as a first approximation of 24 dBm\n",
+        "Power reduction = 6 dBm\n",
+        "Time required by mobile station to make changes as directed by base station is 7.5 msec\n"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 11.8, Page 362"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "P1=-95; #pilot1 in dBm\n",
+      "P2=-100; #pilot2 in dBm\n",
+      "P3=-101; #pilot3 in dBm\n",
+      "P4=-105; #pilot4 in dBm\n",
+      "P5=-102; #pilot in dBm\n",
+      "NoiseP=-107; #Receiver sensitivity(dBm)\n",
+      "Tadd=-13; #dB\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#Pcj = received power of the jth pilot in the candidate set\n",
+      "# Pai= received power of the ith pilot in the active set \n",
+      "Pa1=P1-NoiseP;\n",
+      "Pa2=P2-NoiseP;\n",
+      "Pa3=P3-NoiseP;\n",
+      "Pa4=P4-NoiseP;\n",
+      "Pc5=P5-NoiseP;\n",
+      "\n",
+      "X=10*math.log10(10**(0.1*Pa1)+10**(0.1*Pa2)+10**(0.1*Pa3)+10**(0.1*Pa4)+10**(0.1*Pc5));   \n",
+      "print \"Since P1>P2>P3>P4, we replace P4\"\n",
+      "T_COMP=(P5-P4)/0.5;\n",
+      "print 'The value of T-COMP that could trigger the mobile station to generate a PSMM should be <= %d dB (<= %d)'%(T_COMP,round(10**(0.1*T_COMP)));\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Since P1>P2>P3>P4, we replace P4\n",
+        "The value of T-COMP that could trigger the mobile station to generate a PSMM should be <= 6 dB (<= 4)\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb
new file mode 100755
index 00000000..8234bb5b
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch12.ipynb
@@ -0,0 +1,91 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:5a8dcdff9c441023f41d39cb4ab911bae195c143982b35aa0ceb85309af37715"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 12: Mobility Management in Wireless Networks"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 12.1, Page 374"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "P=10000;  #Mobile density(mobiles/km**2)\n",
+      "R=500*10**-3; #km\n",
+      "V=10;  #Average moving velocity of a mobile in Kmph\n",
+      "Nc=10.; #No of cells per LA\n",
+      "N_LA=5; #Number of LAs per MSC/VLR \n",
+      "\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#Number of transactions and duration of each transaction to MSC/VLR per LU for different LU types are given in Table 12.1.(page no.374)\n",
+      "\n",
+      "\n",
+      "# L=length (km) of the cell exposed perimeter in an LA\n",
+      "L=6*R*(1./3+1./(2*math.sqrt(Nc)-3));   #Km\n",
+      "# lamdaLU=number of transactions processed by MSC/VLR in an LA perimeter of the jth cell per hour\n",
+      "LamdaLu=V*P*L/math.pi;  #Lus per hour\n",
+      "\n",
+      "\n",
+      "# case(1)\n",
+      "print \"Case-1\"\n",
+      "R1_LU=LamdaLu/3600*(1*600./1000); #resource occupancy from Table 12.1\n",
+      "print 'The resource occupancy in the jth cell due to MS LUs is  %.1f Erlangs'%R1_LU;\n",
+      "\n",
+      " \n",
+      "#case(2)\n",
+      "print \"\\nCase-2\"\n",
+      "R2_LU=LamdaLu/3600*(0.8*3500/1000+0.2*4000/1000);  #from Table 12.1\n",
+      "print 'The resource occupancy in the jth cell due to MS LUs is  %.2f Erlangs'%R2_LU;\n",
+      "Np=6*math.sqrt(Nc/3)-3;#Number of cells located on perimeter of an LA\n",
+      "print 'Number of cells where inter-VLR LUs occur will be: %d'%(round(0.5*Np*4));\n",
+      "print 'Number of cells where intra-VLR LUs occur will be: %d'%(4*Nc-16);\n",
+      "TNLU=LamdaLu*(2*24+16*(0.8*14+0.2*16));  #from table 12.1\n",
+      "print 'The MSC/VLR transaction load using the \ufb02uid \ufb02ow model is %.2e transactions at peak hour'%TNLU;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Case-1\n",
+        "The resource occupancy in the jth cell due to MS LUs is  10.1 Erlangs\n",
+        "\n",
+        "Case-2\n",
+        "The resource occupancy in the jth cell due to MS LUs is  60.55 Erlangs\n",
+        "Number of cells where inter-VLR LUs occur will be: 16\n",
+        "Number of cells where intra-VLR LUs occur will be: 24\n",
+        "The MSC/VLR transaction load using the \ufb02uid \ufb02ow model is 1.69e+07 transactions at peak hour\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb
new file mode 100755
index 00000000..fec26202
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch13.ipynb
@@ -0,0 +1,104 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:0963e656a45b56e87c82b1b894058e0c0c5d5a3acfd1e2f8850678ef319681b0"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 13: Security in Wireless Systems"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 13.1, Page 424"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "#Two prime numbers\n",
+      "p=5;\n",
+      "q=7;\n",
+      "\n",
+      "#Calculations\n",
+      "n=p*q;\n",
+      "z=(p-1)*(q-1);\n",
+      "e=5\n",
+      "d=29\n",
+      "\n",
+      "#Results\n",
+      "print 'Public keys is (%d, %d)'%(n,e);\n",
+      "print 'Private key is (%d, %d)'%(n,d);\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Public keys is (35, 5)\n",
+        "Private key is (35, 29)\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 13.2, Page 425"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "p=23; #prime number that both parties agreed upon\n",
+      "g=5;# g is primitive mod p\n",
+      "a=6;  #party A choosen number\n",
+      "b=15;  #party B choosen number\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print 'Party A sends to party B as (g**a mod p) = %d'%(g**a%23);\n",
+      "print 'Party B sends to party A as (g**b mod p) = %d'%(g**b%23);\n",
+      "print 'Party A computes secret key as ((g**b modp)**a mod p) = %d'%(((g**b%23)**a)%p);\n",
+      "print 'Party B computes secret key as ((g**a modp)**b mod p) = %d'%(((g**a%23)**b)%p);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Party A sends to party B as (g**a mod p) = 8\n",
+        "Party B sends to party A as (g**b mod p) = 19\n",
+        "Party A computes secret key as ((g**b modp)**a mod p) = 2\n",
+        "Party B computes secret key as ((g**a modp)**b mod p) = 2\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb
new file mode 100755
index 00000000..58285a29
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch14.ipynb
@@ -0,0 +1,106 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:3bb6fed41815ab02f5db449f0fb6dc3bca89d7411c6822dfe382fccc1777b7c3"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 14: Mobile Network and Transport Layer"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 14.1, Page 452"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "O=800*1000; #Object size(Bytes)\n",
+      "S=536.*8;  #max Segment Size(in bits)\n",
+      "RTT=0.1; #Round trip-time in sec\n",
+      "R=1.*10**6; #Transmission rate of the link from the server to the client in bps\n",
+      "\n",
+      "#Calculations\n",
+      "Lmin=2*RTT+(O/R); #latency(msec)\n",
+      "# For minimum latency (S/R) +RTT -(W*S/R) = 0;Therefore\n",
+      "W=1+(RTT)/(S/R);\n",
+      "\n",
+      "#Results\n",
+      "print 'The minimum possible latency is %d sec'%Lmin;\n",
+      "print 'The minimum window size is %.1f segments'%W;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The minimum possible latency is 1 sec\n",
+        "The minimum window size is 24.3 segments\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 14.2, Page 452"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "RTT=0.1; #Round trip-time in sec\n",
+      "MSS=536.*8; #Maximum segment size in bits\n",
+      "p=0.01;# packet loss probability for the path\n",
+      "RTO=5*RTT; #Retransmission time out(from eqn 14.2 on page 450)\n",
+      "\n",
+      "#Calculations\n",
+      "R=0.93*MSS/(RTT*math.sqrt(p));\n",
+      "RR=MSS/(RTT*math.sqrt(1.33*p)+RTO*p*(1+32*p**2)*min(1,3*math.sqrt(0.75*p)));\n",
+      "\n",
+      "#Results\n",
+      "print 'The upper bound of the throughput is %.4f Mbps'%(R*10**-6);\n",
+      "print 'The throughput with retransmission due to errors is %.4f Mbps'%(RR*10**-6);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The upper bound of the throughput is 0.3988 Mbps\n",
+        "The throughput with retransmission due to errors is 0.3341 Mbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb
new file mode 100755
index 00000000..708d447e
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch17.ipynb
@@ -0,0 +1,769 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:029905df97aa37359789733a28b442f75b82e79e7e96006449e39c092f0d4cca"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 17: Planning and Design of a Wireless Network"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.1, Page 597"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration \n",
+      "Susage=150.;#subscriber usage per month in mins\n",
+      "days=24;#days per month\n",
+      "busyhrs=6;#in a day\n",
+      "BW=4.8*10**3;  #in kHz\n",
+      "Freqreuse=4./12;#Frequency reuse plan\n",
+      "chwidth=200; #in kHz\n",
+      "subscriber=50000;#Present subscriber count\n",
+      "Sgrowth=0.05;#Growth rate per year\n",
+      "Area=500;  #in km\n",
+      "BTScapacity=30; #in Erlangs\n",
+      "N=4;  #Initial installation design years\n",
+      " \n",
+      "#Calculations&Results\n",
+      "Erlangspersub=Susage/(days*busyhrs*60);\n",
+      "print 'Average busy-hour traf\ufb01c per subscriber is %.4f Erlangs'%Erlangspersub;\n",
+      "RFcarriers=BW/chwidth;\n",
+      "RFcarrier_percell=RFcarriers/((Freqreuse**-1)*4); #freq reuse factor of 4\n",
+      "\n",
+      "#Assuming 2 control channels per cell\n",
+      "CC=2;#control channels\n",
+      "TC_percell=2*RFcarriers/3-CC;\n",
+      "#Referring Erlang-B table in Appendix A\n",
+      "print \"Referring Erlang-B table in Appendix A,Traf\ufb01c capacity of a GSM cell at 2% GoS for 14 channels = 8.2 Erlangs \"\n",
+      "Tcapacity=8.2;# in Erlangs\n",
+      "print \"There are 3 cells per BTS\"\n",
+      "BTS=3;\n",
+      "Traffic_perBTS=Tcapacity*BTS;\n",
+      "print 'Traffic capacity per BTS is %.1f Erlangs'%Traffic_perBTS\n",
+      "print \"Therefore, Traffic per BTS is less than BTS capacity(30 Erlangs)\"\n",
+      "maxsubscriber=Traffic_perBTS/Erlangspersub;\n",
+      "initialsub=subscriber*(1+Sgrowth)**N;\n",
+      "BTS_perZone=initialsub/maxsubscriber;\n",
+      "print 'The required number of base stations per zone are %d'%(round(BTS_perZone));\n",
+      "cellRadius=(Area/(BTS_perZone*2.6))**0.5;\n",
+      "print 'The hexagonal cell radius is %.1f km'%cellRadius;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Average busy-hour traf\ufb01c per subscriber is 0.0174 Erlangs\n",
+        "Referring Erlang-B table in Appendix A,Traf\ufb01c capacity of a GSM cell at 2% GoS for 14 channels = 8.2 Erlangs \n",
+        "There are 3 cells per BTS\n",
+        "Traffic capacity per BTS is 24.6 Erlangs\n",
+        "Therefore, Traffic per BTS is less than BTS capacity(30 Erlangs)\n",
+        "The required number of base stations per zone are 43\n",
+        "The hexagonal cell radius is 2.1 km\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.2, Page 598"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "usage=150.; #subscriber usage per month in mins\n",
+      "days=24;#Days in a month\n",
+      "BHrs=6;#Busy hours per day\n",
+      "BW=4.8;  #in MHz\n",
+      "RFch=200;  #in kHz\n",
+      "Psubscribers=50000;#present subscriber count\n",
+      "growth=0.05;#subscriber growth per year\n",
+      "rollover=4;#network roll over period\n",
+      "NPCS=5;#Number of packet calls per session \n",
+      "NPP=25;#Number of packets within a packet call \n",
+      "Tr=120;#Reading time between packet calls(sec)\n",
+      "NBP=480*8;#Packet size(in bits)\n",
+      "Tint=0.01;#Time interval between two packets(sec)\n",
+      "Ttot=3000;#Total packet service holding time\n",
+      "BH_PS=0.15;#Busy hour packet sessions per subscriber\n",
+      "Penetration=0.25;\n",
+      "datarate=48;  #in kbps\n",
+      "PTT=10;#Packet transmission time(sec)\n",
+      "BTS=40;#NO of BTS sites\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Bitstx_duringPTT=NPCS*NPP*NBP/1000;   \n",
+      "PST=PTT+Tr*(NPCS-1)+Tint*(NPP-1);\n",
+      "PT_duringBH=BH_PS*Ttot/PST;\n",
+      "Bits_persub_persec=Bitstx_duringPTT*PT_duringBH/(60*60);\n",
+      "VoiceErlangs=usage/(days*BHrs*60);\n",
+      "Initial_subscribers=round(Psubscribers*(1+growth)**rollover);\n",
+      "Data_subscribers=Initial_subscribers*Penetration;\n",
+      "Totalvoice=Initial_subscribers*VoiceErlangs;\n",
+      "Voicetraffic_perBTS=Totalvoice/BTS;\n",
+      "print 'Voice Traffic per Cell(sector) is %.2f Erlangs'%(Voicetraffic_perBTS/3);\n",
+      "Totaldata=Data_subscribers*Bits_persub_persec;\n",
+      "Datathroughput_perBTS=Totaldata/BTS;\n",
+      "print 'Data throughput per Cell(sector) is %.2f kbps'%(Datathroughput_perBTS/3)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Voice Traffic per Cell(sector) is 8.79 Erlangs\n",
+        "Data throughput per Cell(sector) is 15.50 kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.3, Page 600"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Holdtime=120;#Average holding time during Busy Hours(in sec)\n",
+      "Tx=3;# No of transreceivers\n",
+      "TSsig=3;#No of TSs per cell for signaling\n",
+      "RLC=0.80;#Radio link control efficiency\n",
+      "Radioblocks=9000;#Total numbers of transmitted radio blocks\n",
+      "TSdata=3;#TSs allocated for data traf\ufb01c per cell\n",
+      "Datarate=15.5; #From eg 17.2\n",
+      "Voicetraffic=8.82;  #From eg.17.2\n",
+      "Duration=0.02;#Duration of block in sec\n",
+      "\n",
+      "#Calculations&Results\n",
+      "DataEr=Radioblocks*Duration/Holdtime;\n",
+      "print 'Data Erlangs = %.1f'%DataEr;\n",
+      "TSuti=DataEr/TSsig;\n",
+      "print 'Time Slot(TS) utilization = %.1f'%TSuti;\n",
+      "Throughput=(Datarate/TSdata)*RLC;\n",
+      "TScap=Throughput/TSuti;\n",
+      "print 'TS capacity is %.2f kbps'%TScap;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Data Erlangs = 1.5\n",
+        "Time Slot(TS) utilization = 0.5\n",
+        "TS capacity is 8.27 kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.4, Page 602"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Pt=36;#Base station transmitted power in dBm\n",
+      "Pms=24;#mobile station transmitted power in dBm\n",
+      "Nms=8;#mobile station noise figure in dB\n",
+      "Nbs=5;#Base station nise figure in dB\n",
+      "Ga=18;#Base station transmit and receive antenna gain in dBi\n",
+      "Gm=0;#Mobile antenna gain in dBi\n",
+      "SNR=12;# in dB\n",
+      "Lc_TX=5;#BS transmit antenna cable, connector, and \ufb01lter losses in dB\n",
+      "Lc_RX=2;#BS receiver antenna cable, connector, and \ufb01lter losses in dB\n",
+      "Bodyloss=3;# Body losses at mobile\n",
+      "fading=10.2;# in dB\n",
+      "ThermalNoise=-174;# in dBm/Hz\n",
+      "Gdiversity=5;#Antenna diversity gain at BS in dB\n",
+      "#Assuming standard value of RF channel as \n",
+      "RFch=200*10**3;  #in Hz\n",
+      "\n",
+      "#Calculations\n",
+      "N=ThermalNoise+10*math.log10(RFch)+Nms;\n",
+      "Smin=N+SNR;\n",
+      "Smean=Smin+fading+Bodyloss;\n",
+      "Lp=Pt-Lc_TX+Ga-Smean;\n",
+      "N1=ThermalNoise+10*math.log10(RFch)+Nbs;\n",
+      "Smin=N1+SNR-Gdiversity;\n",
+      "Smean1=Smin+fading+Bodyloss;\n",
+      "Lp1=Pms-Smean1+Ga-Lc_RX;\n",
+      "R=10**((Lp1-133.2)/33.8);\n",
+      "\n",
+      "#Result\n",
+      "print 'Cell radius is %.1f km'%R;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Cell radius is 1.2 km\n"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.5, Page 608"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Ri=12.2*10**3;#Information rate in bps\n",
+      "Rc=3.84*10**6;#Chip rate in cps(chips per second)\n",
+      "Eb_Nt=4.;  #in dB\n",
+      "Imargin=2.;  #Interference margin(3 dB)\n",
+      "B=0.5;#Interference factor due to other cells\n",
+      "Vi=0.65;#Channel activity factor\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Eb_Ntreqd=10**(Eb_Nt/10);\n",
+      "LF_peruser=(1+B)*(1./(1+(Rc/Ri)*(1./Eb_Ntreqd)*(1./Vi)));  #M(no of users=1) in Eq 17.13\n",
+      "print 'Cell load factor per voice user is %.5f'%LF_peruser;\n",
+      "CellLoading=(Imargin-1)/Imargin;\n",
+      "VoiceUsers=CellLoading/LF_peruser;\n",
+      "print 'No of Voice Users are %d per cell'%VoiceUsers;\n",
+      "#From EQ 17.6 assuming Power control efficiency=1\n",
+      "Polecap=Rc/(Ri*Vi*(1+B)*Eb_Ntreqd);\n",
+      "print 'Pole Capacity is %d'%Polecap;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Cell load factor per voice user is 0.00774\n",
+        "No of Voice Users are 64 per cell\n",
+        "Pole Capacity is 128\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.6, Page 608"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Eb_Nt=1.;  #in dB\n",
+      "cellLoading=0.5;#Required interference margin(3 dB)\n",
+      "B=0.5;#Interference factor due to other cells\n",
+      "Vi=1;#Channel activity factor\n",
+      "\n",
+      "#Calculations\n",
+      "Eb_Ntreqd=10**(Eb_Nt/10);\n",
+      "#Assuming standard value of chip rate as 3.84Mcps\n",
+      "Rc=3.84*10**6;#in cps(chips per second)\n",
+      "Throughput=(cellLoading*Rc)/(Eb_Ntreqd*(1+B));\n",
+      "\n",
+      "#Result\n",
+      "print 'Uplink Throughput is %d kbps'%(Throughput/1000);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Uplink Throughput is 1016 kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.7, Page 610"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Ri=12.2*10**3;#Information rate in bps\n",
+      "Rc=3.84*10**6;# Chip rate in chips per second\n",
+      "Eb_Nt=4.;   # in dB\n",
+      "Eb_Nt=10**(Eb_Nt/10);\n",
+      "B=0.5;#Average interference factor due to other cells\n",
+      "Zeta=0.6; # orthogonality factor\n",
+      "Imargin=2.;#Interference margin(3 dB)\n",
+      "Vi=0.65  #assuming Channel activity factor as 0.65\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Loadfactor_peruser=(Zeta+B)*(1./((Rc/Ri)*(1./Eb_Nt)*(1./Vi)))\n",
+      "print 'Downlink cell load factor is %.4f'%Loadfactor_peruser;\n",
+      "cellLoading=(Imargin-1)/Imargin;\n",
+      "Voiceusers=cellLoading/Loadfactor_peruser;\n",
+      "print 'No of voice users per cell are %d'%Voiceusers;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Downlink cell load factor is 0.0057\n",
+        "No of voice users per cell are 87\n"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.8, Page 610"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "N0=-174;#Noise density in dBm/Hz\n",
+      "Bc=1.25;#Channel bandwidth in mHz\n",
+      "Rc=1.2288;#Chip rate in Mcps\n",
+      "Nf=6;  #Receiver Noise figure in dB\n",
+      "Pt=27;  #Effective radiated power from mobile in dBm\n",
+      "Lct=0.5;  #Transmitter cable and connector loss in dBm\n",
+      "Lbody=1.5;#Body loss in dB\n",
+      "Lcr=2;  #Receiver cable and connector loss in dB\n",
+      "Mint=0;  #Interference margin in dB\n",
+      "Mfading=2;#fast fadinf margin in dB\n",
+      "Lpent=8;#Penetration loss in dB\n",
+      "Gm=0;#Transmitter antennna gain in dBi\n",
+      "Gb=12;#Receiver antenna gain in dBi\n",
+      "Fm=8;#Fade margin in dB\n",
+      "Eb_Nt=7;# in dB\n",
+      "\n",
+      "#Calculations\n",
+      "Nth=N0+Nf;\n",
+      "S_Nt=Eb_Nt+10*math.log10((Rc*10**6)/(Bc*10**6));\n",
+      "Smin=S_Nt+10*math.log10(Rc*10**6)+Nth;\n",
+      "Lpmax=(Pt-Smin)+(Gb+Gm)-(Lbody+Lct+Lcr+Fm+Lpent)-Mint-Mfading;\n",
+      "\n",
+      "#Results\n",
+      "print 'Minimum signal power required is %.2f dBm'%Smin;\n",
+      "print 'Maximum allowable path loss is %.2f dB'%Lpmax;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Minimum signal power required is -100.18 dBm\n",
+        "Maximum allowable path loss is 117.18 dB\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.9, Page 612"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Rc=3.84;#Chip rate in Mcps\n",
+      "Ri=16;#Data rate in kbps\n",
+      "UL=0.5;#UL loading factor\n",
+      "DL=0.9;#DL loading factor\n",
+      "Eb_NtU=4;#in dB\n",
+      "Eb_NtD=6;# in dB\n",
+      "Gm=0;#Mobile antenna gain in dBi\n",
+      "Gb=18;#Base station gain in dBi\n",
+      "\n",
+      "#Calculations\n",
+      "R=10**((139.65-138.5)/35.7);\n",
+      "print 'Cell Radius is %.3f km'%R;\n",
+      "Area=round(2.6*R**2);\n",
+      "\n",
+      "#Results\n",
+      "print 'Area covered by hexagonal cell is %d km**2'%Area;\n",
+      "print 'Number of BTSs required to cover an area of 2400 Km**2 are %d'%(2400/Area);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Cell Radius is 1.077 km\n",
+        "Area covered by hexagonal cell is 3 km**2\n",
+        "Number of BTSs required to cover an area of 2400 Km**2 are 800\n"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.10, Page 614"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Rc=3.84;#chip rate in Mcps\n",
+      "N=3.;#Noise rise in dB\n",
+      "OF=0.8;#orthogonality factor\n",
+      "B=0.55;#Interference from other cells \n",
+      "Eb_N0=4.;#in dB\n",
+      "Sec_Eff=0.85;#Sector efficiency\n",
+      "Pwr_Eff=0.80;#Power control efficiency\n",
+      "Y=1.2; #Retransmit rate\n",
+      "X=10.; #10MB at 384Kbps\n",
+      "X1=2.;  #2MB at 144Kbps\n",
+      "X2=1.;  #1MB at 64Kbps\n",
+      "\n",
+      "#Calculations\n",
+      "#Assuming Voice activity=Vf=1\n",
+      "Vf=1;\n",
+      "AvgDR=Y*X*10**6*(1./3600)+Y*X1*10**6*(1./3600)+Y*X2*10**6*(1./3600);\n",
+      "CLoad=(N-1)/(N+1);\n",
+      "DLcap=(Rc*10**6*Pwr_Eff*Sec_Eff)/(((10**(Eb_N0/10))*(B+OF)*Vf));\n",
+      "Allowcap=CLoad*DLcap;\n",
+      "users=Allowcap/AvgDR;\n",
+      "\n",
+      "#Result\n",
+      "print 'NO of users that can be supported on the downlink of the WCDMA network are %d'%(round(users));"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "NO of users that can be supported on the downlink of the WCDMA network are 89\n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.11, Page 616"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "P1=1./2;#relative frequency of packets for user class1 \n",
+      "P2=1./3;#relative frequency of packets for user class2\n",
+      "P3=1./6;#relative frequency of packets for user class3\n",
+      "R1=16; #data rate in kbps for P1\n",
+      "R2=64; #data rate in kbps for P2\n",
+      "R3=1024; #data rate in kbps for P3\n",
+      "S1=16;#number of slots assigned to the R1 user\n",
+      "S2=8;#number of slots assigned to the R2 user\n",
+      "S3=2;#number of slots assigned to the R3 user\n",
+      "\n",
+      "#Calculations\n",
+      "#Using Equation 17.20 from page no 616\n",
+      "Ravg=(P1*R1*S1+P2*R2*S2+P3*R3*S3)/(P1*S1+P2*S2+P3*S3);\n",
+      "# For equal latency, using Eq 17.18\n",
+      "Rav=1./(P1/R1+P2/R2+P3/R3);\n",
+      "# For Latency ratio=4, using Eq 17.19 from page no 616\n",
+      "PL=4;\n",
+      "C=(P1+P2+PL*P3)/(P1/R1+P2/R2+P3/R3);\n",
+      "\n",
+      "#Results\n",
+      "print 'The average throughput for equal access condition is %.1f kbps'%Ravg;\n",
+      "print 'The average throughput by considering equal latency is %.1f kbps'%Rav;\n",
+      "print 'The average throughput by considering latency ratio as 4 is %.2f kkbps'%C\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The average throughput for equal access condition is 58.2 kbps\n",
+        "The average throughput by considering equal latency is 27.3 kbps\n",
+        "The average throughput by considering latency ratio as 4 is 40.96 kkbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.12, Page 620"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Ec_Nt=-23.;#in dB\n",
+      "DRC=-1.5;#DRC gain with respect to pilot in dB\n",
+      "Tg=3.75; # Traf\ufb01c channel gain with respect to pilot in dB\n",
+      "B=0.85;#Interference factor due to other cells \n",
+      "\n",
+      "#Calculations\n",
+      "Mmax=(1./(1+10**(DRC/10)+10**(Tg/10)))*(1./((10**(Ec_Nt/10)*(1+B))));\n",
+      "#The sector loading can be expressed as a fraction of the pole capacity Mmax. This is typically 70% of the pole capacity. \n",
+      "M_allow=int(0.7*Mmax);\n",
+      "#From table 17.2 we get Traffic channel rate as 9.6kbps since we are given traffic channel gain with respect to pilot as 3.75 dB\n",
+      "Ri=9.6; #in kbps(see table 17.2)\n",
+      "Tput=Ri*M_allow;\n",
+      "\n",
+      "#Result\n",
+      "print  'Allowable reverse link throughput is %d kbps'%(round(Tput));"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Allowable reverse link throughput is 173 kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 12
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.13, Page 623"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Ptmax=5.5;#Maximum transmit power of DSCH in watts\n",
+      "Pbs=18;# Total base station power in watts\n",
+      "alpha=0.2;#downlink orthogonality factor \n",
+      "G=0.363;# geometry factor\n",
+      "SF=16; #Spreading Factor for DSCH;fixed at value of 16\n",
+      "\n",
+      "#Calculations\n",
+      "# Using equation no 17.27 given on page no 623\n",
+      "SINR=SF*(Ptmax/(Pbs*(1-alpha+(1/G))));\n",
+      "# In dB\n",
+      "SINR_db=10*math.log10(SINR);\n",
+      "\n",
+      "#Result\n",
+      "print 'The average SINR of HSDPA is %.4f dB(%.1fdB)'%(SINR,SINR_db);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The average SINR of HSDPA is 1.3753 dB(1.4dB)\n"
+       ]
+      }
+     ],
+     "prompt_number": 13
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.14, Page 624"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Users=350;#no of users supported\n",
+      "ExpectedTraf=1.8; # From section 17.7 (in Kbps)\n",
+      "BHTraf=1.785;#Busy hour traffic in kbps\n",
+      "BTS=180;\n",
+      "\n",
+      "#Calculations\n",
+      "IubBW=(ExpectedTraf*Users*BHTraf)/1000;  # in Mbps\n",
+      "TotalBW=BTS*IubBW;\n",
+      "\n",
+      "#Result\n",
+      "print 'Required total bandwidth of Iub Interface is %.2f Mbps'%TotalBW;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Required total bandwidth of Iub Interface is 202.42 Mbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 14
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 17.15, Page 625"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "BTS=800.;#No of BTS sites\n",
+      "Sec=3;#No of sectors per BTS\n",
+      "freq_sec=2;#No of frequencies used per sector\n",
+      "cellsRNC=1152;#Maximum capacity of cellRNC\n",
+      "btsRNC=384;#One RNC can support btsRNC(BTSs)\n",
+      "VE=25;#Voice service(mErl/subscriber)\n",
+      "BRV=16;# bitrate Voice\n",
+      "CS1=10;#CS data service 1(mErl/subscriber)\n",
+      "BRC1=32;#bit rate for CS1 in kbps\n",
+      "CS2=5;#CS data service 2(mErl/subscriber)\n",
+      "BRC2=64;##bit rate for CS2 in kbps\n",
+      "PSdata=0.2;#PS data service(kbps per subscriber)\n",
+      "PSoverhead=0.15;\n",
+      "SHO=0.4;#40%\n",
+      "Totalsub=350000;#Total subsribers\n",
+      "Maxcap=196;#Maximum Iub capacity of tpRNC (in Mbps)\n",
+      "FR1=0.9;FR2=0.9;FR3=0.9;#Filler rates\n",
+      "\n",
+      "#Calculations&Results\n",
+      "RNCreqd=(BTS*Sec*freq_sec)/(cellsRNC*FR1);#from eqn 17.28\n",
+      "print 'using equation 17.28,Number of RNC required are %d'%(round(RNCreqd));\n",
+      "RNC_reqd=BTS/(btsRNC*FR2);#from eqn 17.29\n",
+      "print 'using equation 17.29,Number of RNC required are %d'%(round(RNC_reqd));\n",
+      "RNCrequired=((VE/1000*BRV+CS1/1000*BRC1+CS2/1000*BRC2+(PSdata/(1-PSoverhead)))*(1+SHO)*Totalsub)/(Maxcap*1000*FR3);#from eqn 17.30\n",
+      "print 'using equation 17.30,Number of RNC required are %d'%(round(RNCrequired));\n",
+      "print 'We select first value which is %d RNCs'%(round(RNCreqd));"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "using equation 17.28,Number of RNC required are 5\n",
+        "using equation 17.29,Number of RNC required are 2\n",
+        "using equation 17.30,Number of RNC required are 1\n",
+        "We select first value which is 5 RNCs\n"
+       ]
+      }
+     ],
+     "prompt_number": 15
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb
new file mode 100755
index 00000000..fee9ff09
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch19.ipynb
@@ -0,0 +1,106 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:dd18f098648291d58cdb32b1739d692bc9e7a8620a737fa84a463a3efca95463"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 19: Wireless Personal Area Network - Bluetooth"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 19.1, Page 666"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "SS=80.; #Frame length of HV3 voice packet\n",
+      "R=64*10**3; #Data rate in bps\n",
+      "TS=240; #No of bits carried in a slot\n",
+      "\n",
+      "#Calculations\n",
+      "#From table 19.3:Bluetooth air interface details, we get Frequency hopping rate as 1600hopes/second\n",
+      "\n",
+      "#From table 19.5, we can note that for HV3, No of slots are 1 and carry in all(80(user voice sample)+160(parity bits))=240 bits in one slot packet\n",
+      "HR=1600; #hopes/second\n",
+      "Eff=SS/TS;\n",
+      "x=R/SS;  #x is number of times a packet is sent\n",
+      "\n",
+      "#Results\n",
+      "print 'Hopping rate is %d hopes/sec'%HR;\n",
+      "print 'No of bits transmitted in one slot are %d'%TS;\n",
+      "print 'Efficiency of packet transmission is %.4f'%Eff;\n",
+      "print 'Number of times a packet is sent is equal to %d'%x;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Hopping rate is 1600 hopes/sec\n",
+        "No of bits transmitted in one slot are 240\n",
+        "Efficiency of packet transmission is 0.3333\n",
+        "Number of times a packet is sent is equal to 800\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 19.2, Page 666"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "R=136.; # bits per slot\n",
+      "SR=800; # no of slots per second\n",
+      "\n",
+      "#Calculations\n",
+      "# A symmetric 1-slot DM1 link is setup  between a master and a slave\n",
+      "AR=R*SR; #Data rate in bps\n",
+      "\n",
+      "#Result\n",
+      "print 'Associated data rate is %0.1f kbps'%(AR/1000);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Associated data rate is 108.8 kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb
new file mode 100755
index 00000000..b82f7950
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch2.ipynb
@@ -0,0 +1,533 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:dd4432cc2f7e790571ec64d7a8254cb368aab6a22204c8b382ba85e3c1b5a734"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 2: Teletraffic Engineering"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.1, Page 25"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "LC=10.; #Lost calls\n",
+      "CC=380; #Carried calls\n",
+      "\n",
+      "#Calculations\n",
+      "OC=LC+CC;  #Total offered calls\n",
+      "#Gos=Blocking probability=(number of Lost calls/Total number of offered calls)\n",
+      "Gos=LC/OC;\n",
+      "\n",
+      "#Result\n",
+      "print 'The Gos during busy hour is %f \\n '%Gos"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The Gos during busy hour is 0.025641 \n",
+        " \n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.2, Page 26"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Ht=5; #Average holding time in seconds\n",
+      "PC=450; # Peg count for one hour period\n",
+      "OC=0;    # Overflow count\n",
+      "\n",
+      "#Calculations&Results\n",
+      "# usage(Erlangs)=(peg count- overflow count)*Average holding time(in hrs)\n",
+      "U=(PC-OC)*(5./3600);   \n",
+      "print 'Usage = %.3f Erlangs'%U\n",
+      "\n",
+      "# IN CCS\n",
+      "Uccs=U*36;  # usage in CCS\n",
+      "print '%.1f CCS'%Uccs\n",
+      "\n",
+      "Ucs=Uccs *100;  #usage in call-seconds\n",
+      "print '%d call-seconds'%Ucs"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Usage = 0.625 Erlangs\n",
+        "22.5 CCS\n",
+        "2250 call-seconds\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.3, Page 27"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "B=0.05;  #Blocking(5%)\n",
+      "CL=3000.;  #Carried Load in CCS\n",
+      "\n",
+      "#Calculations\n",
+      "#Offered Load=Carried Load/(1-Blocking);\n",
+      "OL=CL/(1-B);  #Offered Load in CCS\n",
+      "\n",
+      "#Result\n",
+      "print 'Offered load is %d CCS'%OL\n",
+      "print 'Overflow is %d CCS'%((OL-CL))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Offered load is 3157 CCS\n",
+        "Overflow is 157 CCS\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.4, Page 27"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Ht=120;  #Holding time in seconds\n",
+      "CR=2.;  #call rate per hour\n",
+      "\n",
+      "#Calculations\n",
+      "#Traffic Intensity(Erlangs) = call rate * Holding time(in hrs));\n",
+      "I=CR*Ht/3600; #Traffic Intensity\n",
+      "\n",
+      "#Result\n",
+      "print 'Traffic Intensity is %.4f Erlangs = %.1f CCS \\n'%(I,I*36);\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Traffic Intensity is 0.0667 Erlangs = 2.4 CCS \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.5, Page 27"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "time=90.;  #in minutes\n",
+      "calls=10.;  #no of calls in 90mins\n",
+      "\n",
+      "#Calculations\n",
+      "CR=calls/(time/60);    #call arrival rate in calls/hour\n",
+      "tavg=(60.+74+80+90+92+70+96+48+64+126)/10;    #average call holding time in sec per call\n",
+      "I= CR*(tavg/3600);     #traffic intensity in Erlangs\n",
+      "\n",
+      "#Result\n",
+      "print 'Traffic Intensity is %.3f Erlangs = %.2f CCS \\n '%(I,I*36)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Traffic Intensity is 0.148 Erlangs = 5.33 CCS \n",
+        " \n"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.6, Page 28"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "time=8.;  #in hours\n",
+      "calls=11.;  #no of calls in 90mins period\n",
+      "\n",
+      "#Calculations&Results\n",
+      "CR=calls/time;    #call arrival rate in calls/hour\n",
+      "tavg=(3+10.+7+10+5+5+1+5+15+34+5)/11;    #average call holding time in mins per call\n",
+      "I= CR*(tavg/60);     #traffic intensity in Erlangs\n",
+      "print 'Traffic Intensity during eight hour period is %.3f Erlangs = %.1f CCS \\n'%(I,I*36);\n",
+      "\n",
+      "#For Busy Hour i.e between 4:00PM and 5:00PM\n",
+      "CRB=2;       #call arrival rate during busy hour in calls/hour(from table 2.2)\n",
+      "tavgB=(34+5.)/2;  #average holding time during Busy Hour in mins/call (from table 2.2)\n",
+      "IB=CRB*(tavgB/60); #Traffic Intensity during Busy Hour\n",
+      "print 'Traffic Intensity during busy hour is %.2f Erlangs = %.1f CCS'%(IB,IB*36);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Traffic Intensity during eight hour period is 0.208 Erlangs = 7.5 CCS \n",
+        "\n",
+        "Traffic Intensity during busy hour is 0.65 Erlangs = 23.4 CCS\n"
+       ]
+      }
+     ],
+     "prompt_number": 14
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.7, Page 29"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "minutes=500.; #No of minutes used per month per user\n",
+      "Twork=0.9; #Traffic During Work day\n",
+      "TBH=0.1;  #Traffic during busy hour\n",
+      "Days=20;  #No of workdays in a month\n",
+      "\n",
+      "#Calculations\n",
+      "#Avg BH usage per subscriber (in minutes) = minutes*Twork(TBH/Days);\n",
+      "Traffic=minutes*Twork*(TBH/Days);\n",
+      "\n",
+      "#Result\n",
+      "print 'Traffic per user per BH is %.4f Erlangs \\n'%(Traffic/60);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Traffic per user per BH is 0.0375 Erlangs \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 15
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.8, Page 29"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "minutes=500.; #No of minutes used per month per user\n",
+      "Twork=0.9; #Traffic During Work day\n",
+      "TBH=0.1;  #Traffic during busy hour\n",
+      "Days=20;  #No of workdays in a month\n",
+      "MeanHT=100;  #Mean holding time(in secs)\n",
+      "\n",
+      "#Calculations\n",
+      "#Avg BH usage per subscriber (in minutes) = minutes*Twork(TBH/Days);\n",
+      "#BHCAs=traf\ufb01c (in Erlangs) *3600/(meanHT)\n",
+      "\n",
+      "Traffic=minutes*Twork*(TBH/Days);\n",
+      "BHCAs=(Traffic/60)*(3600/MeanHT);\n",
+      "\n",
+      "#Result\n",
+      "print 'Average Busy Hour call attempts are %.2f'%BHCAs"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Average Busy Hour call attempts are 1.35\n"
+       ]
+      }
+     ],
+     "prompt_number": 16
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.9, Page 35"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Tpopu=200000;#Total population\n",
+      "SP=0.25; #subscriber penetration\n",
+      "HT1=100.;  #holding time for Mobile to Land line and vicecersa\n",
+      "c1=3;  #Avg calls/hr for Mobile to Land line and vicecersa\n",
+      "HT2=80.;  #For mobile to mobile\n",
+      "c2=4;   #For mobile to mobile\n",
+      "TMSC=1800;  #traffic one msc can hold\n",
+      "TrafDist=0.9 #Traffic distribution for Mobile to Land line and vicecersa\n",
+      "\n",
+      "#Calculations\n",
+      "aM_L=c1*HT1/3600;  #Traffic Generated by Subscriber (M-L and  L-M).\n",
+      "aM_M=c2*HT2/3600;  #Traffic Generated by Subscriber (M-M).\n",
+      "WlessSub=SP*Tpopu;  #total wireless subscribers\n",
+      "TotalTraffic=WlessSub*TrafDist*aM_L+WlessSub*(1-TrafDist)*aM_M;\n",
+      "MSCreqd=TotalTraffic/TMSC;\n",
+      "if(MSCreqd-int(MSCreqd)>0):#for rounding of to next integer ef 2.33 to 3\n",
+      "    MSCreqd=MSCreqd+1;\n",
+      "     \n",
+      "\n",
+      "#Result\n",
+      "print 'Total Traffic is %.1f Erlangs'%TotalTraffic;\n",
+      "print 'NO of MSCs Required are %d'%(int(MSCreqd))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Total Traffic is 4194.4 Erlangs\n",
+        "NO of MSCs Required are 3\n"
+       ]
+      }
+     ],
+     "prompt_number": 18
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.10, Page 37"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Rlines=15000.;#Residential lines\n",
+      "Blines=80000.;#Business lines\n",
+      "PWElines=5000;#PBX, WATS, and Foreign Exchange (FX) lines\n",
+      "CR_R=2.;#Call rates for Rlines\n",
+      "CR_B=3.;# call rates for Blines\n",
+      "CR_PWE=10.;#call rates for PWElines\n",
+      "HT_R=140.;#average holding time for Rlines(sec)\n",
+      "HT_B=160.;#average holding time for Blines(sec)\n",
+      "HT_PWE=200.;#average holding time for PWE lines(sec)\n",
+      "Slines=100000.;# no of lines carried by switch\n",
+      "HD_ABS=1.5;# HD/ABS for the switch\n",
+      "\n",
+      "#Calculations\n",
+      "percentR_lines=Rlines/Slines;\n",
+      "percentB_lines=Blines/Slines;\n",
+      "percentPWE_lines=PWElines/Slines;\n",
+      "CCSR=CR_R*HT_R/100;\n",
+      "CCSB=CR_B*HT_B/100;\n",
+      "CCSPWE=CR_PWE*HT_PWE/100;\n",
+      "\n",
+      "CR=CR_R*percentR_lines+CR_B*percentB_lines+CR_PWE*percentPWE_lines;\n",
+      "print 'The call rate is %.1f calls per line \\n '%CR\n",
+      "CCS=CCSR*percentR_lines+CCSB*percentB_lines+CCSPWE*percentPWE_lines;\n",
+      "AvgHTperline=CCS*100/CR;\n",
+      "ABS_BH_calls=CR*Slines;\n",
+      "ABS_BH_usage=CCS/36*Slines;\n",
+      "print 'Design cell capacity based on HD is %d calls \\n'%(HD_ABS*ABS_BH_calls);\n",
+      "print 'DESIGN Erlangs based on HD is %d \\n'%(round(HD_ABS*ABS_BH_usage)); "
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The call rate is 3.2 calls per line \n",
+        " \n",
+        "Design cell capacity based on HD is 480000 calls \n",
+        "\n",
+        "DESIGN Erlangs based on HD is 21917 \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 23
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.11, Page 43"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "maxcalls_hour=4000.;#maximum call per hour\n",
+      "avgHT=160.;#average holding time in sec\n",
+      "Gos=0.02;\n",
+      "\n",
+      "#Calculations&Results\n",
+      "A=maxcalls_hour*avgHT/3600; #offered load\n",
+      "print 'Offered load A = %.2f Erlangs \\n'%A\n",
+      "#Refering Appendix A i.e Erlang B table \n",
+      "print \"For calculated Offered load and referring Erlang B table we get Service channels as 182 giving 168.3 Erlangs at 2% blocking\"\n",
+      "#Incorrect answer in textbook"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Offered load A = 177.78 Erlangs \n",
+        "\n",
+        "For calculated Offered load and referring Erlang B table we get Service channels as 182 giving 168.3 Erlangs at 2% blocking\n"
+       ]
+      }
+     ],
+     "prompt_number": 27
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 2.12, Page 43"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "channels=50;\n",
+      "blocking=0.02;\n",
+      "HT=120;#average holding time inm sec\n",
+      "BHcall=1.2;# in calls  per hour\n",
+      "\n",
+      "#Calculations\n",
+      "#Refering Erlang B table in appendix A, For 50 channels at 2% blocking, the offered load=40.26 Erlangs.\n",
+      "A=40.26;\n",
+      "B=A*(1-0.02); #carried load\n",
+      "Avgtraffic_user=BHcall*HT/3600;\n",
+      "No_users=B/Avgtraffic_user;\n",
+      "\n",
+      "#Result\n",
+      "print 'NO of mobile subscribers supported are %d \\n'%(round(No_users))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "NO of mobile subscribers supported are 986 \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 29
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb
new file mode 100755
index 00000000..8bbb0588
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch21.ipynb
@@ -0,0 +1,476 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:0dee4e43707ceeefa5dfd2c385df6788c5d4953bcdfe972a22a90a0c7cd8abc7"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 21: Wireless Local Area Networks"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.1, Page 727"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "import sympy\n",
+      "from sympy import * \n",
+      "\n",
+      "#Variable declaration\n",
+      "Fl=902; #lower limit frequency MHz\n",
+      "Fh=928; #higher limit frequency in MHz\n",
+      "Rt=0.5; #symbol transmission rate in Mega symbols per sec\n",
+      "S=16; #No of symbols\n",
+      "BER=10**-5;#Bir error rate\n",
+      "SG=2.6;#sector gain\n",
+      "B=0.5; #Interference factor\n",
+      "a=0.9; #power control efficiency\n",
+      "\n",
+      "#Calculations&Results\n",
+      "BW=Fh-Fl;\n",
+      "Rb=Rt*math.log(S,2);\n",
+      "Gp=BW/Rb;\n",
+      "x = symbols('x')\n",
+      "y = solve(0.5*(1-erf(sqrt(x)))-10**-5,x)\n",
+      "M=Gp/y[0] * 1/(1+B) * SG * a;\n",
+      "print 'Number of users that can be supported by the WLAN are %d'%M\n",
+      "eff=Rb*int(M)/BW;\n",
+      "print 'The bandwidth efficiency is %.2f bps/Hz'%eff"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Number of users that can be supported by the WLAN are 2\n",
+        "The bandwidth efficiency is 0.15 bps/Hz\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.2, Page 733"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Stepsize=200.; #in Hz\n",
+      "Chipsmin=20.;#length of linear feedback shift register \n",
+      "Datarate=1.2*10**3;  #bps\n",
+      "\n",
+      "#Calculations\n",
+      "No_of_tones=2**Chipsmin;\n",
+      "Bss=No_of_tones*Stepsize;\n",
+      "Chiprate=Datarate*Chipsmin;\n",
+      "Gp=Bss/Datarate;#processing gain\n",
+      "Symbolrate=Datarate/3;  #8-ary FSK is used\n",
+      "Chips_symbol=Chiprate/Symbolrate;\n",
+      "\n",
+      "#Results\n",
+      "print 'The Hopping Bandwidth is %.3f MHz'%(Bss/10**6);\n",
+      "print 'The chiprate is %d kchip/sec'%(Chiprate/10**3);\n",
+      "print 'Chips per symbol are %d'%(Chips_symbol);\n",
+      "print 'The processing gain is %.1f'%Gp"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The Hopping Bandwidth is 209.715 MHz\n",
+        "The chiprate is 24 kchip/sec\n",
+        "Chips per symbol are 60\n",
+        "The processing gain is 174762.7\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.3, Page 734"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "InfoSc=48.;#Information subcarriers\n",
+      "SyncSc=4.;#synchronization subcarriers\n",
+      "ReservedSc=12.;#Reserved subcarriers\n",
+      "Symrate=250.;  #ksps(kilosymbols per second)\n",
+      "BW=20.;  #/in MHz\n",
+      "Grdt=800.; #Guard time in nsec\n",
+      "\n",
+      "#Calculations\n",
+      "TotalSc=InfoSc+SyncSc+ReservedSc;#Total subcarriers\n",
+      "BW_Sch=BW*10**6/TotalSc;#BW of subchannel\n",
+      "Mod_eff=Symrate*10**3/(BW_Sch);#Modulation efficiency\n",
+      "User_txrate=InfoSc*Symrate*10**3;\n",
+      "User_bitsymbol=4;  #16-QPSK is used\n",
+      "User_DR=36; #Mbps\n",
+      "Sym_Dur=1./(Symrate*10**3);\n",
+      "TimeUti=Sym_Dur/(Sym_Dur+(Grdt/10**9));\n",
+      "\n",
+      "#Results\n",
+      "print 'The bandwidth of subchannel is %.1f kHz'%(BW_Sch/10**3);\n",
+      "print 'Modulation efficiency is %.1f symbols/sec/Hz'%Mod_eff\n",
+      "print 'User symbol rate is %d Msps'%(User_txrate/10**6);\n",
+      "print 'Time Utilization efficiency is %.2f'%TimeUti"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The bandwidth of subchannel is 312.5 kHz\n",
+        "Modulation efficiency is 0.8 symbols/sec/Hz\n",
+        "User symbol rate is 12 Msps\n",
+        "Time Utilization efficiency is 0.83\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.4, Page 735"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Eb_No=10;  #in dB\n",
+      "Noise=-120; #in dBm\n",
+      "Pt=20; #in mwatt\n",
+      "R=1; #Data rate in Mbps\n",
+      "CHBW=0.5; #BW in MHz\n",
+      "A=37.7;  #path loss at the \ufb01rst meter in dB\n",
+      "Y=3.3; #path loss exponent\n",
+      "Lf=19; #function relating power loss with number of \ufb02oors n        (in dB)\n",
+      "Ls=10;  # lognormally distributed random variable representing the shadow effect in dB \n",
+      "\n",
+      "#Calculations\n",
+      "S2Nreqd=Eb_No*R/CHBW;\n",
+      "Rx_sensi=Noise+S2Nreqd;\n",
+      "Lp=10*math.log10(20)-Rx_sensi;\n",
+      "#Lp=A+10Ylod(d)+Lf+Ls;therefore\n",
+      "d=10**((Lp-A-Lf-Ls)/(10*Y));\n",
+      "\n",
+      "#Result\n",
+      "print 'The coverage of AP is %.1f metres'%d;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The coverage of AP is 25.3 metres\n"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.5, Page 758"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "R=3./4;#code rate of convolution encoder\n",
+      "M1=9.; #payload transmission rate in Mbps for mode 1\n",
+      "M2=36.; #payload transmission rate in Mbps for mode 2\n",
+      "\n",
+      "#Calculations&Results\n",
+      "D1=M1*10**6/48;#user data  rate in kbps for mode 1 \n",
+      "D2=M2*10**6/48;#user data rate in kbps for mode 2 \n",
+      "#Refering to Table 21.11\n",
+      "print 'Data transmission rate per carrier with 3/4 convolution encoder are %.1f Kbps and %d Kbps'%(D1/10**3,D2/10**3);\n",
+      "C1=D1/R;\n",
+      "C2=D2/R;\n",
+      "print 'Carrier transmission rate with R=3/4 convolutional encoder are %d Kbps and %d Kbps'%(C1/10**3,C2/10**3);\n",
+      "print 'Carrier symbol rate with R=3/4 convolutional encoder are %d ksps and %d Ksps'%(C1/10**3,C2/4/10**3);  #Mode1 as BPSK and MOde2 as 16-QAM"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Data transmission rate per carrier with 3/4 convolution encoder are 187.5 Kbps and 750 Kbps\n",
+        "Carrier transmission rate with R=3/4 convolutional encoder are 250 Kbps and 1000 Kbps\n",
+        "Carrier symbol rate with R=3/4 convolutional encoder are 250 ksps and 250 Ksps\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.6, Page 759"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "R=3./4; #code rate for convolution encoder\n",
+      "\n",
+      "#Calculations\n",
+      "#64-QAM modulation is used\n",
+      "Sc=250; #Carrier symbol rate(ksps) from Exa 21.5\n",
+      "Bits_sym=math.log(64,2); #64-QAM is used\n",
+      "User_R=Bits_sym*Sc*10**3*R*48;\n",
+      "\n",
+      "#Result\n",
+      "print 'The user data rate is %d Mbps'%(User_R/10**6);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The user data rate is 54 Mbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.7, Page 762"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "D=1000.*8;  #packet size in bits\n",
+      "R=2.*10**6;  #transmission rate in bps\n",
+      "L=3.; #msec(Dwell time)\n",
+      "H=0.625; #msec(Duration of BT packet)\n",
+      "\n",
+      "#Calculations\n",
+      "Tw=10**3*D/R;   #the packet duration of IEEE 802.11 in msec\n",
+      "H_L=1.;\n",
+      "G=(H_L)*L-Tw-H;\n",
+      "Gm=abs(G);\n",
+      "PER_FH=1-((1-Gm/L)*(78./79)**(H_L)+Gm/L*(78./79)**((H_L)-G/Gm));\n",
+      "PER_DS=1-((1-Gm/L)*(57./79)**(H_L)+Gm/L*(57./79)**((H_L)-G/Gm));\n",
+      "\n",
+      "#Results\n",
+      "print 'The PER for FH packet and PER for DS packet are %d percent & %.2f percent respectively'%(round(PER_FH*100),PER_DS*100);\n",
+      "print \"The collision probability with 802.11 DS is much higher than with 802.11 FH.\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The PER for FH packet and PER for DS packet are 2 percent & 38.73 percent respectively\n",
+        "The collision probability with 802.11 DS is much higher than with 802.11 FH.\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.8, Page 765"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "d=10; # distance between AP and IEEE 802.11 device in metres\n",
+      "Y=4; #path loss exponent\n",
+      "PBt=20;  #the transmitted power by the BT in dBm\n",
+      "PAp=40;  #the transmitted power by the AP in dBm\n",
+      "Pe=10**-5;#acceptable error probability\n",
+      "\n",
+      "#Calculations\n",
+      "#Pe=0.5*e**(-0.5*Eb/No)\n",
+      "SIR=math.log(Pe/0.5)/(-0.5);# signal-to-interference ratio \n",
+      "rmax=d*(SIR*PBt/PAp)**(1./Y);# range of interference between Bluetooth and 802.11 device \n",
+      "\n",
+      "#Results\n",
+      "print 'Minimum SIR is %.2f dB = %.1f'%(10*math.log10(SIR),SIR);\n",
+      "print 'Maximum coverage range is  %.2f metres'%rmax;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Minimum SIR is 13.35 dB = 21.6\n",
+        "Maximum coverage range is  18.14 metres\n"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.9, Page 765"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "SIRmin=21.6; #From eg 21.8 i.e(13.36 dB)\n",
+      "d=10; #distance between AP and IEEE 802.11 device in m\n",
+      "PMs=40; # transmitted power of the IEEE 802.11 device in dBm\n",
+      "PBt=20; #the transmitted power by the BT in dBm\n",
+      "Y=4 ; #path loss exponent\n",
+      "\n",
+      "#Calculations\n",
+      "rmax=d*(SIRmin*PMs/PBt)**(1./Y);\n",
+      "\n",
+      "#Result\n",
+      "print 'Maximum coverage range is %.1f metres'%rmax"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Maximum coverage range is 25.6 metres\n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 21.10, Page 765"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Gp=11;#processing gain(given)\n",
+      "#Defining variables from Exa 21.8 & 21.9\n",
+      "PBt=20; #  transmitted power by the BT in dBm\n",
+      "PMs=40;  # transmitted power of the IEEE 802.11 device in dBm\n",
+      "PAp=40;  # transmitted power by the AP in dBm\n",
+      "d=10;  # distance between AP and IEEE 802.11 device in m\n",
+      "Y=4;  #path loss exponent\n",
+      "Pe=10**-5;#Error probability\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#Pe=0.5*e**(-0.5*Eb/No)\n",
+      "SIR=math.log(Pe/0.5)/(-0.5);\n",
+      "r1max=d*(SIR*PBt/(PAp*Gp))**(1./Y);# range of interference between Bluetooth and 802.11 device \n",
+      "print 'Maximum coverage range for IEEE 802.11 DS is  %.2f metres'%r1max\n",
+      "r2max=d*(SIR*PMs/(PBt*Gp))**(1./Y);\n",
+      "print 'Maximum coverage range for IEEE 802.11 FH is %.2f metres'%r2max;\n",
+      "print \"Thus, the interference ranges are smaller for the IEEE 802.11 DS device than the IEEE 802.11 FH device.\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Maximum coverage range for IEEE 802.11 DS is  9.96 metres\n",
+        "Maximum coverage range for IEEE 802.11 FH is 14.08 metres\n",
+        "Thus, the interference ranges are smaller for the IEEE 802.11 DS device than the IEEE 802.11 FH device.\n"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb
new file mode 100755
index 00000000..40f3b8ea
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch3.ipynb
@@ -0,0 +1,543 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:f32dec82dcc091d4a1d388fd0afce868d4917308e897fe0d3ace9d832db79571"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 3: Radio Propagation and Propagation Path-Loss Models"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.1, Page 51"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "hb=100; #in feets(height of BS antenna)\n",
+      "hm=5;  # in feets(height of mobile antenna)\n",
+      "f=881.52;#in MHz\n",
+      "lamda=1.116;  #in feet\n",
+      "d=5000;  #in feet\n",
+      "Gb=10**0.8;  #8dB(BS antenna gain)\n",
+      "Gm=10**0;   # 0dB (Mobile antenna gain)\n",
+      "\n",
+      "#Calculations&Results\n",
+      "free_atten=(4*math.pi*d/lamda)**2*(Gb*Gm)**-1;\n",
+      "y=round(10*math.log10(free_atten));\n",
+      "print 'Free space attenuation is %d dB \\n'%y\n",
+      "reflect_atten= (d**4/(hb*hm)**2)*(Gb*Gm)**-1;\n",
+      "x=round(10*math.log10(reflect_atten));\n",
+      "print 'Reflecting surface attenuation is %d dB \\n '%x"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Free space attenuation is 87 dB \n",
+        "\n",
+        "Reflecting surface attenuation is 86 dB \n",
+        " \n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.2, Page 52"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "d=8000; #Distance between base station and mobile station\n",
+      "f=1.5*10**9;#in Hz \n",
+      "lamda=0.2;  #in metres\n",
+      "Pt=10; #BS transmitted power in watts\n",
+      "Lo=8;   #Total system losses in dB\n",
+      "Nf=5;    #Mobile receiver noise figure in dB\n",
+      "T=290;   #temperature in degree kelvin\n",
+      "BW=1.25*10**6; #in Hz\n",
+      "Gb=8;  #in dB\n",
+      "Gm=0;   #in dB\n",
+      "Hb=30;  #in metres\n",
+      "Hm=3.;   #in metres\n",
+      "B=1.38*10**-23; #Boltzmann's constant\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Free_Lp=20*math.log10(Hm*Hb/d**2);\n",
+      "Pr=Free_Lp-Lo+Gm+Gb+Pt;  #in dBW\n",
+      "Te=T*(3.162-1);\n",
+      "Pn=B*(Te+T)*BW;\n",
+      "print 'Received signal power is %d dBW \\n'%(10*math.log10(Pn))\n",
+      "SNR=Pr-10*math.log10(Pn);\n",
+      "print 'SNR ratio is %d dB \\n'%(round(SNR))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Received signal power is -138 dBW \n",
+        "\n",
+        "SNR ratio is 31 dB \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.3, Page 58"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "d=3*1000;#in metres\n",
+      "Y=4;# path loss exponent\n",
+      "Pt=4;  #Transmitted power in watts\n",
+      "f=1800*10**6;#in Hz\n",
+      "Shadow=10.5;  #in dB\n",
+      "d0=100.;#in metres\n",
+      "P0=-32;   #in dBm\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"Using equation 3.11 and including shadow effect we get\"\n",
+      "Pr=P0+10*Y*math.log10(d0/d)+Shadow;\n",
+      "print 'Received power is %.1f dBm \\n'%Pr\n",
+      "path_loss=10*math.log10(Pt*1000)-Pr;\n",
+      "print 'Allowable path loss is %.1f dB \\n'%path_loss"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Using equation 3.11 and including shadow effect we get\n",
+        "Received power is -80.6 dBm \n",
+        "\n",
+        "Allowable path loss is 116.6 dB \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.4, Page 58"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "shadow=10.; #in dB\n",
+      "Lp=150;  #in dB\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"Using equation given in Problem i.e Lp=133.2+40*math.log(d) we get,\"\n",
+      "d=10**((Lp-10-133.2)/40);\n",
+      "print \"Separation between transmitter and receiver as %.2f km\"%d"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Using equation given in Problem i.e Lp=133.2+40*math.log(d) we get,\n",
+        "Separation between transmitter and receiver as 1.48 km\n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.5, Page 61"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "v=60*0.44704;  #.. mph to mps\n",
+      "fc=860*10**6;#in Hz\n",
+      "td=2*10**-6; #RMS delay spread in sec\n",
+      "c=3.*10**8;# speed of light in m/sec\n",
+      "Rs=19200.; #Coded symbol rate in bps\n",
+      "\n",
+      "#Calculations&Results\n",
+      "lamda=c/fc;\n",
+      "fm=v/lamda; #Maximum doppler shift\n",
+      "tc=1/(2*math.pi*fm);#Channel coherence time\n",
+      "print 'Channel coherence time is %.4f sec \\n'%tc\n",
+      "ts=1/Rs; #symbol interval\n",
+      "print 'Symbol interval is %d microsec \\n'%(ts*10**6);\n",
+      "print \"As the symbol interval is much smaller compared to the channel coherence time. So, Symbol distortion is minimal and fading is slow.\";\n",
+      "print \"\";\n",
+      "Bc=1/(2*math.pi*td);\n",
+      "print 'Coherence Bandwidth is %.2f kHz \\n'%(Bc/1000)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Channel coherence time is 0.0021 sec \n",
+        "\n",
+        "Symbol interval is 52 microsec \n",
+        "\n",
+        "As the symbol interval is much smaller compared to the channel coherence time. So, Symbol distortion is minimal and fading is slow.\n",
+        "\n",
+        "Coherence Bandwidth is 79.58 kHz \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.6, Page 65"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "p=1;# re\ufb02ection coef\ufb01cient of ground \n",
+      "c=3.*10**8;# velocity of light in free space(m/sec)\n",
+      "e=2.71828;#Euler's number\n",
+      "fm=20;  #in Hz\n",
+      "fc=900*10**6; #carrier frequency in Hz\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Nr=math.sqrt(2*math.pi)*fm*p*e**-(p**2);\n",
+      "print 'NO of fades per second are %.2f  \\n'%Nr\n",
+      "Afd=e**-(p**2)/(p*fm*math.sqrt(2*math.pi));\n",
+      "print 'Average fade duration is %.4f sec \\n '%Afd\n",
+      "v=fm*c/fc;\n",
+      "print 'Maximum velocity of mobile is %.2f m/sec = %d Km/hour \\n'%(v,v*18/5);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "NO of fades per second are 18.44  \n",
+        "\n",
+        "Average fade duration is 0.0073 sec \n",
+        " \n",
+        "Maximum velocity of mobile is 6.67 m/sec = 24 Km/hour \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 13
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.7, Page 70"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "import matplotlib\n",
+      "import matplotlib.pyplot as plt\n",
+      "import numpy as np\n",
+      "%matplotlib inline\n",
+      "\n",
+      "#Variable declaration\n",
+      "d=np.array([1, 2, 3, 4, 5]);  #in km\n",
+      "hb=30; #Height of BS antenna in metres\n",
+      "hm=2;# height of mobile antenna in matres\n",
+      "fc=900;#carrier frequency in MHz\n",
+      "W=15;  #street width(m)\n",
+      "b=30;  # distance between building along radio path (m) \n",
+      "phi=90; # incident angle relative to the street\n",
+      "hr=30; #in m\n",
+      "\n",
+      "#Calculations\n",
+      "dellhm=hr-hm;\n",
+      "#L50=Lf+Lrts+Lms\n",
+      "\n",
+      "# By COST 231 model\n",
+      "Lf=32.4+20*np.log10(d)+20*np.log10(fc);\n",
+      "L0=4-0.114*(phi-55);\n",
+      "Lrts=-16.9-10*math.log10(W)+10*math.log10(fc)+20*math.log10(dellhm)+L0;\n",
+      "Lbsh=-18*math.log10(11);\n",
+      "ka=54-0.8*hb;\n",
+      "dellhb=hb-hr;\n",
+      "kd=18-15*dellhb/dellhm;\n",
+      "kf=4+0.7*(fc/925-1);\n",
+      "Lms=Lbsh+ka+kd*np.log10(d)+kf*np.log10(fc)-9*np.log10(b);\n",
+      "L50=np.array([0, 0, 0, 0, 0])\n",
+      "L50=Lf+Lrts+Lms;\n",
+      "\n",
+      "#Okumura/Hata model\n",
+      "ahm=(1.1*math.log10(fc)-0.7)*hm-(1.56*math.log10(fc)-0.8);\n",
+      "L_50=69.55+26.16*np.log10(fc)+(44.9-6.55*np.log10(hb))*np.log10(d)-13.82*np.log10(hb)-ahm;\n",
+      "L_50 = np.array(L_50)\n",
+      "\n",
+      "#Results\n",
+      "fig,ax1 = plt.subplots()\n",
+      "ax1.plot(d,L_50,'b-')\n",
+      "ax1.set_xlabel('Distance from transmitter(in km)')\n",
+      "ax1.set_ylabel('Path loss (in dB)')\n",
+      "ax2 = ax1.twinx()\n",
+      "ax2.plot(d,L50,'r')\n",
+      "ax1.legend(['COST 231 model'],loc=0)\n",
+      "ax2.legend(['HATA model'],loc=0)\n",
+      "ax1.grid()\n",
+      "plt.show()\n",
+      "print \"L50 values by Cost 231 model\"\n",
+      "print '%.2f  %.2f  %.2f  %.2f  %.2f \\n '%(L50[0],L50[1],L50[2],L50[3],L50[4]);\n",
+      "print \"L50 values bu Okumura/Hata model\"\n",
+      "print '%.2f  %.2f  %.2f  %.2f  %.2f \\n '%(L_50[0],L_50[1],L_50[2],L_50[3],L_50[4]);\n",
+      "print \"The results from the plot of two models shows that the calculated path loss with the COST 231 model is higher than the value obtained by the Okumura/Hata model.\"\n",
+      "\n",
+      "#Answers vary due to built-in functions of Python used"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "display_data",
+       "png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAEPCAYAAABhkeIdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJztnXd4VNXWh1+KNCkJUqRHBMEGiIUugU+6AlIEFDTCBTWK\nCl4LKk1RAQW8oIgiCAQBQZCO9NAE6R1pCtJ7h0DK+f5YZ5LJZGYyCdNOst7nOU9OP7/sTM6avdbe\na4GiKIqiKIqiKIqiKIqiKIqiKIqiKIqiKIqiKIqiKIqiKIrfGQucAnbY7esHHAW2mEsTu2O9gP3A\nX0BD/0hUFEXJlDh7PwN0B/YAO4FBdvuD5v1cB3iE5ML7Aj2dnPsAsBW4AwgDDgBZfaxPURQls+Ls\n/VwPWIy8hwEKmz/T/H725ct7FXDByf4sTva1ACYDscAhRPgTPlOmKIqSuXH2fn4N+AJ5DwOcMX+m\n+f0ciF5Bd2AbMAYIMfcVR1xkNo4CJfysS1EUJTNTHngSWAdEA4+Z+9P8fva3YfkOuAeoApwAhrg5\n1/CLIkVRFAUgOxAKVAfeBaa6Odft+zm7F0V5wmm79R+BOeb6MaCU3bGS5r5kFC9e3Dh+/Ljv1CmK\nomRMDgLlUjnnKDDDXN8AJACF8PD9bI+/eyzF7NafJSlwNBtoD+RAejTlgfWOFx8/fhzDMIJ+6du3\nb8A1qE7VqTpV4+nTBsOHGwD3evB+ngnUN9fvM9/HZz19P9vjyx7LZKAuYvGOICPCwhE3mAH8A7xi\nnrsb6XbtBuKASCzsCjt06FCgJXiE6vQuqtO7WEFnMGqMiYHZsyEqClatgqefdnqa7f18F/J+7oMM\nQR6LfOG/Bbxonpvm97MvDUsHJ/vGujn/c3NRFEVR0kBCAqxeLcZk+nR49FHo1AkmT4a8eeHnn1Nc\n4uz9DNDJxf40vZ/9HWPJFERERARagkeoTu+iOr2LFXQGWuPevWJMJk6EfPnEmGzfDiVLBlSW0zkl\nwYxhGJb1kCmKotw2Z8/ClCliUP79F55/XgxK5cqQxcUbPYscsNr73m8YzggNDTUQn58uuqRpCQ0N\ndfqZSg/Lly/32r18iTOd+j+UMRZXn2fzuN/IEK6wCxcuYGhPRkkHWVx9xctk6P9QxiBYPs/BocJz\nDGcf/ixZsug/hZIu9LMjaDtkDFz9Hf3tCtNEj4qiKIpXUcOiKF4iOjo60BI8wio6FeuihkWxLOPG\njaNOnToenRsREUHv3r19rEhR0k9aPqNhYWEsXbrUx4rSjxoWPzFp0iQee+wx8uXLR/HixWnatClr\n1qxJPL57926aN29OSEgI+fPnp379+qxduzbZPcaMGcP9999P/vz5ufvuu2nWrBlXr16lSZMm5MuX\nj3z58pEjRw5y5syZuB0ZGZlCy7x586hduzahoaEUK1aMrl27cvXq1cTj7733HqVLlyZ//vyULFmS\nnj17EhcXl3i8W7duVKxYkWzZsjF+/HgftJb3yZIli88Dm+Hh4T69v7ewik4bzl6irr5UhIeHU7Bg\nQWJjJfP7q6++mvi/kDNnTnLkyJG43axZMwAMw6Bs2bI8+OCDvv9l3JCWz6g/Ps+3gxoWPzB06FB6\n9OjBxx9/zOnTpzly5Aivv/46s2fPBuDgwYPUqlWLypUrc+jQIU6cOMGzzz5Lw4YNWbduHQArVqzg\no48+YsqUKVy+fJk9e/bQvn17ABYsWMCVK1e4cuUKL7zwAu+//37i9siRI1PouXz5Mn369OHEiRPs\n2bOHY8eO8e677yYe79KlC7t37+by5cusX7+eRYsW8eOPPyYer1KlCiNHjqRq1apB/eF2RIPT1sTT\nl+ihQ4dYv349RYoUYdasWQCMGjUq8X/hww8/pH379onb8+bNA2DlypXcvHmTM2fOsHHjRp/+LqmR\nUT6jalh8zKVLl+jbty8jR46kZcuW5M6dm2zZstGsWTMGDZLKn/369aNWrVp8+umnhISEcOedd9K9\ne3c6derE+++/D8CGDRuoUaMGlStXBiA0NJROnTqRN2/eFM9M7cPZoUMHGjZsSK5cuQgJCaFr167J\nek8VKlRIvK9hGGTNmpVixZLyh0ZGRlK/fn1y5cqV6u8fERFBZGQkTZs2JV++fNSpU4eTJ0/y1ltv\nERoayv3338/WrVsTz9+zZw/h4eGEhoby0EMPMWfOnMRj586do3nz5hQoUIBq1apx8ODBZM/666+/\naNCgAXfddRcVK1Zk2rRpqerzJlaJXVhFpzucGZoJEybw1FNP0alTJ6c9acNMzOjI+PHjad26NS1a\ntEi1Bx4WFsZXX31FpUqVyJcvH126dOHUqVM0adKEAgUK0KBBAy5evJh4/uzZs3nwwQcJDQ2lXr16\n/PXXX4nHtmzZQtWqVcmfPz/t27cnJiYm2bPmzp1LlSpVCA0NpVatWuzY4VhFOHhRw+Jj1q5dS0xM\nDM8++6zLc5YsWULbtm1T7G/bti1r1qzh5s2bVK9enYULF9KvX7/Efd5ixYoVPPTQQ8n2DRw4kHz5\n8lGqVCmefvppWrRoke77T5s2jc8++4yzZ8+SI0cOqlevzuOPP8758+dp06YNPXtKterY2FieeeYZ\nGjduzJkzZxgxYgQvvPAC+/btA+D1118nT548nDx5krFjx/LTTz8lvmCuXbtGgwYN6NixI2fOnGHK\nlClERkayZ8+edOtWggdHg+DMQEyYMIF27drx3HPPsXDhQk6fPp3iHEeuX7/O9OnTE6+bMmVKohvN\nGVmyZGHGjBksXbqUvXv3MnfuXJo0acLAgQM5ffo0CQkJDB8+HIB9+/bx/PPPM3z4cM6ePUvTpk15\n5plniIuL49atW7Rs2ZKXXnqJCxcu0LZtW6ZPn574ed6yZQtdunRh9OjRnD9/nldeeYXmzZu71aak\nH5ezSlMDvLOklYkTJxp3332323OyZ89uLFy4MMX+PXv2GFmyZDGOHz9uGIZhLFiwwHjmmWeMkJAQ\nI2/evEbPnj2N+Pj4ZNdEREQYH3/8scf6Fi1aZISGhhr79+93enzz5s1G6dKljenTp6c4Vrt2bWP8\n+PFu7x8REWF069YtcXvEiBHGAw88kLi9fft2IyQkxDAMw1i5cmWKturQoYPRr18/Iy4uzrjjjjuM\nvXv3Jh778MMPjdq1axuGYRhTpkwx6tSpk+zabt26Gf3790/U4axdPPnsZAZSbYdA/QMZhlGmTBkj\nb968RkhISOKSJ0+eZH/vVatWGbly5TIuX75sGIZhVK5c2Rg2bFiy+/Tt29fo2LFjsn1RUVFGyZIl\nDcMwjLi4OKNQoULGb7/95lJLWFiYMWnSpMTt1q1bG5GRkYnbI0aMMFq2bGkYhmF88sknRrt27RKP\nJSQkGCVKlDCio6ONFStWGMWLF09275o1axq9e/c2DMMwXn311cR1GxUqVDBWrlyZqGPp0qUp9Ll7\nR/rzRZ1peize+s9IK3fddRdnz54lISHB5TmFChXCWQGzEydOkDVrVkJDQwFo3Lgxs2fP5sKFC8ya\nNYtx48Yli32klXXr1vHCCy8wffp0ypVzXgPokUceITIykqioqHQ/p0iRIonruXLlSradO3fuxIED\nx48fp1SpUsmuLVOmDMePH+fs2bPExcUlO166dOnE9cOHD/Pnn38SGhqauEyaNIlTp06lW7diR6D+\ngZBewqxZs7hw4ULiMnLkyGS9lvHjx9OwYUPy5csHSG/fk4El48ePp1WrVgBky5aNli1bpnpd0aJF\nE9dz586dbDtXrlzJPs/2n9EsWbJQqlQpjh07xokTJyhRInl13zJlyiSuHz58mCFDhiT7PB89etTp\neyIYyRApXYKZGjVqkDNnTn777Tdat27t9JynnnqKadOmpciUOnXqVGrWrOk0llG/fn3q16/Prl27\n0qVry5YttGjRgnHjxlGvXj2358bGxnLnnXem6zlpoXjx4hw5cgTDMBJdAocPH6ZixYoULlyY7Nmz\n8++//1KhQgUA/v3338RrS5cuTd26dVm0aJHPdboiOjraEiOurKLTHfZG5caNG0ydOpWEhITEWODN\nmze5ePEi27dvp1KlSkDKuMzRo0dZtmwZGzZsYOpUqcJ7/fp1YmJiOHfuHHfddVeatdhTokSJZHER\nwzA4cuQIJc3Uw8eOJS/CePjw4cQveKVLl+ajjz7iww8/9EhDsJFpeiyBokCBAnzyySe8/vrrzJo1\ni+vXrxMbG8uCBQsSA/N9+/bljz/+4OOPP+bChQtcuXKFESNGEBUVlRjgnz17Nr/88ktiTqf169ez\nYsUKqlevnux5rj7k9uzcuZPGjRvzzTff0LRp0xTXf//991y8eDHxOSNHjkz8VgdiaGJiYkhISODW\nrVvExMS4fK4nemxUq1aNPHnyMHjwYGJjY4mOjmbu3Lm0b9+erFmz0qpVK/r168eNGzfYvXs348eP\nT3xZNGvWjH379jFx4kRiY2OJjY1lw4YNicHStOhQrMXMmTPJnj07e/bsYdu2bWzbto09e/ZQp04d\nJkyYkHie42cgKiqKihUrsm/fvsTr9u3bR8mSJZk8efJt62rbti3z5s1j2bJlxMbGMmTIEHLlykXN\nmjWpXr062bNnZ/jw4cTGxjJjxgw2bNiQeG3Xrl0ZNWoU69evxzAMrl27xrx585JNCwhm1LD4gZ49\nezJ06FAGDBhAkSJFKF26NCNHjkwM6JcrV47Vq1ezbds2wsLCKF68OL/99huLFi2iRo0agIwCGz16\nNPfddx8FChSgU6dOvPfee3TokLxejydDM4cOHcq5c+fo3Llz4pj+hx9+GJB/vpkzZ3LvvfdSoEAB\nunTpwoABA5IZlgYNGpAnTx7WrVtHt27dyJMnD6tWrXL6LEc9zvTZtnPkyMGcOXNYsGABhQsX5o03\n3iAqKor77rsPgG+++YarV69y991307lzZzp37px4j3z58rFo0SKmTJlCiRIlKFasGL169eLWrVse\nt8vtYpVegFV0usP+7zlhwgQ6d+5MyZIlKVKkCEWKFKFo0aK88cYbTJo0KdEN7fgZmDBhApGRkYnX\n2K579dVXkxkkT7Q401WhQgUmTpxI9+7dKVy4MPPmzWPOnDlkz56dHDlyMGPGDMaNG8ddd93F1KlT\nk3k0Hn30UUaPHs0bb7xBwYIFKV++PBMmTLDM8H5rqEzCcPbNUxPoKelFPzuCtkPGQJNQKkoGwyrz\nQ6yiU7EualgURVEUr6KuMCVTo58dQdshY6CuMEVRFCVDooZFUbyEVWIXVtGpWBc1LIqiKBmRK1dg\n1ix47TVnR8cCpwD7zJb9gKPAFnNpbO4PA27Y7U+ZMt2BDDHzPjQ01DLju5XgwpYuxxtYZX6IM536\nP5QxCC1QAAYNgt9/h40boXp1aNTI2ak/ASMA+wk7BjDUXBw5ADziqY4MYVjOnz8faAmKYmms8D90\n6RJMmwZRUbB7Nzz3HHTqBNWqQaa1iefOweLFYkgWLoS8eeHoUfjvfyE8HGypmOzqLZmsQnoijnil\nJdUV5gOs4sNWnd5FdXqX6OhoYmNh7lxo1w7KlIEFC6BHDzh2DL79Vr6QB9Ko+L0t4+Nh7Vro21cs\natmyMGkSPPEErF4N+/fDiBHQrFmSUUkb3YFtwBggxG7/PYgbLBqondpNMkSPRVGUjMXmzfJ+bNcO\nypWDF1+E776DggUDrSwAHD8uvZHff4clS6BkSWjcGL74AmrVgpw5U1wSHR2dHqP3HfCJuf4pMATo\nAhwHSgEXgKrATOBB4IqrG1mtA+l0HouiKNbHMOT9OXAgHDoEL78MHTvCvfcGWpmfuXkT1qwRQ/L7\n7+LaatBAjEnDhuCQbt8TXMxjCQPmAA87ucTdseXAO8BmV8/THouiKAElLg5+/VUMSnw8fPCB9FSy\nZ6a308GDSXGSFSvg/vvFkHz/PTz+uL8aoxhwwlx/lqQRY4WQ3ko8UBYoD/zt7kYaY/EBVvJhWwHV\n6V2CRWdMjLw3K1SQeMlnn8H27fDCC/IeDRad7ki3xmvXYN486N4dypeH2rVhwwZ4/nn4+29Ytw76\n9YMaNXxlVCYDfwAVgCNAZ2AQsB2JsdQFepjnPmnu2wJMA14BLrq7eWb6TqAoShBw6RKMGgVffw2P\nPgrjx8t7NUNjGLBrV5J7688/4bHHpFfy669QqZK/RyF0cLJvrItzZ5iLx2iMRVEUv3DyJPzvf/DD\nD9CkCbz3nrxPMywXLsDSpUnG5I475Bdv3Bjq1QOzjLI/8HeuMO2xKIriU/7+G776CqZMEU/Pxo1w\nzz2BVuUDEhJg06YkQ7J9O9SpI4bkvffE5ZVJJtxojMUHWME3DKrT26jO5GzbJobkiScgNBT++gu+\n+cZzo2KF9vxjxgyYMEECQ0WLQkQEXLwo8ZEzZ2D+fHjzTbjvvkxjVEB7LIqieBHDkHl6AwfCli0y\nmXHUKMifP9DKvERsrExQNHslj+/fLylTGjWSeSWlSwdaYVDgSxM6FmgGnCblWOh3gC+RYWznkTHT\ne4C/zONrgUgn99QYi6IEIQkJMshp4EA4fVo8P506Qa5cgVbmBQ4dSpqguHy5zNhs3FiWatUkdhLk\nZKQYi7MkZyAzOBsAhx32pynJmaIogSc2VmIngwZBjhwyB6V1a8iWLdDKboMbN2Quic2YnDsnPZI2\nbWR8dJEigVYY9PgyxrIKmVTjyFDgPR8+N+BYwTcMqtPbZCad169LvKR8efjpJxg6VOLWzz3nPaPi\nt/Y0DAkAff219EKKFIHPP4dChWDiRBnOFhUlcRQHo2KVv7m/8XeMpQWS73+7k2O2JGeXgI+B1X7U\npSiKB1y4IJMZR4yAmjWlt1K9eqBVpYPLl5OGAi9cKL68xo2hWzf45RcoUCDQCi2NPw1LHuBDxA1m\nw+bz8zjJWUREBGFhYQCEhIRQpUqVxPoStm8Puu3Ztm1fsOix+rZtX7Do8eb28ePQo0c08+dDmzbh\nREfDqVPRxMQA+Ob5tn1euV9CAhvHjKHg+vWU3bcPNm/mfMWKnH/8ccrNnw/330/0ihVyvmlUPL2/\nvVZv/v6+aE9/4etgThhJicweBpYA181jJYFjwBNIgN8eV0nONHivKH5k3z748kuYPh1eegl69oRS\npQKtykPOnEleqyQkJCnoXrcu5MkTaIV+w9/Be3/OY9kBFEVcXvcgLrGqiFEpBNg8sx4lOQtmHL/J\nBCuq07tkJJ2bNkHbtpKVvUQJMTDDhvnXqKS5PePiJCtwnz4yeaZcOZg6VXx269bB3r0y9b9JE68Z\nFav8zf2NL11hk5FEZnchSc76ICPFbNh3PZ5E6gDEAgl4kORMURTvYhgymvaLLySW/c47EpjPmzfQ\nytxw9GjS6K2lS6UaWKNGMHiwGJQcOQKtMFNitamg6gpTFC+TkAAzZ8oclCtX4P33ZcZ8UL6Tb96E\nVauS3FsnTiSvVVKsWKAVBiX+doWpYVGUTMqtWzKadvBgmRnfqxe0aAFZgy3R04EDSfm3Vq6Ehx4S\nQ9KokWQItvSkGf+QkWMsmQar+F1Vp3exis4FC6IZNkwqM/7yi5T8/fNPePbZIDEqt27B3Lkca9lS\nRD75pNQqfvFFmQX/xx8SR6lWLeBGxSp/c3+jucIUJZNw9qzMP/n6a/myP2sWVK0aaFUmhiE5uCZO\nlID7/fcT8+CD8Omn0kPJRAkcMwJW+2upK0xR0si//8rM+AkTJCvJu+/KjPmgYP9++PlnMSjZs0uC\nsRdeAHOumuIdMlKuMEVRAsju3RI/mTMHunSBnTuhePFAq0K6Tr/8Isbk77+hQweZwv/oo9ozySAE\ng0c1w2EVv6vq9C7BonPdOmjZUooUli8vse/Bg5OMSkB0xsTAtGnQvLnML1mzBnr3luHCX38tQXgH\noxIs7ekOK2gMBNpjUZQMgGHAokUyZPiff8TdNWlSgCeXJyTI0OCoKJgxQwI6nTpJTyXDFGhRnGG1\nfqfGWBTFjvh4+PVXMSixsZK2vl27AJcI2bNHjMnPP0syx06dxN1VsmQARWVuNMaiKEqqxMTA+PGS\nx6toURk81bRpAIcLnzwpcZKoKFl//nkJ7lSqFCBBSiDRGIsPsIrfVXV6F3/ovHxZ4iVly8p7e9w4\nCVc8/bTnRsVrOq9dE39bkyZQsaLUIh40SIahffnlbRsVK/zdraAxEKhhURQLcOoUfPihGJRt22QS\n+ty5ULu2n4XEx8OSJZLquGRJ6aF06gTHjkkX6qmnAj5pUfGIscApJDmwjX5IcuAt5tLE7lgvYD9S\nPr5hajfXGIuiBDH//CNf/qdMkTDFO++IcfE727ZJ0H3SJMnH1bEjtG8Pd98dADFKWnESY6kDXEVK\nxz9s7uuL1MAa6nD5A8Ak4HGgBFL+5D4kYbBTNMaiKEHI9u3iVVq4EF55ReLhRYv6WcTRo2JIJk6E\nS5dk4uLixfDAA34WoviAVUi9LEecdTZaINnqY4FDwAGkjtY6VzdXV5gPsIrfVXV6F2/oXLUKmjWT\nHIuVK8PBg/DZZ941Km51XrkigZunnpIYyf79kgfmn3+kDrwfjYoV/u5W0JhGugPbgDFAiLmvOOIi\ns3EU6bm4RHssihJgEhJg/nwZMnzyJLz3nlRszJXLTwLi4mQSzMSJIqRuXekmPfOMH0Uo3iQ6Ojo9\nRu87pC4WwKfAEKCLi3PdxiQ0xqIoASI2VjKbDBokabI++EByefkl9m0YUiYyKkoCOGXLShD+ueeg\nUCE/CFD8iYt5LGEklY53xP7YB+a+gebP35F4zJ+unqc9FkXxM9evw9ix8NVXcM898rNhQz+lyTp0\nKCnpY2ysBOFXrw6irJRKACkGnDDXnyVpxNhsJHg/FHGBlQfWu7uRxlh8gFX8rqrTu6Sm88IFiZeU\nLStVdKdMkVLAjRr52KhcvAijR0tdk8ce49j69WLZ9u+Hfv2C1qhY4e9uBY0umAz8AVRASsd3BgYB\n25EYS12gh3nubmCq+XMBEEkqrjDtsSiKjzl+HIYNk3f5M8/AsmV+iIHfugULFoira/FiKd/7zjvQ\npAn7//iDEjVq+FiAEuR0cLJvrJvzPzcXj9AYi6L4iP37ZQ7Kr79K8cOePaF0aR8+0LFY1gMPSNyk\nTRsIDfXhg5VgR3OFKYrF2bRJAvLLl0NkJOzb5+N4uLNiWRs3arEsJWBojMUHWMXvqjq9h2HAsGHR\nNGwILVpAjRoy9aN/fx8ZlbNn4dtv5UG1a0scZcoUmUn50UdujYoV2hOsodMKGgOB9lgU5TbZvx+6\ndpViiP37ywT1HDl88KCYGMk8GRUFK1bITMrevSV+EtA8+YqSnLT43HIhIwFu+kiLJ2iMRQka4uPh\nf/+TCem9e8Mbb/hgDoqzYlkdO0KrVlosS/GYYIqxZAVaIqMHaprbWYB4YC3wMzCTVIadKUpG5K+/\noHNn6SisWyfVdr2Ks2JZ27drsSzFEriLsUQDjwJfAWWRyTN3m+tfIZkuV/hYnyWxit9VdaaduDip\nh1K7tri8li9PMiq3rfPkSan//uijkqsrNlZcX9u3S61hLxmVYGpPd1hBpxU0BgJ3PZYGOHd73USy\nWq4DcvpClKIEI7t2wcsvQ758sGGDzJq/ba5dg1mzpHeydq1E/gcNgnr1tK6JYlnS4nO7E7gfOAyc\n8Y2cVNEYi+J34uJkPsrQoTBgAHTrdpsz5ePjpasTFQWzZ0P16uLqatEC7rzTa7oVxUYwxViaA8OB\n88DHwLdIxbF7gPeBcb4WpyiBZscO6aUULChTQ8qUuY2bOSuWNWiQFstSMhzuYiwDkBKUrwDTgP8D\nqiPZLv/re2nWxSp+V9XpmthY+PRTqF8fXn1VCm6lZlSc6jx6VIIylSpB8+YS7V+8WKzU228HxKjo\n3917WEFjIHDXY4kH9pnrf5sLwGmkkpiiZEi2bpVeSrFisHkzlCqVxhtcuSIFVSZOlBu0aiXFsurU\ngaw6J1nJ+LjzuW0Hws1zlpvr2G1X8qUwF2iMRfEZt25J9uHvvpNOxksvpSGW4qxYVseOWixLCQqC\nKcaSH9hkrmexW1eUDMemTdJLKVNGeizFi3t4YWyslPIdMEC6OJ06wfDhWixLydS465eHIYH6exzW\nbYviAqv4XVUn3LwpqbWaNpWSwLNne2hU4uLEoFSoIJmEp0wheuBAeP31oDcq+nf3HlbQGAjc9Viq\npnLtZm8KURR/s3699FLuu08GbHkUR4+Pl2SP/fuLBRo3TgpoAehLRlEA9z63aCRdS25kBv52c38l\nYCOQWqWgsUAzJNjvWFP5HeBLoBAynBmgF1LFLB54E1jk5J4aY1Fum5gY6NsXxo+Xie7t2nkQS0lI\nkIB8v36SYsU2ZMwv9YQV5fYIphhLuPlzBtCVpPrHDwH9Pbj3T8AIYILD/lLIrP7DdvseANqZP0sA\nS4D7gAQPnqMoHrN2rfRSKlWSTClFiqRygWHAzJliiXLlgiFD/FBLWFGsjSdjHyuSZFQAdiIz8FNj\nFXDByf6hwHsO+1ogNZhjgUPAAeAJD54RlFjF75qZdF6/LpV5W7WSOPvUqakYFcOAuXMlb9cnn8hw\nsT//hMaNXRqVzNSe/sAKOq2gMRB4Uo9lO/AjMBHpSj0PbEvn81oAR0lyq9kojuQes3EU6bkoym2z\nahV06SI2YseOVGLrhiHDhvv0EWvUvz+0bKnzTxQlDXjSn88NvAbUMbdXAt8BMR5cGwbMQWIseZD5\nLw2Ay8A/wGPAOcRltg5JxQ9iyOYjbjh7NMaieMy1a/DhhzBtGowcKfbBLcuWiUE5d04MSps2alCU\nDEEwxVhs3EDcV0Nv81n3IobG1tspicyNqQYcQ2Iv2B075uwmERERhJllV0NCQqhSpQrh4eFAUrdU\nt3V7xQp4/vloHngAdu4Mp2BBN+dnzw69e3N9/34Ov/QS93/yCWTLFlS/j27r9u1uZyTCSB6fsecf\noKC5/gCwFciBzJE5iHPraliB5cuXB1qCR2REnVeuGMbrrxtGiRKGMWdOKievXWsYDRoYRliYYYwd\naxixsX7TGUhUp/ewgkbDMAz8XJDRl/38ycAfyOiuI8DLDsftf9HdwFTz5wIgEq1MqaSRpUvh4YfF\nBbZjBzyAM/t9AAAgAElEQVT9tIsTN22SevHPPSfurr17ZahYdk868IqSIRiLZKt39sX/HWREru2L\nfxjiudpiLiNTu7nVxkyaxldRkrh8WWbNz5sHP/wATZq4OHHbNhk2vGGDBF/+8x/IqbXqlIyPkxhL\nHeAqMh3Efp5hKWA0UAGZv3ie5LFyj/Ckx1LBfNBiJPi+HFjm6QMUxZcsWiS9lPh42LnThVHZtQva\ntpWhwuHhcOCApF5Ro6JkXtIyHSTNeGJYpiHpWz4G3rVbFBfYgmbBjpV1XrokHY6uXWH0aFkKFHA4\nae9eeP55mSH/xBNiUN5+G3Ln9pvOYER1eg8raEwDrqaDgMS+tyAZWWqndiNPnMqxyPBiRQkK5s+H\nV16RGMqOHZA/v8MJBw/KpMb586FHD/j+eylUryiZhOjo6LQavTzAh8h0EBs219lxxEV2AckhORN4\nELji6maexFj6ITXuZwA37fafd3q2b9EYSybmwgWxEytXwo8/SkckGYcPSw6vmTOhe3fpnaToxihK\n5sPFPJYwkmInDyOptK6bx2xTPp5A8j3asxwJ8LtMROxJjyUCGaHlWI5YU+crfmP2bHjtNUnJsn07\n5M1rd/DoUUm5MnWqnLRvnxSpVxTFU3YARe22/yEpeF8I6a3EA2WB8iRVFHaKJzGWMFLWYlGj4gar\n+F2toPPcOWjQIJqePWHSJKnwm2hUTpyAN9+UjJL580tMZcCAgBkVK7QnqE5vYgWNLkjLdJAnkYnt\nW5CY+yvARXc3d9dj+T9gKdAa53NKHNOtKIpXmTED3ngDataUkcJ33mkeOH0aBg2Cn36CiAjYsweK\nFnV3K0VRktMhleNl7dZnkMb3vbsYS3+gLzAO54bF0cL5A42xZALOnJEQyebNYjtq1TIPnDsHX34p\nQ8Cefx569UpDDWFFybz4O1eYTpBUgopp08S71bGjDOzKnRuJ2g8dKpkk27aVyY2lSwdaqqJYBn8b\nFncxlgjcu8pyEJheS9BjFb9rMOk8fVpsRp8+8Ntv0jHJHXsZPvmE2LAwOH4cNm6EUaOC1qgEU3u6\nQ3V6DytoDATuDEteYAMS5OmJ1GF5ARlmNhn4E0mpryjpxjBg8mSJv5crB1u2QPWHrsIXX8iOAwfY\n/O23MGYM3KNjRhTFCqTWNcoC1EJmWtq+Jh4GViMjCvztl1JXWAbi5EkZHbx/v8RSHn/wuri7vvwS\n6tWTvF73e1KsVFEUdwRbPRYDMSKr/aBFySQYBkycCP/9r6RkmTIuhpzjf4AWA6FGDViyRBKAKYpi\nSbQ8ng+wit81EDqPHYPmzaVTsmDmTQaU+I6cD5UXYzJvHkyfnsKoaHt6F9XpPaygMRCoYVH8gmGI\nu+uRR+DxKrFsjvyRqh0qwJw5MmFl9mw5qCiK5dHhxorPOXIEunWDMyfimNFqIqXHfQL33it15WvW\nDLQ8RcnwBNNwYxtvAwUQUWOQaf2NfClKyRgYhsxlfOyReF7J+zMbrj1A6aU/Sddl8WI1KoqSQfHE\nsHQGLgENkVKVnYCBvhRldazid/WlzsOHoXHDBA4MnMbhkEq0PPYtWUZ9B9HRULdumu6l7eldVKf3\nsILGQOBJdmNb96kZEAXs9J0cxeokJMD3owzWfjCLqDv7UrhEDrIMGAKNGkEWq3leFUVJD578p48D\niiNJySoD2ZB8/I/6TpZLNMYSxPzzt8EPLefz0sE+lCmdQO7Bn0g1LjUoihJQgjFXWFbgEeAgkir5\nLqAEzstX+ho1LEFIQrzBnDcXU+KHPpQpdI2CI/qTrVVLyKqDDhUlGAjG4H0NYC9iVDoBHyMxF8UF\nVvG7ekPnsYnL2VnwSSr/9BbFB/eg8LFtZGvTyqtGJTO1pz9Qnd7DChoDgSf//aOAa4gbrCdwAJjg\nS1FK8BO/YjVHytfn5ktdOf50N0pd3EnxHu20l6Ioikddoy2IK6wvUgP5R6TWcVUf6nKFusICzbp1\nXHunD5c27WdC6d60mf0i5Sp6MgZEUZRAEWy5wgCuAB8CHYE6SPD+Dl+KUoKQTZswevfhytod9Iv9\nmHIDI3jvzRzaQVEUJQWevBbaATeR+SwnkcD9l74UZXWs4nf1SOe2bdCyJbFNm/PV7qa0rbyfN7Z3\nI/Jt/xmVDNWeQYDq9B5W0BgIPHk1nAB+BkKAp4EYNMaS8dm1C9q2xWjcmCVx4ZSNP0C+D15nwbKc\nlC2b+uWKomRePPG5PYf0UFaY208C7wLTfCXKDRpj8TV790pN4MWLOdnxv7SNfp1cd93J6NEQFhZo\ncYqipIdgnMeyHXgKOG1uFwaWApV8JcoNalh8xcGD8OmnMG8e8d3fZkjsm3w5Kh+ffw7/+Y/OcVQU\nKxOM81iyAGfsts9hvazIfsUqftfo6GhJ6tW1K1SrBmFh7PjtAI/P/IhlG/KxaZMcCrRRsVR7WgDV\n6T2soDEQeGJYfgcWAhHAy8B8YIEPNSn+4MwZyg8bBlWrQpEi3Nq5j3704/9aFaB7d1iwAEqXTv02\niqJYkrHAKWCHk2PvAAlI0mEbvYD9wF9IQmK3ePJdNAvQCql7bwCrgN88uM4XqCvMG+zdC02bytKn\nD1uOFiYiAkqVgu+/hxIlAi1QURRv4sQVVge4igzEsi/ZWgoYDVRA8kGeBx4AJgGPI6OClwD3IcbH\nKZ7MYzGA6eaiWJ3Vq6F1a/j8c2527MKAAfDDD/DVV9CxY+DdXoqi+IVVQJiT/UOB94BZdvtaAJOB\nWOAQkn3lCWCdq5u7c4VdRSZHOlsueyg+UxK0ftdffoFnn4UJE9hbuwsVK0azYwds3QqdOgWvUQna\n9nRAdXoXK+i0gsY00AI4SsoEw8XN/TaOIj0Xl7jrseRNlzQl+DAMGDwYvvkGlizheOHKNKoJrVrB\nkCHBa1AURUkf0dHRaTV6eZAMKw3s9rl7M7iNSVjtlaIxlrQSFwfdu8Mff8C8eVzOX5Inn4R27aBX\nr0CLUxTFH7gYbhwGzEFiLA8jsZPr5rGSSG7IasigLUiqHPw7kjvyT1fP82VSDmejDj4FtgFbkbkw\npcz9YcANJOHlFmCkD3VlHq5ehRYtZI7KqlXEFi1JmzZQowZ88EGgxSmKEkTsAIoC95jLUSTR8Clg\nNtAeyGEeKw+sd3czXxqWn4DGDvsGI+n3qwAzEatn4wCSRfkRINKHunxOUPhdT5yQ2vJFi8K8eRj5\n8vOf/0CuXDBihLi/gkKnB6hO76I6vYcVNLpgMvAHMrrrCEm9Ehv2rqHdwFTz5wLk/ezWdeTLfOfO\nRh1csVvPC5z14fMzL7t2QbNmMmX+o48gSxb69JZRxsuWQXbNcq8omZ0OqRx3zAj4ubl4hCcxltaI\nb62o3fkGkN+Da8NI8uHZ+AypRHkdqI5UpgwDdiITcC4hVSpXO7mfxlhSY9kyaN8ehg6V8cPIcOIv\nv5QwS+HCAdanKIrfCcZcYQeRrMZ70nH/MFIaFhsfIJNwXkZ8d3cCFxC/3kzgQZL3cEANi3uiouCd\nd2RYcb16AMydK2lZVq2CcuUCrE9RlIAQjIW+TpI+o5Iak5D0MAC3zAWkOuVBJEC02fGiiIgIwsw0\nuyEhIVSpUoXw8HAgyd8Z6G3bPr89v25dGDCAmG+/ZfugQTxhGpXvvoumVy9YtCiccuVSXv/1118H\nZfsFvD3Tua3t6d1tK7Tn1q1befvtt4NGj7vtYKG1ufwP+AXxydn2tfLwHmEkHxVW3m69OxBlrhdC\nKlOC+PaOIvVfHDGswPLly/33sFu3DOPllw2jalXDOH48cfeBA4ZRrJhhzJ7t+lK/6rwNVKd3UZ3e\nwwoaDcMwSCXY7m3cdY3GkSQmCymFOY4icGQyUBcxGqeQEWBNEfdXPNIreQ1Jx98K+ARJGZAA9AHm\nObmn2UYKAJcvQ5s2kCMHTJkCeWVO65kzULMm/Pe/8MorAdaoKErACcYYS21SBtKd7fMHalhsHD0q\nSSRr1ZLxw+ZQr+vXoX59eOopGDAgwBoVRQkKgrEey3AP9ykm9r5sn7B1q8xy7NgRRo5MNCrx8dCh\nA1SoIDW7Aq7TS6hO76I6vYcVNAYCd8H7GkBNoAjQkyRrl4+keIjibxYuFIPy7bfw3HOJuw1DMrdc\nvw7Tpmn+L0VRAoe7109doB7wCjDKbv8VZAjxfh/qckXmdoX9+KNMeJw+HWrXTnZo4EAJs6xcCfk9\nmWGkKEqmIRhjLGFIDv5gIHMaFsOA3r1h8mSYP198XXZMnAgffywTIIsXD5BGRVGClmCMsVwHvkLm\nnCw3l2W+FGV1vOp3vXlTXF9LlsDatSmMytKlMidy/vy0GxWr+IdVp3dRnd7DChoDgSeG5WekznFZ\noB/Se9noO0lKIhcuQKNGcOOGpGopUiTZ4W3bJFg/bRo88ECANCqKojjgSddoM5JmZTtQydy3EXjM\nV6LckHlcYYcOyXDiRo2kbnC25OMljhyRuSpDhiSL4SuKoqQgGF1htlQrJ5GcYVWBUJ8pUmDjRrEa\nr7wCw4alMCoXL0KTJtCjhxoVRVGCD08MywAkvco7wH+BH4EevhRldW7L7zpnjliNkSPhrbdSHL55\nE1q2hAYNoGfP9D8GrOMfVp3eRXV6DytoDATu5rHkBl4FygElgDFAuB80ZV6+/Vamy8+dC9WqpTic\nkAAREZL6fsgQ/8tTFEXxBHc+t6mIG2wVkuPrEJDyK7R/yZgxloQEeP99mD0bFiyAso41doR334V1\n62DxYqkEqSiK4gnBlDb/fpLqqIwBNvheTibkxg148UU4eVImotx1l9PThg+XjsyaNWpUFEUJbtzF\nWOJcrCup4LHf9exZyRaZLZt0Q1wYlRkzYPBg6cwULBgAnQFGdXoX1ek9rKAxELgzLJWQ9C225WG7\n9cu+l5bBOXBARn7VqQOTJrnshqxZA6++KjF9s76ZoihKUGO1VIUZI8aydi20agX9+rktmPLXXxAe\nDhMmQMOGflOnKEoGI5hiLIovmD5duiDjx8sESBecPCmHBw5Uo6IoirXwZB6Lkkac+l0NQyY7vvWW\npL53Y1SuXIFmzeDll2V4sa+win9YdXoX1ek9rKAxEKhh8Qfx8WJQxoyRkV9Vq7o8NTZWZtM/+qhk\nLFYURfEBY5GS8Tvs9n0KbAO2AkuBUub+MOAGsMVcRqZ2c42x+Jpr1+D556UbMmMGhIS4PNUwoEsX\nOHUKZs1KLAypKIpyWziJsdQBrgITSJpWkg8ZnAXQHagM/AcxLHPszksV7bH4klOnoF49KFAAfv/d\nrVEB6N8fduyAX35Ro6Ioik9ZBVxw2HfFbj0vcDa9N1fD4gOio6NlSFeNGpL3a/x4yJHD7TVjxkBU\nlEyCzJvXjzotgOr0LqrTe1hBYxr5DPgXeAkYaLf/HsQNFg3UTnlZcvR7sQ8osG0btGsnQ7pefjnV\n8+fPl4rDK1dC0aJ+EKgoSoYmOjo6vUbvI3P5ABgGvAwcR+ItF5Ds9jOBB0new0mGxli8zeTJEqif\nNElm1afCxo3SqZk9Wzo4iqIo3sbFPJYwXMdOSiNVgx9ycmw5ku1+s6vnaY/FWxgGDBok6e6XLoWH\nU49z/f03NG8OP/6oRkVRlIBTHthvrrdAXF8AhZDeSjxSSbg88Le7G2mMxRvExcmkxylTYO1aos+d\nS/WSs2elp/LRR9CihR80OsEq/mHV6V1Up/ewgkYXTAb+ACoAR4DOwBfI8OOtSImUd8xzn0SGIW8B\npgGvABfd3Vx7LLfLlStJZRxXrYJ8+WD/freX3LghPZVnn4XXX/eDRkVRlOR0cLJvrItzZ5iLx2iM\n5XY4flymyD/2mLjA7rgj1Uvi46FtW8iTR3KAZdU+o6IoPiYYa94rzti5UwIjbdvCDz94ZFQMA95+\nGy5dgrFj1agoipIx0Vdbeli6FOrXhy++gA8/hCzJvwi48rt+9RWsWCET8FOZ1uIXrOIfVp3eRXV6\nDytoDAQaY0kr48fDe+/BtGlQt67Hl02eDCNGSKqwAgV8qE9RFCXAaIzF8ydLzpXx42VG4/33e3zp\n8uUyX3LZMnjI2ahwRVEUH6L1WIKRW7egWzfYtUuKdN19t8eX7tghRuWXX9SoKIqSOdAYS2pcuiS1\nU86fh+hoj4yKze969KgMGvvf/yQXZbBhFf+w6vQuqtN7WEFjIFDD4o5//4VataBiRfjtN7jzTo8v\ntdmj7t2hg7MR44qiKBkUjbG4YssWeOYZ6NEDevZMMfLLHbduQePG8OCDMHx4mi5VFEXxOv6OsVjt\nlecfw7JgAbz4Inz3HbRpk6ZLExLk0uvXZeBYtmw+0qgoiuIhGWmCZFpKXwL0QhKg/QU09KEu9/zw\ng6S6nzUrzUYFZFrLli3R/Pxz8BsVq/iHVad3UZ3ewwoaA4EvDctPQGOHfYORcpdVkJz+fc39DwDt\nzJ+NkZrK/o3/JCRAr17w5ZeS86tmzTTf4ttvJRTz+eeQO7cPNCqKolgAX3eNwnCd778XUAApKNML\nSAAGmcd+B/oB6xyu8Y0r7OZNiIiAw4elp1K4cJpvMXMmREbCmjVwzz3el6goipJeMsM8ls+ATsAN\n4AlzX3GSG5GjQAm/qDl/XtIMFy4sqVrS0dVYuxa6dpXQjBoVRVEyO4EwLPalL79GSl86w2nXJCIi\ngrCwMABCQkKoUqUK4eHhQJK/09PtdZMmUemDD8jz3HMweDDRK1em6fro6GiOHIF33w1nwgS4ejUa\nm8s1PDw8zXr8vf3111/fVvv5a9u2L1j0aHv6Z9sK7bl161befvvtoNHjbjsjEUby4L09pYGd5voH\n5mLjd6Cak2sMr/Hnn4ZRrJhhjBiR7lucPGkYZcsaxo8/Jt+/fPny29PmJ1Snd1Gd3sUKOq2g0TAM\nAxdf1H2Fv2Ms9qUvuyOusE5I0H6SuV0CWAKUI2VjmG10m8yaBf/5D4wZIxW30sHVqzKbvlkz6Nfv\n9iUpiqL4iowUY5kM1EXqJR9BRoA1RUphxgMHgdfMc3cDU82fcUAkvrKwI0ZIuvv58+Hxx9N1i7g4\nyf9VqRL07Zv6+YqiKJkJXw7p7YAE5XMg81XGAm2Q3ksVoDVw2u78z5FeSkVgodfVJCTIDPqRI2Xo\nVjqNimHI6K+EBBg1yvmsentfdjCjOr2L6vQuVtBpBY2BIHNkN75xAzp2hLNnpSBKaGi6bzVgAGza\nJAW7PCgaqSiKkunI+CldzpyBFi1kHPDYsZAzZ7ofPm4cfPKJ2KY0ZM5XFEUJKBkppUvg2b9fZtDX\nqwdRUbdlVBYuhA8+kLkqalQURVFck3ENy5o1UKeOlBH+7DPImv5fdfNm6NQJpk+HChVSP98qflfV\n6V1Up3exgk4raAwEGdOwTJsGLVuK76pr19u61aFDkj1/1CgpzaIoipIB8GmS4IwVYzEMGDIEvv4a\n5s6FKlVu62Hnz4sxiYyUgl2KoihWxEmMpQ5wFZhA0jzDfMAVc707kjD4PyTNM3ycpHmG9yH5HZ2S\ncUaFxcXBW2/BypWSvKtUqdSvcUNMjMydfPppNSqKomQ4ViET2O25YreeFzhrrrdA5iXGAoeAA8hk\ndsckwYlkDFfYtWuSSHLfPli9+raNSkKCjE4uVQoGDUr9fEes4ndVnd5FdXoXK+i0gsY08hnwLxAB\nfGHuK44kBraRapJg6/dYTp6UIMhDD0mRrtucXGIYMo/y7FkZCXYbMX9FUZSAEB0dnV6jd1tJgm1Y\nO8ayZw80bSoVH3v39kpx+aFDZbrL6tUQEnLbt1MURQk4LuaxhOG6XlZpYD7wEEkJggeaP39HUnT9\n6ep51v0+Hh0N4eHQvz/06eMVo/LLLzBsmMxVUaOiKEomo7zdegtgi7k+G2iPpOe6xzxvvbsbWdOw\n/PwzPPccTJoEL77olVuuWCFB+nnzbjtEYxm/q+r0LqrTu1hBpxU0umAy8AeSFPgI0BmJqexAhhuH\nA++Y59onCV6AB0mCrRdj+ewziaUsWyZxFS+wa5fYqcmTJWOxoihKBqeDk31j3Zz/ubl4hKViLD+A\n0fWRR2SOSvHiXrnn8eNQo4bYq44dvXJLRVGUoCIj1WPxOtdA5qnkzeuV+12+DE2awGuvqVFRFEXx\nFpaKsfQArxmVW7egdWuZWf/++165ZSJW8buqTu+iOr2LFXRaQWMgsJRh8RaGIZWJ8+SRgpJeGFCm\nKIqimFjtleqVmvcffQRLl0r8P08eL6hSFEUJYjTG4mNGjYKpU6VYlxoVRVEU75OpXGFz5kgFyN9/\nh8KFffccq/hdVad3UZ3exQo6raAxEGSaHsuff0LnzjB/Ptx7b6DVKIqiZFwyRYzlwAEpJjl6tKTB\nVxRFyUxozXsvc+aMzFXp31+NiqIoij/I0Ibl2jUxJu3bQ7du/nuuVfyuqtO7qE7vYgWdVtAYCDKs\nYYmLE4NSsaIE7BVFURT/kCFjLIYhaVr+/lvSiuXI4QdliqIoQYrOY/ECX3who8BWrFCjoiiK4m8y\nnCtswgTJqj9vHuTPHxgNVvG7qk7vojq9ixV0WkFjIMhQPZbFi+Hdd2H5cq9l1VcURVHSSIaJsWzd\nCg0bwvTpMmdFURRFEXQeSzr4918ZVvztt2pUFEVRAo3lDcuFCzIB8p13oG3bQKsRrOJ3VZ3eRXV6\nFyvotILGQGBpwxITAy1bQqNG0KNHoNUoiqIoYOEYS0ICdOggc1amTIGsljaRiqIovkPnsXjIu+/C\niROwaJEaFUVRlGDCl6/kscApYIfdvi+BPcA2YAZQwNwfBtwAtpjLSHc3/vprWLAAZs6EXLm8rNoL\nWMXvqjq9i+r0LlbQaQWNLvDZ+xl8a1h+Aho77FsEPAhUBvYBveyOHQAeMZdIVzf99Vf46isxLAUL\nelewt9i6dWugJXiE6vQuqtO7WEGnFTS6wCfvZxu+NCyrgAsO+xYDCeb6n0DJtN40MlLyf5Upc5vq\nfMjFixcDLcEjVKd3UZ3exQo6raDRBT55P9sIZHSiMzDfbvsepJsVDdR2ddHEiVClim+FKYqiZHLS\n9X62Eajg/UfALWCSuX0cKIVY0KrATKRLdsXxwoYN/aTwNjh06FCgJXiE6vQuqtO7WEGnFTSmg3S/\nn/1FGMmDQwARwBrAXdh9OfILOHIAMHTRRRdddEnTcoCUhOHd97PfCCO58MbALqCQw3mFgGzmelng\nKBDia3GKoiiZmDAs+H6ejHShbgFHEJ/dfuAwKYettQZ2mvs2Ac38LVZRFCUToe9nRVEURbkdnE3c\ncWQ4Yl23IeOqA0FqOsOBSyRZ/4/9IysFpRCf6C7kW8ebLs4LdJt6ojOcwLdpLmQo5lZgN/CFi/MC\n3Z6e6Awn8O0J4mbZAsxxcTzQbWnDnc5wgqMtDwHbTQ3rXZwTLO3pV+ogv6yrF3ZTkobBVQPW+UOU\nE1LTGQ7M9psa19wN2AZo5wX2Avc7nBMMbeqJznCCo03zmD+zI23lOPwyGNoTUtcZTnC0Z0/gZ5xr\nCZa2BPc6w13s9zf/AO6mjvulPYMxy5aziTv2NAfGm+t/IkGkor4W5YTUdEJwJPk8iXxrBbiKpGxw\nrK8ZDG3qiU4Ijja9bv7MgXyLPe9wPBjaE1LXCYFvz5LIy+5HF1qCpS1T04mb/f7GnQ6/tGcwGpbU\nKIEEm2wc5TZmiPoQA6iJdDfnAw8EVg4go0AeQT5Q9gRbm4bhXGewtGlWxAieQtx3ux2OB0t7pqYz\nGNpzGPAuSTO+HQmWtkxNZzC0pU3HEmAj0NXJcb+0pxUNC6S0yEZAVLhnMxI3qAyMQCYVBZK8wK/A\nW0iPwJFgaVN3OoOlTRMQt11J4EnEDeJIMLRnajoD3Z5PA6eReIC7b9mBbktPdAa6LW3UQr6UNQFe\nR1z2jvi8Pa1oWI4hf0AbJc19wcYVklwRC4A7cO/79CV3ANOBiTj/wAdLm6amM5jaFCRYOw94zGF/\nsLSnDVc6A92eNRHXzD/I8Nf6wASHc4KhLT3RGei2tHHC/HkG+A14wuF4MLRnwAjDs+B9dQIbzAvD\ntc6iJH0zeAIZrREIsiD/BMPcnBMMbeqJzmBo00IkTQ7LDawE/s/hnGBoT090BkN72qiL89FWwdCW\n9rjSGQxtmQfIZ67ficygd0yC5Zf2DMZCX5ORP14hxBfYF7H+AN8jjdIUSVFwDXg5ABohdZ1tgNeA\nOOSbTPsAaATpGnckaQgiwIdAaXM9WNrUE53B0KbFkOBnVnOJApYCr5jHg6U9PdEZDO1pj80lE2xt\n6YgzncHQlkWRXgrIu/1nJBV+sLenoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKoiiKkvmI\nR+aP7ETyS/UkacLXo8D/3FxbBujgU3XueRPJgxXl4+e8jUw2DAaeAd4311uSPBP0S8g8lvTwBlKe\nFqA/KSdVuiMCSWeSXpaSNMFPUZQMwBW79cLAYqCfh9eG47qWhj9wlQnZ2xOA/wHucnEskOmRxiFV\n/mwsR74MpIVsyBeJLaS/3V7i9gxLV+QLjaIoGYQrDtv3AGfN9XCSDEddkooZbUKSRq4DLpr73kJ6\nMCvN45uAGnb3iQamIcZgot3zHkdSUGxFshrfibzsvkQKFm0DujnRPQq4iczYfxvJgBAFrEZmHpcB\nlpnXLyEpT9I4pPTqWuCgqW080vP5yclz3rR7zlJz31XgK1NzLaC3qXUHMsvZRjQw0Py99pJUF+VB\nc98WU9+9SJqgv0wNe83foaHZNvvMdoKk3kEN4Bzwt3mf95C/5V9IYsRciJGJRjLe/o7UvrHpGgZs\nQF7otZGMEjbGkWSwDiFfNDaZbVDBSRvZG5ZmwB+IIR6HZ21dFNfFqRRFsSCOhgWk3kxhkhuW2SQZ\nijzIy98xf1JuIKe5Xh55cWHe5yLSu8iCvHhqIvVCDpL0LTuved9uwEfmvpzmfcKc6LQvbtTPPM/2\n/DlAJ3P9ZZJSXowDJpnrzYHLyIs+C/ICrpzKc0CyB7ex2w61W5+AZMUF6UF8aa43QXqDIC/h5831\n7LNdT4kAAAMiSURBVIgRCANiHbSMsdNp0x9B0kv8J6CV3bOXA1XN9TtIesEDtLO733LgG7vrPiB5\nj8H+vv8g2XJBUpeMJiU2w/Is8sWigN19PG3rv5EvFYqFCcZcYUpwswb5lvszMAPJjOqYhjsH8sKq\njMRuytsdWw8cN9e3Ij2jK0hW1k3mflu6/IbAwyS9vPMD5XCf4M9AjN9Nc7s6EoMA6SENtjvPZgx3\nIoXGdpnbu5AX/DY3zwH53abbbddHanbkQQzQTmCueWyG+XMzScbxD8RwljSPHzD3/+OgZYmdTtu1\njjj+DWzbFZCXuO0e2Uhqf4Bf7NZLIz09V9j/Dq2cHM+CtMFjQAOSlz3wtK1PIb3Kv9zoUIIcNSyK\nK8oiL84zDvsHIS/LZoiRaeTk2h6IoeiEvMhi7I7dtFuPRz6D7upBvEHSN3xPue6w7aqGxi3zZ4KD\nrgQ8+9+IIUl7LuBbpNd1DHHJ5bI713Z/2+8M4nZah/Rs5iPJAv9xosVepytdjm1o286CvLxrurju\nmsO2u7oozn4Hx2ceRL4sVCDpiwJ43tZZCM76SkoasGI9FsX3FEZiF84CsfciL6rBiMupAuLasB/N\nkx/5VgrwImJcXGEgsYRiJNULyWdesxCIJOnFcx9Jddw95Q+SMs2+gLho0ssV5Hdzhs2InENceW09\nuF9ZxJCMAGYhvbP0vFQdddlv70X+ntXN7TtwXd3wMEnxl/SQxbxHG8QVmJ4qikWRqoaKhVHDotjI\nTdJw48VIkLe/ecwg6YX3FhKc3oZ8C12ABHPjEdfWW0ig9iVzuwLJXSLOXpyxiO9/hHnNQiRG8iMS\n4N1sPvM7XH9TdrXdHYmtbEMMy1suznN3Dxs/IO2y1Mk5F5G4w07zHMeyys7u/Zx5/hbEXTUB59/Y\nnem0/5tMQVxwmxBjNQ75YrAZ+R9vg/Q0t5rPqoFzVpOyGJgr/c7ax7Z/L9LW00w9rn4Hx+27EcPs\n2ItSFEVRLIptuHGOAD2/G+JGVRRFUTIQkQSu+NNSxI2oKIqiKIqiKIqiKIqiKIqiKIqiKIqiKIqi\nKIqiKIqiKIqiZEz+H0C1ZRMhMDC/AAAAAElFTkSuQmCC\n",
+       "text": [
+        "<matplotlib.figure.Figure at 0xb55925ac>"
+       ]
+      },
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "L50 values by Cost 231 model\n",
+        "129.03  140.47  147.16  151.91  155.59 \n",
+        " \n",
+        "L50 values bu Okumura/Hata model\n",
+        "125.13  135.73  141.93  146.34  149.75 \n",
+        " \n",
+        "The results from the plot of two models shows that the calculated path loss with the COST 231 model is higher than the value obtained by the Okumura/Hata model.\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.8, Page 76"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "SNRmin=12;#in dB\n",
+      "n=3; #No of floors\n",
+      "Backgroundnoise=-115; #dBm\n",
+      "pt=100  #in dBm\n",
+      "\n",
+      "#Calculations\n",
+      "pt_db=10*math.log10(pt);\n",
+      "Sr=Backgroundnoise+SNRmin; #receiver sensitivity\n",
+      "Lpmax=pt_db-Sr;\n",
+      "#Refering table 3.4\n",
+      "Lp_d0=38;  #ref path loss at the first meter(dB)\n",
+      "Lf=15+4*(n-1); #signal attenuation through n floors\n",
+      "y=3; #path loss exponent\n",
+      "X=10; #Shadowing effect(dB)\n",
+      "d=10**((Lpmax-Lp_d0-Lf-X)/30); #max allowable path loss\n",
+      "\n",
+      "#Result\n",
+      "print 'Coverage radius of an access point = %d m \\n'%(round(d))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Coverage radius of an access point = 54 m \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 22
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.9, Page 77"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "SSmean=-100; #signal strength(dBm)\n",
+      "Sr=-110; #receiver sensitivity(dBm)\n",
+      "sd=10;  #standard deviation(dB)\n",
+      "\n",
+      "#Calculations\n",
+      "P_Smin=(0.5-0.5*math.erf((Sr-SSmean)/(math.sqrt(2)*sd)));\n",
+      "\n",
+      "#Result\n",
+      "print 'probability of exceeding signal beyond the receiver sensitivity is %.2f \\n'%(P_Smin)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "probability of exceeding signal beyond the receiver sensitivity is 0.84 \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 24
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 3.10, Page 81"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Lp=140; # path losses in dB \n",
+      "k=1.38*10**-23; # Boltzmann\u2019s constant (W/Kelvin-Hz)\n",
+      "k_db=10*math.log10(k);\n",
+      "f=900;#in MHz\n",
+      "Gt=8; #transmitting antenna gain(dB)\n",
+      "Gr=0; #receiver antenna gain(dB)\n",
+      "Ag=24;#gain of receiver ampli\ufb01er in dB \n",
+      "Fmargin=8;#Fade margin(dB)\n",
+      "Nf=6;#Noise figure(dB)\n",
+      "L0=20; #\u0002 other losses in dB\n",
+      "Lf=12; # antenna feed line loss in dB \n",
+      "T=24.6;#Temperature expressed in dB\n",
+      "R=39.8; #\u0002 data rate in dB \n",
+      "M=8;  #overall link margin(dB)\n",
+      "Eb_No=10;#dB\n",
+      "\n",
+      "#Calculations\n",
+      "#From equation  (3.54)\n",
+      "pt_db=M-Gt-Gr-Ag+ Nf + T+ k_db+ Lp+ Lf+ L0 + Fmargin+ R+ Eb_No;\n",
+      "\n",
+      "Pt=10**(pt_db/10);  #dB into normal number\n",
+      "\n",
+      "#Result\n",
+      "print 'Total transmitted power is %d Watts \\n'%Pt"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Total transmitted power is 6 Watts \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 25
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb
new file mode 100755
index 00000000..6a6cd416
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch4.ipynb
@@ -0,0 +1,338 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:d1cbcab673c40d252caf601352e39b3f6fb5df10eada02ad15211795afd1b59f"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 4: An Overview of Digital Communication and Transmission"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 4.1, Page 93"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Fm=20;  # in KHz\n",
+      "\n",
+      "#Calculations\n",
+      "print \"An Engineering version of the Nyquist sampling rate : fs>=2.2*fm.\"\n",
+      "print 'Therefore sampling rate of >= %d ksps should be used '%(2.2*Fm); \n",
+      "print \"The sampling rate for a compact disc digital audio player = 44.1 ksps and for a studio quality audio player = 48 ksps are used.\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "An Engineering version of the Nyquist sampling rate : fs>=2.2*fm.\n",
+        "Therefore sampling rate of >= 44 ksps should be used \n",
+        "The sampling rate for a compact disc digital audio player = 44.1 ksps and for a studio quality audio player = 48 ksps are used.\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 4.2, Page 96"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Rt=1; #Resistance(ohm)\n",
+      "#L= Number of quantization values\n",
+      "L1=32;\n",
+      "L2=64;\n",
+      "L3=128;\n",
+      "L4=256;\n",
+      "\n",
+      "#Calculations\n",
+      "# L=2**R i.e R=math.log2(L);\n",
+      "R1=math.log(L1,2);\n",
+      "R2=math.log(L2,2);\n",
+      "R3=math.log(L3,2);\n",
+      "R4=math.log(L4,2);\n",
+      "\n",
+      "#P=A**2/2; #average power of signal\n",
+      "#sig**2=0.333*A**2*2**(-2*Rt); #Avg quantization noise power\n",
+      "#SNR=P/sig**2;\n",
+      "# SNR(dB)=1.8+ 6R;\n",
+      "\n",
+      "SNR1=1.8+6*R1;\n",
+      "SNR2=1.8+6*R2;\n",
+      "SNR3=1.8+6*R3;\n",
+      "SNR4=1.8+6*R4;\n",
+      "\n",
+      "#Result\n",
+      "print 'For L=32, SNR is %.1f dB\\n '%SNR1\n",
+      "print 'For L=64, SNR is %.1f dB\\n '%SNR2\n",
+      "print 'For L=128, SNR is %.1f dB\\n '%SNR3\n",
+      "print 'For L=256, SNR is %.1f dB\\n '%SNR4"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "For L=32, SNR is 31.8 dB\n",
+        " \n",
+        "For L=64, SNR is 37.8 dB\n",
+        " \n",
+        "For L=128, SNR is 43.8 dB\n",
+        " \n",
+        "For L=256, SNR is 49.8 dB\n",
+        " \n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 4.3, Page 99"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Fs=8*10**3;  #in Hz\n",
+      "Fm=3.4*10**3; # in Hz\n",
+      "VCH=24; #voice channels\n",
+      "SCH=1; #sunchronization channel\n",
+      "PDur=1;  #extra pulse duration in microsec\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Ts=1/(Fs);\n",
+      "TimeCH=Ts/(VCH+SCH)*10**6;   # in microsec\n",
+      "print 'Time between the pulses is %d microsec\\n'%(TimeCH-PDur);\n",
+      "#Now by using the engineering version of Nyquist rate sampling\n",
+      "NyquistRate=2.2*Fm;\n",
+      "Ts1_microsec=1/NyquistRate*10**6;\n",
+      "Tc=round(Ts1_microsec)/(VCH+SCH);\n",
+      "print \"Time between the pulses by using engineering version of Nyquist rate sampling  is %.2f microsec\\n\"%(Tc-PDur);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Time between the pulses is -1 microsec\n",
+        "\n",
+        "Time between the pulses by using engineering version of Nyquist rate sampling  is 4.36 microsec\n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 4.4, Page 101"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Fm=3000; #highest modulating frequency in signal(Hz)\n",
+      "M=32; # number of pulse levels \n",
+      "b=5; #bits per symbol \n",
+      "p=0.01; #Quantization distortion\n",
+      "\n",
+      "#Calculations\n",
+      "#2**R = L >= 1/2P\n",
+      "# where R is the number of bits required to represent quantization levels L\n",
+      "R=math.log10(1./(2*p))/math.log10(2);\n",
+      "Fs=2*Fm;  # Nyquist sampling criteria (samples per second)\n",
+      "fs=round(R)*Fs;\n",
+      "Rs=fs/b;\n",
+      "\n",
+      "#Result\n",
+      "print 'The minimum number of bits/sample or bits/PCM word that should be used are %d'%(round(R));\n",
+      "print 'The minimum sampling rate is %d samples per second\\n '%Fs;\n",
+      "print 'The resulting transmission rate is %d bps\\n '%fs;\n",
+      "print 'The PCM pulse or symbol transmission rate is %d symbols/sec\\n'%Rs"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The minimum number of bits/sample or bits/PCM word that should be used are 6\n",
+        "The minimum sampling rate is 6000 samples per second\n",
+        " \n",
+        "The resulting transmission rate is 36000 bps\n",
+        " \n",
+        "The PCM pulse or symbol transmission rate is 7200 symbols/sec\n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 4.5, Page 110"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "S_No=53.; #dB-Hz\n",
+      "R=9.6*10**3; #bps\n",
+      "BW=4.8*10**3; #Khz\n",
+      "Pb=10**-5; #BER<=10**-5;\n",
+      "\n",
+      "#Calculations\n",
+      "print \"Since the required data rate of 9.6 kbps is more than the available bandwidth of 4.8 kHz, the channel is bandwidth-limited.\"\n",
+      "Eb_No=S_No-10*math.log10(R); #dB\n",
+      "# Try for 8-PSK modulation scheme\n",
+      "M=8;\n",
+      "Ps=math.log(M,2)*Pb; #Max ps\n",
+      "Es_No=math.log(M,2)*10**(0.1*Eb_No);\n",
+      "#Ps(8)=2*Q(math.sqrt(2*Es_No)*sin(math.pi/8));\n",
+      "#2*Q(math.sqrt(2*Eb_No))=erfc(math.sqrt(Eb_No));  #Refer EQn C(7) from appendix C\n",
+      "\n",
+      "Ps8=math.erfc(math.sqrt(Es_No)*math.sin(math.pi/8));\n",
+      "\n",
+      "#Result\n",
+      "print 'Symbol error rate is given as %.5f \\n '%Ps\n",
+      "print 'The ratio of signal energy to noise is %.2f \\n '%Es_No;\n",
+      "print 'Symbol error rate for 8-PSK  is %.5f \\n '%Ps8;\n",
+      "print \"As symbol error rate for 8-PSK modulation is lower than threshold value. so, We can use 8-PSK modulation.\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Since the required data rate of 9.6 kbps is more than the available bandwidth of 4.8 kHz, the channel is bandwidth-limited.\n",
+        "Symbol error rate is given as 0.00003 \n",
+        " \n",
+        "The ratio of signal energy to noise is 62.35 \n",
+        " \n",
+        "Symbol error rate for 8-PSK  is 0.00002 \n",
+        " \n",
+        "As symbol error rate for 8-PSK modulation is lower than threshold value. so, We can use 8-PSK modulation.\n"
+       ]
+      }
+     ],
+     "prompt_number": 13
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 4.6, Page 111"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "SNR=48.; #dB-Hz\n",
+      "BW=45.*10**3; #in Hz\n",
+      "R=9.6*10**3; #bps\n",
+      "Pb=10**-5; #Bit error rate\n",
+      "e=2.71828; #Natural exponent e\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"since the available bandwidth of 45 kHz is more than adequate to support the required data rate of 9.6 kbps.\";\n",
+      "print \"So, the channel is not bandwidth limited \";\n",
+      "Eb_No=SNR-10*math.log10(R);\n",
+      "#We try the 16-FSK modulation scheme\n",
+      "M=16;\n",
+      "\n",
+      "Es_No=math.log(M,2)*Eb_No;\n",
+      "Ps=(M-1)/2*e**(-Es_No/2);\n",
+      "#For orthogonal signalling\n",
+      "Ps16=(2**M-1)/(2**(M-1))*Pb;\n",
+      "print \"\"\n",
+      "print 'The maximum symbol error probability is %0.5f \\n '%Ps16\n",
+      "print 'The symbol error probability achieved by 16-PSK is %.9f \\n '%Ps;\n",
+      "print \"As achieved symbol error probability is far less than maximum tolerable value\";\n",
+      "print \"So, we can meet the given speci\ufb01cations for this power-limited channel with a 16-FSK modulation scheme without any error-correction coding\""
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "since the available bandwidth of 45 kHz is more than adequate to support the required data rate of 9.6 kbps.\n",
+        "So, the channel is not bandwidth limited \n",
+        "\n",
+        "The maximum symbol error probability is 0.00001 \n",
+        " \n",
+        "The symbol error probability achieved by 16-PSK is 0.000000553 \n",
+        " \n",
+        "As achieved symbol error probability is far less than maximum tolerable value\n",
+        "So, we can meet the given speci\ufb01cations for this power-limited channel with a 16-FSK modulation scheme without any error-correction coding\n"
+       ]
+      }
+     ],
+     "prompt_number": 15
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb
new file mode 100755
index 00000000..153ee7fb
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch5.ipynb
@@ -0,0 +1,416 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:98db718d0bf89da2e915ec31624499d68101b659175b122291fbf41d86cde068"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 5: Fundamentals of Cellular Communications"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 5.1, Page 130"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "ToCH=960.;# Total available channels\n",
+      "Cellarea=6.; #in km^2\n",
+      "Covarea=2000.;#in km^2\n",
+      "N1=4.;  # Cluster Size\n",
+      "N2=7.;  #Cluster Size\n",
+      "\n",
+      "#Calculations\n",
+      "Area1=N1*Cellarea;#for N=4\n",
+      "Area2=N2*Cellarea;#For N=7\n",
+      "No_of_clusters1=round(Covarea/Area1);\n",
+      "No_of_clusters2=round(Covarea/Area2);\n",
+      "No_of_CH1=ToCH/N1;    # No of channels with cluster size 4\n",
+      "No_of_CH2=ToCH/N2;    # No of channels with cluster size 7\n",
+      "SysCap1=No_of_clusters1*ToCH;\n",
+      "SysCap2=No_of_clusters2*ToCH;\n",
+      "\n",
+      "#Results\n",
+      "print 'System Capacity with cluster size 4 is %d channels'%SysCap1\n",
+      "print 'Number of clusters for covering total area with N equals 4 are %d'%No_of_clusters1\n",
+      "print 'System Capacity with cluster size 7 is %d channels'%SysCap2\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "System Capacity with cluster size 4 is 79680 channels\n",
+        "Number of clusters for covering total area with N equals 4 are 83\n",
+        "System Capacity with cluster size 7 is 46080 channels\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 5.2, Page 132"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "S_IAMP=18.;# S/I ratio in dB\n",
+      "S_IGSM=12.;# S/I ratio in dB\n",
+      "PPL=4.; # propogation path loss coefficient\n",
+      "\n",
+      "#Calculations\n",
+      "# Using Equation 5.16 on page no 132, we get\n",
+      "N_AMP=(1./3)*((6*10**(0.1*S_IAMP))**(2/PPL));#reuse factor for AMPS\n",
+      "  \n",
+      "N_GSM=(1./3)*((6*10**(0.1*S_IGSM))**(2/PPL));#reuse factor for GSM\n",
+      "\n",
+      "\n",
+      "#Result\n",
+      "print 'Reuse Factor for AMP system is N = %.3f = approx %d \\n'%(N_AMP,N_AMP+1);\n",
+      "print 'Reuse Factor for GSM system is N = %.3f = approx %d \\n'%(N_GSM,N_GSM+1);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Reuse Factor for AMP system is N = 6.486 = approx 7 \n",
+        "\n",
+        "Reuse Factor for GSM system is N = 3.251 = approx 4 \n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 5.3, Page 132"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "VCH=395.;#Total voice channels\n",
+      "CallHT=120.;#average call holding time in sec\n",
+      "Blocking=0.02;# 2%\n",
+      "PPL=4.;  #propogation path loss coefficient\n",
+      "N1=4.      #reuse factor\n",
+      "N2=7.;     #reuse factor\n",
+      "N3=12.;    #reuse factor\n",
+      "\n",
+      "#Calculations&Results\n",
+      "No_of_VCH1=VCH/N1;  #for reuse factor N1\n",
+      "No_of_VCH2=VCH/N2;  #for reuse factor N2\n",
+      "No_of_VCH3=VCH/N3;  #for reuse factor N3\n",
+      "print 'NO of voice channels for N=4 are %d'%(round(No_of_VCH1));\n",
+      "print 'NO of voice channels for N=7 are %d'%(round(No_of_VCH2));\n",
+      "print 'NO of voice channels for N=12 are %d\\n'%(round(No_of_VCH3));\n",
+      "TrafLoad1=87.004;\n",
+      "Carryload1=(1-Blocking)*TrafLoad1;\n",
+      "TrafLoad2=45.877;\n",
+      "Carryload2=(1-Blocking)*TrafLoad2;\n",
+      "TrafLoad3=24.629;\n",
+      "Carryload3=(1-Blocking)*TrafLoad3;\n",
+      "# To find cell capacity\n",
+      "Ncall1=Carryload1*3600/CallHT;#Calls per hour per cell \n",
+      "Ncall2=Carryload2*3600/CallHT;\n",
+      "Ncall3=Carryload3*3600/CallHT;\n",
+      "print 'calls per hour per cell for N=4 are %d'%(round(Ncall1));\n",
+      "print 'calls per hour per cell for N=7 are %d'%(round(Ncall2));\n",
+      "print 'calls per hour per cell for N=12 are %d  \\n'%(Ncall3);\n",
+      "# To find S BY I\n",
+      "# N=(1/3)[6*(S/I)]**(2/PPL)\n",
+      "S_I1=10*(PPL/2)*(math.log10(N1)-math.log10(1./3)-(2./PPL)*math.log10(6));#Mean S/I (dB)\n",
+      "\n",
+      "S_I2=10*(PPL/2)*(math.log10(N2)-math.log10(1./3)-(2./PPL)*math.log10(6));\n",
+      "S_I3=10*(PPL/2)*(math.log10(N3)-math.log10(1./3)-(2./PPL)*math.log10(6));\n",
+      "\n",
+      "print 'Mean S/I(dB) for N=4 is %.1f'%S_I1\n",
+      "print 'Mean S/I(dB) for N=7 is %.1f'%S_I2\n",
+      "print 'Mean S/I(dB) for N=12 is %.1f'%S_I3"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "NO of voice channels for N=4 are 99\n",
+        "NO of voice channels for N=7 are 56\n",
+        "NO of voice channels for N=12 are 33\n",
+        "\n",
+        "calls per hour per cell for N=4 are 2558\n",
+        "calls per hour per cell for N=7 are 1349\n",
+        "calls per hour per cell for N=12 are 724  \n",
+        "\n",
+        "Mean S/I(dB) for N=4 is 13.8\n",
+        "Mean S/I(dB) for N=7 is 18.7\n",
+        "Mean S/I(dB) for N=12 is 23.3\n"
+       ]
+      }
+     ],
+     "prompt_number": 12
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 5.4, Page 154"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "spectrum=12.5*10**6; #in Hz\n",
+      "CHBW=200*10**3;#in Hz\n",
+      "N=4.;#reuse factor\n",
+      "Blocking=0.02; # 2%\n",
+      "callHT=120.;#average call holding time in sec\n",
+      "PPL=4.;#propogation path loss coefficient\n",
+      "CntrlCH=3.; #No of control channels\n",
+      "Ts=8.; # No of voice channels per RF channel\n",
+      "\n",
+      "#Calculations&Results\n",
+      "No_ofVCH=((spectrum*Ts)/(CHBW*N))-CntrlCH;\n",
+      "print 'No of voice channels for N=4 are %d'%(No_ofVCH)\n",
+      "TrafLoad=110.;\n",
+      "CarryLoad=(1-Blocking)*TrafLoad;\n",
+      "Ncall=CarryLoad*3600/callHT;\n",
+      "print 'Calls per hour per cell for N=4 are %d calls/hour/cell \\n '%(round(Ncall));\n",
+      "S_I=10*(PPL/2)*(math.log10(N)-math.log10(1./3)-(2./PPL)*math.log10(6));\n",
+      "print 'Mean S/I(dB) for N=4 is %.1f dB \\n '%(S_I)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "No of voice channels for N=4 are 122\n",
+        "Calls per hour per cell for N=4 are 3234 calls/hour/cell \n",
+        " \n",
+        "Mean S/I(dB) for N=4 is 13.8 dB \n",
+        " \n"
+       ]
+      }
+     ],
+     "prompt_number": 18
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 5.5, Page 139"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "VCH=395.;#Total allocated voice channels\n",
+      "CHBW=30.; # in kHz\n",
+      "Spectrum=12.5;  # in MHz\n",
+      "CallHT=120.; #Average call holding time in sec\n",
+      "Blocking=0.02; # 2%\n",
+      "PL=40.;  #slope of path loss in dBperdecade\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"We consider only the \ufb01rst tier interferers and neglect the effects of cochannel interference from the second and other higher tiers.\"\n",
+      "#FOR 120degree sectorization\n",
+      "#N=4\n",
+      "VCH11=(VCH/(4*3));\n",
+      "OffLoad11=24.629;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site11=3*OffLoad11;\n",
+      "CarLoad11=(1-Blocking)*Load_site11;\n",
+      "Calls_hr_site11=CarLoad11*3600/CallHT;\n",
+      "R11=math.sqrt(CarLoad11/0.52);\n",
+      "Seff11=CarLoad11/(2.6*Spectrum*R11**2);\n",
+      "S_I11=PL*math.log10(math.sqrt(3*4))-10*math.log10(2);\n",
+      "#N=7\n",
+      "VCH12=(VCH/(3*7));\n",
+      "OffLoad12=12.341;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site12=3*OffLoad12;\n",
+      "CarLoad12=(1-Blocking)*Load_site12;\n",
+      "Calls_hr_site12=CarLoad12*3600/CallHT;\n",
+      "R12=math.sqrt(CarLoad12/0.52);\n",
+      "Seff12=CarLoad12/(2.6*Spectrum*R12**2);\n",
+      "S_I12=PL*math.log10(math.sqrt(3*7))-10*math.log10(2);\n",
+      "#N=12\n",
+      "VCH13=VCH/(3*12);\n",
+      "OffLoad13=5.842;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site13=3*OffLoad13;\n",
+      "CarLoad13=(1-Blocking)*Load_site13;\n",
+      "Calls_hr_site13=CarLoad13*3600/CallHT;\n",
+      "R13=math.sqrt(CarLoad13/0.52);\n",
+      "Seff13=CarLoad13/(2.6*Spectrum*R13**2);\n",
+      "S_I13=PL*math.log10(math.sqrt(3*12))-10*math.log10(2);\n",
+      "#For omnidirectional \n",
+      "#N=4\n",
+      "VCH21=VCH/(4);\n",
+      "OffLoad21=87.004;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site21=OffLoad21;\n",
+      "CarLoad21=(1-Blocking)*Load_site21;\n",
+      "Calls_hr_site21=CarLoad21*3600/CallHT;\n",
+      "R21=math.sqrt(CarLoad21/0.52);\n",
+      "Seff21=CarLoad21/(2.6*Spectrum*R21**2);\n",
+      "S_I21=PL*math.log10(math.sqrt(3*4))-10*math.log10(6);\n",
+      "#N=7\n",
+      "VCH22=VCH/(7);\n",
+      "OffLoad22=46.817;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site22=OffLoad22;\n",
+      "CarLoad22=(1-Blocking)*Load_site22;\n",
+      "Calls_hr_site22=CarLoad22*3600/CallHT;\n",
+      "R22=math.sqrt(CarLoad22/0.52);\n",
+      "Seff22=CarLoad22/(2.6*Spectrum*R22**2);\n",
+      "S_I22=PL*math.log10(math.sqrt(3*7))-10*math.log10(6);\n",
+      "#N=12\n",
+      "VCH23=VCH/(12);\n",
+      "OffLoad23=24.629;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site23=OffLoad23;\n",
+      "CarLoad23=(1-Blocking)*Load_site23;\n",
+      "Calls_hr_site23=CarLoad23*3600/CallHT;\n",
+      "R23=math.sqrt(CarLoad23/0.52);\n",
+      "Seff23=CarLoad23/(2.6*Spectrum*R23**2);\n",
+      "S_I23=PL*math.log10(math.sqrt(3*12))-10*math.log10(6);\n",
+      "# For 60degree Sectorization\n",
+      "#N=3\n",
+      "VCH31=VCH/(6*3);\n",
+      "OffLoad31=14.902;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site31=6*OffLoad31;\n",
+      "CarLoad31=(1-Blocking)*Load_site31;\n",
+      "Calls_hr_site31=CarLoad31*3600/CallHT;\n",
+      "R31=math.sqrt(CarLoad31/0.52);\n",
+      "Seff31=CarLoad31/(2.6*Spectrum*R31**2);\n",
+      "S_I31=PL*math.log10(math.sqrt(3*3))-10*math.log10(1);\n",
+      "#N=4\n",
+      "VCH32=VCH/(6*4);\n",
+      "OffLoad32=10.656;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site32=6*OffLoad32;\n",
+      "CarLoad32=(1-Blocking)*Load_site32;\n",
+      "Calls_hr_site32=CarLoad32*3600/CallHT;\n",
+      "R32=math.sqrt(CarLoad32/0.52);\n",
+      "Seff32=CarLoad32/(2.6*Spectrum*R32**2);\n",
+      "S_I32=PL*math.log10(math.sqrt(3*4))-10*math.log10(1);\n",
+      "#N=7\n",
+      "VCH33=VCH/(6*7);\n",
+      "OffLoad33=5.084;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site33=6*OffLoad33;\n",
+      "CarLoad33=(1-Blocking)*Load_site33;\n",
+      "Calls_hr_site33=CarLoad33*3600/CallHT;\n",
+      "R33=math.sqrt(CarLoad33/0.52);\n",
+      "Seff33=CarLoad33/(2.6*Spectrum*R33**2);\n",
+      "S_I33=PL*math.log10(math.sqrt(3*7))-10*math.log10(1);\n",
+      "#N=12\n",
+      "VCH34=VCH/(6*12);\n",
+      "OffLoad34=2.227;  #  Offered traf\ufb01c load per sector from Erlang-B table(Appendix A)\n",
+      "Load_site34=6*OffLoad34;\n",
+      "CarLoad34=(1-Blocking)*Load_site34;\n",
+      "Calls_hr_site34=CarLoad34*3600/CallHT;\n",
+      "R34=math.sqrt(CarLoad34/0.52);\n",
+      "Seff34=CarLoad34/(2.6*Spectrum*R34**2);\n",
+      "S_I34=PL*math.log10(math.sqrt(3.*12))-10*math.log10(1);\n",
+      "\n",
+      "print 'For Omnidirectional    Calls_per_hour_per_cellsite      Mean S_I ratio      SpecrtalEfficiency'\n",
+      "print 'For N=4                         %d                           %.1f          %.3f\\n'%(Calls_hr_site21,S_I21,Seff21);\n",
+      "print 'For N=7                         %d                           %.1f          %.3f\\n'%(Calls_hr_site22,S_I22,Seff22);\n",
+      "print 'For N=12                        %d                            %.1f          %.3f\\n'%(Calls_hr_site23,S_I23,Seff23);\n",
+      "\n",
+      "print 'For 120deg sector    Calls_per_hour_per_cellsite      Mean S_I ratio      SpecrtalEfficiency\\n'\n",
+      "print 'For N=4                         %d                           %.1f          %.3f\\n'%(Calls_hr_site11,S_I11,Seff11);\n",
+      "print 'For N=7                         %d                           %.1f          %.3f\\n'%(Calls_hr_site12,S_I12,Seff12);\n",
+      "print 'For N=12                        %d                            %.1f          %.3f\\n'%(Calls_hr_site13,S_I13,Seff13);\n",
+      "\n",
+      "print 'For 60 deg Sector    Calls_per_hour_per_cellsite        Mean S_I ratio      SpecrtalEfficiency\\n'\n",
+      "print 'For N=3                         %d                           %.1f          %.3f\\n'%(Calls_hr_site31,S_I31,Seff31);\n",
+      "print 'For N=4                         %d                           %.1f          %.3f\\n'%(Calls_hr_site32,S_I32,Seff32);\n",
+      "print 'For N=7                          %d                           %.1f          %.3f\\n'%(Calls_hr_site33,S_I33,Seff33);\n",
+      "print 'For N=12                         %d                           %.1f          %.3f\\n'%(Calls_hr_site34,S_I34,Seff34);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "We consider only the \ufb01rst tier interferers and neglect the effects of cochannel interference from the second and other higher tiers.\n",
+        "For Omnidirectional    Calls_per_hour_per_cellsite      Mean S_I ratio      SpecrtalEfficiency\n",
+        "For N=4                         2557                           13.8          0.016\n",
+        "\n",
+        "For N=7                         1376                           18.7          0.016\n",
+        "\n",
+        "For N=12                        724                            23.3          0.016\n",
+        "\n",
+        "For 120deg sector    Calls_per_hour_per_cellsite      Mean S_I ratio      SpecrtalEfficiency\n",
+        "\n",
+        "For N=4                         2172                           18.6          0.016\n",
+        "\n",
+        "For N=7                         1088                           23.4          0.016\n",
+        "\n",
+        "For N=12                        515                            28.1          0.016\n",
+        "\n",
+        "For 60 deg Sector    Calls_per_hour_per_cellsite        Mean S_I ratio      SpecrtalEfficiency\n",
+        "\n",
+        "For N=3                         2628                           19.1          0.016\n",
+        "\n",
+        "For N=4                         1879                           21.6          0.016\n",
+        "\n",
+        "For N=7                          896                           26.4          0.016\n",
+        "\n",
+        "For N=12                         392                           31.1          0.016\n",
+        "\n"
+       ]
+      }
+     ],
+     "prompt_number": 22
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb
new file mode 100755
index 00000000..7c64b872
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch6.ipynb
@@ -0,0 +1,466 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:0b8e52617510df277ef1e48e119f37ff192613df767b6d3b9de6242855aa9cf9"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 6: Multiple Access Techniques"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.1, Page 158"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Area=8;  #in km^2\n",
+      "Cover=4000.;# in km^2\n",
+      "CallBH=1.2;  #Avg calls during BH\n",
+      "HT=100; # Avg holding time in sec\n",
+      "Block=0.02; #Blocking=2%\n",
+      "N=4.;#Frequency reuse factor\n",
+      "Spectrum=12.5;# in MHz\n",
+      "CHBW=200;# in kHz\n",
+      "User_CH=8;#No of  users per RF channel\n",
+      "\n",
+      "#Calculations&Results\n",
+      "RFCH=Spectrum*1000/CHBW;\n",
+      "TCH=int(RFCH)*User_CH;\n",
+      "SigCH=3;#No of signalling channels per cell\n",
+      "TCH_cell=TCH/N-SigCH;\n",
+      "Cells=Cover/Area;\n",
+      "OffLoad=108.4;  # in Erlangs\n",
+      "print 'Using Erlang-B Tables, Total traffic offered by %d channels at 0.02 blocking = %.1f Erlangs/cell'%(TCH_cell,OffLoad*(1-Block));\n",
+      "CarLoad=OffLoad*(1-Block);\n",
+      "Calls_hr_cell=CarLoad*3600/HT;\n",
+      "MaxUser_hr_cell=Calls_hr_cell/CallBH;\n",
+      "Seff=CarLoad*Cells/(Spectrum*Cover);\n",
+      "print 'Spectral Efficiency is %.2f Erlangs/MHz/km^2'%Seff;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Using Erlang-B Tables, Total traffic offered by 121 channels at 0.02 blocking = 106.2 Erlangs/cell\n",
+        "Spectral Efficiency is 1.06 Erlangs/MHz/km^2\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.2, Page 159"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "TCH=395;  # Traffic Channels\n",
+      "SysBW=12.5;  #in MHz\n",
+      "CHspace=30.;  # in kHz\n",
+      "\n",
+      "#Calculations\n",
+      "Eff=TCH*CHspace/(SysBW*1000);\n",
+      "\n",
+      "#Result\n",
+      "print 'Multiple access spectral efficiency of FDMA System is %.3f'%Eff"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Multiple access spectral efficiency of FDMA System is 0.948\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.3, Page 160"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Tf=40;  #Frame duration in msec\n",
+      "Mt=6;   # Frames per slot\n",
+      "Bu=30; #bandwidth(KHz) of an individual user during his or her time slot\n",
+      "Nu=395.;#  number of users sharing the same time slot in the system, but having access to different frequency sub-bands\n",
+      "Bw=12.5; # in MHz\n",
+      "DR=16.2;#Data rate in kbps\n",
+      "FDur=40.; # Frame duration in msec\n",
+      "slots=6; #No of slots per time frame\n",
+      "IndiRate=16.2; #Individual data rate in kbps\n",
+      "Srate=13.;  #Speech rate in kbps\n",
+      "\n",
+      "#Calculations\n",
+      "TimeSlot=(Srate/IndiRate)*(FDur/slots);\n",
+      "Seff=TimeSlot*slots*Bu*Nu/(FDur*Bw*1000);\n",
+      "\n",
+      "#Results\n",
+      "print 'Multiple access spectral efficiency of TDMA is %.2f'%Seff;\n",
+      "print 'The overhead portion of the frame is %d percent'%((1-Seff)*100);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Multiple access spectral efficiency of TDMA is 0.76\n",
+        "The overhead portion of the frame is 23 percent\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.4, Page 161"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "nb=0.9; #BW efficiency factor\n",
+      "u=2;  # Bit Efficiency with QPSK\n",
+      "Vf=1;  # Voice activity factor\n",
+      "BW=12.5; #in MHz\n",
+      "IR=16.2; # in kbps\n",
+      "N=19; #frequency reuse factor\n",
+      "\n",
+      "#Calculations\n",
+      "Nu=nb*u*BW*1000/(Vf*IR*N);# number of channels (mobile users) per cell\n",
+      "Seff=int(Nu)*IR/(BW*1000);\n",
+      "\n",
+      "#Results\n",
+      "print 'Capacity of system is %d mobile users per cell'%Nu;\n",
+      "print 'Spectral efficiency of TDMA system is %.3f bit/sec/Hz'%Seff"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Capacity of system is 73 mobile users per cell\n",
+        "Spectral efficiency of TDMA system is 0.095 bit/sec/Hz\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.5, Page 163"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Nr=2.;# number of reference bursts per frame\n",
+      "Nt=24;  # number of traf\ufb01c bursts (slots) per frame(120msec)\n",
+      "FL=120;  #Frame length in msec\n",
+      "Br=148;  # number of overhead bits per reference burst\n",
+      "Bp=34; # number of overhead bits per preamble per slot \n",
+      "Bg=8.25;#number of equivalent bits in each guard time interval \n",
+      "Tf=120; # frame duration in msec\n",
+      "Rrf=270.83333333;  # bit rate of the RF channel in kbps\n",
+      "R=22.8;  #bit rate of each channel in kbps\n",
+      "\n",
+      "#Calculations\n",
+      "B0=Nr*(8*Br)+Nt*(8*Bp)+(Nt+Nr)*(8*Bg);#The number of overhead bits per frame\n",
+      "Bt=FL*10**-3*Rrf*10**3;#The total number of bits per frame \n",
+      "Eff=(1-B0/Bt)*100;\n",
+      "CH_Frame=(Eff/100)*Rrf/R;#No of channels/frame\n",
+      "\n",
+      "#Results\n",
+      "print 'The frame efficiency is %.2f percent'%Eff;\n",
+      "print 'Number of channels/frame are %d'%(CH_Frame)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The frame efficiency is 67.35 percent\n",
+        "Number of channels/frame are 7\n"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.6, Page 170"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "nb=0.9;#bandwidth ef\ufb01ciency\n",
+      "nf=0.45;#frequency reuse ef\ufb01ciency \n",
+      "Cd=0.8; #capacity degradation factor \n",
+      "Vf=0.4;#voice activity factor \n",
+      "Eb_I0=7; # desired energy-to-interference ratio in dB\n",
+      "L=1;#  ef\ufb01ciency of sector-antenna in cell \n",
+      "BW=12.5;#One way system BW in MHz\n",
+      "R=16.2;#Information rate in kbps\n",
+      "\n",
+      "#Calculations\n",
+      "Eb_I=10**(Eb_I0*0.1);#To convert from dB to a normal value\n",
+      "Nu=(nf*nb*Cd*L/Vf)*(BW*1000/(Eb_I*R));#Capacity of system\n",
+      "Seff=round(Nu)*R/(12.5*10**3);\n",
+      "\n",
+      "#Results\n",
+      "print 'Capacity of system is %d mobile users per cell'%round(Nu);\n",
+      "print 'Spectral efficiency of TDMA system is %.3f bits/sec/Hz'%Seff;\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Capacity of system is 125 mobile users per cell\n",
+        "Spectral efficiency of TDMA system is 0.162 bits/sec/Hz\n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.7, Page 171"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "#Given Data from Exa 6.4 and Exa 6.6\n",
+      "Cd=0.8; #capacity degradation factor\n",
+      "R=16.2;#Data rate in kbps\n",
+      "Eb_I0=7; #in dB\n",
+      "Eb_I=10**(Eb_I0*0.1);#To convert from dB to a normal value\n",
+      "Vf=0.4;#voice activity factor \n",
+      "u=2;  # Bit Efficiency\n",
+      "IR=16.2; # in kbps\n",
+      "N=19; #frequency reuse factor\n",
+      "nf=0.45;#frequency reuse ef\ufb01ciency \n",
+      "\n",
+      "#Calculations\n",
+      "Ncdma_by_Ntdma=Cd*N*nf*IR/(Eb_I*Vf*u*R);\n",
+      "\n",
+      "#Result\n",
+      "print 'The ratio of capacity of DS-CDMA to TDMA is %.3f'%Ncdma_by_Ntdma"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The ratio of capacity of DS-CDMA to TDMA is 1.706\n"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.8, Page 172"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Bss=600;  #Hopping bandwidth in MHz\n",
+      "stepsize=400; # in Hz\n",
+      "\n",
+      "#Calculations\n",
+      "No_of_Tones=Bss*10**6/stepsize;\n",
+      "Min_chips_required=math.log(No_of_Tones,2);\n",
+      "\n",
+      "#Result\n",
+      "print 'Minimum number of chips required are %d chips'%Min_chips_required"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Minimum number of chips required are 20 chips\n"
+       ]
+      }
+     ],
+     "prompt_number": 12
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.9, Page 179"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "e=2.71828; #Euler's number\n",
+      "Tprop=0.4; #Max propogation delay in sec\n",
+      "R=10; #data rate in Mbps\n",
+      "PackLen=400; #packet length in bits\n",
+      "\n",
+      "#Calculations\n",
+      "Tp=PackLen/R; #packet transmission time in microsec\n",
+      "a=Tprop/Tp;\n",
+      "G=Tp*10**-6*R*10**6/PackLen;#normalized offered traf\ufb01c load \n",
+      "#Slotted nonpersistent\n",
+      "S0=a*G*e**(-a*G)/(1-e**(-a*G)+a);#normalized throughput \n",
+      "#Unslotted nonpersistent\n",
+      "S1=G*e**(-a*G)/(1+(2*a)+e**(-a*G));#normalized throughput \n",
+      "#Slotted 1-persistent\n",
+      "S2=G*e**(-G*(1+a))*(1+a-e**(-a*G))/((1+a)*(1-e**(-a*G))+a*e**(-G*(1+a)));#normalized throughput \n",
+      "\n",
+      "#Results\n",
+      "print 'The Normalized throughput with an unslotted non persistent,a slotted persistent and a slotted 1-persistent CSMA protocol are \\n %.3f,%.3f and %.3f respectively'%(S0,S1,S2);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The Normalized throughput with an unslotted non persistent,a slotted persistent and a slotted 1-persistent CSMA protocol are \n",
+        " 0.496,0.493 and 0.531 respectively\n"
+       ]
+      }
+     ],
+     "prompt_number": 14
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 6.10, Page 188"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "Tprop=4;  #maximum propogation delay in sec\n",
+      "R=10; # data rate in Mbps\n",
+      "PackLen=400.; #data packet length in bits\n",
+      "ACK=20;  #length of ACK packet in bits\n",
+      "Tproc=1; #processing time(sec)\n",
+      "p=0.01;#probability that a data packet or its ACK can be corrupted during transmission\n",
+      "\n",
+      "#Calculations\n",
+      "Tp=PackLen/R; #packet transmission time in microsec\n",
+      "Ta=ACK/R; # transmission time for an ACK in microsec\n",
+      "T=Tp+2*Tprop+2*Tproc+Ta;# total time for transmission time \n",
+      "# Stop and wait ARQ\n",
+      "Eff0=(1-p)*Tp/((1-p)*T+p*Tp);\n",
+      "#SRP with window size W=8\n",
+      "W=8;\n",
+      "Eff1=(2+p*(W-1))/(2+p*(3*W-1));\n",
+      "#Go-Back-N protocol with window size W=8\n",
+      "Eff2=1./(1+W*(p/(1-p)));\n",
+      "\n",
+      "#Results\n",
+      "print 'The data link protocol efficiency with Stop and Wait protocol, SRP and GBN are \\n %.3f, %.3f abd %.3f respectively'%(Eff0,Eff1,Eff2);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The data link protocol efficiency with Stop and Wait protocol, SRP and GBN are \n",
+        " 0.763, 0.928 abd 0.925 respectively\n"
+       ]
+      }
+     ],
+     "prompt_number": 15
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb
new file mode 100755
index 00000000..ccf24614
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch8.ipynb
@@ -0,0 +1,178 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:f50ddd5f96951e3a4bd117adfc40133b15c129b8f04d9b391396a08431c3aae2"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 8: Speech Coding and Channel Coding"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 8.1, Page 227"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Pdiff=-3.;  #in dB\n",
+      "AMR1=12.2; #in kbps\n",
+      "AMR2=7.95;  #in kbps\n",
+      "AMR3=4.75;  #in kbps\n",
+      "\n",
+      "#Calculations\n",
+      "#CG(dB)=10math.log{(DPDCH(kbps)+DPCCH)/(DPDCH(AMR bit rate (kbps))+ DPCCH)}\n",
+      "CG1=10*math.log10((AMR1+AMR1*10**(Pdiff/10))/(AMR2+AMR1*10**(Pdiff/10)));\n",
+      "CG2=10*math.log10((AMR1+AMR1*10**(Pdiff/10))/(AMR3+AMR1*10**(Pdiff/10)));\n",
+      "\n",
+      "#Results\n",
+      "print 'By reducing the AMR bit rate from 12.2 to 7.95 kbps coverage gain becomes %.2f dB'%CG1;\n",
+      "print 'By reducing the AMR bit rate from 7.95 to 4.75 kbps coverage gain becomes %.2f dB'%CG2;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "By reducing the AMR bit rate from 12.2 to 7.95 kbps coverage gain becomes 1.15 dB\n",
+        "By reducing the AMR bit rate from 7.95 to 4.75 kbps coverage gain becomes 2.27 dB\n"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 8.2, Page 239"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import numpy as np\n",
+      "import sympy\n",
+      "from sympy import symbols\n",
+      "\n",
+      "#Variable declaration\n",
+      "K=4; #constraint length\n",
+      "r=1./2; #code rate(n/k)\n",
+      "x=symbols('x');#Defining x as a ploynomial variable\n",
+      "G1=1+x**2+x**3;\n",
+      "G2=1+x+x**2+x**3;\n",
+      "ins=np.array([1, 0, 1, 1, 1]);#input(first bit first)\n",
+      "\n",
+      "#Calculations&Results\n",
+      "#with reference to Fig 8.9 on page no 239\n",
+      "g1=np.array([1, 0, 1, 1]); #converting from G1 polynomial to bit form\n",
+      "g2=[1, 1, 1, 1];##converting from G2 polynomial to bit form\n",
+      "x1=np.convolve(g1,ins)\n",
+      "x2=np.convolve(g2,ins)\n",
+      "V1=x1%2;\n",
+      "V2=x2%2;\n",
+      "print \"Multiplexing the V1 and V2 to get required output sequence as\"\n",
+      "a=5;\n",
+      "for i in range(0,6):\n",
+      "   print '%d%d'%(V2[a],V1[a]);\n",
+      "   a=a-1;\n",
+      "  "
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Multiplexing the V1 and V2 to get required output sequence as\n",
+        "10\n",
+        "10\n",
+        "10\n",
+        "00\n",
+        "10\n",
+        "11\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 8.3, Page 246"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import numpy as np\n",
+      "\n",
+      "#Variable declaration\n",
+      "BitStream=np.array([0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]);#Last bit to first bit\n",
+      "\n",
+      "# Interleaver\n",
+      "Input1=[[1, 0, 0, 0],[1,0,0,0],[1,1,1,0],[0,0,0,0]]      #Writing data row wise\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"GIven Bit stream is\",BitStream\n",
+      "print \"Input to interleaver is\",Input1\n",
+      "\n",
+      "Output1=np.array([0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1]);    # Reading data column wise\n",
+      "print \"Output of interleaver is\",Output1\n",
+      "#De-interleaver\n",
+      "Input2=[[1, 1, 1, 0],[0,0,1,0],[0,0,1,0],[0,0,0,0]]  #Writing o/p data row wise\n",
+      " # Let From 6th to 9th bits have Burst Error \n",
+      "print \"Input to de-interleaver is\",Input2\n",
+      " #Output of deinterleaver\n",
+      "                             \n",
+      "Output2= [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]; \n",
+      "print \"Output of de-interleaver is\",Output2\n",
+      "print  \"Bits with Burst error were from 6th to 9th. But in output of de-interleaver, they relocated to positions 3rd, 6th, 10th and 14th.\";"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "GIven Bit stream is [0 0 0 0 0 1 1 1 0 0 0 1 0 0 0 1]\n",
+        "Input to interleaver is [[1, 0, 0, 0], [1, 0, 0, 0], [1, 1, 1, 0], [0, 0, 0, 0]]\n",
+        "Output of interleaver is [0 0 0 0 0 1 0 0 0 1 0 0 0 1 1 1]\n",
+        "Input to de-interleaver is [[1, 1, 1, 0], [0, 0, 1, 0], [0, 0, 1, 0], [0, 0, 0, 0]]\n",
+        "Output of de-interleaver is [0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1]\n",
+        "Bits with Burst error were from 6th to 9th. But in output of de-interleaver, they relocated to positions 3rd, 6th, 10th and 14th.\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb b/Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb
new file mode 100755
index 00000000..7efd7e54
--- /dev/null
+++ b/Wireless_Communications_and_Networking_by_V._Garg/ch9.ipynb
@@ -0,0 +1,478 @@
+{
+ "metadata": {
+  "name": "",
+  "signature": "sha256:4f7509b378d9baa23589f40ce770175499b6cadfd03b87969971e1834bcae9ad"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Chapter 9: Modulation Schemes"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.1, Page 259"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "import scipy\n",
+      "from scipy.optimize import fsolve\n",
+      "\n",
+      "#Variable declaration\n",
+      "Pe=10**-6;#Probability of error\n",
+      "e=2.71828; #Euler's Number\n",
+      "\n",
+      "#Calculations\n",
+      "# For BPSK\n",
+      "#Pe(=10**-6)=e**(-x)/(2*sqrt(%pi*x)); where x=Eb/No\n",
+      "def f(x):\n",
+      "    y=2.71828**(-x)/(2*math.sqrt(math.pi*x))-10**-6\n",
+      "    return y\n",
+      "x = fsolve(f,0.1);\n",
+      "\n",
+      "#Results\n",
+      "print 'Eb/No For BPSK is %.2f dB'%(10*math.log10(x));\n",
+      "print 'FSK requires 3 dB more in terms of Eb/N0 to give the same Pe as BPSK so it comes out to be %.2f dB'%(10*math.log10(x)+3);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Eb/No For BPSK is 10.54 dB\n",
+        "FSK requires 3 dB more in terms of Eb/N0 to give the same Pe as BPSK so it comes out to be 13.54 dB\n"
+       ]
+      }
+     ],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.2, Page 259"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Pe=10.**-6;#Probability of error\n",
+      "No=10.**-10;  # PSD in W/Hz\n",
+      "R=100*10**3;  #data rate in bps\n",
+      "\n",
+      "#Calculations\n",
+      "#From Example 9.1, Eb/N0= 10.54dB (11.32) for Pe=10**-6 \n",
+      "#Therefore\n",
+      "Eb_No=11.32; #From Exa. 9.1\n",
+      "# Eb/No = A**2/(2*No*R);\n",
+      "A=math.sqrt(2*No*(Eb_No)*R);\n",
+      "\n",
+      "#Result\n",
+      "print 'Amplitude of a carrier signal is %.3f mV'%(A*1000);\n",
+      "#Incorrect answer in textbook"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Amplitude of a carrier signal is 15.047 mV\n"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.3, Page 267"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "B=['00','10','01','11','01','00','11','10','10','01','01','00'];#Given Bit stream\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"Phase transition table for pi/4-DQPSK Modulation is given as \"\n",
+      "print \" By Referring Table 9.1 on page No 266 i.e\"\n",
+      "print \"Symbol    Phase transition\"\n",
+      "print \"00     =>    45\u00b0\"\n",
+      "print \"01     =>   135\u00b0\"\n",
+      "print \"10     =>   -45\u00b0\"\n",
+      "print \"11     =>  -135\u00b0\"\n",
+      "print \"sym      Dell phi(k)   Phi(k)\"\n",
+      "#BitStream='001001110100111010010100';\n",
+      "\n",
+      "phase=0; #Taking initial phase as zero\n",
+      "for i in range(0,12):\n",
+      "    if(B[i]=='00'):\n",
+      "        phase=phase+45;  \n",
+      "        print ' %s          45          %d'%(B[i],phase);\n",
+      "    \n",
+      "    if(B[i]=='01'):\n",
+      "        phase=phase+135;\n",
+      "        print ' %s         135          %d'%(B[i],phase);\n",
+      "    \n",
+      "    if(B[i]=='10'):\n",
+      "        phase=phase-45;\n",
+      "        print ' %s         -45          %d'%(B[i],phase);\n",
+      "    \n",
+      "    if(B[i]=='11'):\n",
+      "        phase=phase-135;\n",
+      "        print ' %s        -135          %d'%(B[i],phase);\n",
+      "   \n",
+      "\n",
+      "print 'final phase for the pi/4-DQPSK modulation method for given bitstream is %d degree'%phase"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Phase transition table for pi/4-DQPSK Modulation is given as \n",
+        " By Referring Table 9.1 on page No 266 i.e\n",
+        "Symbol    Phase transition\n",
+        "00     =>    45\u00b0\n",
+        "01     =>   135\u00b0\n",
+        "10     =>   -45\u00b0\n",
+        "11     =>  -135\u00b0\n",
+        "sym      Dell phi(k)   Phi(k)\n",
+        " 00          45          45\n",
+        " 10         -45          0\n",
+        " 01         135          135\n",
+        " 11        -135          0\n",
+        " 01         135          135\n",
+        " 00          45          180\n",
+        " 11        -135          45\n",
+        " 10         -45          0\n",
+        " 10         -45          -45\n",
+        " 01         135          90\n",
+        " 01         135          225\n",
+        " 00          45          270\n",
+        "final phase for the pi/4-DQPSK modulation method for given bitstream is 270 degree\n"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.4, Page 270"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "CHBW=200; #Channel BW in KHz\n",
+      "R=270.83; #Data rate in kbps\n",
+      "Fc=900;  #carrier frequency in MHz\n",
+      "\n",
+      "#Calculations\n",
+      "FreqShift=0.5*R;\n",
+      "#Transmitted Frequencies\n",
+      "Fh=Fc*1000+0.25*R;#Max\n",
+      "Fl=Fc*1000-0.25*R;#Min\n",
+      "BWEff=R/CHBW;\n",
+      "\n",
+      "#Results\n",
+      "print 'The frequency shift between binary 1 and binary 0 is %.3f kHz'%FreqShift;\n",
+      "print 'Maximum and Minimum value of transmitted frequencies are %.4f mHz and %.4f mHz respectively'%(Fh/1000,Fl/1000);\n",
+      "print 'Bandwidth efficiency is %.2f bps/Hz'%BWEff"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "The frequency shift between binary 1 and binary 0 is 135.415 kHz\n",
+        "Maximum and Minimum value of transmitted frequencies are 900.0677 mHz and 899.9323 mHz respectively\n",
+        "Bandwidth efficiency is 1.35 bps/Hz\n"
+       ]
+      }
+     ],
+     "prompt_number": 5
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.5, Page 271"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "R=270.; #data rate in kbps\n",
+      "Eb_No=6.; # in dB\n",
+      "GMSK=0.3; #Gaussian minimum shift keying\n",
+      "\n",
+      "#Calculations&Results\n",
+      "Tb=1./R *10**3; #in microsec\n",
+      "B=GMSK/Tb;\n",
+      "print '3-dB BW for a gaussian low pass filter is %.f kHz'%(B*1000);\n",
+      "PowerBW=1.41*R;\n",
+      "DegradFac=0.89;\n",
+      "Pe=math.erfc(math.sqrt(2*DegradFac*10**(0.1*Eb_No)));\n",
+      "print 'Power bandwidth in the RF channel is %.1f kHz'%PowerBW\n",
+      "print 'Bit error probability for GMSK is %.1e'%Pe;  #Incorrect answer in textbook"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "3-dB BW for a gaussian low pass filter is 81 kHz\n",
+        "Power bandwidth in the RF channel is 380.7 kHz\n",
+        "Bit error probability for GMSK is 1.7e-04\n"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.6, Page 273"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "\n",
+      "#Variable declaration\n",
+      "Rs=19200; #symbols per second\n",
+      "states=64;\n",
+      "\n",
+      "#Calculations\n",
+      "Bits_symbol=math.log(states,2);\n",
+      "BitRate=Bits_symbol*Rs;\n",
+      "\n",
+      "#Result\n",
+      "print 'Bit Rate of the modulator is %.1f kbps'%(BitRate/1000)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Bit Rate of the modulator is 115.2 kbps\n"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.7, Page 274"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "import scipy\n",
+      "from scipy.optimize import fsolve\n",
+      "\n",
+      "#Variable declaration\n",
+      "Rb=144; #data rate in kbps\n",
+      "BW=36; #in MHz\n",
+      "Pb=3*10**-5;#probability of bit error\n",
+      "\n",
+      "#Calculations\n",
+      "Seff=Rb/BW;  #spectral efficiency in bps/Hz\n",
+      "M=2**(Rb/BW); #since the channel is band limited\n",
+      "\n",
+      "#since Q[sqrt(2*Eb_No)]=(1/2)*erfc[sqrt(Eb_No)]            # refer page no 257 equ 9.35\n",
+      "def f(x):\n",
+      "    y=(3./8)*math.erfc(math.sqrt((2./5)*x))-Pb       #from eqn 9.66 and 9.35\n",
+      "    return y\n",
+      "               \n",
+      "x = fsolve(f,0.1)\n",
+      "\n",
+      "#Result\n",
+      "print 'For a rectangular constellation (refer Figure 9.12), with a Gaussian channel and matched \ufb01lter reception, the calculated Eb/No value is %.1f dB'%(10*math.log10(x));"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "For a rectangular constellation (refer Figure 9.12), with a Gaussian channel and matched \ufb01lter reception, the calculated Eb/No value is 12.9 dB\n"
+       ]
+      }
+     ],
+     "prompt_number": 8
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.8, Page 274"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "import math\n",
+      "import scipy\n",
+      "from scipy.optimize import fsolve\n",
+      "\n",
+      "#Variable declaration\n",
+      "Pb=10**-8;#BER probability\n",
+      "\n",
+      "#Calculations&Results\n",
+      "print \"For 16-PSK:\"\n",
+      "# Pb=0.5*Q(0.552*sqrt(Eb_No));\n",
+      "#since Q[sqrt(2*Eb_No)]=(1/2)*erfc[sqrt(Eb_No)]            # refer page no 257 equ 9.35\n",
+      "def f(x):\n",
+      "    y=0.25*math.erfc(math.sqrt(0.5*0.552**2*x))-Pb\n",
+      "    return y\n",
+      "\n",
+      "x = fsolve(f,0.1)\n",
+      "\n",
+      "print 'Using equation 9.50 we get Eb/No as %d dB (approx)'%round(10*math.log10(x));\n",
+      "\n",
+      "print \"For 16-QAM\"\n",
+      "#Pb=0.75*Q(sqrt(0.8*Eb_No));\n",
+      "def f(x1):\n",
+      "    y=(3./8)*math.erfc(math.sqrt(0.4*x1))-Pb\n",
+      "    return y\n",
+      "    \n",
+      "x1 = fsolve(f,0.1)\n",
+      "\n",
+      "#since Q[sqrt(2*Eb_No)]=(1/2)*erfc[sqrt(Eb_No)] # refer page no 257 equ 9.35\n",
+      "print 'Using equation 9.66 we get Eb/No as %d dB (approx)'%round(10*math.log10(x1));\n",
+      "print 'Thus 16-QAM has an advantage of about %d dB compared to 16-PSK'%(10*math.log10(x)-10*math.log10(x1));"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "For 16-PSK:\n",
+        "Using equation 9.50 we get Eb/No as 20 dB (approx)\n",
+        "For 16-QAM\n",
+        "Using equation 9.66 we get Eb/No as 16 dB (approx)\n",
+        "Thus 16-QAM has an advantage of about 4 dB compared to 16-PSK\n"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Example 9.9, Page 277"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "#Variable declaration\n",
+      "M=8; #number of different signal elements\n",
+      "Fc=250; #carrier frequency in kHz\n",
+      "DelF=25; #kHz\n",
+      "Pe=10**-6;#probability of error\n",
+      "\n",
+      "#Calculations\n",
+      "TotalBW=2*M*DelF;\n",
+      "nb=2*math.log(M,2)/(M+3);\n",
+      "#Pe=7*Q(z) and z=approx(5.08)\n",
+      "z=5.08;\n",
+      "Eb_No=(z)**2/math.log(M,2);\n",
+      "bits_sym=math.log(M,2);\n",
+      "\n",
+      "#Results\n",
+      "print 'Total bandwidth required is %d kHz \\n '%TotalBW;\n",
+      "print 'The bandwidth efficiency is %.4f \\n '%nb;\n",
+      "print 'The required Eb/No is %.3f dB \\n '%(10*math.log10(Eb_No));\n",
+      "print 'Carried bits per symbol are %d \\n '%bits_sym;"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "Total bandwidth required is 400 kHz \n",
+        " \n",
+        "The bandwidth efficiency is 0.5455 \n",
+        " \n",
+        "The required Eb/No is 9.346 dB \n",
+        " \n",
+        "Carried bits per symbol are 3 \n",
+        " \n"
+       ]
+      }
+     ],
+     "prompt_number": 10
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png
new file mode 100755
index 00000000..8b71e082
Binary files /dev/null and b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/EbbyNo.png differ
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png
new file mode 100755
index 00000000..21f83b0e
Binary files /dev/null and b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/comparision_of_models.png differ
diff --git a/Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png
new file mode 100755
index 00000000..913873f0
Binary files /dev/null and b/Wireless_Communications_and_Networking_by_V._Garg/screenshots/multiplexing.png differ
-- 
cgit