Class Wiki - User contributions [en]

Mark's Homework 15

2007-12-04T01:07:18Z

Pridma: /* Explanations */

==Problem==
Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter.

==MATLAB Script==
<pre>
%Author: Mark Priddy
%Homework #15 MATLAB script
%Description: Demonstrates oversampling and cancelling of the effects of the D/A converter
clear all;
close all;

%Number of sample points for our original signal
N = 20;
%Time, in seconds, to extend our original signal. We then sample this signal N times
tmax=2;
%Number of oversampling points
oversampling = 4;

%Calculations
T=tmax/N;
t=0:T:(N-1)*T;

%This is our signal to over sample
x=sin(2*pi*t)+sin(2*pi*2*t)+sin(2*pi*5*t);

%The following three lines is our oversampling/interpolating filter
N1=(oversampling-1)*N;
X=fft(x);
X1 = (N1+N)/N*[X(1:N/2), zeros(1, N1), X(N/2+1:N)];

%This preserves our interpolated signal for graphing later on
x2= ifft(X1);

%
%This is to cancel out the effects of the D/A Converter
%
%sT is how many times we are going to sample our pulse p(t)
sT = T*oversampling;
%This is how wide our pulse has to be when we oversample
stmax = oversampling*T;
%This is the total number of sampling points for sampling p(t)
sN = stmax/sT;
t = 0:sT:stmax-sT;
%This is p(t), the pulse of the D/A converter, sampled at our oversampling rate
p = u(t+1e-9) - u(t-T/(2*oversampling)) + u(t - (oversampling*T-T/(2*oversampling)));
%P(f) is calculated:
P = fft(p);

%Take 1/P(f) so we cancel the effects of the D/A converter (which is P(f))
iP = 1./P;

%Element multiply our interpolating filter with our D/A converter effect canceller filter
X1 = X1 .* iP;
x1 = ifft(X1);

%
%Graphs
%
%Figure 1 plots the original signal and our interpolated signal (with D/A converter effects cancelled.)
figure(1)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
t=0:T:(N-1)*T;
plot(t1, x1, 'bo', t, x, 'r-o', t1, x2, 'g-');
legend('Interpolated signal with D/A effects cancelled', 'Original sampled signal', 'Interpolated oversampled signal')
xlabel('Time (s)');
ylabel('Amplitude');

%Figure 2 plots just our interpolated signal, but this time with lines connecting each point.
figure(2)
plot(t1, x1, 'b-');
title('Interpolated oversampled signal');
xlabel('Time (s)');
ylabel('Amplitude');

%Figure 3 plots the frequency response of our original sampled signal.
figure(3)
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
plot(f,abs(fftshift(X)))
title('Frequency response of the original signal');
xlabel('Frequency (Hz)');
ylabel('Amplitude');
</pre>

To run this script, you'll also need another script, called "u.m" with the following contained inside. This must be located in the same folder as the main script above.
<pre>
function [out] = u(t)
out=(1+sign(t))./2;
end
</pre>

I couldn't find MATLAB's step function, so I created my own.

==Graphs==

[[Image:OVR20071203Fig1.png|thumb|left|1600px| Figure 1. The signals.]]

[[Image:OVR20071203Fig2.png|thumb|left|694px| Figure 2. The interpolated signal.]]

[[Image:OVR20071203Fig3.png|thumb|left|894px| Figure 3. The frequency response of the original signal.]]

 

==Explanations==

Actually, this homework was relatively straight-forward. I sampled a signal, and ran it through the interpolation filter. The filter works by inserting (oversampling rate) - 1 times the number of points on the original DFT of the sampled signal. This causes the signal to be interpolated as well as oversampled.

For canceling out the effects of the D/A converter, I simply DFT'd the pulse that a D/A converter would output, inverted it, and multiplied it with the DFT of my interpolating filter. This cancels out the effects of the D/A converter. There is hardly a difference due to oversampling. When you oversample the signal, the D/A converter pulse becomes much wider, so the edges where it goes down to zero don't go down to zero anymore. If that made any sense...

Mark's Homework 15

2007-12-04T01:02:54Z

Pridma: /* MATLAB Script */

Mark's Homework 15

2007-12-04T01:02:41Z

Pridma: /* Graphs */

==Problem==
Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter.

==MATLAB Script==
<pre>
%Author: Mark Priddy
%Homework #15 MATLAB script
%Description: Demonstrates oversampling and cancelling of the effects of the D/A converter
clear all;
close all;

%Number of sample points for our original signal
N = 20;
%Time, in seconds, to extend our original signal. We then sample this signal N times
tmax=2;
%Number of oversampling points
oversampling = 4;

%Calculations
T=tmax/N;
t=0:T:(N-1)*T;

%This is our signal to over sample
x=sin(2*pi*t)+sin(2*pi*2*t)+sin(2*pi*5*t);

%The following three lines is our oversampling/interpolating filter
N1=(oversampling-1)*N;
X=fft(x);
X1 = (N1+N)/N*[X(1:N/2), zeros(1, N1), X(N/2+1:N)];

%This preserves our interpolated signal for graphing later on
x2= ifft(X1);

%
%This is to cancel out the effects of the D/A Converter
%
%sT is how many times we are going to sample our pulse p(t)
sT = T*oversampling;
%This is how wide our pulse has to be when we oversample
stmax = oversampling*T;
%This is the total number of sampling points for sampling p(t)
sN = stmax/sT;
t = 0:sT:stmax-sT;
%This is p(t), the pulse of the D/A converter, sampled at our oversampling rate
p = u(t+1e-9) - u(t-T/(2*oversampling)) + u(t - (oversampling*T-T/(2*oversampling)));
%P(f) is calculated:
P = fft(p);

%Take 1/P(f) so we cancel the effects of the D/A converter (which is P(f))
iP = 1./P;

%Element multiply our interpolating filter with our D/A converter effect canceller filter
X1 = X1 .* iP;
x1 = ifft(X1);

%
%Graphs
%
%Figure 1 plots the original signal and our interpolated signal (with D/A converter effects cancelled.)
figure(1)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
t=0:T:(N-1)*T;
plot(t1, x1, 'bo', t, x, 'r-o', t1, x2, 'g-');
legend('Interpolated signal with D/A effects cancelled', 'Original sampled signal', 'Interpolated oversampled signal')
xlabel('Time (s)');
ylabel('Amplitude');

%Figure 2 plots just our interpolated signal, but this time with lines connecting each point.
figure(2)
plot(t1, x1, 'b-');
title('Interpolated oversampled signal');
xlabel('Time (s)');
ylabel('Amplitude');

