5615 Chapter 3. April 8, Set #3 RP Simulation 3 Working with rp1 in the Notebook Proper Numerical Integration 5

Size: px

Start display at page:

Download "5615 Chapter 3. April 8, Set #3 RP Simulation 3 Working with rp1 in the Notebook Proper Numerical Integration 5"

Lucinda Chambers
5 years ago
Views:

1 5615 Chapter 3 April 8, 2015 Contents Mixed RV and Moments 2 Simulation Set #3 RP Simulation 3 Working with rp1 in the Notebook Proper Numerical Integration 5 Working with the Covariance Matrix 6 Random Processes 7 Autocorrelation Function Estimation Example: AR(1) Process Correlated Random Gaussian Signal Generator In [1]: %pylab inline #%matplotlib qt from future import division # use so 1/2 = 0.5, etc. import ssd import scipy.signal as signal from IPython.display import Image, SVG Populating the interactive namespace from numpy and matplotlib In [2]: pylab.rcparams[ savefig.dpi ] = 100 # default 72 #pylab.rcparams[ figure.figsize ] = (6.0, 4.0) # default (6,4) %config InlineBackend.figure_formats=[ png ] # default for inline viewing #%config InlineBackend.figure_formats=[ svg ] # SVG inline viewing #%config InlineBackend.figure_formats=[ pdf ] # render pdf figs for LaTeX 1

2 Mixed RV and Moments For mixed RV you may find it useful to consider the conditional expectation where A B = and A B = S. Simulation In [8]: v =randint(0,2,10000) mean(v) Out[8]: In [9]: N= x1 = randint(0,2,n) x2 = randn(n) # RV x x = x1*x2 # RV y y = (x-3)*(x-1) E{h(x)} = P (A) E{h(x) A} + P (B) E{h(x) B} (1) In [14]: figure(figsize=(6,3)) hist(x,50,normed=true,cumulative=false); xlabel(r x ) ylabel(r Probability Density ) title(r Density Estimate $f_x(x)$ ) grid(); figure(figsize=(6,3)) hist(y,100,(-1,5),normed=true); ylim([0,1]) xlabel(r y ) ylabel(r Probability Density ) title(r Density Estimate $f_y(y)$ ) grid(); 2

In [11]: print( mean on x = %6.4f, var on x = %6.4f % (mean(x),var(x))) mean on x = -0.0017, var on x = 0.4993 In [12]: print( mean on y = %6.4f, var on y = %6.4f % (mean(y),var(y))) mean on y = 3.

3 In [11]: print( mean on x = %6.4f, var on x = %6.4f % (mean(x),var(x))) mean on x = , var on x = In [12]: print( mean on y = %6.4f, var on y = %6.4f % (mean(y),var(y))) mean on y = , var on y = Set #3 RP Simulation In problem #2 of Set #3 you need to generate a discrete-time random process ensemble. The function below does just that. If you chose to work with this function without the %pylab command invoked in IPython, then you will need to modify the code to include the numpy namespace alias you use and also do your own importing of matplotlib for graphics, e.g., # RP1 Test Script rp1_test.py import numpy as np import matplotlib.pyplot as plt def rp1(m,n): V = RP1(M,N) Random Process #1 from McClellan a = 0.02 b = 5 n = np.arange(1,n+1) Mc = np.ones((m,1))*b*np.sin((n*np.pi/n)) 3

4 Ac = a*np.ones((m,1))*n v = (np.random.rand(m,n)-0.5)*mc + Ac return v if name == main : v = rp1(10,100) plt.figure(figsize=(7,5)) plt.plot(v[0,:]) plt.plot(v[5,:]) plt.title(r Plot Some Sample Functions ) plt.ylabel(r Amplitude ) plt.xlabel(r Sample Index ) plt.grid() plt.show() I recommend against this unless you feel real comfortable with these aspects of Python. The IPython notebook offers a much more comfortable and interactive environment. In the IPython qtterminal for example you can run this script using the %run magic, i.e.,: > %run rp1_test.py You can also run this script right from the terminal window as: c:\>python rp1_test.py In [1]: # If you run this cell it will pop up a plot window outside the browser that will be modal, # meaning the the cell keeps running until you close the plot window. %run rp1_test.py On the positive side, by putting rp1() into a Python source file, you can now import the file into your workspace and have access to the single def(): In [3]: import rp1_test In [4]: rp1_test.rp1(3,3) Out[4]: array([[ , , 0.06 ], [ , , 0.06 ], [ , , 0.06 ]]) Working with rp1 in the Notebook Proper In [22]: def rp1(m,n): V = RP1(M,N) Random Process #1 from McClellan a = 0.02 b = 5 n = arange(1,n+1) Mc = ones((m,1))*b*sin((n*pi/n)) Ac = a*ones((m,1))*n v = (rand(m,n)-0.5)*mc + Ac return v In [23]: rp1(5,6) 4

