-DwGrJ8JxDc.txt

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.

PROFESSOR: The things we
can talk about today, we

can talk about this code.

We can talk a little bit more
about the hash functions.

And we can talk a little
bit more about amortization.

What to do guys want to hear?

AUDIENCE: Amoritizaiton.

PROFESSOR: OK, so one
vote for amortization.

So who wants to look
at the PSET code?

Who wants to talk about hashes?

Who wants to talk
about amortization?

Two, three, four, five, OK.

So then let's try this.

Let's look at the PSET code then
talk about amortization a bit

at the end.

I do have to talk a
little bit about hashes

though, because I owe someone
a question from last time.

And the question was,
we have rolling hashes,

so the hashes look like this.

K where K is a big
number, modulo p.

And we argue that it's
really nice if p is a prime.

And then the question was, what
if instead p is 2 to the w,

and is not prime, as long
as the base that we're using

is co-prime with p?

Does this work?

And the answer
is-- I didn't want

to say yes without making sure
that I don't say something

stupid-- but the
answer is yes, this

works just fine, because the
way a compute multiplicative

inverse is is you
use so something

called the extended
Euclid's method.

And if we have b and p, then
if we compute their GCD,

the that's the greatest common
divisor-- so GCD is greatest--

If you use extended Euclid you
get something like xb plus yp

equals GCD of b and p.

So if this is 1, then you
have xb plus yp equals 1.

And if you're working
modulo p, whatever that is,

then you have that
xb is 1 mod p.

So there's your
multiplicative inverse.

Well so now that's
nice math, right?

But that doesn't tell me
why are we not using this.

So with the multiplicative
inverse would work,

but there's
something else that's

wrong with using 2 to the w.

Will this give me a
good hash function?

OK, the fact that it's
p might be confusing.

So let's say h equals
K mod 2 to the w.

And remember that the K is
some digits in base b, right?

It's a big number made
out of digits in base b.

So K is d1, d2, d3, all the way
up until d length in base b.

And I'll make things easier
and say that b is 2 to the 8,

because we're working with
ASCII characters, or colors,

or something that
fits nicely in a bit.

So what could go
wrong with using this?

AUDIENCE: Well if your series
of-- if your K is bigger than

2-- if it's K is bigger
than 2 to the w--

PROFESSOR: It will be, for sure.

AUDIENCE: Yes, that's the
problem, because then you'll

loop.

You'll get the same hashes for--

PROFESSOR: Yeah, yeah.

So you will get-- So hashing
takes a lot of possible inputs

and maps them to a relatively
small set of outputs.

Inputs hash output.

And we argued last
time that we're

going to have collisions
no matter what,

because we have a ton of inputs
and not that many outputs.

For example, if
we're hashing strings

that are a million
characters then this

is going to be 2 to the 8 to
the 1 million possible strings.

And then the number
of possible values

is, if we're using the
word size, 2 to the 32.

There is no way we can
design a function that

will take this many inputs,
map them to this many outputs,

and not do collisions.

But instead, what do we want?

What makes a good hash function?

Say my hash function
is 0 for all the K's.

Is that a good hash function?

AUDIENCE: It's an
excellent hash function.

PROFESSOR: What's wrong with it?

AUDIENCE: You would
put everything in one

so that it's searching, or
it would take a long time?

PROFESSOR: Yeah, searching
takes a long time.

And we've don't do
sorting with this yet.

Searching takes a long
time, string sub-matching

will take a long
time, it's horrible.

AUDIENCE: So what
would that distribute--

like [INAUDIBLE] over all--

PROFESSOR: All right,
so we want something

that looks sort of random.

The ideals hash function
takes an input then

gives it a random output,
and then stays consistent.

So when it sees an input,
returns the same output.

So I think distribute
is the keyword here.

What's wrong with
this hash function?

If it takes random
data, it's going

to distribute it randomly.

That's true, so that's all good.

But what data that we
might see in real life

will make it behave badly?

AUDIENCE: The K is a series
of characters, right?

PROFESSOR: Maybe.

AUDIENCE: It just
could be anything.

But we know for sure that
L will be larger than w.

PROFESSOR: Say L is a million.

AUDIENCE: OK, well that sucks.

PROFESSOR: Oh, no.

That in itself,
that doesn't suck.

That's what let's us do
sub-string matching really

fast, even if we
have large strings.

AUDIENCE: --say for
2 to the w, though,

because then it will be much
larger, like the number of--

PROFESSOR: Yeah, but that's OK.

So I'm OK with doing this as
long as all the values here

are distributed sort
of uniformly here.

So that's fine.

AUDIENCE: OK.

PROFESSOR: But there's-- I'm
arguing that there are some

values which will make this
hash function behave badly.

And that those values are so
simple that we might see them

in real life.

OK, what if all these
numbers are-- what

if all the digits are even?

So d is 0 mod 2.

What happens to K?

AUDIENCE: Well, you're saying
that instead of 2 to the w,

we're just using 2.

PROFESSOR: So no, the
modulo is 2 to the w.

Say it's 2 to the 32.

So d are the digits that
make up my K. So what

if the base is 2 to the 8?

So I have digits from
0 to 255, 256 of them.

And all the digits
are 0 modulo 2.

For my sub-string
matching example,

what if all the characters
in the sub-string are even?

AUDIENCE: [INAUDIBLE]