%Figure 3 plots the frequency response of our original sampled signal.
figure(3)
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
plot(f,abs(fftshift(X)))
title('Frequency response of the origianl signal');
xlabel('Frequency (Hz)');
ylabel('Amplitude');
</pre>

To run this script, you'll also need another script, called "u.m" with the following contained inside. This must be located in the same folder as the main script above.
<pre>
function [out] = u(t)
out=(1+sign(t))./2;
end
</pre>

I couldn't find MATLAB's step function, so I created my own.

==Graphs==

[[Image:OVR20071203Fig1.png|thumb|left|1600px| Figure 1. The signals.]]

[[Image:OVR20071203Fig2.png|thumb|left|694px| Figure 2. The interpolated signal.]]

[[Image:OVR20071203Fig3.png|thumb|left|894px| Figure 3. The frequency response of the original signal.]]

 

==Explanations==

File:OVR20071203Fig3.png

2007-12-04T00:59:51Z

Pridma:

File:OVR20071203Fig2.png

2007-12-04T00:59:46Z

Pridma:

File:OVR20071203Fig1.png

2007-12-04T00:59:40Z

Pridma:

Mark's Homework 15

2007-12-04T00:59:24Z

Pridma:

==Problem==
Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter.

==MATLAB Script==
<pre>
%Author: Mark Priddy
%Homework #15 MATLAB script
%Description: Demonstrates oversampling and cancelling of the effects of the D/A converter
clear all;
close all;

%Number of sample points for our original signal
N = 20;
%Time, in seconds, to extend our original signal. We then sample this signal N times
tmax=2;
%Number of oversampling points
oversampling = 4;

%Calculations
T=tmax/N;
t=0:T:(N-1)*T;

%This is our signal to over sample
x=sin(2*pi*t)+sin(2*pi*2*t)+sin(2*pi*5*t);

%The following three lines is our oversampling/interpolating filter
N1=(oversampling-1)*N;
X=fft(x);
X1 = (N1+N)/N*[X(1:N/2), zeros(1, N1), X(N/2+1:N)];

%This preserves our interpolated signal for graphing later on
x2= ifft(X1);

%
%This is to cancel out the effects of the D/A Converter
%
%sT is how many times we are going to sample our pulse p(t)
sT = T*oversampling;
%This is how wide our pulse has to be when we oversample
stmax = oversampling*T;
%This is the total number of sampling points for sampling p(t)
sN = stmax/sT;
t = 0:sT:stmax-sT;
%This is p(t), the pulse of the D/A converter, sampled at our oversampling rate
p = u(t+1e-9) - u(t-T/(2*oversampling)) + u(t - (oversampling*T-T/(2*oversampling)));
%P(f) is calculated:
P = fft(p);

%Take 1/P(f) so we cancel the effects of the D/A converter (which is P(f))
iP = 1./P;

%Element multiply our interpolating filter with our D/A converter effect canceller filter
X1 = X1 .* iP;
x1 = ifft(X1);

%
%Graphs
%
%Figure 1 plots the original signal and our interpolated signal (with D/A converter effects cancelled.)
figure(1)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
t=0:T:(N-1)*T;
plot(t1, x1, 'bo', t, x, 'r-o', t1, x2, 'g-');
legend('Interpolated signal with D/A effects cancelled', 'Original sampled signal', 'Interpolated oversampled signal')
xlabel('Time (s)');
ylabel('Amplitude');

%Figure 2 plots just our interpolated signal, but this time with lines connecting each point.
figure(2)
plot(t1, x1, 'b-');
title('Interpolated oversampled signal');
xlabel('Time (s)');
ylabel('Amplitude');

%Figure 3 plots the frequency response of our original sampled signal.
figure(3)
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
plot(f,abs(fftshift(X)))
title('Frequency response of the origianl signal');
xlabel('Frequency (Hz)');
ylabel('Amplitude');
</pre>

To run this script, you'll also need another script, called "u.m" with the following contained inside. This must be located in the same folder as the main script above.
<pre>
function [out] = u(t)
out=(1+sign(t))./2;
end
</pre>

I couldn't find MATLAB's step function, so I created my own.

==Graphs==

[[Image:OVR20071203Fig1.png|thumb|left|694px| Figure 1. The sampled signal with only 7 sample points.]]

[[Image:OVR20071203Fig2.png|thumb|left|694px| Figure 2. The DFT of Figure 1.]]

[[Image:OVR20071203Fig3.png|thumb|left|894px| Figure 3. The same as Figure 1 but with 600 sample points, and zoomed in.]]

 

==Explanations==

Mark's Homework 15

2007-12-03T23:14:40Z

Pridma: /* MATLAB Script */

==Problem==
Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter.

==MATLAB Script==
The following is currently '''NON-WORKING'''. A working script will follow.
<pre>
clear all;
close all;
N = 10; %Number of sample points for our original signal
tmax=2; %Time, in seconds, to extend our original signal. We then sample this signal N times
oversampling = 4; %Number of oversampling points
T=tmax/N; %Calculate T, the sample period
t=0:T:(N-1)*T;
x=sin(2*pi*t)+sin(2*pi*2*t)+sin(2*pi*5*t); %This is our signal to over sample
N1=(oversampling-1)*N;
X=fft(x);
X1 = (N1+N)/N*[X(1:N/2), zeros(1, N1), X(N/2+1:N)]; %This is our interpolating filter

x2= ifft(X1);

%This is to cancel out the effects of the D/A Converter
sT = T/100; %sT is hwo many times we are going to sample our pulse p(t)
stmax = oversampling*T; %This is how wide our pulse has to be when we oversample
sN = stmax/sT; %This is the total number of sampling points for sampling p(t)
t = 0:sT:stmax-sT;
p = u(t+1e-9) - u(t-T/(2*oversampling)) + u(t - (oversampling*T-T/(2*oversampling))); %This is p(t) sampled
P = fft(p);
P(161) = 1e-19;
iP = 1./P; %Take 1/P(f) so we cancel the effects of the D/A converter (which is P(f))
numpoints = 2*T/sT;
%We can only go out to 1/(2*T) on the 1/P(f). The rest we need to zero out.
iP = [iP(1:numpoints) zeros(1, sN-numpoints*2-1) iP(sN-numpoints:sN)]
iP = iP(1:sN/(N1+N):sN); %Down sample 1/P(f) so we can element multiply with our interpolating filter

%This plots P(f)
f = -1/(2*sT):1/(sN*sT):1/(2*sT)-1/(sN*sT);
Ps = fftshift(P); %Shift P(f)
%Figure 4 plots P(f) shifted
figure(4)
plot(f, abs(Ps));
%Figure 5 plots P(f) shifted and zoomed in the f axis
figure(5)
plot(f(sN/2-numpoints+1:sN/2+numpoints), abs(Ps(sN/2-numpoints+1:sN/2+numpoints)));