Out[23]: array([[-1.02719045, -0.55203525, 1.56387729, -1.39253795, 1.13881577, 0.12 ], [ 0.34325453, 1.47060339, 2.41160848, -1.85292042, 1.31773331, 0.12 ], [ 1.03419792, 0.32834652, -2.24424205, 2.

5 Out[23]: array([[ , , , , , 0.12 ], [ , , , , , 0.12 ], [ , , , , , 0.12 ], [ , , , , , 0.12 ], [ , , , , , 0.12 ]]) In [24]: v = rp1(10000,1000) Numerical Integration In [16]: import scipy.integrate as integrate Consider the joint pdf f xy (x, y) = abe ax e by u(x)u(y) (2) We wish to find the probability P R associated with the triangle shape region shown below: In [60]: Image( 5615 Chapter 3_files/project5615_fig1.png,width= 80% ) Out[60]: We will use the scipy integrate module to numerically integrate this function in two dimensions. The appriate function is dblquad() import scipy.integrate as integrate This function gives you some nice options. In particular you can make the limits of the inner inegral a function of the outer integration variable, and you can pass parameters of the function being integrated into the function call. 5

6 In the case of P R we desire P R = 1 2 x 0 x f xy (x, y) dydx (3) In the case of this example numerical integration is not required and it can be shown that P R = b [ 1 e (b+a)] b [ b + a b 1 e 2a 1 e (b 1)] (4) This is good however, as you can try out dblquad() and veryify that the numerical solution matches the theoretical solution. Below I define three simple Python functions to support the needs of the numerical integration. Note: The y variable must come first in the integrand function. In [52]: def fxy1(y,x,b,a): return a*b*exp(-a*x)*exp(-b*y) def g(x): return x def h(x): return 2-x In [59]: #integrate.dblquad(f_integrand,x_low,x_up,g_of_x,h_of_x,args=(a1,a2,..)) integrate.dblquad(fxy1,0,1,g,h,args=(8,5)) Out[59]: ( , e-12) Compare with theory for the case a = 5 and b = 8. In [58]: a = 5 b = 8 PR_thy = a/(a+b)*(1-e**(-(a+b))) - a/(a-1)*e**(-2*b)*(1 - e**(-(a-1))) PR_thy Out[58]: Working with the Covariance Matrix Working with the covariance matrix can mean many things. An example of interest is finding the variance of a random variable that is obtained via a linear transformation of a random vector. Suppose that the scalar rv z can be written as z = AX + b (5) where A = [a 1, a 2,..., a N ], random vector X = [x 1, x 2,..., x N ] t has N N covariance matrix C x (or K x ) and mean vector [m x1, m x2,..., m xn ] t, and b is a constant. The mean of X is and m x = E { AX + b } = Am x + b (6) 6

7 Random Processes σ 2 z = E { (z m z ) 2} (7) Autocorrelation Function Estimation In [4]: x = 0.5*randn(100) In [3]: import digitalcom as dc = E { (AX + b m z ) 2} = E { (AX + b Am x b) 2} (8) = E { (AX + Am x ) 2} = E { ([A(X m x )][A(X m x )] t} (9) = AE { (X m x )(X m x ) t} A t (10) = AC x A t (11) r xy,lags = xcorr(x,y,nlags): The function below can be used to efficiently compute the auto- and cross-correlation functions of both real and complex signals. A transform domain approach is used. A drawback of this function is that it currently only outputs correlation coefficient normalized form for r xx [k] and r xy [k], which is equivalent to energy normalization. Mathematically this can be viewed as r xx [k]/r xx [0] and r xy /r xy [0], respectively. In [6]: def xcorr(x1,x2,nlags): r12, k = xcorr(x1,x2,nlags), r12 and k are ndarray s Compute the energy normalized cross correlation between the sequences x1 and x2. If x1 = x2 the cross correlation is the autocorrelation. The number of lags sets how many lags to return centered about zero K = 2*(len(x1)/2) X1 = fft.fft(x1[:k]) X2 = fft.fft(x2[:k]) E1 = sum(abs(x1[:k])**2) E2 = sum(abs(x2[:k])**2) r12 = np.fft.ifft(x1*np.conj(x2))/np.sqrt(e1*e2) k = np.arange(k) - K/2 r12 = np.fft.fftshift(r12) idx = mlab.find(abs(k) <= Nlags) return r12[idx], k[idx] r xx,lags = xcorr bias(x,nlags): The function below steps back from trying to be fast and efficient, to just calculating the biased autocorrelation function in the time domain. This time-averaged autocorreation function estimate takes the mathematical form r xx [k] = 1 N N 1 n=0 For small sample sizes, i.e., small N the calculation is still very fast. x[n]x[n k] (12) In [47]: def xcorr_bias(x,nlags): A slow time domain, biased, auto correlation estmation. Easily modified to do cross correlation and handle complex signals. 7

8 Example: AR(1) Process Mark Wickert, April 2015 N = len(x) rxx = zeros(2*nlags+1) k = arange(-nlags,nlags+1) for n,nk in enumerate(k): if nk < 0: rxx[n] = sum(x[0:n+nk]*x[-nk:])/n elif nk > 0: rxx[n] = sum(x[nk:]*x[:-nk])/n else: rxx[n] = sum(x*x)/n return rxx,k The example below considers an AR(1) process of the form x[n] + a(1)x[n 1] = b(0)v[n] (13) or x[n] = a(1)x[n 1] + b(0)v[n] (14) where v[n] is white noise having unit variance. In this example we further assume that b(0) = 1. In [125]: v = randn(1000) a1 = 0.9 # The a1 is used over the next few cells x = signal.lfilter([1],[1,a1],v) x24 = x[-24:] #last 24 samples x500 = x[-500:] #last 500 samples rx24,lags = xcorr_bias(x24,24) # compute 24 lags either side of zero rx500,lags = xcorr_bias(x500,24) In [126]: rxx24 Out[126]: array([ 0., , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , 0. ]) In [127]: figure(figsize=(6,2.5)) stem(lagsxx,1/(1-(a1)**2)*(-(a1))**abs(lagsxx)) title(r Theoretical $r_{xx}[k]$ for $a(1)$ = %1.2f % a1) ylabel(r Autocorrelation Function ) xlabel(r Lags $k$ ) xlim([-20,20]); grid(); figure(figsize=(6,2.5)) stem(lags,rxx500) title(r Estimated $r_{xx}[k]$ for $N=500$ and $a(1)$ = %1.2f % a1) 8

9 ylabel(r Autocorrelation Function ) xlabel(r Lags $k$ ) xlim([-20,20]); grid(); figure(figsize=(6,2.5)) stem(lags,rxx500) title(r Estimated $r_{xx}[k]$ for $N=24$ and $a(1)$ = %1.2f % a1) ylabel(r Autocorrelation Function ) xlabel(r Lags $k$ ) xlim([-20,20]); grid(); 9

10 Correlated Random Gaussian Signal Generator The simplest approach is to use the function multivariate normal() which is part of Numpy. Suppose you want to create random vector realizations organized as column vectors. Each new realization is accessed by the column index. The rows contain the elements. The function requires as input 1D ndarray of length M describing the mean of the PDF and a M M 2D ndarray containing the covariance matrix. Suppose we wish to create N realizations of the M = 3 normal random vector having mean and covariance matrix X = [ x 1 x 2 x 3 ] t (15) respectively. Generate 4 realizations, so the 2D array has shape (3,4): m x = [ ] t (16) C x = K x = (17) In [117]: y = np.random.multivariate_normal(array([1,2,3]), array([[2,1,-1],[1,3,2],[-1,2,5]]), (4,)).T In [118]: y.shape Out[118]: (3L, 4L) In [119]: y Out[119]: array([[ , , , ], [ , , , ], [ , , , ]]) 10

11 Now generate 1000 realizations and compute the sample mean vector (arra) and the sample mean covariance: In [120]: y = np.random.multivariate_normal(array([1,2,3]), array([[2,1,-1],[1,3,2],[-1,2,5]]), (1000,)).T y.shape Out[120]: (3L, 1000L) In [123]: mean(y,axis=1) Out[123]: array([ , , ]) In [124]: cov(y) Out[124]: array([[ , , ], [ , , ], [ , , ]]) The results look good! 11

ECE 5615/4615 Computer Project

Set #1p Due Friday March 17, 017 ECE 5615/4615 Computer Project The details of this first computer project are described below. This being a form of take-home exam means that each person is to do his/her