PROFESSOR: Not the same thing.

But there's a problem.

They will hash to-- so
if all the digits are

0 modulo 2 then
what about the K?

AUDIENCE: [INAUDIBLE]
0 modulo 2--

PROFESSOR: Yep.

So it's just like when you
have numbers in base 10.

10 happens to be divisible by 2.

So if your last digit is even,
then the entire number is even.

That makes sense, right?

That's math.

Please nod, tell me
that I'm making sense.

OK, so here, the base is 256.

And it's also divisible by 2.

So if your last digit
is divisible by 2,

then the whole number
is divisible by 2.

So then if I take this
K modulo 2 to the 32

then the hash is also
going to be divisible by 2.

AUDIENCE: Why does it matter
if the hash is divisible by 2?

PROFESSOR: So it
matters because this

is supposed to be
my universe, right?

These are supposed to
be all the outputs.

And I'm saying that if
my inputs look like this,

then the hash function will
not distribute them uniformly.

Instead, if this is my
possible set of outputs,

the hash function will always
put outputs in this half.

So the outputs will
always be here.

And these are the numbers
that are divisible by 2.

So these are even,
and these are odd.

And this area gets no love.

Absolutely no number
will hash here.

So--

AUDIENCE: Wait, what about
something with all odds?

AUDIENCE: Something
with all odd digits?

AUDIENCE: Because
you're asking--

AUDIENCE: You have
all A's rather than

all B's in your sub-string
or in your string.

AUDIENCE: Or because
your last digit was odd.

PROFESSOR: If all of
our digits are odd

then the last digit is odd.

And then you'd also get
something odd, right?

AUDIENCE: Yeah.

AUDIENCE: So there's a pattern.

But there's an
even distribution.

PROFESSOR: Well if your
hash function is always odd,

then it's not an
even distribution.

It's--

AUDIENCE: Wait,
our hash function?

I thought we were
talking about--

AUDIENCE: Isn't it
even if your K is even?

And if it's odd [INAUDIBLE]?

PROFESSOR: Yeah, so that's bad.

Because if all your K's
happens to be even--

say if you're doing
the nucleotides,

and the nucleotides
are A, C, G, T.

If they happen to be
encoded as, say, 0, 2, 4, 6,

then these are all even.

So the hash function
will always be even

and I'm wasting the last bit.

So if I'm building a hash
table, half the entries

will be wasted.

They'll never get
anything in there.

I'm just wasting memory.

AUDIENCE: So if
you could guarantee

that your inputs would
be evenly distributed--

PROFESSOR: So if our
inputs are random

then the hash function--
most hash functions will

do a good job of
producing a random output.

The problem is real life
inputs are not random.

For example, if you
get-- asides from this--

if you get data from a camera,
so if you get your color pixels

from a camera, then
because of noise those

might have the last few bits,
always be the same thing.

Also it seems like in
real life-- [INAUDIBLE],

in his book, argues about this.

It seems like in
real life there are

a lot of sequences that look
like that, that would make

your hash function
behave poorly.

So again, the keyword
is distribute.

If some non-random
property in the input

is reflected in the output,
then that's a bad hash function.

AUDIENCE: Would you
gain a lot of time

from your mod operation?

Because in mod 2 to the n
you just truncate any bits

to the left of the n.

PROFESSOR: Yeah, so that's
why we would do this, right?

That's why we're even
considering this case.

AUDIENCE: Because that'd be
really nice to be able to not--

PROFESSOR: So modulo is faster,
but in return my hash function

is crap here.

So usually we prefer-- it turns
out that in practice nicer hash

functions give better
speed improvements overall.

So if you think of how a
hash is laid out in memory,

you'll see that
because of caching.

And everything gets better
to take more time on the mod

function and use up all your
memory for the hash table.

So this is why we don't
use the and we use this.

Not because of this argument.

So a good question required a
lot of talking and remembering

what's a good hash function,
what's a bad hash function.

Thank you.

OK, let's look at the
code a little bit.

Everyone looked at it, right?

So this time we have modules.

We don't have everything
in one big file.

Can someone tell me what are the
modules we care about, and why?

AUDIENCE: The problem
with the one's

we have to code ourselves.

PROFESSOR: OK, let's
start with that.

AUDIENCE: Sub-sequence hashes--
interval sub-sequence hashes.

PROFESSOR: OK, so these
are all in DNA seq, right?

So the module is-- so
yeah, the PSET hopefully

says that you need to upload
this file because it's

the only file you'll
need to modify.

So everything that we
need to write is here.

Now pretty much everything
that's in that file

needs to be modified.

So I'm not going
to list them out.

What else do we want
to read in that PSET?

AUDIENCE: Rolling [INAUDIBLE]

PROFESSOR: OK, where
is rolling hash?

AUDIENCE: In the [INAUDIBLE]

PROFESSOR: So what's different
between the API in rolling hash

and the API that we
talked about last time?

Yes?

AUDIENCE: Them having
the [INAUDIBLE] pop,

or it would skip.

And that's something else
[INAUDIBLE] just has a slide,

it puts everything
in one operation.

PROFESSOR: All right, so
we have append and skip.

And we built some
beautiful code with that.

And we looked at some
fancy math because of it.

But it turns out
that for this PSET

we can get away with slide.

And we started from slide
and built these two methods

last time.

So I'm not going to
explain slide again.