X1 = X1 .* iP; %Element multiply our interpolating filter with our D/A converter effect canceller filter
x1 = ifft(X1);

%Figure 1 plots the original signal and our interpolated signal (with D/A
%converter effects cancelled.)
figure(1)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
plot(t1, x1, 'bo');
hold on
t=0:T:(N-1)*T;
plot(t, x, 'ro', t, x, 'r-');
hold off

%Figure 2 plots just our interpolated signal, but this time with lines
%connecting each point.
figure(2)
plot(t1, x1, 'b-');

%Figure 3 plots the frequency response of our original sampled signal.
figure(3)
Xs((N+1)/2:N) = X(1:(N+1)/2); %The fftshift didn't work for me
Xs(1:(N+1)/2) = X((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
plot(f,abs(Xs))
%figure(4)
%plot(f, abs(fftshift(X1)))

</pre>

==Graphs==

==Explanations==

Mark's Homework 15

2007-12-03T22:59:24Z

Pridma: /* MATLAB Script */

==Problem==
Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter.

==MATLAB Script==
The following is currently '''NON-WORKING'''. A working script will follow.
<pre>
clear all;
close all;
N = 50; %Number of sample points for our original signal
tmax=2; %Time, in seconds, to extend our original signal. We then sample this signal N times
oversampling = 4; %Number of oversampling points
T=tmax/N; %Calculate T, the sample period
t=0:T:(N)*T;
x=sin(2*pi*t)+sin(2*pi*2*t)+sin(2*pi*5*t); %This is our signal to over sample
N1=(oversampling-1)*N;
X=fft(x);
X1 = (N1+N)/N*[X(1:N/2), zeros(1, N1), X(N/2+1:N)]; %This is our interpolating filter

x2= ifft(X1);

figure(7)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
plot(t1, x2, 'bo');
hold on
t=0:T:(N)*T;
plot(t, x, 'ro', t, x, 'r-');
hold off

f = -1/(2*T):1/(N*T):1/(2*T);

figure(8)
plot(f, abs(fftshift(x)))

%This is to cancel out the effects of the D/A Converter
sT = T/100; %sT is hwo many times we are going to sample our pulse p(t)
stmax = oversampling*T; %This is how wide our pulse has to be when we oversample
sN = stmax/sT; %This is the total number of sampling points for sampling p(t)
t = 0:sT:stmax-sT;
p = u(t+1e-9) - u(t-T/(2*oversampling)) + u(t - (oversampling*T-T/(2*oversampling))); %This is p(t) sampled
P = fft(p);
iP = 1./P; %Take 1/P(f) so we cancel the effects of the D/A converter (which is P(f))
numpoints = 2*T/sT;
%We can only go out to 1/(2*T) on the 1/P(f). The rest we need to zero out.
iP = [iP(1:numpoints) zeros(1, sN-numpoints*2-1) iP(sN-numpoints:sN)]
iP = iP(1:sN/(N1+N):sN); %Down sample 1/P(f) so we can element multiply with our interpolating filter

%This plots P(f)
f = -1/(2*sT):1/(sN*sT):1/(2*sT)-1/(sN*sT);
Ps = fftshift(P); %Shift P(f)
%Figure 4 plots P(f) shifted
figure(4)
plot(f, abs(Ps));
%Figure 5 plots P(f) shifted and zoomed in the f axis
figure(5)
plot(f(sN/2-numpoints+1:sN/2+numpoints), abs(Ps(sN/2-numpoints+1:sN/2+numpoints)));

X1 = X1 .* iP; %Element multiply our interpolating filter with our D/A converter effect canceller filter
x1 = ifft(X1);

%Figure 1 plots the original signal and our interpolated signal (with D/A
%converter effects cancelled.)
figure(1)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
plot(t1, x2, 'bo');
hold on
t=0:T:(N)*T;
plot(t, x, 'ro', t, x, 'r-');
hold off

%Figure 2 plots just our interpolated signal, but this time with lines
%connecting each point.
figure(2)
plot(t1, x1, 'b-');

%Figure 3 plots the frequency response of our original sampled signal.
figure(3)
Xs((N+1)/2:N) = X(1:(N+1)/2); %The fftshift didn't work for me
Xs(1:(N+1)/2) = X((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
plot(f,abs(Xs))
%figure(4)
%plot(f, abs(fftshift(X1)))
</pre>

==Graphs==

==Explanations==

Mark's Homework 15

2007-12-03T22:58:22Z

Pridma: New page: ==Problem== Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter. =...

==Problem==
Make a MATLAB script to do four times oversampling and a filter so as to eliminate as much as possible the effect of the D/A converter that follows the interpolation filter.

==MATLAB Script==
The following is currently '''NON-WORKING'''. A working script will follow.
<pre>
clear all;
close all;
N = 500; %Number of sample points for our original signal
tmax=2; %Time, in seconds, to extend our original signal. We then sample this signal N times
oversampling = 4; %Number of oversampling points
T=tmax/N; %Calculate T, the sample period
t=0:T:(N)*T;
x=sin(2*pi*t)+sin(2*pi*2*t)+sin(2*pi*5*t); %This is our signal to over sample
N1=(oversampling-1)*N;
X=fft(x);
X1 = (N1+N)/N*[X(1:N/2), zeros(1, N1), X(N/2+1:N)]; %This is our interpolating filter

x2= ifft(X1);

figure(7)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
plot(t1, x2, 'bo');
hold on
t=0:T:(N)*T;
plot(t, x, 'ro', t, x, 'r-');
hold off

f = -1/(2*T):1/(N*T):1/(2*T);

figure(8)
plot(f, abs(fftshift(x)))

%This is to cancel out the effects of the D/A Converter
sT = T/100; %sT is hwo many times we are going to sample our pulse p(t)
stmax = oversampling*T; %This is how wide our pulse has to be when we oversample
sN = stmax/sT; %This is the total number of sampling points for sampling p(t)
t = 0:sT:stmax-sT;
p = u(t+1e-9) - u(t-T/(2*oversampling)) + u(t - (oversampling*T-T/(2*oversampling))); %This is p(t) sampled
P = fft(p);
iP = 1./P; %Take 1/P(f) so we cancel the effects of the D/A converter (which is P(f))
numpoints = 2*T/sT;
%We can only go out to 1/(2*T) on the 1/P(f). The rest we need to zero out.
iP = [iP(1:numpoints) zeros(1, sN-numpoints*2-1) iP(sN-numpoints:sN)]
iP = iP(1:sN/(N1+N):sN); %Down sample 1/P(f) so we can element multiply with our interpolating filter

%This plots P(f)
f = -1/(2*sT):1/(sN*sT):1/(2*sT)-1/(sN*sT);
Ps = fftshift(P); %Shift P(f)
%Figure 4 plots P(f) shifted
figure(4)
plot(f, abs(Ps));
%Figure 5 plots P(f) shifted and zoomed in the f axis
figure(5)
plot(f(sN/2-numpoints+1:sN/2+numpoints), abs(Ps(sN/2-numpoints+1:sN/2+numpoints)));

X1 = X1 .* iP; %Element multiply our interpolating filter with our D/A converter effect canceller filter
x1 = ifft(X1);

%Figure 1 plots the original signal and our interpolated signal (with D/A
%converter effects cancelled.)
figure(1)
t1 = 0:N/(N+N1)*T:(N-1/(N1+N))*T;
plot(t1, x2, 'bo');
hold on
t=0:T:(N)*T;
plot(t, x, 'ro', t, x, 'r-');
hold off

%Figure 2 plots just our interpolated signal, but this time with lines
%connecting each point.
figure(2)
plot(t1, x1, 'b-');

%Figure 3 plots the frequency response of our original sampled signal.
figure(3)
Xs((N+1)/2:N) = X(1:(N+1)/2); %The fftshift didn't work for me
Xs(1:(N+1)/2) = X((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
plot(f,abs(Xs))
%figure(4)
%plot(f, abs(fftshift(X1)))
</pre>

==Graphs==

==Explanations==

User:Pridma

2007-12-03T22:53:29Z

Pridma: /* Homework */

=Mark Priddy's Wiki Page=

==About Me==
I program computers and tinker around with them in my spare time. My spare time only comes around when I'm not doing homework in classes such as this one.

If you really want to know more, just ask. I can't think of what to put here.

==Things I notice==
Oh yeah, I did notice that the picture in the top left corner is currently out-of-date.

==Homework==
[[Pridma's Article on Fourier Transforms|Homework #4]]

[[Mark's Article on Sampling|Homework #8]]

[[Mark's Article on Aliasing|Homework #11]]

[[Mark's Article on the DFT|Homework #12]]

[[Mark's Homework 13|Homework #13]]

[[Mark's Homework 15|Homework #15]]

User:Pridma

2007-12-03T22:53:01Z

Pridma: /* Homework */

Chris' Page on Aliasing using MatLab

2007-11-12T18:53:07Z

Pridma: /* Demo of Aliasing Using Matlab */

== Demo of Aliasing Using Matlab ==

Frequencies above half the sample rate will produce aliasing. This should appear as a lower frequency signal.

Below is a spectrogram of a quadratic sweep from 20 Hertz to 20,000 Hertz using a 441000 Hertz sample rate.

[[Image:Chirp41000b.jpg]]

[[Media:44100hz.ogg]]

This one is the same script and parameters except the sample rate has been changed to 8000 Hertz.

[[Image:Chirp8000b.jpg]]

[[Media:8000hz.ogg]]

'''Matlab Program'''

<pre>
% Chris Rasmussen
% Based on Matlab examples
% Show aliasing

clc
%****************%
% Parameters
duration = 8
fmax = 20000
fmin = 20
samplerate = 8000
%****************%

%****************%
% Setup Soundcard
% Will still work if this is removed, you just won't hear anything
% It works with my onboard soundcard with Vista.
AO = analogoutput('winsound');
chan = addchannel(AO,1);
set(AO,'SampleRate',samplerate);
set(AO,'TriggerType','Manual');
ActualRate = get(AO,'SampleRate')
%****************%

%****************%
% Setup arrays
totalsamples = ActualRate*duration;
t = 0:1./ActualRate:duration;
y= 0.2 .* chirp(t,fmin,duration, fmax,'q',[],'concave');
%****************%

%****************%
% Write data to soundcard and play
% Will still work if this is removed, you just won't hear anything
putdata(AO,y')
start(AO)
trigger(AO)
waittilstop(AO,duration+1)
%****************%

%****************%
% Plot raw data
figure(1)
plot(y)
title('Waveform')
%****************%

%****************%
% Plot spectragram (uses FFT)
figure(3), specgram(y, 256, samplerate);
title('Quadratic Sine Sweep')
set(gcf,'Color',[1 1 1]);
%****************%

wavwrite(y,samplerate,16,'File.wav')

%****************%
% Picking up the messes
delete(AO)
clear AO
clear all
</pre>

Using the DFT

2007-11-12T18:50:51Z

Pridma:

sampling <math>sin(2*pi*t)</math> and taking the DFT we get this graph:

[[Image:Signals-13.jpg]]

Script for matlab:

<pre>
clear all;
t=0:.01:1;
T=0.20;
ts=0:T:1;
f1=2;
f2=1/0.125;
x = sin(2*pi*3*t); %this is the function
plot(t,x); % plot the original signal
X = fft(x); % take the DFT
pause (2);
plot (t,X); %plot the DFT of the signal
</pre>

Mark's Homework

2007-11-12T18:50:13Z

Pridma: Removing all content from page

Fourier Transform

2007-11-12T18:47:52Z

Pridma: Removing all content from page

Mark's Article on Aliasing

2007-11-12T18:46:14Z

Pridma: /* MATLAB script */

==Aliasing==

Aliasing is the problem you get if you ignore Nyquist's theorem that says you must sample at least twice the fastest frequency.

===MATLAB script===

<pre>
clear all;
f = 3; %sine wave frequency
fs = 2.5; %sample frequency
tmax = 2; %go to 5 seconds
T = 1/fs;
t = 0:0.001:tmax;
x = cos(2*pi*f*t);
ts = 0:T:tmax;
xs = cos(2*pi*f*ts);
xa = cos(2*pi*(f-fs)*t);
figure(1)
plot(t, x, '-b', ts, xs, 'ro', t, xa, 'g')
legend('Original signal', 'Sampled Points', 'Derived signal');
xlabel('Time (s)')
ylabel('Signal')
title('Plots Showing Aliasing')
</pre>

===Aliasing Displayed===
If you ran the above MATLAB script, MATLAB would display the following figure:

[[Image:alias11082007fig1.png]]

===Aliasing Explained===
In the MATLAB script, we generated a sine wave with a frequency of 3 (blue line). We then sampled the sine wave at a frequency of 2.5 (red circles). If we were to generate a sine wave from the sampled points, you'd get the green sine wave, which as you can tell, is not the same signal as the original! The frequency of the sine wave generated from the sample points would be:

<math>
\! f_{generated} = f_{original} - f_{sampled} = 3 - 2.5 = 0.5 Hz
</math>

Thus you have aliasing: your signal obtained from the sample points is very different from the original sine wave.

If you sample at twice the frequency of the original signal, the signal obtained from the sample points would be exactly the same as the original signal. If you sample even faster, you can apply a bandpass filter to still obtain the original signal. The given MATLAB script does not contain any such filter, so it would show you the wrong frequency sine wave if you tried values that are faster than twice the original frequency.

Mark's Homework 13

2007-11-09T20:51:38Z

Pridma: New page: ==Problem== Sample <math>sin(2 \pi t)</math> at 3Hz and take the DFT. Explain the results. ==MATLAB script== <pre> clear all; close all; f = 1; %sine wave frequency fs = 3; %sample frequ...

==Problem==
Sample <math>sin(2 \pi t)</math> at 3Hz and take the DFT. Explain the results.

==MATLAB script==
<pre>
clear all;
close all;
f = 1; %sine wave frequency
fs = 3; %sample frequency
tmax = 600/fs; %go to tmax seconds -- 600 points
T = 1/fs;
t = 0:T:tmax;
N=length(t);
x = sin(2*pi*f*t); % My signal to transform
t2 = 0:.01:tmax;
x2 = sin(2*pi*f*t2);
X=fft(x);
Xs((N+1)/2:N) = X(1:(N+1)/2); %The fftshift didn't work for me
Xs(1:(N+1)/2) = X((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
figure(1)
plot(t, x, '-o', t2, x2, 'r')
xlabel('Time (s)')
ylabel('x(t)')
title('Input Signal')
legend('Sampled signal', 'Original signal');
figure(2)
plot(f, abs(Xs))
xlabel('Frequency')
ylabel('X(f)')
title('Graph of F[sin(2 \pi t)]')

</pre>

==Graphs==
[[Image:DFT20071109Fig1.png|thumb|left|694px| Figure 1. The sampled signal with only 7 sample points.]]

[[Image:DFT20071109Fig2.png|thumb|left|694px| Figure 2. The DFT of Figure 1.]]

[[Image:DFT20071109Fig3.png|thumb|left|894px| Figure 3. The same as Figure 1 but with 600 sample points, and zoomed in.]]

[[Image:DFT20071109Fig4.png|thumb|left|694px| Figure 4. The DFT of Figure 3.]]

 

==Explanation==

In Figure 1. I took only 7 sample points. As you can see, the DFT (Figure 2) looks nothing like what it should look like (a spike at -1 and 1 Hz). This occurs because the edge effects account for 28% of the points. If you take a whole bunch more points, like that in Figure 3, the DFT looks much more what it should be as in Figure 4. With this many more points, the edge effects are much less noticeable, because the edge points are a small fraction of the total amount of sample points.

User:Pridma

2007-11-09T20:51:27Z

Pridma: /* Homework */

Mark's Homework

2007-11-09T20:49:01Z

Pridma: /* MATLAB script */

Mark's Homework

2007-11-09T20:48:04Z

==Problem==
Sample <math>sin(2 \pi t)</math> at 3Hz and take the DFT. Explain the results.

==MATLAB script==
<pre>
clear all;
close all;
f = 1; %sine wave frequency
fs = 3; %sample frequency
tmax = 600/fs; %go to tmax seconds -- 600 points
T = 1/fs;
t = 0:T:tmax;
N=length(t);
x = sin(2*pi*f*t); % My signal to transform
t2 = 0:.01:tmax;
x2 = sin(2*pi*f*t2);
X=fft(x);
Xs((N+1)/2:N) = X(1:(N+1)/2); %The fftshift didn't work for me
Xs(1:(N+1)/2) = X((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
figure(1)
plot(t, x, '-o', t2, x2, 'r')
xlabel('Time (s)')
ylabel('x(t)')
title('Input Signal')
legend('Original signal', 'Sampled signal');
figure(2)
plot(f, abs(Xs))
xlabel('Frequency')
ylabel('X(f)')
title('Graph of F[sin(2 \pi t)]')

</pre>

==Graphs==
[[Image:DFT20071109Fig1.png|thumb|left|694px| Figure 1. The sampled signal with only 7 sample points.]]

[[Image:DFT20071109Fig2.png|thumb|left|694px| Figure 2. The DFT of Figure 1.]]

[[Image:DFT20071109Fig3.png|thumb|left|894px| Figure 3. The same as Figure 1 but with 600 sample points, and zoomed in.]]

[[Image:DFT20071109Fig4.png|thumb|left|694px| Figure 4. The DFT of Figure 3.]]

 

==Explanation==

In Figure 1. I took only 7 sample points. As you can see, the DFT (Figure 2) looks nothing like what it should look like (a spike at -1 and 1 Hz). This occurs because the edge effects account for 28% of the points. If you take a whole bunch more points, like that in Figure 3, the DFT looks much more what it should be as in Figure 4. With this many more points, the edge effects are much less noticeable, because the edge points are a small fraction of the total amount of sample points.

File:DFT20071109Fig4.png

2007-11-09T20:43:19Z

Pridma:

File:DFT20071109Fig3.png

2007-11-09T20:43:14Z

Pridma:

File:DFT20071109Fig2.png

2007-11-09T20:43:09Z

Pridma:

File:DFT20071109Fig1.png

2007-11-09T20:43:03Z

Pridma:

User:Pridma

2007-11-09T20:35:38Z

Pridma: /* Homework */

Mark's Article on the DFT

2007-11-09T01:39:27Z

Pridma: /* The DFT */

==The DFT==
The '''Discrete Fourier Transform''', or '''DFT''' for short, is the Fourier Transform in the discrete world. It is almost exactly like the Fourier Transform.

===MATLAB script===
<pre>
clear all;
tmax = 1; %The signal will run from 0 to tmax (in seconds)
T=.01; %Sampling period
wf=5; %Waveform frequency: the frequency of the signal to transform
t=0:T:tmax;
N=length(t);
%x = sin(wf*pi*t)./(wf*pi*t); %This signal did not work out well
%x((N+1)/2) = 1;
x = sin(2*pi*wf*t); %This is the signal to transform
X = 0.*t; %The fourier transform of the signal x (calculated by hand)
X((N+1)/2-round(wf*N*T)+1) = 0.5; %I did this to simulate the delta function
X((N+1)/2+round(wf*N*T)) = 0.5;
Xdft = fftshift(x); %The DFT (Discrete Fourier Transform of the signal x)
Xdftu = fft(x); %The DFT (Discrete Fourier Transform of the signal x)
Xdft((N+1)/2:N) = Xdftu(1:(N+1)/2); %The fftshift didn't work for me
Xdft(1:(N+1)/2) = Xdftu((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
figure(1)
plot(t, x)
title('Original Sampled Signal')
xlabel('Time (s)')
ylabel('x(t)')
figure(2)
plot(f, abs(Xdftu))
title('Unshifted Discrete Fourier Transform of x(t)')
xlabel('Frequency')
ylabel('Magnitude of X(f)')
figure(3)
plot(f, abs(Xdft))
title('Shifted Discrete Fourier Transform of x(t)')
xlabel('Frequency')
ylabel('Magnitude of X(f)')
figure(4)
plot(f, X)
title('Actual Fourier Transform of x(t)')
xlabel('Frequency')
ylabel('Magnitude of X(f)')
</pre>

===Graphs===
[[Image:DFT20071108Fig1.png|thumb|left|694px| Figure 1. The sampled signal]]

[[Image:DFT20071108Fig2.png|thumb|left|694px| Figure 2. The unshifted fast Fourier transform of Figure 1.]]

[[Image:DFT20071108Fig3.png|thumb|left|694px| Figure 3. The shifted fast Fourier transform of Figure 1.]]

[[Image:DFT20071108Fig4.png|thumb|left|694px| Figure 4. The actual Fourier transform of Figure 1.]]

 

===Explanations===

I picked a sine wave of frequency 5 for my signal. (Shown in Figure 1.) I sampled it and took the discrete Fourier transform of the signal. (Shown in figure 2.) Using the FFT algorithm, the transform only shows the positive frequencies. You have to shift the graph to get the correct frequencies. Figure 3 shows the shifted (and now correct) graph. In Figure 4, I've shown the actual Fourier transform of the signal. As you can see, they are very similar. The heights are different and on the DFT graph, you'll see some frequencies other than the exact frequencies, but that is because of sampling.

Mark's Article on the DFT

2007-11-09T01:39:16Z

Pridma: New page: ==The DFT== The ''Discrete Fourier Transform'', or ''DFT'' for short, is the Fourier Transform in the discrete world. It is almost exactly like the Fourier Transform. ===MATLAB script=== ...

==The DFT==
The ''Discrete Fourier Transform'', or ''DFT'' for short, is the Fourier Transform in the discrete world. It is almost exactly like the Fourier Transform.

===MATLAB script===
<pre>
clear all;
tmax = 1; %The signal will run from 0 to tmax (in seconds)
T=.01; %Sampling period
wf=5; %Waveform frequency: the frequency of the signal to transform
t=0:T:tmax;
N=length(t);
%x = sin(wf*pi*t)./(wf*pi*t); %This signal did not work out well
%x((N+1)/2) = 1;
x = sin(2*pi*wf*t); %This is the signal to transform
X = 0.*t; %The fourier transform of the signal x (calculated by hand)
X((N+1)/2-round(wf*N*T)+1) = 0.5; %I did this to simulate the delta function
X((N+1)/2+round(wf*N*T)) = 0.5;
Xdft = fftshift(x); %The DFT (Discrete Fourier Transform of the signal x)
Xdftu = fft(x); %The DFT (Discrete Fourier Transform of the signal x)
Xdft((N+1)/2:N) = Xdftu(1:(N+1)/2); %The fftshift didn't work for me
Xdft(1:(N+1)/2) = Xdftu((N+1)/2:N); %So this manually shifts the FFT
f = -1/(2*T):1/(N*T):1/(2*T)-1/(N*T);
figure(1)
plot(t, x)
title('Original Sampled Signal')
xlabel('Time (s)')
ylabel('x(t)')
figure(2)
plot(f, abs(Xdftu))
title('Unshifted Discrete Fourier Transform of x(t)')
xlabel('Frequency')
ylabel('Magnitude of X(f)')
figure(3)
plot(f, abs(Xdft))
title('Shifted Discrete Fourier Transform of x(t)')
xlabel('Frequency')
ylabel('Magnitude of X(f)')
figure(4)
plot(f, X)
title('Actual Fourier Transform of x(t)')
xlabel('Frequency')
ylabel('Magnitude of X(f)')
</pre>

===Graphs===
[[Image:DFT20071108Fig1.png|thumb|left|694px| Figure 1. The sampled signal]]

[[Image:DFT20071108Fig2.png|thumb|left|694px| Figure 2. The unshifted fast Fourier transform of Figure 1.]]

[[Image:DFT20071108Fig3.png|thumb|left|694px| Figure 3. The shifted fast Fourier transform of Figure 1.]]

[[Image:DFT20071108Fig4.png|thumb|left|694px| Figure 4. The actual Fourier transform of Figure 1.]]

 

===Explanations===

I picked a sine wave of frequency 5 for my signal. (Shown in Figure 1.) I sampled it and took the discrete Fourier transform of the signal. (Shown in figure 2.) Using the FFT algorithm, the transform only shows the positive frequencies. You have to shift the graph to get the correct frequencies. Figure 3 shows the shifted (and now correct) graph. In Figure 4, I've shown the actual Fourier transform of the signal. As you can see, they are very similar. The heights are different and on the DFT graph, you'll see some frequencies other than the exact frequencies, but that is because of sampling.

File:DFT20071108Fig4.png

2007-11-09T01:16:27Z

Pridma: The actual Fourier transform of a sample signal for describing the DFT.

The actual Fourier transform of a sample signal for describing the DFT.

File:DFT20071108Fig3.png

2007-11-09T01:15:50Z

Pridma: The shifted FFT signal for describing the DFT.

The shifted FFT signal for describing the DFT.

File:DFT20071108Fig2.png

2007-11-09T01:15:42Z

Pridma: The unshifted FFT signal for describing the DFT.

The unshifted FFT signal for describing the DFT.

File:DFT20071108Fig1.png

2007-11-09T01:15:09Z

Pridma: The original sampled signal for describing the DFT.

The original sampled signal for describing the DFT.

User:Pridma

2007-11-09T01:10:22Z

Pridma: /* Homework */

Mark's Article on Aliasing

2007-11-08T23:10:34Z

Pridma: New page: ==Aliasing== Aliasing is the problem you get if you ignore Nyquist's theorem that says you must sample at least twice the fastest frequency. ===MATLAB script=== <pre> clf; f = 3; %sine ...

==Aliasing==

Aliasing is the problem you get if you ignore Nyquist's theorem that says you must sample at least twice the fastest frequency.

===MATLAB script===

<pre>
clf;
f = 3; %sine wave frequency
fs = 2.5; %sample frequency
tmax = 2; %go to 5 seconds
T = 1/fs;
t = 0:0.001:tmax;
x = cos(2*pi*f*t);
ts = 0:T:tmax;
xs = cos(2*pi*f*ts);
xa = cos(2*pi*(f-fs)*t);
figure(1)
plot(t, x, '-b', ts, xs, 'ro', t, xa, 'g')
legend('Original signal', 'Sampled Points', 'Derived signal');
xlabel('Time (s)')
ylabel('Signal')
title('Plots Showing Aliasing')
</pre>

===Aliasing Displayed===
If you ran the above MATLAB script, MATLAB would display the following figure:

[[Image:alias11082007fig1.png]]

===Aliasing Explained===
In the MATLAB script, we generated a sine wave with a frequency of 3 (blue line). We then sampled the sine wave at a frequency of 2.5 (red circles). If we were to generate a sine wave from the sampled points, you'd get the green sine wave, which as you can tell, is not the same signal as the original! The frequency of the sine wave generated from the sample points would be:

<math>
\! f_{generated} = f_{original} - f_{sampled} = 3 - 2.5 = 0.5 Hz
</math>

Thus you have aliasing: your signal obtained from the sample points is very different from the original sine wave.

If you sample at twice the frequency of the original signal, the signal obtained from the sample points would be exactly the same as the original signal. If you sample even faster, you can apply a bandpass filter to still obtain the original signal. The given MATLAB script does not contain any such filter, so it would show you the wrong frequency sine wave if you tried values that are faster than twice the original frequency.

File:Alias11082007fig1.png

2007-11-08T23:00:55Z

Pridma: Figure generated by MATLAB which shows aliasing.

Figure generated by MATLAB which shows aliasing.

User:Pridma

2007-11-08T22:30:17Z

Pridma: /* Homework */

Mark's Article on Sampling

2007-10-26T05:16:43Z

Pridma:

==About Sampling==
It is impossible to store all possible information about a waveform in a computer. The function on any interval has an infinite amount of points inside that interval. We need a way of storing a waveform inside finite memory. This can be accomplished through the awesomeness of something called sampling. With some restrictions, mentioned below, you can take the magnitude of the waveform at a given time interval, store it, and be able to reproduce the the same waveform through Fourier Transforms.

==Restrictions==
When you sample, you must first band-limit your input waveform before you sample. Otherwise, you'll get a lot of artifacts.

===Why you must band-limit the input===
When you look at the Fourier Transform of an example input waveform, you'll get a semicircle. After you sample, the semicircle will be periodic. If you do not band-limit the input wavevform, the semicircles may overlap, and if that happens, there is no way of knowing what part of each semicircle is where. You won't be able to tell the difference between each semicircle.

==Nyquist Theorem==
If you sample a band-limited signal at a sample rate greater than 2 times the highest frequency component of the input waveform, you won't lose any information about the signal and you'll be able to reconstruct the waveform from the samples.

Pridma's Article on Fourier Transforms

2007-10-12T03:29:12Z

Pridma: /* Useful Applications */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}\left[e^{-j2\pi ft_{0}} X(f)\right]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)]\left(cos(2\pi ft) - j sin(2\pi ft)\right) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \begin{Bmatrix} 0, |f| > f_{0} \\ 1, |f| < f_{0} \end{Bmatrix}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi t}\right]_{f=-f_{0}}^{f_{0}}

= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T03:18:50Z

Pridma:

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}\left[e^{-j2\pi ft_{0}} X(f)\right]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)]\left(cos(2\pi ft) - j sin(2\pi ft)\right) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \begin{Bmatrix} 0, |f| > f_{0} \\ 1, |f| < f_{0} \end{Bmatrix}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=-f_{0}}^{f_{0}}
= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T03:16:59Z

Pridma: /* Useful Applications */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}\left[e^{-j2\pi ft_{0}} X(f)\right]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)]\left(cos(2\pi ft) - j sin(2\pi ft)\right) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \begin{Bmatrix} 0, |f| > f_{0} \\ 1, |f| < f_{0} \end{Bmatrix}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=-f_{0}}^{f_{0}}

= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T03:02:25Z

Pridma: /* Useful Applications */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}\left[e^{-j2\pi ft_{0}} X(f)\right]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)]\left(cos(2\pi ft) - j sin(2\pi ft)\right) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=-f_{0}}^{f_{0}}

= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T02:32:50Z

Pridma: /* Even and Odd Parts */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}\left[e^{-j2\pi ft_{0}} X(f)\right]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)]\left(cos(2\pi ft) - j sin(2\pi ft)\right) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=f_{0}}^{f_{0}}
= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T02:30:55Z

Pridma: /* Time Shift */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}\left[e^{-j2\pi ft_{0}} X(f)\right]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)](cos(2\pi ft) - j sin(2\pi ft)) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=f_{0}}^{f_{0}}
= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T02:25:28Z

