The following content is
provided under a Creative
Commons license.
Your support will help MIT
OpenCourseWare continue to
offer high quality educational
resources for free.
To make a donation or view
additional materials from
hundreds of MIT courses, visit
MIT OpenCourseWare at
ocw.mit.edu.
[MUSIC PLAYING]
PROFESSOR: In the last lecture,
we discussed a number
of general properties for
systems, which, as you recall,
applied both to continuous-time
and to
discrete-time systems.
These properties were the
properties associated with a
system having memory.
The issue of whether a system
is or isn't invertible, we
talked about causality and
stability, and finally we
talked about when linearity
and time invariance.
In today's lecture, what
I'd like to do is focus
specifically on linearity and
time invariance, and show how
for systems that have those
properties, we can exploit
them to generate a general
representation.
Let me begin by just
reviewing the two
properties again quickly.
Time invariance, as you recall,
is a property that
applied both to continuous-time
and
discrete-time systems, and in
essence stated that for any
given input and output
relationship if we simply
shift the input,
then the output
shifts by the same amount.
And of course, exactly the same
kind of statement applied
in discrete time.
So time invariance was a
property that said that the
system didn't care about
what the time origin
of the signal is.
Linearity was a property related
to the fact that if we
have a set of outputs
associated with a
given set of inputs--
as I've indicated here with the
inputs as phi_k and the
outputs psi_k, then the property
of linearity states
that if we have an input which
is a linear combination of
those inputs, then the output is
a linear combination of the
associated outputs.
So that linear combination of
inputs generates, for a linear
system, an output which is a
linear combination of the
associated outputs.
Now the question is, how can we
exploit the properties of
linearity and time invariance?
There's a basic strategy which
will flow more or less through
most of this course.
The strategy is to attempt to
decompose a signal, either
continuous-time or
discrete-time, into a set of
basic signals.
I've indicated that here.
And the question then is, what
basic signal should we pick?
Well, the answer, kind of, is we
should pick a set of basic
signals that provide a certain
degree of analytical
convenience.
So we choose a set of inputs
for the decomposition that
provide outputs that we
can easily generate.
Now, as we'll see, when we do
this, there are two classes of
inputs that are particularly
suited to that strategy.
One class is the set of delayed
impulses, namely
decomposing a signal into a
linear combination of these.
And as we'll see, that leads to
a representation for linear
time-invariant systems, which is
referred to as convolution.
The second is a decomposition
of inputs into complex
exponentials--
a linear combination of
complex exponentials--
and that leads to a
representation of signals and
systems through what we'll refer
to as Fourier analysis.
Now, Fourier analysis will
be a topic for a
set of later lectures.
What I'd like to begin with is
the representation in terms of
impulses and the associated
description of linear
time-invariant systems
using convolution.
So let's begin with a discussion
of discrete-time
signals, and in particular the
issue of how discrete-time
signals can be decomposed
as a linear
combination of delayed impulses.
Well, in fact, it's relatively
straightforward.
What I've shown here is a
general sequence with values
which I've indicated
at the top.
And more or less as we did
when we talked about
representing a unit step in
terms of impulses, we can
think of this general sequence
as a sequence of impulses--
delayed, namely, occurring at
the appropriate time instant,
and with the appropriate
amplitude.
So we can think of this general
sequence and an
impulse occurring at n = 0 and
with a height of x[0], plus an
impulse of height x[1]
occurring at time n = 1,
and so that's x[1]
delta[n-1], an impulse
at -1 with an
amplitude of x[-1], etc.
So if we continued to generate
a set of weighted, delayed
unit samples like that, and if
we added all these together,
then that will generate
the total sequence.
Algebraically, then, what that
corresponds to is representing
the sequence as a sum of
individual terms as I've
indicated here or in terms of a
general sum, the sum of x[k]
delta[n-k].
So that's our strategy--
the strategy is to decompose an
arbitrary sequence into a
linear combination of weighted,
delayed impulses.
And here again is the
representation, which we just
finished generating.
Now, why is this representation
useful?
It's useful because we now have
a decomposition of the
sequence as a linear combination
of basic
sequences, namely the
delayed impulses.
And if we are talking about a
linear system, the response to
that linear combination
is a linear
combination of the responses.
So if we denote the response
to a delayed impulse as
h_k[n], then the response to
this general input is what
I've indicated here, where y[n],
of course, is the output
due to the general input x[n].
h_k[n]
in is the output due to the
delayed impulse, and these are
simply the coefficients
in the weighting.
So for a linear system, we
have this representation.
And if now, in addition, the
system is time-invariant, we
can, in fact, relate the
outputs due to these
individual delayed impulses.
Specifically, if the system is
time-invariant, then the
response to an impulse at time
k is exactly the same as the
response to an impulse at time
0, shifted over to time k.
Said another way, h_k[n]
is simply h_0[n-k], where h_0 is
the response of the system
to an impulse at n = 0.
And it's generally useful to,
rather than carrying around
h_0[n], just simply
define h_0[n]
as h[n], which is the unit
sample or unit impulse
response of the system.
And so the consequence, then, is
for a linear time-invariant
system, the output can
be expressed as
this sum where h[n-k]
is the response to an impulse
occurring at time n = k.
And this is referred to as
the convolution sum.
Now, we can--
just to emphasize how we've gone
about this, let me show
it from another perspective.
We of course have taken the
sequence x[n], we have
decomposed it as a linear
combination of these weighted,
delayed impulses.
When these are added together,
those correspond to the
original sequence x[n].
If this impulse, for example,
generates a
response which is x[0]
h[n], where h[n]
is the response to a unit
impulse at n = 0, and the
second one generates a delayed
weighted response, and the
third one similarly, and we
generate these individual
responses, these are all added
together, and it's that linear
combination that forms
the final output.
So that's really kind of the way
we're thinking about it.
We have a general sequence,
we're thinking of each
individual sample individually,
each one of
those pops the system, and
because of linearity, the
response is the sum of those
individual responses.
That's what happens in discrete
time, and pretty much
the same strategy works
in continuous time.
In particular, we can begin in
continuous time with the
notion of decomposing a
continuous-time signal into a
succession of arbitrarily
narrow rectangles.
And as the width of the
rectangles goes to 0, the
approximation gets better.
Essentially what's going to
happen is that each of those
individual rectangles, as they
get narrower and narrower,
correspond more and more
to an impulse.
Let me show you what I mean.
Here we have a continuous-time
signal, and I've approximated
it by a staircase.
So in essence I can think of
this as individual rectangles
of heights associated with the
height of the continuous
curve, and so I've indicated
that down below.
Here, for example, is the
impulse corresponding to the
rectangle between t = -2
Delta and t = -Delta.
Here's the one from -Delta to 0,
and as we continue on down,
we get impulses, or rather
rectangles, from successive
parts of the wave form.
Now let's look specifically at
the rectangle, for example,
starting at 0 and ending at
Delta, and the amplitude of it
is x(Delta).
So what we have--
actually, this should be x(0),
and so let me just
correct that here.
That's x(0).
And so we have a rectangle
height x(0), and recall the
function that I defined last
time as delta_Delta(t), which
had height 1 / delta
and width delta.
So multiplying finally by this
last little Delta, then, this
is a representation
for the rectangle
that I've shown there.
Now there's a little bit of
algebra there to kind of track
through, but what we're really
doing is just simply
representing this in terms
of rectangles.
What I want to do is describe
each rectangle as in terms of
that function delta_Delta(t),
which in the limit, then,
becomes an impulse.
So let's track that through
a little further.
When we have that linear
combination, then, we're
saying that x(t) can be
represented by a sum as I
indicate here, which I can then
write more generally in
this form, just indicating that
this is an infinite sum.
We now want to take the limit
as Delta goes to 0, and as
Delta goes to 0, notice
that this term
becomes arbitrarily narrow.
This goes to our impulse
function, and this, of course,
goes to x of tau.
And in fact, in the limit, a
sum of this form is exactly
the way an integral
is defined.
So we have an expression
for y(t) in terms
of an impulse function.
There, I have to admit, is a
little bit of detail to kind
of focus on at your leisure, but
this is the general flow
of the strategy.
So what we have now is an
integral that tells us that
tells us how x(t) can be
described as a sum or linear
combination involving
impulses.
This bottom equation, by the
way, is often referred to as
the sifting integral.
In essence, what it says is that
if I take a time function
x(t) and put it through that
integral, the impulse as it
zips by generates x(t)
all over again.
Now, at first glance, what it
could look like is that we've
taken a time function x(t) and
proceeded to represent it in a
very complicated way, in terms
of itself, and one could ask,
why bother doing that?
And the reason, going back to
what our strategy was, is that
what we want to do is exploit
the property of linearity.
So by describing a time
function as a linear
combination of weighted, delayed
impulses, as in effect
we've done through this
summation that corresponds to
a decomposition in terms of
impulses, we can now exploit
linearity, specifically
recognizing that the output of
a linear system is the sum
of the responses to these
individual inputs.
So with h_kDelta(t)
corresponding to the response
to delta_Delta(t-kDelta) and
the rest of this stuff, the
x(kDelta) and this
little Delta are
basically scale factors--
for a linear system, then, if
the input is expressed in this
form, the output is expressed in
this form, and again taking
the limit as Delta goes to
0, by definition, this
corresponds to an integral.
It's the integral that I
indicate here with h_tau(t)
corresponding to the impulse
response due to an impulse
occurring at time tau.
Now, again, we can do
the same thing.
In particular, if the system
is time-invariant, then the
response to each of these
delayed impulses is simply a
delayed version of the impulse
response, and so we can relate
these individual terms.
And in particular, then, the
response to an impulse
occurring at time t = tau is
simply the response to an
impulse occurring at time 0
shifted over to the time
origin tau.
Again, as we did before, we'll
drop this subscript h_0, so
h_0(t) we'll simply
define as h(t).
What we're left with when we do
that is the description of
a linear time-invariant system
through this integral, which
tells us how the output is
related to the input and to
the impulse response.
Again, let's just quickly look
at this from another
perspective as we did
in discrete time.
Recall that what we've done
is to take the continuous
function, decompose it in terms
of rectangles, and then
each of these rectangles
generates its individual
response, and then
these individual
responses are added together.
And as we go through that
process, of course, there's a
process whereby we let the
approximation go to the
representation of
a smooth curve.
Now, again, I stress if there is
certainly a fair amount to
kind of examine carefully there,
but it's important to
also reflect on what we've done,
which is really pretty
significant.
What we've managed to accomplish
is to exploit the
properties of linearity and time
invariance, so that the
system could be represented in
terms only of its response to
an impulse at time 0.
So for a linear time-invariant
system--
quite amazingly, actually--
if you know its response to an
impulse at t = 0 or n = 0,
depending on discrete or
continuous time, then in fact,
through the convolution sum
in discrete time or the
convolution integral in
continuous time, you can
generate the response to
an arbitrary input.
Let me just introduce a small
amount of notation.
Again, reminding you of the
convolution sum in the
discrete-time case, which looks
as I've indicated here--
the sum of x[k]
h[n-k]
will have the requirement of
making such frequent reference
to convolution that it's
convenient to notationally
represent it as I have here
with an asterisk.
So x[n]
* h[n]
means or denotes the
convolution of x[n]
with h[n].
And correspondingly in the
continuous-time case, we have
the convolution integral, which
here is the sifting
integral
as we talked about, representing
x(t) in terms of
itself as a linear combination
of delayed impulses.
Here we have the convolution
integral, and again we'll use
the asterisk to denote
convolution.
Now, there's a lot about
convolution that we'll want to
talk about.
There are properties of
convolution which tell us
about properties of linear
time-invariant systems.
Also, it's important to focus
on the mechanics of
implementing a convolution--
in other words, understanding
and generating some fluency
and insight into what these
particular sum and integral
expressions mean.
So let's first look at
discrete-time convolution and
examine more specifically what
in essence the sum tells us to
do in terms of manipulating
the sequences.
So returning to the expression
for the convolution sum, as I
show here, the sum of x[k]
h[n-k]--
let's focus in on an example
where we choose x[n]
as a unit step and h[n]
as a real exponential times
the a unit step.
So the sequence x[n]
is as I indicate here,
and the sequence h[n]
is an exponential for positive
time and 0 for negative time.
So we have x[n]
and h[n], but now let's look
back at the equation and let
me stress that what we
want is not x[n]
and h[n]--
we want x[k], because
we're going to sum
over k, and not h[k]
but h[n-k].
So we have then from x[n],
it's straightforward to
generate x[k].
It's simply changing the
index of summation.
And what's h[n-k]?
Well what's h[-k]?
h[-k]
is h[k]
flipped over.
So if this is what h[k]
looks like, then this
is what h[n-k]
looks like.
In essence, what the operation
of convolution or the
mechanics of convolution tells
us to do is to take the
sequence h[n-k],
which is h[-k]
positioned with its origin at
k = n, and multiply this
sequence by this sequence and
sum the product from k =
-infinity to +infinity.
So if we were to compute, for
example, the output at n = 0--
as I positioned this sequence
here, this is at n = 0--
I would take this and multiply
it by this and sum from
-infinity to +infinity.
Or, for n = 1, I would position
it here, for n = 2, I
would position it here.
Well, you can kind of see
what the idea is.
Let's look at this a little more
dynamically and see, in
fact, how one sequence slides
past the other, and how the
output y[n]
builds up to the
correct answer.
So the input that we're
considering is a step input,
which I show here, and the
impulse response that we will
convolve this with is a
decaying exponential.
Now, to form the convolution, we
want the product of x[k]--
not with h[k], but with h[n-k],
corresponding to
taking h[k]
and reflecting it about the
origin and then shifting it
appropriately.
So here we see h[n-k]
for n = 0, namely h[-k], and now
h[1-k], which we'll show
next, is this shifted to
the right by one point.
Here we have h[1-k]--
shifting to the right by one
more point is h[2-k], and
shifting again to the right
we'll have h[3-k].
Now let's shift back to the left
until n is negative, and
then we'll begin the
convolution.
So here's n = 0, n = -1,
n = -2, and n = -3.
Now, to form the convolution,
we want the product of x[k]
with h[n-k]
summed from -infinity
to +infinity.
For n negative, that product is
0, and therefore the result
of the convolution is 0.
As we shift to the right,
we'll build up the
convolution, and the result of
the convolution will be shown
on the bottom trace.
So we begin the process
with n negative, and
here we have n = -1.
At n = 0, we get our first
non-zero contribution.
Now as we shift further to the
right corresponding to
increasing n, we will accumulate
more and more terms
in the sum, and the convolution
will build up.
In particular for this example,
the result of the
convolution increases
monotonically, asymptotically
approaching a constant, and
that constant, in fact, is
just simply the accumulation
of the values under the
exponential.
Now let's carry out the
convolution this time with an
input which is a rectangular
pulse instead of a step input.
Again, the same impulse
response, namely a decaying
exponential, and so we want
to begin with h[n-k]
and again with n negative
shown here.
Again, with n negative, there
are no non-zero terms in the
product, and so the convolution
for n negative
will be 0 as it was in
the previous case.
Again, on the bottom trace we'll
show the result of the
convolution as the impulse
response slides along.
At n = 0, we get our first
non-zero term.
As n increases past 0, we will
begin to generate an output,
basically the same as the output
that we generated with
a step input, until the impulse
response reaches a
point where as we slide further,
we slide outside the
interval where the rectangle
is non-zero.
So when we slide one point
further from what's shown
here, the output will now decay,
corresponding to the
fact that the impulse response
is sliding outside the
interval in which the
input is non-zero.
So, on the bottom trace we
now see the result of the
convolution.
OK.
So what you've seen, then, is
an example of discrete-time
convolution.
Let's now look at an example
of continuous-time
convolution.
As you might expect,
continuous-time convolution
operates in exactly
the same way.
Continuous-time convolution--
we have the expression again
y(t) is an integral with now
x(tau) and h(t-tau).
It has exactly the same kind of
form as we had previously
for discrete-time
convolution--
and in fact, the mechanics
of the continuous-time
convolution are identical.
So here is our example with x(t)
equal to a unit step and
h(t) now a real exponential
times a unit step.
I show here x(t), which is
the unit step function.
Here we have h(t), which is an
exponential for positive time
and 0 for negative time.
Again, looking back at the
expression for convolution,
it's not x(t) that we want,
it x(tau) that we want.
And it's not h(t) or h(tau) that
we want, it's h(t-tau).
We plan to multiply these
together and integrate over
the variable tau, and that gives
us the output at any
given time.
If we want it at another time,
we change the value of t as an
argument inside this integral.
So here we have x(t), and here
we have h(t), which isn't
quite what we wanted.
Here we have x(tau), and that's
fine-- it's just x(t)
with t relabeled as tau.
Now, what is h(t-tau)?
Well, here's h(tau), and
if we simply turn that
over, here is h(t-tau).
And h(t-tau) is positioned,
then, at tau equal to t.
As we change the value of t that
change the position of
this signal, now we multiply
these two together and
integrate from -infinity to
+infinity with h(t-tau)
positioned at the appropriate
value of t.
Again, it's best really to see
this example and get the
notion of the signal being
flipped and the two signals
sliding past each other,
multiplying and integrating by
looking at it dynamically
and observing how the
answer builds up.
Again, the input that we
consider is a step input.
And again, we use an impulse
response which is a decaying
exponential.
To form the convolution, we want
the product of x(tau)--
not with h(tau), but
with h(t-tau).
So we want h(t) time-reversed,
and then shifted appropriately
depending on the value of t.
Let's first just look at
h(t-tau) for t positive
corresponding to shifting
h(-tau) out to the right, and
here we have t increasing.
Here is t decreasing, and
we'll want to begin the
convolution with t negative,
corresponding to shifting
h(-tau) to the left.
Now to form the convolution,
we want the
product of these two.
For t negative, there are no
non-zero contributions to the
integral, and so the convolution
will be 0 for t
less than 0.
On the bottom trace, we show the
result of the convolution,
here for t negative, and for t
less than 0, we will continue
to have 0 in the convolution.
Now as t increases past 0, we
begin to get some non-zero
contribution in the product,
indicated by the fact that the
convolution--
the result of the
convolution--
starts to build up.
As t increases further, we
will get more and more
non-zero contribution
in the integrand.
So, the result of the
convolution will be a
monotonically increasing
function for this particular
example, which asymptotically
approaches a constant.
That constant will be
proportional to the area under
the impulse response, because
of the fact that we're
convolving with a step input.
Now let's carry out the
convolution with an input
which is a rectangular pulse--
again, an impulse response
which is an exponential.
So to form the convolution, we
want x(tau) with h(t-tau)--
h(t-tau) shown here
for t negative.
To form the convolution, we
take the integral of the
product of these two, which
again will be 0
for t less than 0.
The bottom trace shows the
result of the convolution
here, shown as 0, and it will
continue to be 0 until t
becomes positive, at which
point we build up some
non-zero term in
the integrand.
Now as we slide further, until
the impulse response shifts
outside the interval in which
the pulse is non-zero, the
output will build up.
But here we've now begun to
leave that interval, and so
the output will start to
decay exponentially.
As the impulse response slides
further and further
corresponding to increasing t,
then the output will decay
exponentially, representing the
fact that there is less
and less area in the product
of x(tau) and h(t-tau).
Asymptotically, this output
will then approach 0.
OK.
So you've seen convolution,
you've seen the derivation of
convolution, and kind of the
graphical representation of
convolution.
Finally, let's work again with
these two examples, and let's
go through those two examples
analytically so that we
finally see how, analytically,
the result develops for those
same examples.
Well, we have first the
discrete-time case, and let's
take our discrete-time
example.
In general, the convolution sum
is as I've indicated here.
This is just our expression
from before, which is the
convolution sum.
If we take our two examples--
the example of an input which is
a unit step, and an impulse
response, which is a real
exponential multiplied by a
unit step--
we have then replacing x[k]
by what we know the input
to be, and h[n-k]
by what we know the impulse
response to be, the output is
the expression that
we have here.
Now, in this expression--
and you'll see this very
generally and with some more
complicated examples when
you look at the text--
as you go to evaluate these
expressions, generally what
happens is that the signals
have different analytical
forms in different regions.
That's, in fact, what
we have here.
In particular, let's look at the
sum, and what we observe
first of all is that the limits
on this sum are going
to be modified, depending
on where this unit
step is 0 and non-zero.
In particular, if we first
consider what will turn out to
be the simple case--
namely, n less than 0--
for n less than 0, this
unit step is 0 for k
greater than n.
With n less than 0, that means
that this unit step never is
non-zero for k positive.
On the other hand, this unit
step is never non-zero or
always 0 for k negative.
Let me just stress that by
looking at the particular
graphs, here is the
unit step u[k].
Here is the unit step u[n-k],
and for n less than 0, so that
this point comes before this
point, the product of these
two is equal to 0.
That means there is no overlap
between these two terms, and
so it says that y[n],
the output, is 0
for n less than 0.
Well, that was an easy one.
For n greater than 0, it's not
quite as straightforward as
coming out with the answer 0.
So now let's look at what
happens when the two unit
steps overlap, and this would
correspond to what I've
labeled here as interval 2,
namely for n greater than 0.
If we just look back at the
summation that we had, the
summation now corresponds to
this unit step and this unit
step, having some overlap.
So for interval 2, corresponding
to n greater
than 0, we have u[k],
the unit step.
We have u[n-k], which is a unit
step going backward in
time, but which extends for
positive values of n.
If we think about multiplying
these two together, we will
get in the product unity
for what values of k?
Well, for k starting at 0
corresponding to one of the
unit steps and ending at
n corresponding to
the other unit step.
So we have an overlap between
these for k equal to 0, et
cetera, up through
the value n.
Now, that means that in terms
of the original sum, we can
get rid of the unit steps
involved by simply changing
the limits on the sum.
The limits now are from 0 to
n, of the term alpha^(n-k).
We had before a u[k]
and u[n-k], and that disappeared
because we dealt
with that simply by modifying
the limits.
We now pull out the term
alpha^n, because the summation
is on k, not on n, so
we can simply pull
that term of the sum.
We now have alpha^(-k), which
we can rewrite as
(alpha^(-1))^k.
The upshot of all of
this is that y[n]
now we can reexpress as alpha^n,
the sum from 0 to n
of (alpha^(-1)^k.
The question is, how do
we evaluate that?
It essentially corresponds to a
finite number of terms in a
geometric series.
That, by the way, is a summation
that will recur over
and over and over and over
again, and it's one that you
should write down, write on your
back pocket, write on the
palm of your hand, or whatever
it takes to remember it.
What you'll see is it that
will recur more or less
throughout the course, and so
it's one worth remembering.
In particular, what the sum of a
geometric series is, is what
I've indicated here.
We have the sum from
0 to r, of beta^k.
It's 1 - beta^(r+1)--
this is one more than the upper
limit on the summation--
and in the denominator
is 1 - beta.
So, this equation
is important.
There's no point in attempting
to derive it.
However you get to it, it's
important to retain it.
We can now use that summation
in the expression
that we just developed.
So let's proceed to evaluate
that sum in closed form.
We now go back to the expression
that we just
worked out-- y[n]
is alpha^n, the sum from
0 to n, (alpha^(-1))^k.
This plays the role of beta
in the term that I just--
in the expression then
I just presented.
So, using that result, we can
rewrite this summation as I
indicate here.
The final result that we end up
with after a certain amount
of algebra is y[n]
equal to (1 - alpha^(n+1))
/ (1 - alpha).
Let me just kind of indicate
with a few dots here that
there is a certain amount of
algebra required in going from
this step to this step, and I'd
like to leave you with the
fun and opportunity of doing
that at your leisure.
The expression we have
now for y[n], is y[n]
= (1 - alpha^(n+1))
/ (1 - alpha).
That's for n greater than 0.
We had found out previously
there it was 0
for n less than 0.
Finally, if we were to plot
this, what we would get is the
graph that I indicate here.
The first non-zero value occurs
at n = 0, and it has a
height of 1, and then the next
non-zero value at 1, and this
has a height of 1 + alpha, and
this is 1 + alpha + alpha^2.
The sequence continues on like
that and asymptotically
approaches, as n goes to
infinity, asymptotically
approaches 1 / (1 - alpha),
which is consistent with the
algebraic expression that we
have, that we developed, and
obviously of course is also
consistent with the movie.
That's our discrete-time
example, which we kind of went
through graphically with the
transparencies, and we went
through graphically with the
movie, and now we've gone
through analytically.
Now let's look analytically at
the continuous-time example,
which pretty much flows
in the same way as
we've just gone through.
Again, we have the convolution
integral, which is the
integral indicated at the top.
Our example, you recall, was
with x(t) as a unit step, and
h(t) as an exponential
times a unit step.
So when we substitute those in,
this then corresponds to
x(t) and this corresponds
to h(t-tau).
Again, we have the same issue
more or less, which is that
inside that integral, there
are two steps, one of them
going forward in time and one
of them going backward in
time, and we need to examine
when they overlap and when
they don't.
When they don't overlap, the
product, of course, is 0, and
there's no point doing any
integration because the
integrand is 0.
So if we track it through, we
have again Interval 1, which
is t less than 0.
For t less than 0, this unit
step, which only begins at tau
= 0, and this unit step which is
0, by the time tau gets up
to t and beyond.
For t less than 0, there's no
overlap between the unit step
going forward in time
and the unit step
going backward in time.
Consequently, the integrand is
equal to 0, and consequently,
the output is equal to 0.
We can likewise look at the
interval where the two unit
steps do overlap.
In that case what happens again
is that the overlap, in
essence of the unit step, tells
us, gives us a range on
the integration--
in particular, the two steps
overlap when t is greater than
0 from tau = 0 to tau = t.
For Interval 2, for
t greater than 0--
again, of course, we have
this expression.
This product of this unit step
and this unit step is equal to
1 in this range, and so that
allows us, then, to change the
limits on the integral--
instead of from -infinity to
+infinity, we know that the
integrand is non-zero only
over this range.
Looking at this integral, we
can now pull out the term
which corresponds to e^-at, just
as we pulled out a term
in the discrete-time case.
We notice in the integral that
we have e^(-a*-tau), so that
gives us the integral from
0 to t of e^(a*tau).
If we perform that integration,
we end up with
this expression.
Finally, multiplying this by
e^-at, we have for y(t), for t
greater than 0, the algebraic
expression that I've indicated
on the bottom.
So we had worked out t
less than 0, and we
come out with 0.
We work out t greater than 0,
and we come out with this
algebraic expression.
If we plot this algebraic
expression as a function of
time, we find that what it
corresponds to is an
exponential behavior starting
at zero and exponentially
heading asymptotically toward
the value 1 / a.
We've gone through these
examples several ways, and one
is analytically.
In order to develop a feel and
fluency for convolution, it's
absolutely essential to work
through a variety of examples,
both understanding them
graphically and understanding
them as we did here
analytically.
You'll have an opportunity to
do that through the problems
that I've suggested in the
video course manual.
In the next lecture, what we'll
turn to are some general
properties of convolution, and
show how this rather amazing
representation of linear
time-invariant systems in fact
leads to a variety of
properties of linear
time-invariant systems.
We'll find that convolution is
fairly rich in its properties,
and what this leads to are some
very nice and desirable
and exploitable properties of
linear time-invariant systems.
Thank you.