It's exactly what
we had in the code

before we started
breaking them up.

OK so this is the rolling hash.

It is good.

Do we care about anything else?

AUDIENCE: I guess you can
look at the rest of the code,

if you feel like it.

PROFESSOR: You can look
at the rest of the code

if you feel like it, yep.

So I highlighted one file
that might be useful,

and that's Kfasta.py.

That file has a
FASTA sequence class,

and that's reads from a
file and returns something.

And the important thing is
it doesn't return a list.

If you remember the doc
dists, doc dist 1 thorugh doc

dist 8 dot PI, fun times.

What we had there was
we took the input file,

and we read it all a list.

This time we're not doing that.

We're writing, what, 20
lines of code instead of what

could be five lines of
code to read the input.

Why is that?

AUDIENCE: Less memory?

PROFESSOR: Less memory, OK.

So if we're doing
it this way, chances

are that if we tried to shove
the whole input into memory,

it wouldn't fit.

And it would crash
and you would get 0

on the test because of that.

So that's not good.

So what do we use instead?

Does anyone know what
this thing is called?

What this class is called?

AUDIENCE: [INAUDIBLE]

PROFESSOR: Iterator, very good.

AUDIENCE: Why do
they call it FASTA?

Because it goes faster?

PROFESSOR: I think the
letters are a bio acronym.

AUDIENCE: Oh, OK.

PROFESSOR: Does anyone,
does anyone do bio here?

I've seen that before.

So it's a bio thing.

Let's not worry about it.

AUDIENCE: OK.

Or, your can use that
for any type of file.

Like, you don't have to
use it just for bio files.

PROFESSOR: Well,
presumably it's reads,

it takes advantage of the
format that they're stored in,

and gives you a list
instead of something else.

So how does an iterator work?

Suppose you're building
your own iterator.

What do you have to implement?

AUDIENCE: Iterator [INAUDIBLE]

PROFESSOR: OK, let's start
with next, that's the fun one.

What does next do?

AUDIENCE: It's like pop.

PROFESSOR: OK, so it's
like pop in what way?

AUDIENCE: It gives you
the next character.

PROFESSOR: OK.

And what happens when you're
at the end of the list?

AUDIENCE: It stops.

PROFESSOR: How do you stop?

AUDIENCE: It raises
an exception?

PROFESSOR: So next will
either return an element,

that's the next
element in the sequence

that you're iterating over.

Or it will raise a stop
iteration exception

error to stop iteration, cool.

So what's the other method?

Someone said it
before, say it again.

AUDIENCE: Iter.

PROFESSOR: Iter.

What does this do
in an iterator?

AUDIENCE: It returns itself.

PROFESSOR: All right, very good.

In an iterator this is how you
will implement it all the time.

Does anyone know what's
the point of iter?

AUDIENCE: So you can
return an iterator?

Because that's what it
told us to do in the PSET.

PROFESSOR: OK, so iter
returns and iterator.

But it doesn't-- you don't
have to start from an iterator.

You can start from any object.

And if it has a
method iter, then it

should give you an iterator
that iterates over that object.

So if you have something like
a list-- 1, 2, 3, 4-- then

if you call iter on this,
you'll get an iterator for it,

hopefully, right?

And this is what Python
uses when you say for i in.

So behind the scenes, whatever
object you give it here,

gets an iter call.

And then that
produces an iterator.

And then Python calls next
until stop iteration happens.

So you can write
an iterator that

almost behaves like a list.

You can use it in these
[INAUDIBLE] instructions,

and it works as
if it was a list,

except it uses a lot less
memory, because it computes

the elements.

Hopefully every
time next is called,

you're computing the next
element that you're returning.

If you're storing everything
in a list then returning

the elements that way, that's
not the very smart iterator.

OK let's look at the last page.

So the last page has
an iterator on top.

And the iterator
computes-- given a list,

it computes the
reverse of that list.

And you can see that it
doesn't reverse the list

and then keep the
reversed list in memory.

Instead, every
time you call next,

it does some magic
with the indexes--

I think the magic
is called math--

and then it return something
for as long as it can.

So this is how you
implement reverse

without producing a new list.

If the original list was
order, say had n elements, then

if you'd produce a new list,
you'd consume order and memory.

This think consumes
order 1 memory,

and the running time is
the same, asymptotically.

OK, any question on iterators?

AUDIENCE: So it's going
from the very end,

oh, to the very beginning,
and then it's stepping back.

PROFESSOR: So
reverse, if I give it

the list 1, 2, 3, 4, I want
reverse to give it back 4, 3,

2, 1.

Except it's not going
to return a list,

it's going to return
something that I can use here.

AUDIENCE: Mm hm, ah, OK.

PROFESSOR: OK, yes.

AUDIENCE: Is it ever
possible to, sort of,

rewind the iterator to
like, sort of, reset it?

PROFESSOR: OK, is it?

AUDIENCE: No.

PROFESSOR: Nope.

So Python iterators are simple.

All you can do is go forward.

AUDIENCE: OK.

PROFESSOR: The reason
that is good is

because you can use
them for streams.

So if you get data from a
file, or if you can get data

from the network, you can
wrap it in an iterator.

If you wanted to support
resume on data that you

get from the network, you'd
have to buffer all the data.

AUDIENCE: So you
would have to call

the iter about that again and--

PROFESSOR: Yeah.