Pridma: /* The Derivative of x(t) */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} \left[e^{j2\pi ft}\right] df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}\left[j2\pi fX(f)\right]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}[e^{-j2\pi ft_{0}} X(f)]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)](cos(2\pi ft) - j sin(2\pi ft)) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=f_{0}}^{f_{0}}
= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T02:21:01Z

Pridma:

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} e^{j2\pi ft} df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}[j2\pi fX(f)]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}[e^{-j2\pi ft_{0}} X(f)]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)](cos(2\pi ft) - j sin(2\pi ft)) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=f_{0}}^{f_{0}}
= \left(\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j}\right)\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T02:18:37Z

Pridma: /* Useful Applications */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} e^{j2\pi ft} df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}[j2\pi fX(f)]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}[e^{-j2\pi ft_{0}} X(f)]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)](cos(2\pi ft) - j sin(2\pi ft)) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}\left[H(f)\right] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \left[\frac{e^{j2\pi ft}}{j2\pi ft}\right]_{f=f_{0}}^{f_{0}}

= (\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j})\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

Pridma's Article on Fourier Transforms

2007-10-12T02:15:03Z

Pridma: /* Examples */

=Mark's Wiki Article on Fourier Transforms=

==About the Fourier Transform==
The '''Fourier Transform''' is a way to change a function of time into a function of frequency. This comes in very handy at times as it allows you to talk about a function in the frequency domain and will make some things very obvious about a function when you see it in the frequency domain that would not be very obvious in the time domain.

