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 to
view additional materials
from hundreds of MIT courses,
visit MIT OpenCourseWare
at ocw.mit.edu.
JOHN GUTTAG: Today
we're starting
a new topic, which
is, of course, related
to previous topics.
As usual, if you go to either
the 60002 or the 600 web site,
you'll find both today's
PowerPoint and today's Python.
You'll discover if you
look at the Python file
that there is quite a
lot of code in there.
And I'll be talking
only about some of it.
But it's probably
all worth looking at.
And a fair amount of reading
associated with this week.
Why are we looking
at random walks?
See a picture here of, think of
them as molecules just bouncing
around.
This is actually a
picture of what's
called Brownian motion,
though Robert Brown probably
did not discover it.
We're looking at random walks
because, well, first of all,
they're important
in many domains.
There are people who
will argue, for example,
that the movement of
prices in the stock market
is best modeled
as a random walk.
There was a very popular book
called A Random Walk Down Wall
Street that made this argument.
And a lot of modern portfolio
analysis is based upon that.
Those of you who are not
interested in making money,
and I presume
that's most of you,
it's also very important
in many physical processes.
We use random walks,
say, to model diffusion,
heat diffusion, or the
diffusion of molecules
in suspension, et cetera.
So they're very important in a
lot of scientific, and indeed,
social disciplines.
They're not the only
important thing,
so why are we looking at those?
Because I think it provides
a really good illustration
of how we can use simulation to
understand the world around us.
And it does give me an excuse
to cover some important topics
related to programming.
You'll remember that one of
the subtexts of the course
is while I'm covering a
lot of what you might think
of as abstract
material, we're using it
as an excuse to teach more
about programming and software
engineering.
A little practice with
classes and subclassing,
and we're going to also
look at producing plots.
So the first random
walk I want to look at
is actually not a diffusion
process or the stock market,
but an actual walk.
So imagine that you've got
a field which has somehow
inexplicably been mown to look
like a piece of graph paper,
and you've got a drunk
wandering around the field,
taking a step every once in a
while in some random direction.
We can then ask the
question is there
an interesting relationship
between the number of steps
the drunk takes and
how far the drunk is
from the origin at the
end of those steps?
You could imagine that if
the drunk takes more steps,
he's ever further
from the origin.
Or maybe you could
imagine, since it's random,
that he just wanders away and he
wanders back in all directions
and more or less
never gets very far.
So just out of curiosity,
I'll take a poll.
Who thinks that the
drunk doesn't much
matter how many
steps he takes, he'll
be more or less the
same distance away?
And who thinks the more steps
he takes, the further away he's
likely to be?
It seems to be a season
where when you take polls,
they come out almost tied.
Let's look at a small example.
Suppose he takes one step only.
Well, if he takes
one step, and we'll
assume for simplicity
that he's not so drunk
that he moves at random.
He either moves north
or south, east or west.
These are all the places
he can get to in one step.
What they have in common
is that after one step,
the drunk is always exactly
one unit away from the origin.
Well, how about after two steps?
So without loss of
generality, let's assume that
the first step--
let me use the pen
that you're supposed
to use to write on this, rather
than this pen, which would
make a real mess on my screen.
What did I do with it?
Well, I won't write on it.
So without loss of
generality, we'll
assume that the drunk
is there after one step.
Took one step to the east.
Well, after two steps, those
are all the possible places
he could be.
So on average, how far is
the drunk from the origin?
Well, if we look, he could
either be two steps away,
if he took another step
east, zero steps away,
if he took a step west, or
what do we see for the top two?
Well, the top and
the bottom one,
we can go back and use
the Pythagorean theorem.
c squared equals a
squared plus b squared.
And that will tell us that
it'll be the square root
of a squared plus b squared.
And that will tell us how
far away the upper two are,
and then we can just average
them and get a distance.
And as we can see,
on average, the drunk
will be a little bit further
away after two steps than
after one step.
Well how about
after 100,000 steps?
It would be a little bit
tedious to go through the case
analysis I just did.
There are a lot of cases
after 100,000 steps.
So we end up resorting
to a simulation.
So we'll structure it
exactly the same way
we've been structuring
our other simulations.
We're going to simulate one
walk of k steps, n such walks,
and then report the
average distance
from the origin of the n walks.
Before we do that, in line
with the software engineering
theme of the course,
we'll start by defining
some useful abstractions.
There are three of
them I want to look at.
Location, the field
that the drunk is in,
and the drunk him or herself.
So let's first look at location.
This is going to be
an immutable type.
So what we see here--
as long as I can't
point in the screen,
I'll point with a pointer--
is that we'll initiate it.
We'll initialize it
with an x and y value.
That makes sense.
We'll be able to have two
getters, getX and getY.
And here's how we
see it's immutable.
What move is doing is it's
not changing the location,
it's returning a new location.
Perhaps move is poor
choice of name for that.
But that is what it's doing.
It's just returning
a new location
where it adds the change
in x and the change in y
to get two new xy values.
Notice, by the way,
that I'm not restricting
these to be integers, or
one, or anything like that.
So this would work
even if I did not
want to take those nice little
east-west, north-south steps.
I've got a underbar
underbar string, _str_,
and then here's my
implementation--
you can see it's
very sophisticated--
of the Pythagorean theorem.
So I just do it
that way, and that
will get me the distance
between two things.
It's one of the annoying things
about classes in, actually,
all languages I know
with classes, is
you would like to
think that self
and other-- there's
a symmetry here.
The distance from self to
other is the same as from other
to self.
But syntactically,
because of the way
the language is structured,
we treat them a little bit
differently.
How about class Drunk?
Well, this is kind of boring.
Drunk has a name and a string.
And that's all.
The point of this,
and I don't think
we've looked at
this before, is this
is not intended to be a
useful class on its own.
It's what we call a base class.
The notion here is its only
purpose is to be inherited.
It's not supposed to
be useful on itself,
but it does give me
something that will
be used for the two subclasses.
And we'll look at
two subclasses.
The so-called usual
drunk, the one
I tried to simulate when
I was wandering around,
wanders around at random.
And a drunk I like
to think of it
as a New Englander, or
a masochistic drunk,
who tries forever to move
ever northward, because he
or she wants to be frozen.
I do like this picture of
entering the state of Maine
in the winter.
So here is the usual drunk.
Subclass of drunk,
and it can take steps
at random, one step, either
increasing y, a step north,
decreasing y, a step south,
increasing x, a step east,
or decreasing x a step west.
So those are the choices.
And it's going to return
one of those at random.
I think we saw random.choice
in the last lecture.
And then our
masochistic drunk, it's
almost the same, except the
choices are slightly different.
If he chooses to head north,
he doesn't go one step.
He goes 1.1 steps north.
And if he chooses to go south,
he only goes 9/10 of a step.
So what we're seeing
here is what's
called a biased random walk.
And the bias here is the
direction of the walk
that he's moving
either up or down.
Pretty simple.
How about just for
to test things out,
we'll ask the question is this
an immutable or a mutable type?
Are drunks mutable or immutable?
This is a deep
philosophical question.
But if we ignore the
philosophical underpinnings
of that question, what
about the two types here?
Who thinks it's immutable?
Who thinks it's mutable?
Why do you think it's mutable?
What's getting changed?
The answer is nothing.
It gets created, and then
it's returning the step,
but it's not actually
changing the drunk.
So so far we have two things
that are immutable, drunks
and locations.
Let's look at fields.
Fields are a little
bit more complicated.
So field will be a
dictionary, and the dictionary
is going to map a drunk to his
or her location in the field.
So we can add a drunk
at some location,
and we're going to check.
And if the drunk
is already there,
we're not going to
put the drunk in.
We're going to raise a value
error, "Duplicate drunk."
Otherwise we're going to set
the value of drunkenness mapping
to loc.
Now you see, by the way, why I
wanted drunks to be immutable.
Because they have
to be hashable so
I can use them as a
key in a dictionary.
So it was not an idle question
whether they were immutable.
It was an important question.
I can get the
location of a drunk.
If the drunk is not
in there, then I'll
raise a different value
error, "Drunk not in field."
Otherwise I'll
return the location
associated with that drunk.
And finally, we're
going to have moveDrunk.
Again I'll check whether
the drunk is there.
If the drunk is there, I'm
going to get the distance
on x and the distance in y
by calling drunk.takeStep.
So we saw takeStep for a drunk
didn't move the drunk anywhere,
because the drunks
were immutable,
but returned new locations.
A new x and new values.
And then I'm going to use that
to move the drunk in the field.
So I'll set self.drunk, so
drunk to move x distance and y
distance.
So it's very simple, but having
built this set of classes,
we can now actually
write the simulation.
Oh.
What about our classes?
Are they mutable or immutable?
Not classes.
What about fields?
Any votes for mutable?
Yeah, exactly.
Because you can see I'm
mutating it right here.
I'm changing the value
of the dictionary.
And in fact, every time I
add a drunk to the field,
I'm changing the value
of the dictionary, which
is to say mutating the field.
So I'll have a
bunch of locations,
which are immutable objects.
Makes sense that a
location is immutable.
A bunch of drunks, and the
thing I'm going to change
is where the drunks
are in the field.
I said we'd start by
simulating a single walk.
So here it is, a walk in a field
with a drunk, and that drunk
will take some number
of steps in the field.
And you can see this.
It's very simple.
I just have a loop.
Drunk takes some
number of random steps,
and I'm going to return
the distance from the start
to the final location
of the drunk.
So how far is the
drunk from the origin?
I then need to simulate
multiple walks.
Notice here that I've
got the number of steps,
the number of trials, and dClass
stands for class of the drunk.
And that's because I want
to use the same function
to simulate as many
different kinds of drunks
as I care about.
We've only seen two here,
the masochistic drunk
and the usual drunk, but you
can imagine many other kinds
as well.
So let's do it.
So here I'm going to simulate
a walk for one drunk, Homer.
So we'll create a drunk named
Homer, or the variable Homer,
which is the drunk class.
Then the origin,
distances, and for t
in range number of
trials, we'll just do it,
and then we'll
return the distances.
So it's initialized
to the empty list.
So we're going to return a list
for however many trials we do,
how far the drunk ended
up from the origin.
Then we can average that,
and we look at the mean.
Maybe we'll look at
the min or the max.
Lots of different questions we
could ask about the behavior.
And now we can put
it all together here.
So drunkTest will take a set
of different walk lengths,
a list of different walk
lengths, the number of trials,
and the class.
And for a number of
steps and walk lengths,
distances will be
simWalks of number
of steps, numTrials, dClass.
And then I'm going to just
print some statistics.
You may or may not
have seen this.
This is something that's
built in to Python.
I can ask for the
name of a class.
So dClass, remember, is a
class, and _name_ will give me
the name of the class.
Might be usual, it might
be drunk, in this case.
So let's try it.
So the code we've looked at.
So let's go down here,
and we'll run it,
and we'll try it for
walks of 10, 100, 1,000,
and 10,000 steps.
And we'll do 100 trials.
Here's what we got.
So my question to you is
does this look plausible?
What is it telling us here?
Well, it's telling us here
that the length of the walk
actually doesn't really affect--
the number of steps doesn't
affect how far the drunk gets.
There's some randomness.
8.6, 8.57, 9.2, 8.7.
Not much variance.
So we've done this simulation
and we've learned something,
maybe.
So does this look plausible?
We can look at it here.
I've just transcribed it.
What do you think?
Well, go ahead.
AUDIENCE: I was going to
say, it seems plausible
because after the
first two steps,
there's a 50% chance he's
going closer to the origin.
And a 50% chance he's
going away from it.
JOHN GUTTAG: So we have at
least one vote for plausible,
and it's certainly a
plausible argument.
Well, one of the things
we need to learn to do
is whenever we
build a simulation,
we need to do what I
call a sanity check
to see whether or not
the simulation actually
makes sense.
So if we're going to
do a sanity check,
what might we do in this case?
We should try it on cases where
we think we know the answer.
So we say, let's take
a really simple case
where we're pretty sure we
know what the answer is.
Let's run our
simulation and make
sure it gives us the right
answer for this simple case.
So if we think of a
sanity check here,
maybe we should look
at these numbers.
We just did it.
We know how far the drunk
should get in zero steps.
How far should the drunk
move in zero steps?
Zero.
How far should the
drunk move in one steps?
We know that should be one.
Two steps, well, we knew
what that should be.
Well, if I run
this sanity check,
these are the numbers I get.
I should be pretty suspicious.
I should also be
suspicious they're
kind of the same numbers
I got for 10,000 steps.
What should I think about?
I should think that maybe
there's a bug in my code.
So if we now go back
and look at the code,
yes, this fails the
pants on fire test
that there's clearly something
wrong with these numbers.
What we were appending is
walk of Homer, numTrials, 1.
Well, numTrials is a constant.
It's always 100.
What I intended to write here
was not numTrials but numSteps.
I actually did
this the first time
I wrote this simulation
many years ago.
I made this typo,
if you will, and I
got these bizarre answers.
So I looked at the
code and I said, well,
that's actually wrong.
No wonder it's always
the same number.
I'm calling it with a constant.
The constant happens to be 100.
So let's go fix the simulation.
So this should
have been numSteps.
Now let's run it again.
Well, these results
are pretty different.
Now we see that in fact,
they're increasing.
Should I just look
at this and be happy?
Probably not.
I should run my
sanity check again
and make sure I get the right
results for zero, one, and two.
So let's go back and do that,
just to be a little bit safe.
So I'll just change this
tuple of values to be--
and I should feel a
lot better about this.
The mean, the max, and
the min are all zero
when he doesn't take any steps.
One is exactly what
we should expect,
and two is also-- the mean is
where we would guess it to be,
and the max is two,
happened to take
two steps in the same direction,
and the min is zero, happened
to end up where he started.
So I've passed my sanity check.
Doesn't mean my
simulation is right,
but at least I have
reason to be hopeful.
So getting back.
So we saw these results, and
now we're getting the indication
that in fact, contrary to
what we might have thought,
it does appear to be that the
more steps the drunk takes,
the further away
the drunk ends up.
And that was the usual drunk.
We can try the
masochistic drunk,
and then we see something
pretty interesting.
I won't make you sit through
it, but when we run it,
here are the usual
drunks, the numbers,
and I just looked at
it for 1,000 and 10,000
so it would fit on the screen.
You see for the usual drunk,
it's 26.8, roughly 90.
Fair dispersion in
the min and the max.
And the masochistic drunk seems
to be making considerably more
progress than the usual drunk.
So we see is this
bias actually appears
to be changing the distance.
Well, that's interesting.
Now we could ask
the question why?
What's going on?
And to do that, I want to
go and start visualizing
what's the trend?
So rather than just looking at
two numbers or three numbers,
as we've been doing, I'm going
to draw a pretty picture.
Actually, I'm not going to draw.
I'm a terrible artist.
But Python will draw us
some pretty pictures.
We're going to simulate
walks of multiple lengths
for each kind of
drunk, and then plot
the distance at the
end of each length
walk for each kind of drunk.
I now digress for a moment to
talk about how we do plotting.
So we're going to use
something called Pylab.
I've listed here four
really important libraries
that you will surely
end up using extensively
if you continue to use
Python for research purposes.
NumPy adds vectors,
matrices, and many high-level
mathematical functions.
Actually, it might be NumPy.
It might be "Num-Pee."
I'm not sure how
to pronounce it.
But we'll call it NumPy.
So these are really
useful things.
SciPy adds on top
of that a bunch
of mathematical classes and
functions useful to scientists.
Things like-- well, we'll
look at some of them
as we go on through the term.
MatPlotLib adds an
object-oriented programming
interface for plotting.
Anybody here used MATLAB?
Great.
Well you'll find that MatPlotLib
is the Mat, think MATLAB.
Lets you, in Python, use
all the plotting stuff
that you've come to either
like or hate in MATLAB.
So it's really convenient.
If you know how to
do plots in MATLAB,
you'll know how to
do it in Python.
PyLab combines all
of these to give you
a MATLAB-like
interface to Python.
So once you have PyLab,
you can do a lot of things
that you would normally
want to do in MATLAB,
for example, produce
weird-looking plots
like this one.
I'm going to show you one of the
many, many plotting commands.
It is called plot.
It takes two arguments,
which must be
sequences of the same length.
The first argument
is the x-coordinates,
the second argument is the
y-coordinates corresponding
to the x ones.
There are roughly three
zillion optional arguments,
and you'll see me use only
a small subset of them.
It plots the points in order.
First the first xy, then the
second xy, then the third xy.
Why is it important that I
say it plots them in order?
Because by default, as
each point is plotted,
it draws a line connecting
one point to the next point
to the next point.
And so the order in
which they're plotted
will determine
where the lines go.
Now we'll see, as we go on, that
we often don't draw the lines,
but by default they are drawn.
Here's an example.
You start by importing PyLab.
Then I've given xVals
and yVals1, and if I call
pylab.plot of xVals, yVals1.
Here is one of the
arguments I can give it.
I'm saying I'd like this to be
plotted in blue, b for blue,
and I'd like it to be plotted
as a solid line, a single dash.
And I want to give that
line a label, which
I've said is first.
YVals2 is a different list.
I'll plot it again.
Here I'm going to say I
want a red dotted line,
and the label will be second.
And then after
plotting it, I'm going
to invoke pylab.legend, which
puts this nice little box up
here in the corner,
in this case,
saying that first is a
solid blue line and second
a dashed red line, I should say.
Now again, there are
lots of arguments,
lots of other arguments
I could give in plot.
Also legend, I can tell it
where to put the legend,
if I so choose.
Here I've just said,
put it wherever
you happen to want to put
it, or PyLab wants to put it.
So a very simple way
to produce a plot.
There are lots of
details and many more
examples about plotting
in the assigned reading.
We've posted a video that
Professor Grimson produced
for an online course, 600.1x.
It's about a 50 minute video
broken into multiple segments
about how to use plotting in
PyLab with a lot more detail
than I've given you.
You'll see if you read
the code for this lecture.
And as you see this
lecture, there'll
be lots of other plots
showing up of different kinds.
These are my two
favorite online sites
for finding out what to do.
And of course, you can
google all sorts of things.
That's all I'm going to tell
you about how to produce plots
in class, but we're
going to expect
you to learn a lot about
it, because I think
it's a really useful skill.
And at the very
least, you should
feel comfortable that any
plot I show you, you now--
obviously not right now--
but you will eventually
know how to produce.
So if you do these
things, you'll
be more than up to speed.
So I started by saying I wanted
to plot the trends in distance,
and they're interesting.
So here's the usual drunk
and the masochistic drunk.
So you can see, sure
enough, the usual drunk,
this fuschia line is
progressing very slowly
and the masochistic drunk,
considerably faster.
I looked at these, and
after looking at those two,
I tried to figure
out whether there
was some mathematical
explanation of what
was going on, and
decided, well, it
looked to me like
the usual drunk
was moving at about the square
root of the number of steps.
Not so odd to think about it,
if you go back to old Pythagoras
here.
And sure enough, when I plot,
and I ran this simulation up
to 100,000 steps.
When I plot the square root
of the number of steps,
it's not identical, but
it's pretty darn close.
Seems to be moving just a tad
faster than the square root,
but not much.
But who knows exactly?
But pretty good.
And then the
masochistic drunk seems
to be moving at a rate
of numSteps times 0.05.
A less intuitive answer
than the square root.
Why do you think it
might be doing that?
Well, what we notice is that--
and we'll look at this--
maybe there's not
much difference
between what the masochistic
drunk and the usual drunk
do on the x-axis, east and west.
In fact, they shouldn't be.
But there should be a
difference on the y-axis,
because every time,
1/4 of the time,
the drunk is taking a
step north of 1.1 units,
and 1/4 of the time, he's taking
a step south of 0.9 units.
And so 1/2 the
time, the steps are
diverging by a small fraction.
And if we think about
it, 0.1 1/2 the time.
We divide it.
We get 0.05.
So at least we need to
do some more analysis,
but the data is
pretty compelling here
that it's a very good fit.
Well, let's look at
the ending location.
So here you see a rather
different kind of plot.
Here I'm showing
that you can plot
these things without
connecting them by lines.
And giving them
different shapes.
So what here I've said is
that the masochistic drunk
we're going to plot
using red triangles,
and the usual drunk I'm going
to plot using black plus signs.
And since I'm going
to plot the location
at the end of many walks,
it doesn't make sense
to draw lines
connecting everything,
because all we're caring
about here is the endpoints.
So since I only
want the endpoints,
I'm plotting them
a different way.
So for example, I can write
something like plot( xVals,
yVals, and then if I do
something like let's see.
Just 'b0' in fact.
What that says is
plot blue circles.
I could have written--
in fact I did write 'k+' and
that says black plus signs.
And I don't actually
remember what
I did to get the triangles,
but it's in the code.
And so that's very
flexible what you do.
And as you can see
here, we get the insight
I'd communicated earlier that
if you look at east and west,
not much difference between
this ball and that ball.
They seem to be moving about the
same spread, the same outliers.
But this ball is
displaced north.
And not surprisingly,
after 10,000 steps,
you would not expect
any of these points
to be below zero, where
you'd expect roughly half
of these points
to be below zero.
And indeed that's about true.
And we see here what's
going on that if we
look at the mean absolute
difference in x and y,
we see that not
a huge difference
between the usual drunk
and the masochistic drunk.
There happens to be a distance.
But a huge difference--
sorry, x and x.
Comparing the two y values,
there's a big difference,
as you see here.
So what's the point of all this?
It's not to learn about
different kinds of drunks.
It's to show how,
by visualization, we
can get insight into
our data that if I just
printed spreadsheets showing
you all of these endpoints,
it would be hard to make
sense of what was there.
So get accustomed
to using plotting
to help you understand data.
Now let's play a little bit
more with the simulation.
We looked at different
kinds of drunks.
Let's look at different
kinds of fields.
So I want to look
at a field with what
we'll call a wormhole in it.
For those of you of
a certain generation,
you will recognize the Tardis.
So the idea here is
that the field is such
that as you wander around
it, everything is normal.
But every once in a
while you hit a place
where you're
magically transported
to a different place.
So it behaves very peculiarly.
So let's call this an OddField.
Not odd numbers, but
odd as in strange.
So it's going to be
a subclass of field.
We're going to have a
parameter that tells us
how many worm holes it has.
A default value of 1,000.
And we'll see how we use
xRange and yRange shortly.
So what are the
first thing we do?
Well, we'll call Field _init
to initialize the field
in the usual way.
And then we're going to create
a dictionary of wormholes.
So for w in the range
number of worm holes,
I'm going to choose a
random x and a random y
in xRange minus xRange to plus
xRange, minus yRange to yRange.
So this is going to be where
the worm holes are located.
And then for each
of those, I'm going
to get a random location
where you're, in some sense,
teleported to if you
enter the wormhole.
So here we're using random
to get random integers.
We've seen that before.
And so the new location
will be the location
of the new x and
the new y, and we're
going to update this
dictionary of wormholes
to say that paired with the
location x, y is newLoc.
Now when we move the drunk, and
again this is just changing--
we're overriding moveDrunk,
so we're overriding one
of the methods in Field.
So Field.moveDrunk will
take a self and a drunk.
It's going to get the
x value, the y value,
and if that is in
the wormholes, it's
going to move the drunk
to the location associated
with that wormhole.
So we move a drunk, and
if the drunk ends up
being in the wormhole,
he gets transported.
So we're using Field.moveDrunk.
So notice that we're using the
moveDrunk of the superclass,
even though we're
overriding it here.
Because we've overridden it
here, I have to say Field.
to indicate I want the one
from the superclass, not
the subclass.
And then we're doing something
peculiar after the move.
So interestingly
here, I've taken,
I think, a usual drunk and
plotted the usual drunk
on a walk of 500 steps.
One walk, and shown all the
places the drunk visited.
So we've seen three
kinds of plots,
one showing how far the drunk
would get at different length
walks, one showing
all the places
the drunk would end up with
many walks of the same length,
and here a single walk, all
the places the drunk visits.
And as you can
see, the wormholes
produce a profound
effect, in this case,
on where the drunks end up.
And again, you have the code.
You can run this
yourself and simulate it
and see what you go.
And I think I've set
random.Seed to zero
in each of the
simulations in the code,
but you should play
with it, change it,
to just see that you'll
actually get different results
with different seeds.
Let me summarize here,
and say the point of going
through these random walks is
not the simulations themselves,
but how we built them.
That we started by
defining the classes.
We then built
functions corresponding
to one trial, multiple trials,
and reported the results.
And then made a set
of incremental changes
to the simulation so
that we could investigate
different questions.
So we started with
a simple simulation
with just the usual drunk
and the simple field,
and we noticed it didn't work.
How did we know it?
Well, not because when we
did the full simulation
we had great insight.
I probably could have
fooled 1/2 of you
and convinced you that that
was a reasonable answer.
But as soon as we went and
did the sanity check, where
we knew the answer, we could
know something was wrong.
And then we went
and we fixed it.
And then we went
and we elaborated it
at a step of a time.
I first got a more sophistic--
I shouldn't say sophisticated.
A different kind of drunk.
And then we went to a
different kind of field.
Finally, we spent
time showing how
to use plots to get an insight.
And in the remaining few
minutes of the class,
I want to go back and show you
some of the plotting commands.
To show you how these
plots were produced.
So one of the things
I did, since I
knew I was going to be producing
a lot of different plots,
I decided I would actually
not spend time worrying
about what kind of markers--
those are the things
like the triangles
and the plus sign-- or
what colors for each one
individually, but
instead I'd set up
a styleIterator that
would just return
a bunch of different styles.
So once and for all, I
could define n styles,
and then when I want to
plot a new kind of drunk,
I would just call
the styleIterator
to get the next style.
So this is a fairly
common kind of paradigm
to say that I just want to
do this once and for all.
I don't want to have to go
through each time I do this.
So what do the styles look like?
Let me just get this window.
Oh.
So here it is.
I said there were going to
be three styles that I'm
going to iterate through.
Style one is going
to be an m, I guess
that's maroon with a line,
a blue with a dashed line,
and green with a line with
a comma and a minus sign.
So these are called the styles.
And you can control the
marker, if you have a marker.
You can control the line.
You can control the color.
Also you can control the size.
You can give the sizes
of all these things.
What you'll see when
you look at the code
is I don't like
the default styles
things, because when they
show up on the screen,
they're too small.
So there's something
called rcParams.
Those of you who
are Unix hackers
can maybe guess where
that name came from.
And I've just said
a bunch of things,
like that my default line
width will be four points.
The size for the
titles will be 20.
You can put titles
on the graphs.
Various kinds of things.
Again, once and for all trying
to set some of these parameters
so they get used
over and over again.
And then finally
down here, you'll
see that I did
things like you want
to put titles on the slides.
So on the graph.
So here's the location
at end of walk.
Title is just a string.
You want to label
your x and y-axis,
so I've labeled them here.
And here I've said where I
want the legend to appear
in the lower center.
I've also set the y-limits
and the x-limits on the axis,
because I wanted a
little extra room.
Otherwise, by default
it will put points
right on the axes, which
I find hard to read.
Anyway, the point here is
not that you understand
all of this instantaneously.
The point I want to communicate
is that it's very flexible.
And so if you decide
you don't like
the way a plot looks and
you want to change it,
and you know what you
want it to look like,
there's almost surely a
way to make it do that.
So don't despair.
You can look at the
references I gave earlier
and figure that out.
Next lecture we're
going to move on.
No more random walks.
We'll look at
simulating other things,
and in particular, we'll look at
the question of how believable
is a simulation?
See you Wednesday if the
world has not come to an end.