Yeah, if you want to rewind,
get another iterator.

OK, that's a good
question, thank you.

So these are iterators.

Now we're going to go over
some Python magic, which

is called generators.

So look at the iterator
code, and then look

at the equivalent
code right below it.

So 12 lines of Python turned
into three lines of Python

that do exactly the same thing.

So the reverse method
will return an object

that is an iterator, and
that you can use just

like the iterator in
the reverse class.

Do people understand
what that code does?

If you do I'm so out
of here, we're done.

AUDIENCE: What does yield do?

PROFESSOR: What does yield do?

All right, that's the hard
question, what does yield do?

I will probably spend the rest
of the session on the answer

to that question.

You're asking all the
had questions today, man.

So yield, does anyone know
conceptually what yield does?

Not in detail, just
what's it supposed

to do so that the rest
of the code works?

Yes.

AUDIENCE: If you're
driving someplace

and there's a yield
sign, you pause.

PROFESSOR: OK, Python yield.

So I like the word
pause in there.

The word pause is useful.

So say, instead of
implementing this,

say we're implementing
sub-sequence hashes.

AUDIENCE: It kind of spit
something out, but keeps going.

PROFESSOR: Yep.

AUDIENCE: Returns [INAUDIBLE]

PROFESSOR: OK, so suppose
you're implementing

sub-sequence hashes.

What's the worst, worst possible
way you could implement this?

AUDIENCE: Return a list.

PROFESSOR: OK, so the worst,
worst way is to go all the way,

brute force, don't use
the rolling hashes,

don't use anything.

The next best way is
to make a list, right?

So you're going to start
with an empty list.

Then you're going to use the
rolling hash in some way.

And in some loop you're
going to say list.append e.

And then you're going
to return the list.

Does this makes sense?

OK, what's the problem
with this code?

AUDIENCE: You're going
to have a huge list.

PROFESSOR: Going to
have a huge list.

So the way we fix it with
iterators is we remove this,

we replace this with yield
e, and we remove this.

And now it's a generator.

And now this consumes a
constant amount of memory,

instead of building a list.

And as long as you only want
an iterator out of this method,

you'll get the right thing.

Your code will still work
in exactly the same way.

OK, so the big question is
what does this guy do, right?

This is where the magic is.

So I already said,
as a first hint,

that this guy will
return an iterator.

So can someone try to imagine
their Python, and see this?

So suppose it's your
Python, you see this.

What do you do?

AUDIENCE: You wait for some sort
of command of some sort, right?

PROFESSOR: No, let's
try something else.

AUDIENCE: OK.

PROFESSOR: So the
execution of this pauses.

What happens?

So we're looping
somewhere, we got a yield.

We stop, what's the
first thing we do?

AUDIENCE: Spit out e.

PROFESSOR: So you're saying
you return e from this guy?

AUDIENCE: [INAUDIBLE]
out e [INAUDIBLE]

PROFESSOR: So I want
to return something--

I want to return
something else from this.

So I want to use this as
if it was a list, yes?

AUDIENCE: We store e somewhere.

PROFESSOR: OK,
store e somewhere.

AUDIENCE: Do you return
the pointer of e?

PROFESSOR: Almost, so
there's a word for the object

that I'm returning.

So I want to use it
as if it was a list.

So I want to pretend that I had
returned list in this method,

right?

So what's the closest thing
to a list that I can return.

AUDIENCE: An iterator.

PROFESSOR: An iterator,
thank you, all right.

So we will grab some
information from here.

We'll put it in a nice box.

And that box will
behave like an iterator.

OK, so the first thing,
someone said put e away,

so that's when we call next
we're going to spit that out.

What else do I need to put away?

AUDIENCE: [INAUDIBLE]

PROFESSOR: Yep, so
this is a lot of magic.

This tiny box actually
has a lot of magic in it.

Because when I call
next, I want to get e.

But I want to come back
here and keep going, right?

So I have my code that's
using the iterator.

And there's this code
here, that's sort of

in a frozen state.

Did you guys see any movies
where people are frozen up

and then, in the
future, they're unfrozen

and they start moving again?

AUDIENCE: [INAUDIBLE] movies.

PROFESSOR: All right, cool.

So this is like that, this
takes up the whole function,

freezes it up and
puts it in a box here.

And it returns an iterator that
can use the box in the future.

So when you call
next, it gives e,

which is the guy
that you put in here.

And then it take the
function out of the box,

unfreezes it, and
lets it run again

until it hits yield again.

Then what happens the
next time it hits yield?

So, you're looping, and
you're yielding again.

And say this time
you're yielding.

AUDIENCE: Just do
the same thing?

AUDIENCE: Do you put
it in that iterator?

Or do you make another iterator?

PROFESSOR: Same iterator.

So while this is
looping, the code outside

should get the values
that it's yielding.

So this has to behave
as one iterator.

So the code is
unfrozen, it's allowed

to execute until it
says yield again.

And then it says yield
with a new element.

I put this guy in the box.

Then I return the old guy as
the return value for next.

AUDIENCE: Oh.

PROFESSOR: And then
it's frozen again.

So this guy's still
in a frozen state.

In the movies, I think
you're only unfrozen once.

And then you keep going, right?

And there's a happy ending.

Where here, every
time you call yield

you're frozen again,
until someone calls next.

Does this make sense?