==Formulas==
The Fourier Transform is as follows:

:<math>
\mathcal{F}[x(t)] = X(f) = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft}\, dt
</math>

where <math>x(t) \!</math> is the function in the time domain that you want to transform and <math>X(f) \!</math> is the transformed function which will be in the frequency domain.

The inverse Fourier Transform is similar:

:<math>
\mathcal{F}^{-1}[X(f)] = x(t)=\int_{-\infty}^{\infty} X(f) e^{-j2\pi ft}\, df
</math>

==Some Properties==

===The Derivative of x(t)===
If you take the derivative of <math>x(t) \!</math> and if you know it's transform <math>X(f) \!</math>, you can easily find the transform of the derivative:

:<math>\frac{dx(t)}{dt} = \frac{d}{dt}\int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} X(f) \frac{d}{dt} e^{j2\pi ft} df = \int_{-\infty}^{\infty} j2\pi fX(f) e^{j2\pi ft}df = \mathcal{F}^{-1}[j2\pi fX(f)]</math>

===Time Shift===
The time shift property of the Fourier Transform is fairly straight-forward as well.

:<math>x(t-t_{0}) = \int_{-\infty}^{\infty} X(f) e^{j2\pi ft} df = \int_{-\infty}^{\infty} e^{-j2\pi ft_{0}} X(f) e^{j2\pi ft} df = \mathcal{F}^{-1}[e^{-j2\pi ft_{0}} X(f)]</math>

