import math
#page 247
#problem 5.2
#Highest frequency(fH) = 10000/2 = 5000 Hz
fH = 5000.
#Lowest frequency(fL) = 6000/2 = 3000 Hz
fL = 3000.
#Minimum sampling frequency from low pass consideration(S_LOW) = 2*fH
S_LOW = 2*fH
print 'Minimum sampling frequency from low pass consideration is ',S_LOW,' Hz'
#B = fH-fL = 2000 Hz
B = fH-fL
#k = floor(fH/B) = 2, where floor(x) gives the largest integer that does not exceed x
k = math.floor(fH/B)
#The required sampling frequency from band pass consideration(S_BAND) = 2*fH/k
S_BAND = 2*fH/k
print 'Minimum sampling frequency from band pass consideration is ',S_BAND,' Hz'
import math
#page 259
#problem 5.3
#Given width of each pulse W = 150 us
W = 150. * 10**-6
#One cycle is a period,T = 1ms
T = 1000. * 10**-6
#There are 5 messages multiplexed each utilizeallocated time pulse width = s(T_5) = T/5
T_5 = T/5
#Gaurd time(GT_5) = allocated time-pulse width = T_5-W
GT_5 = T_5-W
print 'Gaurd time where 5 messages multiplexed is ',GT_5,' seconds'
#Here there are 10 messages multiplexed each utilizeallocated time pulse width = s(T_10) = T/10
T_10 = T/10
#Gaurd time(GT_10) = allocated time-pulse width = T_10-norrow pulses width = T_10 -50* 10**-6
GT_10 = T_10 - 50 * 10**-6
print 'Gaurd time where 10 messages multiplexed is ',GT_10,' seconds'
import math
#Let Abe the maximum value of the discrete samples.
#Error tolerated is 0.1% i.e. 0.001A
#If D is step size then possible maximum error is D/2
#Thus D/2 = 0.001A or A/D = 500 = no of levels required(Levels)
Levels = 500.
#minimum no of binary digits required(B) = rounded value to the next higher integer of math.log2 (Levels)
B = round(math.log(Levels))
print 'Minimum no of binary digits required ',B
import math
#The y axis is uniformly quantized with step size(step_size) = 1/((2**8)/(2-1)) in both +ve & -ve direction between 1 & -1 when peak of input varies between 1 & -1.
#The smallest step in x direction occurs nearest to x = 0 i.e between y1 = 0 & y2 = step_size
step_size = 1./((2**8)/2-1)
y1 = 0.
y2 = step_size
#Then, y1 = (ln(1+255*x1))/(ln(1+255))
x1 = (math.e**(y1*math.log(256)) - 1)/255;
#y2 = (ln(1+255*x2))/(ln(1+255))
x2 = (math.e**(y2*math.log(256)) - 1)/255;
#The smallest step size is 10*(x2-x1)
print 'The smallest step size is ',round(10*(x2-x1),4),' Volts'
#The largest step size occurs when x is at its extreme between y1 = 1-1/127 = 126/127 & y2 = 1
y1 = 1-1/127.
y2 = 1
#Then, y1 = (ln(1+255*x1))/(ln(1+255))
x1 = (math.e**(y1*math.log(256)) - 1)/255;
#y2 = (ln(1+255*x2))/(ln(1+255))
x2 = (math.e**(y2*math.log(256)) - 1)/255;
#The largest step size is 10*(x2-x1)
print 'The largest step size is ',round(10*(x2-x1),4),' Volts'
import math
from numpy import zeros
#for error calculation e(n) = m(n) - [**hj(n)*m(n-1)+**hj(n)*m(n-2)+**hj(n)*m(n-3)+ ........+**hj(n)*m(n-N)]
#for coefficient upgradation **hj(n+1) = **hj(n)+um(n-j)e(n) where u = learning parameter = 0.1.
u = 0.1
#Assign m values taking from m = -3 to 5
#Denoting m(x) as matrix m where each element repesents from n = -3 to 5
m = [0, 0, 0, 1, 2, 3, 4, 5, 6]
#taking e(n) as matrix e, **hj(n) as matrises h_j
e = zeros(5)
h_1 = zeros(6)
h_2 = zeros(6)
#given **h1(0) = **h2(0) = 0
for i in range(5):
e[i] = m[i+3] - h_1[i]*m[i+2] - h_2[i]*m[i+1]
h_1[i+1] = h_1[i] + u*m[i+2]*e[i]
h_2[i+1] = h_2[i] + u*m[i+1]*e[i]
#here e(3) is given as 1.32 but it is print laying 0.92
#here **h2(3) is given as 0.26 but it is print laying 0.46
for i in range(5):
print 'e(',i,') = ',e[i],
print '**h1(',i,') = ',h_1[i+1],
print '**h2(',i,') = ',h_2[i+1]
import math
#case 1(a)
#f = 400Hertz, fs = 8000Hertz
f = 400.
fs = 8000.
#We know that maximum signal to noise ratio(SNR_max) = 3*(fs**2)/(8*(pi**2)*(f**2))
SNR_max = 3*(fs**2)/(8*(math.pi**2)*(f**2))
#SNR_max in decibels is SNR_max_db
SNR_max_db = 10*math.log10 (SNR_max)
print 'Maximum signal to noise ratio for f = 400 & fs = 8000 is %.4f'%SNR_max,' = %.4f'%SNR_max_db,' db'
#case 1(b)
#f = 400Hertz, fs = 16000Hertz
f = 400.
fs = 16000.
#We know that maximum signal to noise ratio(SNR_max) = 3*(fs**2)/(8*(pi**2)*(f**2))
SNR_max = 3*(fs**2)/(8*(math.pi**2)*(f**2))
#SNR_max in decibels is SNR_max_db
SNR_max_db = 10*math.log10 (SNR_max)
#Given solution is 13.8385 dB obtained solution is 17.838515 dB
print 'Maximum signal to noise ratio for f = 400 & fs = 16000 is %.4f'%SNR_max,' = %.4f'%SNR_max_db,' db'
#case 2(a)
#f = 400Hertz, fs = 8000Hertz & fc = 1000Hertz
f = 400.
fs = 8000.
fc = 1000.
#If a 1kHz low pass post reconstruction filter is used then maximum signal to noise ratio(SNR_max) = 3*(fs**3)/(8*(pi**2)*(f**2)*fc)
SNR_max = 3*(fs**3)/(8*(math.pi**2)*(f**2)*fc)
#SNR_max in decibels is SNR_max_db
SNR_max_db = 10*math.log10 (SNR_max)
print ('If a 1kHz low pass post reconstruction filter is used then')
print 'Maximum signal to noise ratio for f = 400, fs = 8000 & fc = 1000 is %.4f'%SNR_max,' = %.4f'%SNR_max_db,' db'
#case 2(b)
#f = 400Hertz, fs = 16000Hertz & fc = 1000Hertz
f = 400.
fs = 16000.
fc = 1000.
#If a 1kHz low pass post reconstruction filter is used then maximum signal to noise ratio(SNR_max) = 3*(fs**3)/(8*(pi**2)*(f**2)*fc)
SNR_max = 3*(fs**3)/(8*(math.pi**2)*(f**2)*fc)
#SNR_max in decibels is SNR_max_db
SNR_max_db = 10*math.log10 (SNR_max)
print 'Maximum signal to noise ratio for f = 400, fs = 16000 & fc = 1000 is %.4f'%SNR_max,' = %.4f'%SNR_max_db,' db'