AUDIENCE: It's kind
of like Groundhog Day.

PROFESSOR: Yes, except
you're allowed to go forward.

So this keeps going forward.

AUDIENCE: --up, thought.

So it's looping.

It's the same day, really.

It's doing different
things, though.

PROFESSOR: Yeah.

But all your state is saved.

So there, some of the
state is rolled back.

Here all the state is saved.

AUDIENCE: OK.

PROFESSOR: OK, but if that
analogy helps, keep it.

AUDIENCE: When you call
next, are you computing e

or e prime to be returned?

PROFESSOR: So when
you're calling next,

you're computing e
prime and returning e.

AUDIENCE: So the value you
get from next is pre-computed?

PROFESSOR: So the value
you get form next is

what you yielded before.

AUDIENCE: Wait, so you would
just take some sequence hashes

instance of that, and then
just by putting in yield,

now it's magically
become an iterator

and you can call
that next on it?

PROFESSOR: Yep.

And inside, you don't have to
know that it's an iterator.

So you don't have a
method next here, right?

I don't implement
next or iter here.

I write this as if it's
printing stuff to the output.

You can think of
yield is a print.

If you wanted an
iterator, then pretend

you're printing what you
want to iterate over.

And instead of saying
print you say yield.

And then you use that.

OK, now what happens
when we're done?

What happens when
this loop is done

and you return from this method?

We said there's no return value.

AUDIENCE: It raises a stop?

PROFESSOR: So when
we return, it's

going to keep in-- have to
remember that it's done, right?

And the first time, it
has some element here

that it has to return.

So every time you call yield we
put a new element in the box,

and return the old one.

So now we would
return the old one.

We've returned e prime, take it
out, and put done in the box.

So in the future, if
next is called again,

raise stop iteration.

No more freezing, unfreezing,
because we're done.

We're returned.

AUDIENCE: So if you called next
it would just give you nothing?

PROFESSOR: It has to
raise this exception.

AUDIENCE: So you mean,
like-- oh, so it-- oh, I see.

It would give you red text then?

PROFESSOR: If you
called it directly, yes,

it would give you red text.

Yes?

AUDIENCE: So this takes
a sequence or a list,

not another iterator, ever?

PROFESSOR: This?

What's this?

This other code here?

AUDIENCE: Yeah.

PROFESSOR: Not necessarily.

AUDIENCE: Or you could
give it a procedure.

PROFESSOR: I can
give it an iterator

if I'm iterating
over it using for-in.

AUDIENCE: Like, for something
in one iterator, yield

that something, and
then [INAUDIBLE]

AUDIENCE: Oh, OK.

PROFESSOR: Yeah,
that's a good point.

I'll get to that
later, when we talk

about how we're going
to solve the PSET.

No, we're not solving
the PSET for you.

But we'll talk about
it a little bit.

But yeah, that's a good point.

So there's no
reason why you can't

have an argument here that,
either a list or an iterator,

and then you're
iterating over it.

And then you have
nested generators.

So you have generators
returned in other generators,

and you have a whole
chain of things

happening when you say next.

AUDIENCE: Wait, so this
is a generator then,

because it produces-- well
it is an iterator though?

PROFESSOR: So a generator
returns an iterator

from this method.

So a generator acts
like an iterator,

except when you call next,
it unfreezes this code here,

and it let's it run.

AUDIENCE: But I mean, it's
basically an iterator then?

PROFESSOR: Yeah.

AUDIENCE: But we're just
calling it a generator because--

PROFESSOR: Because
there's a lot more magic.

AUDIENCE: OK.

PROFESSOR: So an iterator
just says next and iter.

This is all that an
iterator is, nothing more.

Any object that has these
two methods is an iterator.

AUDIENCE: Oh, OK.

PROFESSOR: Now a generator
is a piece of Python magic

that let's you write
shorter iterators.

So three lines, as
opposed to 13 lines.

And we came up
with a way to turn

in a code that
would build a list,

and easily turn it into a
code that uses a generator,

and that uses constant memory
instead of building that list.

AUDIENCE: OK, now I know
how an iterator functions.

PROFESSOR: Exactly.

OK, do generators
make sense now?

Yes.

AUDIENCE: If you wanted
to loop through all

of the values in a
generator, do you just

wait until the
exception's raised?

Or should you, like, keep
track of how many things

are going to be
in that generator?

PROFESSOR: So, when
you have a generator,

you'd have no idea how
many things there are.

That's a good point.

So you're wondering if I have
an iterator, say any iterator,

not necessarily a generator, how
do I know how many things it's

going to return, right?

Do I have ln?

I do not have ln.

So an iterator does not have ln.

So you have to
iterate through it.

And most importantly, some
iterators can never return.

So you can have an iterator
that streams data for you

across the network.

Or you can have an iterator
that iterates over the Fibonacci

numbers.

That's an infinite
sequence, right?

It's never going to end.

So ln would not even
be defined then.

Good question, I like it.

AUDIENCE: Is there an is-next
method for either iterators

or generators?

PROFESSOR: Nope.

This is what you get,
if there is no in.

AUDIENCE: If that
is mature then--

PROFESSOR: Yeah.

So in Java you have
this belief that you

shouldn't get exceptions.

You should be able to
check for them, right?

So maybe that's
why you're asking.

So if people coming from Java
know that any time a method

raises an exception,
there should

