random walk DEMO

#quote from 'introduction to computation and programming
#using Python, revised, MIT press'
import random

def stdDev(X):
mean = sum(X)/len(X)
tot = 0.0
for x in X:
tot += (x-mean)**2
return (tot/len(X))**0.5

def CV(X):
mean = sum(X)/len(X)
return stdDev(X)/mean

class Location(object):

def __init__(self, x, y):
"""x and y are floats"""
self.x = x
self.y = y

def move(self, deltaX, deltaY):
"""deltaX and deltaY are floats"""
return Location(self.x + deltaX, self.y + deltaY)

def getX(self):
return self.x

def getY(self):
return self.y

def distFrom(self, other):
ox = other.x
oy = other.y
xDist = self.x - ox
yDist = self.y - oy
return (xDist**2 + yDist**2)**0.5

def __str__(self):
return '<' + str(self.x) + ', ' + str(self.y) + '>'

class Field(object):

def __init__(self):
self.drunks = {}

def addDrunk(self, drunk, loc):
if drunk in self.drunks:
raise ValueError('Duplicate drunk')
else:
self.drunks[drunk] = loc

def moveDrunk(self, drunk):
if drunk not in self.drunks:
raise ValueError('Drunk not in field')
xDist, yDist = drunk.takeStep()
currentLocation = self.drunks[drunk]
#use move method of Location to get new location
self.drunks[drunk] = currentLocation.move(xDist, yDist)

def getLoc(self, drunk):
if drunk not in self.drunks:
raise ValueError('Drunk not in field')
return self.drunks[drunk]

class Drunk(object):

def __init__(self, name = None):
"""Assumes name is a str"""
self.name = name

def __str__(self):
if self != None:
return self.name
return 'Anonymous'

class UsualDrunk(Drunk):
def takeStep(self):
stepChoices = [(0.0, 1.0), (0.0, -1.0), (1.0, 0.0), (-1.0, 0.0)]
return random.choice(stepChoices)

def walk(f, d, numSteps):
"""Assumes: f a field, d a Drunk in f, and numSteps an int >= 0.
Moves d numSteps times, and returns the difference between
the final location and the location at the start of the walk."""
start = f.getLoc(d)
for s in range(numSteps):
f.moveDrunk(d)
return start.distFrom(f.getLoc(d))

def simWalks(numSteps, numTrials, dClass):
"""Assumes numSteps an int >= 0, numTrials an int > 0,
dClass a subclass of Drunk
Simulates numTrials walks of numSteps steps each.
Returns a list of the final distances for each trial"""
Homer = dClass()
origin = Location(0.0, 0.0)
distances = []
for t in range(numTrials):
f = Field()
f.addDrunk(Homer, origin)
distances.append(walk(f, Homer, numSteps))
return distances

def drunkTest(walkLengths, numTrials, dClass):
"""Assumes walkLengths a sequence of ints >= 0
numTrials and int > 0, dClass a subclass of Drunk
For each number of steps in walkLengths, runs simWalk with
numTrials walks and prints results"""
for numSteps in walkLengths:
distances = simWalks(numSteps, numTrials, dClass)
print dClass.__name__, 'random walk of', numSteps, 'steps'
print ' Mean =', sum(distances)/len(distances),\
'CV =', CV(distances)
print ' Max =', max(distances), 'Min =', min(distances)

drunkTest((10, 100, 1000, 10000), 100, UsualDrunk)

%run "C:\Users\Administrator\test.py"

UsualDrunk random walk of 10 steps

 Mean = 2.53406018714 CV = 0.606044622899

 Max = 6.32455532034 Min = 0.0

UsualDrunk random walk of 100 steps

 Mean = 9.1303520316 CV = 0.504488309002

 Max = 20.0 Min = 0.0

UsualDrunk random walk of 1000 steps

 Mean = 28.2648152173 CV = 0.48577238125

 Max = 64.88451279 Min = 1.41421356237

UsualDrunk random walk of 10000 steps

 Mean = 89.18140116 CV = 0.527296885645

 Max = 232.206804379 Min = 13.0384048104