This formula is actually fairly obvious... a time delay is really just a linear phase delay, which can be seen from the <math>e^{-j2\pi ft_{0}}</math> part of the inverse Forier Transform shown above.

===Even and Odd Parts===
You can also split up a function to a sum of it's even and odd parts and take a Fourier Transform using sine and cosine instead of <math>e</math>.
:<math>x(t) = x_{o}(t) + x_{e}(t) \!</math>

:<math>x_{e}(t) = \frac{x(t) + x(-t)}{2}</math>

:<math>x_{o}(t) = \frac{x(t) - x(-t)}{2}</math>

where <math>x_{e}(t) \!</math> is the even part of <math>x(t) \!</math> and <math>x_{o}(t) \!</math> is the odd part of <math>x(t) \!</math>

Once you have the function split up into it's even and odd parts, you can use the following Fourier Transform formula:

:<math>\mathcal{F}[x(t)] = \int_{-\infty}^{\infty} x(t) e^{-j2\pi ft} dt = \int_{-\infty}^{\infty} [x_{e}(t) + x_{o}(t)](cos(2\pi ft) - j sin(2\pi ft)) dt</math>

::::<math>= \int_{-\infty}^{\infty} x_{e}(t) cos(2\pi ft) dt - j \int_{-\infty}^{\infty} x_{o}(t) sin(2\pi ft) dt</math>