be another method that tells
you whether this first method is

going to raise an
exception or not.

In Python the exception
is just raised.

So exceptions are not
a lot more expensive

than regular instructions,
because we're

using an interpreted
language, and it's already

reasonably slow.

So it can do exceptions
for free, yay.

So this is how it works.

This is how for-in works.

Every time you do a for-in,
an exception is raised.

AUDIENCE: We don't have
to catch that, then?

PROFESSOR: Nope, the
for-in catches it for you.

AUDIENCE: That's tricky stuff.

PROFESSOR: But it's
nice because then you

can build any iterator
that acts like a list.

And then you can do
even more fancy stuff,

and build a generator.

And you're using constant memory
instead of order and memory

for producing an
order and size list.

Yes?

AUDIENCE: So if we get
passed in an iterator

and then just yielded
what we passed in, yielded

the iterator, would
that just, essentially,

delay everything by one?

PROFESSOR: So you're yielding
the iterator as next, right?

AUDIENCE: What?

Yeah.

PROFESSOR: You want to
yield the iterator as next.

Because if you yield
the iterator object,

you're going to return
that object every time.

So you're thinking
of something that--

AUDIENCE: So you
need to increase--

PROFESSOR: You'll
yield up next, right?

AUDIENCE: Right.

PROFESSOR: You can have a method
that says this is the method.

And then you take
in an iterator.

And then you yield it up next.

But then you'll, basically,
get the same thing.

AUDIENCE: The same thing.

But is it delayed by one or no?

PROFESSOR: Nope.

No, so you have to
work through this

to convince yourself
that it's not delayed.

So if it would be
delayed by one,

what's the first thing
that you're yielding.

AUDIENCE: I don't know.

PROFESSOR: Yeah, so no delay.

AUDIENCE: OK.

PROFESSOR: OK, cool.

So let's see, what do
we have to implement

in DNA seq, sub-sequence hashes.

Do people have an idea of
how to implement that now?

Yes?

Does it make sense for everyone?

So you build it as if
you were building a list,

and then you use
yield to make it fast.

And by fast I mean less memory.

OK, how about interval
sub-sequence hashes?

The one below.

AUDIENCE: Is that just
like rolling hash,

except you, like, have
a step in your range?

PROFESSOR: OK, so it's like
having a step in your range.

So how can you do that?

What's one way of doing it?

AUDIENCE: [INAUDIBLE] hashes?

PROFESSOR: Did anyone
solve the PSET yet?

Yes, OK how did you guys do it?

Wait, no.

That's a bad question because
you guys can answer too much.

So interval sub-sequence hashes
versus sub-sequence hashes.

Did you copy paste the code?

AUDIENCE: Absolutely.

PROFESSOR: OK, so one
way of doing it is copy

and pasting the code.

The problem if you copy
paste the code is then you're

not DRY.

There's this engineering
thing-- DRY means do not

repeat yourself.

So if you're not DRY,
if you copy paste,

then suppose you
find the bug later.

Suppose you run the big test
and it crashes somewhere.

And you fix a bug in
sub-sequence hashes.

AUDIENCE: Oh, we're
supposed to, like,

call sub-sequence hashes from
interval sub-sequence hashes,

right?

PROFESSOR: That's another
way of doing it that is DRY.

So this way you're not
copy pasting the code.

AUDIENCE: We're
inlining the code.

PROFESSOR: You're inlining
it manually, right?

All right.

So the problem, if you
do this on a large scale,

like when you go
work somewhere, is

that you end up with 20
copies of the same code.

And then five of them have
bug fixes and the other 15

don't, because people
forgot where they are.

So ideally, try to
keep your code DRY.

AUDIENCE: So, basically,
a list of tuples, right?

PROFESSOR: OK, so
a list of tuples.

What does a tuple have?

AUDIENCE: The index at which
the sub-sequence operates?

PROFESSOR: So two
indexes, right?

The index in the first
sub-sequence, say--

AUDIENCE: [INAUDIBLE]

PROFESSOR: OK, say i1 and then
the index in a second sequence,

for the same
sub-sequence, r right?

And then i1, i2 prime, i1, i2
second, so on and so forth.

So you have the
same sub-sequence

in the first sequence matches
more things in the second one.

This is how you're
supposed to return them.

AUDIENCE: Does the order matter?

PROFESSOR: I hope not.

OK, any questions on this?

We went through generators fast.

You guys are smart.

Yes?

AUDIENCE: Can you explain
how the imaging works?

Like, how they create the
[INAUDIBLE] on tuples.

PROFESSOR: No.

[LAUGHTER]

PROFESSOR: Sorry, I do not know.

AUDIENCE: Wait, which part?

AUDIENCE: So we
yield the tuples.

But I don't really get how they
come up with the image from it.

AUDIENCE: From the tuples?

Oh, I mean, I guess
they're probably values.

AUDIENCE: Yeah,
because I thought

if you compared two strings of
DNA that had the exact same,

I thought it would be
like a diagonal line down,

not just a small black box.

PROFESSOR: OK.

AUDIENCE: So I don't
think I'm understanding

how they, like, image it.

PROFESSOR: So you're
supposed to get--

your image has some
things here, and a match

is going to give you a
big diagonal line that's

stronger than
everything else, right?

AUDIENCE: It's
really fanned out.

PROFESSOR: Well I
don't have thin chalk.

