diff options
| author | Thomas Stephen Lee | 2015-09-04 22:04:10 +0530 |
|---|---|---|
| committer | Thomas Stephen Lee | 2015-09-04 22:04:10 +0530 |
| commit | 41f1f72e9502f5c3de6ca16b303803dfcf1df594 (patch) | |
| tree | f4bf726a3e3ce5d7d9ee3781cbacfe3116115a2c /Digital_Communications_by_S._Sharma/Chapter3.ipynb | |
| parent | 9c9779ba21b9bedde88e1e8216f9e3b4f8650b0e (diff) | |
| download | Python-Textbook-Companions-41f1f72e9502f5c3de6ca16b303803dfcf1df594.tar.gz Python-Textbook-Companions-41f1f72e9502f5c3de6ca16b303803dfcf1df594.tar.bz2 Python-Textbook-Companions-41f1f72e9502f5c3de6ca16b303803dfcf1df594.zip | |
add/remove/update books
Diffstat (limited to 'Digital_Communications_by_S._Sharma/Chapter3.ipynb')
| -rwxr-xr-x | Digital_Communications_by_S._Sharma/Chapter3.ipynb | 2238 |
1 files changed, 2238 insertions, 0 deletions
diff --git a/Digital_Communications_by_S._Sharma/Chapter3.ipynb b/Digital_Communications_by_S._Sharma/Chapter3.ipynb new file mode 100755 index 00000000..805bc62b --- /dev/null +++ b/Digital_Communications_by_S._Sharma/Chapter3.ipynb @@ -0,0 +1,2238 @@ +{
+ "metadata": {
+ "name": ""
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+ {
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "<h1> Chpater 3: WAVEFORM CODING TECHNIQUES<h1>"
+ ]
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3,1 Page No 110"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "print('This is a Theoretical example')\t"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "This is a theoretcal example\n"
+ ]
+ }
+ ],
+ "prompt_number": 104
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3,2,i, Page No 111"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math \n",
+ "#find code word length\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "bandwidth=4.2*10**6\n",
+ "fm=bandwidth\n",
+ "q=512 #Quantization levels\n",
+ "#q=2^v\n",
+ "\n",
+ "#Calculation\n",
+ "v=math.log10(512)/math.log10(2)\n",
+ "\n",
+ "#Result\n",
+ "print(\"The code word legth is = %.f bits\" %v)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "The code word legth is = 9 bits\n"
+ ]
+ }
+ ],
+ "prompt_number": 105
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.2.ii, Page No 111"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#find The transmission Bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "bandwidth=4.2*10**6\n",
+ "fm=bandwidth\n",
+ "q=512.0 #Quantization levels\n",
+ "v=9.0\n",
+ "\n",
+ "#Calculation\n",
+ "bw=v*fm*10**-6\n",
+ "\n",
+ "#Result\n",
+ "print(\"The transmission Bandwidth is = %.1f MHz\" %bw)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "The transmission Bandwidth is = 37.8 MHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 106
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.2.iii, Page No 111 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#find Final Bit rate\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "bandwidth=4.2*10**6\n",
+ "fm=bandwidth\n",
+ "q=512.0 #Quantization levels\n",
+ "v=9.0\n",
+ "\n",
+ "#Calculation\n",
+ "fs=2*fm\n",
+ "r=v*fs #signaling rate\n",
+ "\n",
+ "#Result\n",
+ "print(\"Final Bit rate =%.1f x 10^6 bits/sec\" %(r/(10**6)))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Final Bit rate =75.6 x 10^6 bits/sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 107
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.2.iv, Page No 111"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#find Output signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "bandwidth=4.2*10**6\n",
+ "fm=bandwidth\n",
+ "q=512 #Quantization levels\n",
+ "v=9.0\n",
+ "\n",
+ "#Calculation\n",
+ "sn=4.8+6*v #noise in dB\n",
+ "\n",
+ "\n",
+ "print(\"Output signal to noise ratio is = %.1f dB\" %sn)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Output signal to noise ratio is = 58.8 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 108
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.3.i, Page No 112"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#find bits per sample\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fmax=4*10**3\n",
+ "xmax=3.8\n",
+ "snr=100\n",
+ "\n",
+ "#Calculation\n",
+ "P=30*10**-3\n",
+ "v=(math.log10(((snr*xmax**2)/(3*P)))/(2*math.log10(2)))\n",
+ "\n",
+ "#Result\n",
+ "print(\"Number of bits required per sample are = %.2f bits\" %v)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Number of bits required per sample are = 6.98 bits\n"
+ ]
+ }
+ ],
+ "prompt_number": 109
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.3.ii, Page No 168"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Find Transmission Bandwith\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "fm=4*10**3 #Bandwidth of PCM\n",
+ "xmax=3.8\n",
+ "snr=100 #Signal to Noise Ratio\n",
+ "outputs=30.0\n",
+ "v=7.0\n",
+ "\n",
+ "#Calculation\n",
+ "bw=outputs*v*fm \n",
+ "r=bw*2\n",
+ "bw=bw/10**3\n",
+ "\n",
+ "#Result\n",
+ "print('Transmission Bandwith R = %.f kHz' %bw)\n",
+ "r=r/1000\n",
+ "print('Signaling rate R = %.f bits/sec' %r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Transmission Bandwith R = 840 kHz\n",
+ "Signaling rate R = 1680 bits/sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 110
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.4, Page No 112"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#find sampling rate,number of bits,bit rate,bandwidht\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "emax=0.001\n",
+ "de=2*emax\n",
+ "fm=100.0\n",
+ "xmax=10.0\n",
+ "\n",
+ "#Calculation\n",
+ "q=(2*xmax)/de\n",
+ "fs=2*fm\n",
+ "v=(math.log10(q))/math.log10(2)\n",
+ "v=math.ceil(v)\n",
+ "r=v*fs\n",
+ "\n",
+ "#Result\n",
+ "print('1. sampling Frequncy = %.f Hz ' %fs) \n",
+ "print('2. No.of bits in PCM = %.f bits ' %v) \n",
+ "print('3. sampling rate = %.f bits per second ' %r)\n",
+ "r=r/2\n",
+ "print('4. Transmission Bandwidth = %.f Hz ' %r) "
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "1. sampling Frequncy = 200 Hz \n",
+ "2. No.of bits in PCM = 14 bits \n",
+ "3. sampling rate = 2800 bits per second \n",
+ "4. Transmission Bandwidth = 1400 Hz \n"
+ ]
+ }
+ ],
+ "prompt_number": 111
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.5, Page No 113 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Bandwidth,Sampling Rate\n",
+ "\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "fm=3.4*10**3\n",
+ "N=24\n",
+ "r=1.5*10**6\n",
+ "encoder=8\n",
+ "\n",
+ "#Calculation\n",
+ "BW=N*fm\n",
+ "BW=BW/10**3\n",
+ "r1=r/N\n",
+ "fs=r1/encoder\n",
+ "\n",
+ "#Result\n",
+ "print(\"i. Channel Bandwith is = %.2f kHz\" %BW)\n",
+ "print(\"ii. Sampling frequency is = %.2f Hz or samples per second.\" %fs)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i. Channel Bandwith is = 81.60 kHz\n",
+ "ii. Sampling frequency is = 7812.50 Hz or samples per second.\n"
+ ]
+ }
+ ],
+ "prompt_number": 112
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.6, Page No 114 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Find Signal Bandwidth,Noise Ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "v=7\n",
+ "r=50*10**6\n",
+ "\n",
+ "#Calculation\n",
+ "#fs=2*fm\n",
+ "fm=r/(2*v)\n",
+ "snr=1.8+(6*v);\n",
+ "fm=fm*10**-6\n",
+ "\n",
+ "#Result\n",
+ "print('i. Maximum message Bandwidth is = %.2f MHz ' %fm)\n",
+ "print('ii. signal to quantization niose ration = %.2f dB ' %snr)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i. Maximum message Bandwidth is = 3.57 MHz \n",
+ "ii. signal to quantization niose ration = 43.80 dB \n"
+ ]
+ }
+ ],
+ "prompt_number": 113
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.7, Page No 114"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#find i)bits per sample,ii)transmission rate\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "fm=3*10**3\n",
+ "q=16\n",
+ "\n",
+ "#Calculation\n",
+ "v=(math.log10(q))/math.log10(2)\n",
+ "\n",
+ "#Result\n",
+ "print('i) Bits in code word= %.f bits' %v)\n",
+ "fs=2*fm\n",
+ "r=v*fs\n",
+ "print('ii) it trasmission rate= %.f x 10^3 bits per second' %(r/(10**3)))\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Bits in code word= 4 bits\n",
+ "ii) it trasmission rate= 24 x 10^3 bits per second\n"
+ ]
+ }
+ ],
+ "prompt_number": 114
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.8, Page No 115"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Find signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "fm=3.5*10**3\n",
+ "r=50*10**3\n",
+ "\n",
+ "#Calculation\n",
+ "fs=2*fm\n",
+ "rms=0.2\n",
+ "xmax=2\n",
+ "v=r/fs #signaling rate r=v*fs\n",
+ "v=math.ceil(v)\n",
+ "P=(rms**2)/1\n",
+ "SNR=((3*P*2**(2*v))/(xmax**2))\n",
+ "SN=10*math.log10(SNR)\n",
+ "SN=math.ceil(SN)\n",
+ "\n",
+ "#Result\n",
+ "print(\"signal to niose ratio =%.f dB\" %SN)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "signal to niose ratio =33 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 115
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.10, Page No 117 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find i)noise ratio ii)bits\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "Am=3.0\n",
+ "v=10.0\n",
+ "\n",
+ "#Calculation\n",
+ "SNR=1.8+6*v #noise ratio \n",
+ "SN=40\n",
+ "v=(SN-1.8)/6\n",
+ "\n",
+ "#Result\n",
+ "print(\"i) Signal to Quantization noise ratio = %.1f dB\" %SNR)\n",
+ "print(\"ii) Bits required to get signal to niose ratio of 40dB = %.f \" %math.ceil(v))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Signal to Quantization noise ratio = 61.8 dB\n",
+ "ii) Bits required to get signal to niose ratio of 40dB = 7 \n"
+ ]
+ }
+ ],
+ "prompt_number": 116
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.11, Page No 117 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Maximum frequency\n",
+ "\n",
+ "#Variable Declaration\n",
+ "#Given data\n",
+ "v=7\n",
+ "SNR=1.8+6*v\n",
+ "r=56*10**3\n",
+ "\n",
+ "#Calculation\n",
+ "fs=r/v #r=v*fs signaling rate\n",
+ "fm=fs/2 #Nquset rate\n",
+ "\n",
+ "#Result\n",
+ "fm=fm/10**3\n",
+ "print(\"Maximum frequency is = %.f kHz\" %fm)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Maximum frequency is = 4 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 117
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.14, Page No 129 "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Maximum Amplitude\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=3*10**3.0\n",
+ "\n",
+ "#Calculation\n",
+ "Nyquistrate=2*fm #Nyquistrate\n",
+ "fs=5*Nyquistrate #Samplingfrquency\n",
+ "Ts=1/fs #Sampling Interval\n",
+ "de=0.25 #step size\n",
+ "fm1=2*10**3.0\n",
+ "Am=de/(2*math.pi*fm1*Ts)\n",
+ "\n",
+ "#Result\n",
+ "print(\"Maximum Amplitude = %.4f Volts\" %Am)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Maximum Amplitude = 0.5968 Volts\n"
+ ]
+ }
+ ],
+ "prompt_number": 118
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.16, Page No 130"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find signaling rate\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs1=8*10**3.0\n",
+ "de=31.25*10**-3\n",
+ "q=64.0\n",
+ "\n",
+ "#Calculation\n",
+ "v=math.log(q,2)\n",
+ "r=v*fs1 #signaling rate\n",
+ "fm=3*10**3.0\n",
+ "A=1\n",
+ "fs2=(2*math.pi*fm*A)/(de)\n",
+ "\n",
+ "#Result\n",
+ "r=r*10**-3\n",
+ "print(\"Signaling rate of PCM is = %.f kHz\" %r)\n",
+ "fs2=fs2*10**-3\n",
+ "print(\"The signaling rate of DM is = %.2f kHz\" %fs2)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Signaling rate of PCM is = 48 kHz\n",
+ "The signaling rate of DM is = 603.19 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 119
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.17, Page No 131"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=64.0*10**3 #frequency\n",
+ "fm=2.0*10**3 #Sinosoidal input signal sample \n",
+ "fM=4.0*10**3 #bandwidth\n",
+ "\n",
+ "#Calculation\n",
+ "SNR=(3*fs**3)/(8*math.pi**2*fm**2*fM) #Signal to noise ratio\n",
+ "SNRO=10*math.log10(SNR)\n",
+ "\n",
+ "#Result\n",
+ "print(\"Output signal to noise ratio = %.2f dB\" %SNRO)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Output signal to noise ratio = 27.94 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 120
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.18, Page No 131"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find signal to Quatization noise ratio \n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=8.0*10**3 #Sampling frequency\n",
+ "r=64.0*10**3 #Data Rate\n",
+ "N=8 #number of bits\n",
+ "\n",
+ "#Calculation\n",
+ "SNR=(1.8+6*N) #signal to Quatization noise ratio\n",
+ "\n",
+ "#Result\n",
+ "print(\"Signal to Quatization noise ratio of PCM system is = %.f dB\" %SNR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Signal to Quatization noise ratio of PCM system is = 50 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 121
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.20, Page No 149"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#Find sampling rate,quantizing level\n",
+ "\n",
+ "#Variable Declaration\n",
+ "r=36000\n",
+ "fm=3.2*10**3\n",
+ "\n",
+ "#Calculation\n",
+ "fs=2*fm #Nquest rate\n",
+ "v=r/fs #r=v*fs signaling rate\n",
+ "v=math.floor(v)\n",
+ "q=2**v\n",
+ "fs1=r/v\n",
+ "\n",
+ "#Result\n",
+ "print(\"Quantizing level q = %.f \" %q)\n",
+ "fs1=fs1/1000\n",
+ "print(\"sampling rate fs = %.1f kHz \" %fs1)\n",
+ "print(\"Number of binary digits = %.f \" %v)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Quantizing level q = 32 \n",
+ "sampling rate fs = 7.2 kHz \n",
+ "Number of binary digits = 5 \n"
+ ]
+ }
+ ],
+ "prompt_number": 122
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.21, Page No 149"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find time duration of 1bit binary encoded signal\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=input(\"Enter the Nyquist rate of Signal fs(Hz)=\")\n",
+ "q=input(\"Enter the Quantization levels q =\")\n",
+ "\n",
+ "#Calculation\n",
+ "v=math.log(q,2) #binary pulses transmitted per second\n",
+ "t=1.0/(v*fs) #Nyquist interval\n",
+ "\n",
+ "#Result\n",
+ "print('Time duration of binary signal t = %.4f sec ' %t)\n",
+ "#output\n",
+ "#Enter the Nyquist rate fs(Hz)=3\n",
+ "#Enter the Quantization levels q =5\n",
+ "#time duration of 1bit binary signal \n",
+ "#t=0.1435589 sec"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Enter the Nyquist rate of Signal fs(Hz)=23\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Enter the Quantization levels q =34\n"
+ ]
+ },
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Time duration of binary signal t = 0.0085 sec \n"
+ ]
+ }
+ ],
+ "prompt_number": 123
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.23, Page No 150"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#find signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "SNR=40\n",
+ "SNRO=10**(SNR/10)\n",
+ "\n",
+ "#SNR=3(q**2)/2, Signal to Quantization noise ratio\n",
+ "\n",
+ "#Calculation\n",
+ "q=math.sqrt((2*SNRO)/3)\n",
+ "q=math.ceil(q)\n",
+ "v=math.log(q,2) #q=2**v Quantization levels\n",
+ "v=math.ceil(v)\n",
+ "snr=1.76+6.02*v #output Signal to Quantization noise ratio\n",
+ "\n",
+ "#Result\n",
+ "print(\"Output Signal to Quantization noise ratio = %.1f dB\" %snr)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Output Signal to Quantization noise ratio = 43.9 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 124
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.24.i, Page No 150"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Quantizing levels,minimum number of bits per sample\n",
+ "\n",
+ "#Variable Declaration\n",
+ "SNRO=30.0\n",
+ "fmin=300.0\n",
+ "fmax=3300.0\n",
+ "fs=80000.0\n",
+ "\n",
+ "#Calculation\n",
+ "#SNRO=1.76+20log10(q)\n",
+ "q=10**((SNRO-1.76)/20)\n",
+ "q=math.ceil(q)\n",
+ "v=math.log(q,2)\n",
+ "\n",
+ "#Result\n",
+ "print('Quantizing levels required is =%.f' %q)\n",
+ "print('minimum number of bits per sample are=%.1f that is approximately 5' %v)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Quantizing levels required is =26\n",
+ "minimum number of bits per sample are=4.7 that is approximately 5\n"
+ ]
+ }
+ ],
+ "prompt_number": 125
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.24.ii, Page No 150"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find minimum required bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "SNRO=30.0 #Signal to quantisizing noise ratio\n",
+ "fmin=300.0 #min frequency band\n",
+ "fmax=3300.0 #max frequency band\n",
+ "fs=8000.0 #Sampling rate\n",
+ "v=5.0 #Minimum number of bits per sample\n",
+ "\n",
+ "#Calculation\n",
+ "fPCM=(v*fs)/2\n",
+ "fPCM=fPCM/1000\n",
+ "\n",
+ "#Result\n",
+ "print('minimum required bandwidth =%.f kHz' %fPCM)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "minimum required bandwidth =20 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 126
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.24.iii, Page No 150"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Quantizing levels,minimum number of bits per sample and bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "SNRO=30.0 #Signal to quantisizing noise ratio\n",
+ "fmin=300.0 #min frequency band\n",
+ "fmax=3300.0 #max frequency band\n",
+ "fs=8000.0 #Sampling rate\n",
+ "\n",
+ "#Calculation\n",
+ "q=10**((SNRO+10.1)/20)\n",
+ "q=math.ceil(q)\n",
+ "v=math.log(q,2)\n",
+ "v=math.ceil(v)\n",
+ "\n",
+ "#Result\n",
+ "print('Quantizing levels need is =%.f' %q)\n",
+ "print('minimum number of bits per sample is =%.f' %v)\n",
+ "fPCM=(v*fs)/2\n",
+ "fPCM=fPCM/1000\n",
+ "print('minimum required bandwidth =%.f Khz' %fPCM)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Quantizing levels need is =102\n",
+ "minimum number of bits per sample is =7\n",
+ "minimum required bandwidth =28 Khz\n"
+ ]
+ }
+ ],
+ "prompt_number": 127
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.27, Page No 152"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "\n",
+ "#determine the Maximum Amplitude,\n",
+ "\n",
+ "#Variable Declaration\n",
+ "de=250*10**-3\n",
+ "wm=2*math.pi*1000 \n",
+ "fs=3*10**3\n",
+ "Ts=1/fs\n",
+ "\n",
+ "#Calculation\n",
+ "Amax=(de*3*fs*2)/(wm) #Amplitude\n",
+ "SNR=(3.0*((3*6*(10**3))**3))/((8*(math.pi**2)*(10**3)**3))\n",
+ "\n",
+ "#Result\n",
+ "print('Maximum Amplitude= %.1f mV' %(Amax*(10**2)))\n",
+ "print('Signal to noise ratio = %.2f dB' %(10*math.log10(SNR)))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Maximum Amplitude= 71.6 mV\n",
+ "Signal to noise ratio = 23.46 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 128
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.29, Page No 153"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find number of bits per sample\n",
+ "\n",
+ "#Variable Declaration\n",
+ "SNR=20\n",
+ "averagepower=30*10**-3\n",
+ "SNRO=10**(SNR/10)\n",
+ "A=3.8\n",
+ "\n",
+ "#SNRO=average signal power/Quatizing power\n",
+ "#de=(2*A)/L\n",
+ "\n",
+ "#Calculation\n",
+ "L=math.sqrt((SNRO*A**2)/(3*averagepower))\n",
+ "n=math.log(L,2)\n",
+ "n=math.ceil(n)\n",
+ "\n",
+ "#Result\n",
+ "print('Bits required per sample =%.f' %n)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Bits required per sample =7\n"
+ ]
+ }
+ ],
+ "prompt_number": 129
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.30.i, Page No 153"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Normalized power for quantization noise\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=3.0*10.0**3\n",
+ "v=8.0\n",
+ "VH=5.0\n",
+ "VL=-5.0\n",
+ "q=2**v\n",
+ "\n",
+ "#Calculation\n",
+ "de=(VH-VL)/q\n",
+ "Nq=de**2/12.0 #quantization noise\n",
+ "\n",
+ "#Result\n",
+ "print('Normalized power for quantization noise =%.2f x 10^-6 W' %(Nq*(10**6)))\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Normalized power for quantization noise =127.16 x 10^-6 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 130
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.30.ii, Page No 153"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find bit transmission rate\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=3*10.0**3\n",
+ "v=8.0\n",
+ "VH=5.0\n",
+ "VL=-5\n",
+ "q=2**v\n",
+ "\n",
+ "#Calculation\n",
+ "fs=2*fm #Nyquist rate\n",
+ "r=8*fs/1000\n",
+ "\n",
+ "#Result\n",
+ "print('bit transmission rate %.f K bits/s' %r)\n",
+ " \n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "bit transmission rate 48 K bits/s\n"
+ ]
+ }
+ ],
+ "prompt_number": 131
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.30.iii, Page No 153"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Signal to quantization noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "Nq=127.15*10**-6\n",
+ "Meansignal=2\n",
+ "\n",
+ "#Calculation\n",
+ "P=Meansignal/1\n",
+ "SNR=P/Nq\n",
+ "SNRq=10*math.log10(SNR)\n",
+ "\n",
+ "#Result\n",
+ "print('Signal to quantization noise ratio %.2f dB ' %SNRq)\n",
+ " \n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Signal to quantization noise ratio 41.97 dB \n"
+ ]
+ }
+ ],
+ "prompt_number": 132
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.31, Page No 154"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find i)SNR ii)output bit rate iii)no.of bits recorded\n",
+ "\n",
+ "#Variable Declaration\n",
+ "N=16.0\n",
+ "v=16.0\n",
+ "fs=44.1*10**3\n",
+ "\n",
+ "#Calculation\n",
+ "SNR=1.76+6*N\n",
+ "bitrate=2*v*fs\n",
+ "outputbitrate=2*bitrate*10**-6 #including addtional 100% over head\n",
+ "CD=outputbitrate*3600*10**-3\n",
+ "\n",
+ "#Result\n",
+ "print('i)Out put signal noise ratio =%.2f dB' %SNR)\n",
+ "print('ii)output bit rate =%.3f Mbits/sec' %outputbitrate)\n",
+ "print('iii)no.of bits recorded in CD =%.2f gigabits' %CD)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i)Out put signal noise ratio =97.76 dB\n",
+ "ii)output bit rate =2.822 Mbits/sec\n",
+ "iii)no.of bits recorded in CD =10.16 gigabits\n"
+ ]
+ }
+ ],
+ "prompt_number": 133
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.32, Page No 155"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find output SNR\n",
+ "#Variable Declaration\n",
+ "fm=1*10.0**3\n",
+ "fs=32*10**3\n",
+ "\n",
+ "#Calculation\n",
+ "FM=4*10**3 #Bandwidth\n",
+ "SNR=(3*fs**3)/(8*math.pi**2*fm**2*FM) #SNR\n",
+ "SNRO=10*math.log10(SNR)\n",
+ "\n",
+ "#Result\n",
+ "print('Output signal to noise ratio %.2f dB' %SNRO)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Output signal to noise ratio 24.93 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 134
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.33.i, Page No 155"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find step size\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=64000.0 #samples/sec\n",
+ "Amax=1.0 #Maximum signal amplitude\n",
+ "fm=3500.0 #Sample Rate\n",
+ "\n",
+ "#Calculation\n",
+ "de=(2*math.pi*fm*Amax)/fs*1000\n",
+ "\n",
+ "#Result\n",
+ "print('Step Size %.2f mV ' %de)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Step Size 343.61 mV \n"
+ ]
+ }
+ ],
+ "prompt_number": 135
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.33ii, Page No 155"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Quantizatio noise power \n",
+ "#Variable Declaration\n",
+ "fs=64000.0 #sample Rate\n",
+ "Amax=1.0 #Maximum signal Amplitude\n",
+ "fm=3500.0\n",
+ "\n",
+ "#Calculation\n",
+ "de=343.6117*10**-3 #step size\n",
+ "Nq=de**2/3.0 #Quantizatio noise power\n",
+ "Nqd=Nq*(fm/fs)*1000\n",
+ "\n",
+ "#Result\n",
+ "print('Quantizatio noise power %.3f mW' %Nqd)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Quantizatio noise power 2.152 mW\n"
+ ]
+ }
+ ],
+ "prompt_number": 136
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.33iii, Page No 155"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find SNR\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=64000.0\n",
+ "Amax=1.0\n",
+ "fm=3500.0\n",
+ "Nqd=2.1522995*10**-3\n",
+ "\n",
+ "#Calculation\n",
+ "So=Amax**2/2\n",
+ "SNR=So/Nqd\n",
+ "SNRO=10*math.log10(SNR)\n",
+ "\n",
+ "#Result\n",
+ "print('Output signal noise ratio dB %.3f dB' %SNRO)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "Output signal noise ratio dB 23.661 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 137
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.34, Page No 156"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Assuming signal is sampled at the rate 20% above Nyquist rate\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=4.5*10**6\n",
+ "q=1024.0\n",
+ "\n",
+ "#Calculation\n",
+ "fs=1.2*2*fm #20% above Nyquist rate\n",
+ "v=math.log(q,2)\n",
+ "r=v*fs/10**6\n",
+ "\n",
+ "#Result\n",
+ "print('no.of bits/sec = %.f M bit/sec' %r)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "no.of bits/sec = 108 M bit/sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 138
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.35, Page No 156"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#assume bandwidth of the singal is 4kHz\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=32000.0\n",
+ "A=2.0\n",
+ "fm=4000.0\n",
+ "BW=4000.0\n",
+ "\n",
+ "#Calculation\n",
+ "de=(2*math.pi*fm*A)/fs\n",
+ "Nq=de**2/3\n",
+ "SNR=(3*fs**3)/(8*math.pi**2*fm**2*BW)\n",
+ "\n",
+ "#Result\n",
+ "print('i)step size = %.3f M Volt' %de)\n",
+ "print('ii)noise power = %.3f W' %Nq)\n",
+ "print('iii)SNR= = %.3f ' %SNR)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i)step size = 1.571 M Volt\n",
+ "ii)noise power = 0.822 W\n",
+ "iii)SNR= = 19.454 \n"
+ ]
+ }
+ ],
+ "prompt_number": 139
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.36, Page No 157"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#assuming signal is sampled at the rate 20% above Nyquist rate\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=15*10**3\n",
+ "fs=1.2*2*fm\n",
+ "q=65536\n",
+ "\n",
+ "#Calculation\n",
+ "v=math.log(q,2)\n",
+ "r=v*fs/1000\n",
+ "BW=r/2\n",
+ "\n",
+ "#Result\n",
+ "print('i)signaling rate,= %.f K bits/sec ' %r)\n",
+ "print('ii)bandwidth BW min = %.f kHz ' %BW)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i)signaling rate,= 576 K bits/sec \n",
+ "ii)bandwidth BW min = 288 kHz \n"
+ ]
+ }
+ ],
+ "prompt_number": 140
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.37, Page No 157"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find step size,noise power\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=64*10**3\n",
+ "fm=3500.0\n",
+ "A=1.0\n",
+ "\n",
+ "#Calculation\n",
+ "de=(2*math.pi*fm*A)/fs #step size\n",
+ "Nq=(de**2/3)*(fm/fs) #Granular noise power\n",
+ "\n",
+ "#Result\n",
+ "print('i)step size = %.3f Volts' %de)\n",
+ "print('ii)Nq= %.5f W' %Nq)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i)step size = 0.344 Volts\n",
+ "ii)Nq= 0.00215 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 141
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.40, Page No 159"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find step Nr,Transmission Bandwidth, SNR\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fs=4 #kHz\n",
+ "N=12\n",
+ "\n",
+ "#Calculation\n",
+ "Nr=2*fs #Nyquest rate\n",
+ "Bt=1.0/2*N*fs #Transmission Bandwidth\n",
+ "SNR=1.8+(6*N) \n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('i)Nyquest rate = %.1f kHz' %Nr)\n",
+ "print('ii)Transmission Bandwidth = %.1f kHz' %Bt)\n",
+ "print('iii)SNR = %.1f dB' %SNR)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i)Nyquest rate = 8.0 kHz\n",
+ "ii)Transmission Bandwidth = 24.0 kHz\n",
+ "iii)SNR = 73.8 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 142
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.41, Page No 159"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find step size,noise power\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=3.5*10**3\n",
+ "fs=64*10**3\n",
+ "A=2.0\n",
+ "\n",
+ "#Calculation\n",
+ "de=(2*math.pi*fm*A)/fs #step size\n",
+ "Nq=(de**2/3)*(fm/fs) #Granular noise power\n",
+ "\n",
+ "#Result\n",
+ "print('i)step size = %.3f Volts' %de)\n",
+ "print('ii)Nq= %.1f X 10^-3 W' %(Nq*10**3))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i)step size = 0.687 Volts\n",
+ "ii)Nq= 8.6 X 10^-3 W\n"
+ ]
+ }
+ ],
+ "prompt_number": 143
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.42, Page No 159"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find number of binay pulse per word, Bit rate, Bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "W=4.5 * 10**6 #khz\n",
+ "Nr = 2 * W #Nyquist Rate\n",
+ "Q = 1024\n",
+ "fs=10.8\n",
+ "\n",
+ "#Calculation\n",
+ "N = math.log(Q,2) #number of binay pulse per word\n",
+ "Br= N*fs #Bit rate\n",
+ "Bw= 1.0/2*Br #Bandwidth\n",
+ "\n",
+ "#Result\n",
+ "print('i) Number of binay pulse per word = %.1f k bits/sec' %N)\n",
+ "print('ii) Bit rate = %.1f k bits/sec' %Br)\n",
+ "print('iii)Bandwidth= %.1f X 10^-3 kHz' %Bw)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Number of binay pulse per word = 10.0 k bits/sec\n",
+ "ii) Bit rate = 108.0 k bits/sec\n",
+ "iii)Bandwidth= 54.0 X 10^-3 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 144
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.43, Page No 160"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find number of binay pulse per word, Bit rate, Bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "W=15 #khz\n",
+ "Nr = 2*W #Nyquist Rate\n",
+ "Q = 65.53\n",
+ "fs=44.1 # Sampling rate kHz\n",
+ "N=16\n",
+ "\n",
+ "#Calculation\n",
+ "Br= N*fs #Bit rate\n",
+ "Bw= 1.0/2*Br #Bandwidth\n",
+ "\n",
+ "#Result\n",
+ "print('i) Number of binay pulse per word = %.3f bits' %N)\n",
+ "print('ii) Bit rate = %.1f k bits/sec' %Br)\n",
+ "print('iii)Bandwidth= %.1f kHz' %Bw)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Number of binay pulse per word = 16.000 bits\n",
+ "ii) Bit rate = 705.6 k bits/sec\n",
+ "iii)Bandwidth= 352.8 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 145
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.44, Page No 160"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Number of binay pulse per word\n",
+ "\n",
+ "#Variable Declaration\n",
+ "W=3.3 #khz\n",
+ "fm = 1*10**3 #kHz\n",
+ "de = 250 #mV\n",
+ "fs=19.8 # Sampling rate kHz\n",
+ "\n",
+ "#Calculation\n",
+ "A=(de*fs)/(2*math.pi*fm)\n",
+ "\n",
+ "#Result\n",
+ "print('i) Number of binay pulse per word = %.3f' %A)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Number of binay pulse per word = 0.788\n"
+ ]
+ }
+ ],
+ "prompt_number": 146
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.45, Page No 160"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find number of binay pulse per word, Signaling rate, Bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "W=3.3 #khz\n",
+ "fm = 3300 #Hz\n",
+ "Snq = 40 #dB\n",
+ "fs= 8000 # Samples/sec\n",
+ "\n",
+ "#Calculation \n",
+ "N=math.ceil((Snq-4.8)/6) # Number of bits per word\n",
+ "Q=2**N #\n",
+ "r=N*fs #Signaling rate k bits/sec\n",
+ "Bw=1.0/2*r\n",
+ "\n",
+ "#Result\n",
+ "print('i) Number of bits per word = %.1f' %N)\n",
+ "print('ii) Signaling rate rate = %.1f k bits/sec' %(r/10**3))\n",
+ "print('iii)Bandwidth= %.1f kHz' %(Bw/10**3))"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Number of bits per word = 6.0\n",
+ "ii) Signaling rate rate = 48.0 k bits/sec\n",
+ "iii)Bandwidth= 24.0 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 147
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.46, Page No 161"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find the maximun frequency with 1 volt amplitude\n",
+ "\n",
+ "#Variable Declaration\n",
+ "de=256*10**-3 #V\n",
+ "Ts = 10*10**-6 #kHz\n",
+ "fm = 10 #kHz\n",
+ "fs= 100 # kHz\n",
+ "A=1 #V\n",
+ "\n",
+ "#Calculation \n",
+ "wm=(de/A*Ts)*10**7\n",
+ "\n",
+ "#Result\n",
+ "print('i) maximun frequency = %.1f X 10^3 rad/sec' %wm)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) maximun frequency = 25.6 X 10^3 rad/sec\n"
+ ]
+ }
+ ],
+ "prompt_number": 148
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.47, Page No 162"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find the Signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "Q=256 \n",
+ "m=255\n",
+ "\n",
+ "#Calculation \n",
+ "SNR=(3*Q**2)/(math.log((1+m),math.e))**2 #dB\n",
+ "Gc=m/(math.log(1+m)) #Companding gain\n",
+ "Gc=20*math.log(Gc,10)\n",
+ "\n",
+ "#Result\n",
+ "print('i) The Signal to noise ratio= %.1f dB' %SNR)\n",
+ "print('ii) The Companding gain = %.1f dB' %Gc)"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) The Signal to noise ratio= 6394.0 dB\n",
+ "ii) The Companding gain = 33.3 dB\n"
+ ]
+ }
+ ],
+ "prompt_number": 149
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.48, Page No 162"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find number of binay pulse per word, Signaling rate, Bandwidth\n",
+ "\n",
+ "#Variable Declaration\n",
+ "fm=15*10**3 #kHz\n",
+ "Q=200\n",
+ "fs=2*fm\n",
+ "\n",
+ "#Calculation \n",
+ "N=math.ceil(math.log(Q,2))\n",
+ "tr=N*fs #Transmission rate kbps\n",
+ "Bw=1.0/2*tr\n",
+ "\n",
+ "#Result\n",
+ "print('i) Number of bits per Samples = %.1f' %N)\n",
+ "print('ii) Signaling rate = %.1f k bits/sec' %(tr/10**3))\n",
+ "print('iii)Bandwidth= %.1f kHz' %(Bw/10**3))\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Number of bits per Samples = 8.0\n",
+ "ii) Signaling rate = 240.0 k bits/sec\n",
+ "iii)Bandwidth= 120.0 kHz\n"
+ ]
+ }
+ ],
+ "prompt_number": 150
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.49, Page No 162"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find number of quantization level\n",
+ "\n",
+ "#Variable Declaration\n",
+ "tr=36.0 #kbps\n",
+ "fm=3.4 #kHz\n",
+ "fs=8\n",
+ "\n",
+ "#Calculation \n",
+ "N=math.ceil(tr/fs)\n",
+ "Q=2**N\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('i) number of quantization level = %.1f' %Q)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) number of quantization level = 32.0\n"
+ ]
+ }
+ ],
+ "prompt_number": 151
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.50, Page No 162"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find delta modulation\n",
+ "\n",
+ "#Variable Declaration\n",
+ "A=1 #V\n",
+ "fm=3.4 #kHz\n",
+ "fs=20\n",
+ "\n",
+ "#Calculation \n",
+ "de=1*2*math.pi*(fm/fs)\n",
+ "\n",
+ "\n",
+ "#Result\n",
+ "print('i) delta modulation = %.2f V' %de)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) delta modulation = 1.07 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 152
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.51, Page No 163"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "W=3.5 #kHz\n",
+ "r=50.0 #kbps\n",
+ "Vpp=4 #V\n",
+ "fs=8\n",
+ "\n",
+ "#Calculation \n",
+ "N=r/fs\n",
+ "SNR=4.8+(6.8*N)\n",
+ "\n",
+ "#Result\n",
+ "print('i) Signal to noise ratio = %.2f V' %SNR)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Signal to noise ratio = 47.30 V\n"
+ ]
+ }
+ ],
+ "prompt_number": 153
+ },
+ {
+ "cell_type": "heading",
+ "level": 2,
+ "metadata": {},
+ "source": [
+ "Example 3.52, Page No 163"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "collapsed": false,
+ "input": [
+ "import math\n",
+ "#Find Signal to noise ratio\n",
+ "\n",
+ "#Variable Declaration\n",
+ "W=1 #MHz\n",
+ "fs1=3 #MHz\n",
+ "fs2=2.4 #MHz\n",
+ "Q=256\n",
+ "m=255\n",
+ "\n",
+ "#Calculation \n",
+ "SNR=((3*Q**2)/(math.log((1+m),math.e))**2)\n",
+ "SNR1=63095.73 #SNR=38+10\n",
+ "Q1=math.sqrt((SNR1*((math.log(256,math.e))**2))/3)\n",
+ "N1=math.ceil(math.log(Q1,2))\n",
+ "r=N1*fs2\n",
+ "Bw=1.0/2*r\n",
+ "\n",
+ "#Result\n",
+ "print('i) Number of bits/word = %.2f ' %N1)\n",
+ "print('ii) Bit rate = %.1f Mb/s' %r)\n",
+ "print('iii) Bandwidth = %.1f Mb/s' %Bw)\n"
+ ],
+ "language": "python",
+ "metadata": {},
+ "outputs": [
+ {
+ "output_type": "stream",
+ "stream": "stdout",
+ "text": [
+ "i) Number of bits/word = 10.00 \n",
+ "ii) Bit rate = 24.0 Mb/s\n",
+ "iii) Bandwidth = 12.0 Mb/s\n"
+ ]
+ }
+ ],
+ "prompt_number": 154
+ }
+ ],
+ "metadata": {}
+ }
+ ]
+}
\ No newline at end of file |