::::<math>= X_{e}(f) + j X_{o}(f) \!</math>

==Examples==

Here are some examples of Fourier Transforms:

:<math> \mathcal{F}\left[cos(2\pi f_{0}t)\right] = \int_{-\infty}^{\infty} \left(\frac{e^{j2\pi f_{0}t} + e^{-j2\pi f_{0}t}}{2}\right) e^{-j2\pi ft} dt = \frac{1}{2}\left(\int_{-\infty}^{\infty} e^{-j2\pi(f-f_{0})t} dt + \int_{-\infty}^{\infty} e^{j2\pi(f+f_{0})t} dt\right)</math>

::::::<math> = \frac{1}{2} \delta\left(f-f_{0}\right) + \frac{1}{2} \delta\left(f+f_{0}\right)</math>

==Useful Applications==

One application of Fourier Transforms is in answering the question, "Why can't we build a brick-wall low pass filter?"

An ideal low pass filter would keep all the frequencies below a certain frequency, <math> f_{0} \!</math> and would discard all higher frequencies.

The transfer function of said system would have to be <math>H(f) = \{_{0, |f| > f_{0}}^{1, |f| < f_{0}}</math>.

To build this into a circuit, we need to find the transfer function in the time domain. We can inverse Fourier transform <math>H(f) \!</math>.

:<math>h(t) = \mathcal{F}^{-1}[H(f)] = \int_{-f_{0}}^{f_{0}} 1 e^{j2\pi ft} df = \frac{e^{j2\pi ft}}{j2\pi ft}|_{f=f_{0}}^{f_{0}}
= (\frac{e^{j2\pi ft} - e^{-j2\pi f_{0}t}}{2j})\frac{1}{\pi t} = \frac{sin(\pi t)}{\pi t}
</math>

If we take a closer look at the transfer function, we'd notice that if we input an impulse function, the output would have to be non-causal: the output would be a sine wave extending from <math>-\infty</math> to <math>\infty</math>! So, it is impossible to build an exact "brick-wall" low pass filter, unless we know the input an infinite amount of time before it even happened!

User:Pridma

2007-09-26T02:44:08Z

Pridma: /* About Me */

User:Pridma

2007-09-26T02:38:59Z

Pridma:

Signals and Systems

2007-09-26T02:38:00Z

Pridma: /* 2007-2008 contributors */

== Topics ==
[[Fourier series - by Ray Betz|Overview of Signals and Systems]]

===Individual Subjects===
*[[Linear Time Invarient System|Linear Time Invarient Systems]]
**[[The Game|"The Game"]]
*[[Orthogonal functions|Orthogonal Functions]]
*[[Energy in a signal|Finding the Energy in a Signal]]
**[[Rayleigh's Theorem]]
*[[Fourier series|Fourier Series]]
*[[Fourier transform|Fourier Transforms]]
**[[Discrete Fourier transform]]
*[[Sampling]]
*[[FIR Filter Example]]

===Course Pages===
[[2005-2006 Assignments]]

[[2006-2007 Assignments]]

[http://www.wwc.edu/~frohro/ClassNotes/engr455index.htm Class notes for Signals & Systems]

[[User:Frohro|Instructor: Rob Frohne]]

==2004-2005 contributors==

[[User:Barnsa|Sam Barnes]]

[[User:Santsh|Shawn Santana]]

[[User:Goeari|Aric Goe]]

[[User:Caswto|Todd Caswell]]

[[User:Andeda|David Anderson]]

[[User:Guenan|Anthony Guenterberg]]

==2005-2006 contributors==

[[User:GabrielaV|Gabriela Valdivia]]

[[User:SDiver|Raymond Betz]]

[[User:chrijen|Jenni Christensen]]

[[User:wonoje|Jeffrey Wonoprabowo]]

[[User:wilspa|Paul Wilson]]

==2006-2007 contributors==

[[User:Smitry|Ryan J Smith]]

[[User:Nathan|Nathan Ferch]]

[[User:Andrew|Andrew Lopez]]

[[User:Sherna|Nathan Sherman]]

[[User:Adkich|Chris Adkins]]

==2007-2008 contributors==

[[User:Fonggr|Greg Fong]]

[[User:Pridma|Mark Priddy]]