AUDIENCE: No, no, there's like
one really dark black box,

that's like really black.

So I thought that meant that
all the tuples are there,

and everything else
is just kind of gray.

PROFESSOR: Good question.

I will have to
think about that--

AUDIENCE: --supposed
to be there.

Is it like a
notation thing, or--

PROFESSOR: I think that black
box is supposed to be there.

Did anyone try comparing
two things that

shouldn't match, like
the dog and the monkey?

AUDIENCE: Yeah.

And the entire
thing was like dark.

PROFESSOR: Yeah.

AUDIENCE: --against, like,
two same DNAs everything

was very light.

And there was like a very,
very light gray line.

But I thought that
would be like black.

PROFESSOR: So I think
how black it is means

relative to all the
sub-sequences, how long it is--

how long the sub-sequence
you're recording is.

Either that or how many.

There is a function
somewhere in there

that computes the intensity
of a pixel, that's

square root of order
4 of something.

OK, and I can look at
that now and tell you.

AUDIENCE: It's OK.

It's not super important.

PROFESSOR: Or we can talk about
amortized analysis for a bit.

Yay!

Let's talk about
amortized analysis.

So this is what you're supposed
to get, that's what matters.

AUDIENCE: [INAUDIBLE]

PROFESSOR: OK, so
amortized analysis,

what's the example that
we talked about in class?

AUDIENCE: It's like
list expansion?

PROFESSOR: OK, so you
have-- you have a list.

And we know that the list is
stored as an array, right?

So this means that you can
do indexing in constant time.

So if you want to get the
first element, order 1.

If you want to get the
millionth element, order 1.

This is not true if you
had a link list instead.

The millionth element
would be order a million.

So this is an array.

What do we implement?

What's the operation that
we implement on this list?

AUDIENCE: Insert--

PROFESSOR: Insert, append, push.

Let's go for append, because
that's what Python calls it.

OK, so append puts an element
at the end of the list, right?

So how does append work?

AUDIENCE: The array is not full.

PROFESSOR: OK.

So say I have some
count variable here.

So if the length of the
array is bigger than count

then what do I do?

AUDIENCE: Then we
can directly insert.

And because we're
looking up in an array

and we're doing constant time.

PROFESSOR: OK.

AUDIENCE: And so an order
amount of information

in x [INAUDIBLE]?

PROFESSOR: Sorry?

AUDIENCE: Order amount of
information of x [INAUDIBLE]?

Or do we just--

PROFESSOR: Let's say
this is our reference,

so it's constant time.

AUDIENCE: Otherwise we don't
have enough room in our array.

So we need to make it bigger.

PROFESSOR: OK.

So we have array 2
becomes new array

of size 2 times count, right?

Copy everything from--

AUDIENCE: --length of the array.

I guess they're the same.

PROFESSOR: I hope
they're the same.

AUDIENCE: It is.

PROFESSOR: Yeah, I'd say that.

So copy from array to--
let's do this-- to array 2.

And then array 2 becomes array.

And then this code
here goes here, right?

So there's a better way
to write this if statement

so the code isn't duplicated.

OK, so if the length is bigger
than how many elements I have,

if I still have room in
the array, what's the cost?

What's the running time?

Constant.

Oh, let's put it on the left.

OK, if I have to resize
the array, what's the cost?

AUDIENCE: [INAUDIBLE]

PROFESSOR: So, if I did an
operations, what then, right?

N is the size of the array.

If the only operation
I have is append,

then I can say n
operations will cause

the array of grow to size n.

So n where n is the
number of operations.

AUDIENCE: You mean,
like, re-adding to the--

PROFESSOR: So an operation is
a data structure operation,

like a query or an update.

This is my update
and this is my query.

AUDIENCE: Wait, but like,
it's order n though, because--

PROFESSOR: Yeah.

AUDIENCE: I know, it's order n.

But because we
have like an array,

and then you have
to make a new one,

and you have to move all
those old items over, right?

PROFESSOR: Yep.

AUDIENCE: OK.

But, I mean, sometimes
like, if your actual array,

if you expand it before--
like, let's say you notice

you're getting full and you
decide to like make it bigger

at that point, is
it still order n,

as in the number of
elements that are--

PROFESSOR: It depends
on how you decide.

There's a problem on the PSET
that asks you about that.

So, depends on when
you make the decision

and how you make the decision,
the answer is either yes,

you're still
constant time, or no.

So if you understand the
amortized analysis then

you can argue of whether
it still holds or not.

If this breaks
down at any point,

not going to be constant time.

Yes?

AUDIENCE: So the only cost
is really copying everything

from the old array
to the new array?

PROFESSOR: Yes.

AUDIENCE: Actually
allocating that space is--

PROFESSOR: We assume
that allocating the space

is constant time.

Good question, because you can't
take that for granted, right?

So we assume that this is
order 1, copying is order n.

And then the insertion is
order 1, just like before.

So allocating may
not be constant.

In real life,
allocating is actually

logarithmic either of the
size that you're asking for

or logarithmic of how many
buffers you've allocated.

And you can make a
constant time allocator.

But that's lower than a
logarithmic allocator,

because the constant
factor behind it is so big.

But even if this
allocation would

be order n, which
would be terrible,

it would still
get absorbed here.

So the overall model works no
matter what the allocation is.

It's reasonable, from a
theoretical standpoint,

to say that
allocation is order 1,

from a theoretical standpoint.

So this is the real cost
copying the elements.

And this makes an append
order n worst case.

So if you look at this
data structure then

suppose we want to compute
the cost of an append.

So say we have code
like this, 4, 1, 2, n.

First we have L
be an empty list.

Then we want to compute
the cost of this.

So if we do it without
amortized analysis,

line by line
analysis, just like we

learned in the first lecture,
what's the cost of this,

making a new list constant?

What's the cost of one append?

AUDIENCE: Constant.

PROFESSOR: One append.

So an append can either
branch here or branch here.

So what's the cost
of one append?

AUDIENCE: It would be
showing with an empty list?

AUDIENCE: Depends.

PROFESSOR: It depends.

So worst case.

We have to look at a worst case.

So this is line
by line analysis.

We're going to get
one number for this.

AUDIENCE: N.

AUDIENCE: An n.

PROFESSOR: Yep.

So in the worst case,
the list will be full.

And you'll have
to make a new one.

And then you're going on
this branch of the if,

so the cost is order n.

So order n, worst case.

So the cost of one call
is order n, worst case.

How many calls do we make?

So what is the total
cost of this thing?

AUDIENCE: It's not
actually n squared.

PROFESSOR: Yes, it's
not actually n squared.

But if we do line
by line analysis,

before we learn
amortized analysis,

all we can say it's
order of n squared.

And this is correct, it's not
bigger than n squared, right?

So O is correct.

But it's not the tight bound.

So if we had a multiple
choice, and you selected this,

you wouldn't get the score
because we usually ask you

what the tightest
bound that you can get.

OK, so line by line analysis.

We worked through that
a lot in doc dist.

Doesn't work all the time.

When it doesn't
work, we tell you

to use amortized
analysis instead.

So what's the goal of
amortized analysis?

What do we want?

You guys are yelling at me that
this is not n squared, why?

I mean not why, what?

What is it instead?

What do we want from
amortized analysis?

AUDIENCE: [INAUDIBLE]

AUDIENCE: It's a
[INAUDIBLE] that's an n.

PROFESSOR: So we want
amortized analysis

to say that this is order
1 amortized, and this is--

[ALARM SOUNDING]

PROFESSOR: Am I out of time?

Yeah.

OK, so there's a difference
between the worst

case and amortized, right?

We can argue that this
is order 1 amortized.

And if this is
order 1 amortized,

then this is order n amortized.

So does the difference between
worst case and amortized

make sense now?

So this is what I want,
the rest is fancy math.

If you forget the
fancy math after you're

done with this class, that's OK.

If you remember that this
is order 1 amortized,

and that's order n
amortized, that's good.

That's all you need
to know to write code

if you don't design algorithms.

So this is an important piece
of knowledge on its own.

OK, so questions about the
difference between worst case

and amortized?

OK, what does amortized mean?

AUDIENCE: Average.

PROFESSOR: Yep, averaged out
over multiple operations.

So instead of doing
line by line analysis,

we have to look at what happens
over multiple operations,

right?

So there are two methods that
I think are useful in CLRS.

There are three in
total, but the last one

is horribly complicated.

So there's something
called aggregate analysis.

And there's something called
the cost based accounting.

So last time when we looked
at the costs for append,

we argued that, hey, it's
order 1 for a lot of times.

And then it's only
order n for an operation

that's a power of 2.

So if we're looking
at the K-ith append,

then this is order K
for K equals 2 to the i.

And it's order 1 otherwise.

Right?

So if we sum up
all these costs, we

get-- plus sum over log
n of O of 2 to the i.

And this is clearly order n.

And if you do the math
here, this is also order n.

So this is aggregate analysis.

This is what we
taught you in lecture.

Does this make sense?

So the key here is that whenever
we are increasing the array,

we're increasing it to 2 times.

And we start with a
size of 1, count is 1.

We start with an
array with 1 element.

So the size of the
array will first

be 1, then 2, then 4, then
8, then 16, 32, 64, 128,

so on so forth.

It increases exponentially.

So on the first append
I'll have to do a resize.

On the second one, resize.

Fourth one, resize.

Eighth, resize, so
on and so forth.

So if I'm adding up the
cost for n operations,

each operation is
order 1 because I'm

inserting everywhere.

And then all these
operations are all order n.

But there's few of them.

They're few and far out.

So if you write the sum this
way, and you do the math,

you get that it's order n.

So aggregate analysis
says, look at n operations

and add the costs up together.

And last time we had that good
example of walking over a tree,

and in order traversal where
we drew arrows across edges.

So that's aggregate analysis.

And then you should look
at the cost method in CLRS

because that's also
useful sometimes.

Does this help?

Any questions?

No, everyone wants to go home.

AUDIENCE: Wait--

PROFESSOR: Almost.

AUDIENCE: For log n, so you're
starting from log n going to--

PROFESSOR: So I'm starting
from 1 going to log n.

AUDIENCE: Oh, oh, so [INAUDIBLE]
after you're buffering.

PROFESSOR: So this is
fancy math for saying only

add up powers of two.

So that's what I'm trying
to say, add these guys up.

AUDIENCE: Well that's
your step [INAUDIBLE].

PROFESSOR: Yeah.

AUDIENCE: Oh, OK.

Oh, I like that.

OK.

PROFESSOR: OK.