central limit theorem study

slanj · slanj · commit fdca8701e731 · 2018-09-23T15:55:10.000+03:00
diff --git a/stats/climit_theorem.py b/stats/climit_theorem.py
@@ -0,0 +1,149 @@
+import random, pylab
+
+#set line width
+pylab.rcParams['lines.linewidth'] = 4
+#set font size for titles
+pylab.rcParams['axes.titlesize'] = 20
+#set font size for labels on axes
+pylab.rcParams['axes.labelsize'] = 20
+#set size of numbers on x-axis
+pylab.rcParams['xtick.labelsize'] = 16
+#set size of numbers on y-axis
+pylab.rcParams['ytick.labelsize'] = 16
+#set size of ticks on x-axis
+pylab.rcParams['xtick.major.size'] = 7
+#set size of ticks on y-axis
+pylab.rcParams['ytick.major.size'] = 7
+#set size of markers, e.g., circles representing points
+#set numpoints for legend
+pylab.rcParams['legend.numpoints'] = 1
+
+def getMeanAndStd(X):
+    mean = sum(X)/float(len(X))
+    tot = 0.0
+    for x in X:
+        tot += (x - mean)**2
+    std = (tot/len(X))**0.5
+    return mean, std
+
+#L = [1,1,1,1,2]
+#pylab.hist(L)
+#factor = pylab.array(len(L)*[1])/len(L)
+#print(factor)
+#pylab.figure()
+#pylab.hist(L, weights = factor)
+
+def plotMeans(numDice, numRolls, numBins, legend, color, style):
+    means = []
+    for i in range(numRolls//numDice):
+        vals = 0
+        for j in range(numDice):
+            vals += 5*random.random()
+        means.append(vals/float(numDice))
+    pylab.hist(means, numBins, color = color, label = legend,
+               weights = pylab.array(len(means)*[1])/len(means),
+               hatch = style)
+    return getMeanAndStd(means)
+
+mean, std = plotMeans(1, 1000000, 19, '1 die', 'b', '*')
+print('Mean of rolling 1 die =', str(mean) + ',', 'Std =', std)
+mean, std = plotMeans(50, 1000000, 19, 'Mean of 50 dice', 'r', '//')
+print('Mean of rolling 50 dice =', str(mean) + ',', 'Std =', std)
+pylab.title('Rolling Continuous Dice')
+pylab.xlabel('Value')
+pylab.ylabel('Probability')
+pylab.legend()
+pylab.show()
+
+class FairRoulette():
+    def __init__(self):
+        self.pockets = []
+        for i in range(1,37):
+            self.pockets.append(i)
+        self.ball = None
+        self.blackOdds, self.redOdds = 1.0, 1.0
+        self.pocketOdds = len(self.pockets) - 1.0
+    def spin(self):
+        self.ball = random.choice(self.pockets)
+    def isBlack(self):
+        if type(self.ball) != int:
+            return False
+        if ((self.ball > 0 and self.ball <= 10)\
+            or (self.ball>18 and self.ball<=28)):
+            return self.ball%2 == 0
+        else:
+            return self.ball%2 == 1
+    def isRed(self):
+        return type(self.ball) == int and not self.isBlack()
+    def betBlack(self, amt):
+        if self.isBlack():
+            return amt*self.blackOdds
+        else: return -amt
+    def betRed(self, amt):
+        if self.isRed():
+            return amt*self.redOdds
+        else: return -amt*self.redOdds
+    def betPocket(self, pocket, amt):
+        if str(pocket) == str(self.ball):
+            return amt*self.pocketOdds
+        else: return -amt
+    def __str__(self):
+        return 'Fair Roulette'
+
+def playRoulette(game, numSpins, toPrint = True):
+    luckyNumber = '2'
+    bet = 1
+    totRed, totBlack, totPocket = 0.0, 0.0, 0.0
+    for i in range(numSpins):
+        game.spin()
+        totRed += game.betRed(bet)
+        totBlack += game.betBlack(bet)
+        totPocket += game.betPocket(luckyNumber, bet)
+    if toPrint:
+        print(numSpins, 'spins of', game)
+        print('Expected return betting red =',
+              str(100*totRed/numSpins) + '%')
+        print('Expected return betting black =',
+              str(100*totBlack/numSpins) + '%')
+        print('Expected return betting', luckyNumber, '=',\
+              str(100*totPocket/numSpins) + '%\n')
+    return (totRed/numSpins, totBlack/numSpins, totPocket/numSpins)
+
+class EuRoulette(FairRoulette):
+    def __init__(self):
+        FairRoulette.__init__(self)
+        self.pockets.append('0')
+    def __str__(self):
+        return 'European Roulette'
+
+class AmRoulette(EuRoulette):
+    def __init__(self):
+        EuRoulette.__init__(self)
+        self.pockets.append('00')
+    def __str__(self):
+        return 'American Roulette'
+
+def findPocketReturn(game, numTrials, trialSize, toPrint = False):
+    pocketReturns = []
+    for t in range(numTrials):
+        trialVals = playRoulette(game, trialSize, toPrint)
+        pocketReturns.append(trialVals[2])
+    return pocketReturns
+#
+#random.seed(0)
+#numTrials = 50000
+#numSpins = 200
+#game = FairRoulette()
+#
+#means = []
+#for i in range(numTrials):
+#    means.append(findPocketReturn(game, 1, numSpins)[0]/numSpins)
+#
+#pylab.hist(means, bins = 19,
+#           weights = pylab.array(len(means)*[1])/len(means))
+#pylab.xlabel('Mean Return')
+#pylab.ylabel('Probability')
+#pylab.title('Expected Return Betting a Pocket')
+
+
+
diff --git a/stats/coin_flips.txt b/stats/coin_flips.txt
@@ -0,0 +1 @@
+THTTHTHTTHTHHHHTHHHHHHTTHTTTHHTHTTTHHTHTTHTHHHHTHHTHHTTHHTHHHHTHHTHTHTTTTHHTHHHHHHHHTTTTHHHHHHHHHTHTTHHHHHHTHHHHTHHTHHHHTTHTHHTTHHTHTHHTTHHHTHHTHTTTHHHHHTHHHHHHHHTHTTTHHTHTTHTHHTHTTTHTHTHTHHHHTHHHTHHHHHHHTTHTTHHHHHHHHHTHHHTHHHHHTHTTHTTTHHTHHTHHHHHTHHHTHTTHHHTTTHHHHHTTHTTTTHTTTHHHHHHHHHHHHTHHHHHHHHHHTTHTTHHTHHTHTTHTTHHHHHTHHHHTHTTHHTHTHHHHHHHTTHHHTHHHHHHHHTHHHHHTTHHHHHHTTHHHHHTTHHHHHTHHTHHTHHHTTHTTTHHTHTTHHTTHTHHTTTHTHHHTHHHTHTHTHHHTTHTHTTTTTHHHTHHTHHHTHHHTTTHHHTHHHHHHHTHHTHHHTTHHTTHHHTHHHHTHTHTHTTHHHTTTHHHTHTTHTHTHTHHHHHHHHHTHHTHHHTHHHHHHTHTTHTHTHHTHTHHHHTTHHHHHTHTTHTTHHHHHHTHHHHHHTTHHTHTTTTHTHHHHTHHHHHHHHHHHHTTTTTHTHHHHHHTTHHTHTTTHTHTTHHTHTTHTHTHHTHHHTTTHHHHTHHHTTHTHHTHHTHTTHHHTTTHTHTTHHHHHTHTHHHHHTHTHHTHTTHHTHTTHHHTHHHHHTHHHHHHHTHHHHTTHHHHHTHTHHHHHTTHHTHHHTHTHHHTTHTTTHTTHHHTHHTTHHHHTHHHHTHHHTTHHHTTHHTTHTHHTTHHHHTHTHHTHTTTTTHHHTHHTHHHHHTHHHHHTHTHHHTHTHTHHTHTHHHHHHHHTHTHHHHHTHHHTTTTHHHHHHHTHHHTTHTTHHHHTTHHHHHHHTHHHHTHHHHHHHHHTTHHHHHHHTHTHHTHHHHHHHTHHHHTHHHTTTTHHHHHHTHHTHTTHHTHTTTTHTHHHTHHHTHHHTTTTHHHTHTHHHHTHTHHTTHTTHHTHHTHHTHHTHHTHTTHHHHHTHTHHHHHHHTTTHTHTHTTHTHHHHTTHHHHHHHTHTHHTHTHHTHHHHTTHHHTHTHTHHTHHTTHTHTTHHTHHHHHHTTTTTTHHHTHTHTHHHTHHTHTHHHHTHHTTTHHTHHHHHHTHHHHHHHHTHHTTTHHTHTHTHHHHHHTTHHHTHHTHHHHTHTHTHTHHTHTTHTHHTHHHHHTTTHHHHHHTTHHHHHTHTHHHHTHHTHHHHHHTTHHHHHHTHHTHHHHTHHHTHHTHHHHHTHHTHHHHHTHHTTHHHHHTHTHHHTHHHHTHTHHTTTHHHTTTTHTHHTHTHHHHHHHHTTTTHTTHHHTTHTHHHTHHHHHHTHHHHHHHHHHHHHHTHTTTHHTHHHHHHHHHHTHTTHTHHHTTTTTHHTTHTTHHTHTTHHTTTHHHHHHHTHHHHHHTHHTHHHHHHTHTTHTHHHTHHHTHTTHHTHTHHHHTHTTHHHHHTTHHHTTHHHHHHTHHHHHHHHTHHHHHHHHTHTHHHTTTHHTHHHHHHHTHTHHHHHHHTHHHHHHHHTTHHHHTTHTHHHHTHHTHHTHHTHTHHTTHTHTHHTHTTTHHTHHTHTHHHHHTHTTHTHHTHHTHTHTHTTHHHHTHHHHHHHTHHHHHHHHTTHTHHTHHTHHTHTHHTHTTHHHTHHHHTHHTTHHTHHTHHTHHTHHHTHHHHTTHHHTHHTHHTTHHHTHHTTTHHHTHHHTTTTHTTTHHHHTHHHTTHTHHHHHHTTHTHHTTTHTHHHHTHTHHHTTTTHHTHHHHTHHTTHHHHHTHHHTHHHHTHHTHHHHHHHHTTHHHHHHHHHTHHHTHHHTTTTHTHHTTHHHTHTHHHTHHHHHHHHHTHHTHTTTHHHHHHHTHTHHHHTHHHHTTHHTHHTHTHTTTHHHTHHHHHTHHHHHTHTHHHHTTTHTTHHHTHTHHHTHHTHHHHHHHHTHHTHTTHHHTTHTHTHTTTHHHHTTHTTHTHTTHHTTHHHHTTHHHTTTHHHHHHHHHHHHHTHTHHTHTTTHHHHTTHHTTHHHTHTHHHHHHTTHHHTHTHHHHHHHTHHHHHHHHHTTHHHHHTTHTTHHHHTHHHHHHTHTHHHHHTHHTHTHHHTHHHHHTTHHHHTHHHTHHHHTHHHTHHTHTHHHTHHTHHHHHTTHHTTTHTHTTHHHTHTHHTHTHHHHHHTTTHTTHTTTTTHTHHHTTTHHTHTHHHTHHHHHHHHTTHTHTHHHTHHTTHHHHHHTHTHHTTTHHHHHTTHTTTHHHHHTHHHTTHTHHHHTTTHHHTTHHHHTTHHHTTHTTTHHHTHTHHHTHHHHHTHTHHHHTTHTTHTHHHHTHTHHTTTHHHHTHHHTHHHHHHHHTTHHTHTHHHTTTHHHHHTHTTHHTTTHHTHTTHHHHHHHHHHTHHTHHTHHHHTHTHHHHHTTTHTHHHTHHTTTHHTTTHHTHTHTHHHHHHHHHHHTHHHHTHTTHHTHHHTTTHHTHHHHHHTTHTTHHTHHTHHHTTHTHHHTTTHHTHHHHHHHHHHTHHHHHHTTTHHTTHHHHTTHHTHHHHTHHHHTHTHHHHHHTTTHHHTHHHHHHHTTTHHHHHTHHHHHTHHHHHHHHHHHHHHTTHHTTTHHTHHTTHTHTHHHHHTHHTHHTTHTHTTHTHTHHTHHHTHHTHHTTTTHHHTTHHHTTHTHHHTHHHHHTHHHTHTHTHHHHTHHHTHTHHHTHHTTHHHTTHHTHHHTHHTHTHTTTTHTHHHHHHTTHHHTHHTHHHHTHTHHHHTHHHTTHHHHHTTHTHTHTHHHHHHHHTHHHTHHHHHHHHHHHTHTHHHTHHHHHTTHHTHHTTTTHHHHHTTTTHTHHHHHHHHHTHHTHHHTHHHHHTHTHTTTHHTHTHHTHHHHHHHHHHHHTHHTHTTHHTHHHTHTHHTHHTHHHHHHHTHTHHHTHHHTTTTTHTTHHHHTHHTTTTHHTHHTHHTHHTHHTHHHTHTHHHTTHHHTTHTHTHHHHHHHHHTTHTHHHHHHTHHHHTTHHTHHTHTTTHHHHHHHHTTHHTTHHTTTHHHHHHTHTTHHHTHHTHTTHTHHHHHHHHHHHHHHHTHHHHHHTHHHTTTHTHTTHHHHTHHTHTHHTHHHHTHHHTHTHTHTHHTHHTHTTHTHTHTHHHTHTHTTHHTTHTHHTHTHTHHHHHTTHHHHTHHTHTTHHHTHHHHHTHHHHHTTHTHHTHTHHHHHHTHHHTHHHHHHTHHTHHHHTTHHHHTHHTHHHHTHHHHHHHHHHHTHHTTHTHHHHTTHHHTHHHHHTHHTHHHHHHTHHHHTHHTTTHHHHHTHHHHHHHHHTHTHHTTHHHHHHTTHHHTHHHTTTHHHHTHHHTHHHHHHHHHHHHTHTTTTHTTTHHTHHHHHHHHHHHHHHHHHTHTHHTTTTHHHHHTHHTTHHHHHHHTHHTHTHHHTTTHTHHTTHHTHTHTHTTTHHHHTHTHHTHTHHHHTHHTTHTHHHHTHHHHTTTHTHTTHTTHHHHHHHHHTHTHHHTHHHTHHHTHTTHHTHHHTHHHHTHTTHTHTHTHHHHHTHHHHTHTTTHHHHHTHHTHTHTTTHTHTTHTHHHTHHTHHHTHTHTHHTHHHHTHHHHHHHHHTTTTTTHHHHHHTHHHHHTHHHHHHHHTHHHHHHHHTHTHHHHHHHTHHHHHTTHHHHTHHHTHHHHTHHHHTTTHTTHHHTTHHHTHTTTHTTHTTHHTHHHTHHHHTHTTTTTTHTHHHHTHHTHHHHHTTTHHHTTHTTTHHHHHTHTHHTHHTHHHHHTHHHHHTTHHHTHTHTHHHTTHHTTHHTHHHTHHHTTHHHTHHHHHTHHTTTTTHTTHTHTHTHHHTTHHHHTTTHHHHHHTHHHHHHHHHHHTTHTHTHTTTHHTHHTHTHTHHHHTTHHTTHHHHHHHHHHHHHHTHHHTHTHHHTHHHHHHTHHTTHTTTTTTHHTTHTTTTHHHTHHTTHHTTHHTHHTHHHHHHHHTTHHTHHHHHHHHTHTHHTHHHTHHTTTHHTTHHTHHHTHHHHTHHHHHHHTTHTHTTTTTHTHHTHTTTTHTHHHTHTTTHTHTHHHHHHHHTHHHHTHTTHHTTHTHHHTHHTTHHHHHHHHTTTHHHHHTHHHHTHHTTTTTHHTTHHTTHHHTHHTHHTHHHHHHHHTTHHHHTHHHTHTHHTHHTHHHHHTTTHTTHHTHHHHHHHHHHTHTHHHTHHTHHHTTTHHTHTTTHHHTHTTHHTHHHHHTHTHTHTHHHTHHHHHHHHHHHHHHTHTHHHHHHHTHTHHTHTTHHHHTHHTTHHHHHHHTTHTHHHTTTTTHHHHHHTHHHHHHTTHHHTHHTTTHHHTHTHHHHHHHTHHHHTHHTTTTTTTHHTTTHHTHHTTTTHHTHHHHHHHTTTTTTHHTHHHHHTHHHTHHHTTHHTHHTHHTTHHHHTHHTHHTHTHHHTHHTTTTHHHHHHHHHHTTHHHHTHHTHTTHTTHHHHHHHHTTHHHHHTTHHTHHTHTHTTTHHHTHHHTHTHTHTTTHHTTTHHTHHHHHHHHTHTTTTTHHHTHTHTTHTTHHHTHTTTHTHHHTTTHHTHHHHTTTHHHTHHHTHTTTHHTTHHTHHHTHHHHHHHHHHTHHHHHHHHHTHTHHHHHTHHHTHTTTHHTHHHTTHHTHHHTHTHHHHTHHHTTHTHTHHHHTHTTTHHHHTHHTHTHHHHHHHHHTTHHHHHHTTHHTHHHHHHHTTHTHHHHHHTHHTTHHTHHHHHTHHHTHHHHHHHHHHHHHHTTHHHHHHHHTHHHHHHHHTHHTTHHHHHHHHHTTTTHTTHHHTHTHHHHHTHHTHHHHHTTTHTHHTHTHHHTHHTTHHHTTHHHTHTHHTHHHTHHHHHHHHHTTHTHTTHHTTHHTHHHHHHHHHTTHHHHHTTHHTHTTHTHTHHHTHTTTHTHTHHHTHHHHHTHHHHHHHHTTTHTHHHTHTHHHHHHHHHHTHHTHHHTHHHHHHTHTHHHTHTHHHHTHHHHTTHHTTHHHHHHHHHHHTHTHHHTHTHTHHHHTHTHHHHTHHHHHHTHTHHTHTTTHHHTHTTHTHHTTHTHHHTHTHHHTHHHTTTHHTHTTHHHHHTTTTTHTTHHHTHTHHHTTTHHHHTTHHHTHTTHHTHTHTTHHTHHHHHHHHHHHHTHHHTTHHHHTHHHHHHHTHHHTHHHHHHTHHHHHHHHHHHHTHHTHHHTTTTTHHTHHHHHHHTHHHTTTTHHHTTHHTTHTTTTTHTHHTHHTHHHHHHTHHTTTTHHHHTHHHTTHHHTTHHTHHTHTTHTHHTTHHTHTTTHHHHTHHHHHHHHHTHHTHTHTTHHHHHHTTHHTHHHHHHTHHTTHHTHHTHHHTHHHHHTTHTTTTHHHTTHTTHHHTTHHHHTHTTHHHTHHTHHHTHHHHHHHHHHTTTTHTTTTHHHHHHTTHHHHTHTHTHHHHTTTTHTHHHTHTTHHTHHHHHHHTHHHTTHHTHHTTHTTHTTHTTHHHHHHTHHHHHHHHTHHHHTTTHHTHHHTTHTHTHHTTHTHHHHHTHHTHHTTTTHHHHTHHHHTTTHHHHTHHHHHHHHTTHHHHTTHHHHHTHTHHTHHHHTTTHHHHHHHHTHTHHHHHTHTHTHHHHHHHHHHHHHHTHHHTTTHHHTHHHTHTHHTHHTHHHHTHHHHHHTTHHTTHHTHHTHHHTTHHHTHHHHTHTTHTHHHHHHHHHTHTTHTTHHHTTTTTHHTTTHHTHTHHTTTHHHHHHHHTTHHTTTTHHHTHHHTHHHHTHHHHHHTHTHTTHTHHHTHHHTTTTHHHHHHHHHHHHHTHHHTHHHHTHTTTHTTHHTHHTHHHHHHHTHTHHHHHHTHTTTTHHHTTTHTTHTHTTTTTHHHHHTTHTTTHHHHHTTHTHHTHHTHHHHHHHTTTHHHTTHHTTHTTTHHHHHHTHTTTHHHHHHTHHTTHHHHHHHHHHTTHHHHHHHHTHHHHTHTTHTTTHTTHTHHHHHHHTHHHTHHTHTHTTTHTTHTTHHHHTHHTHHHTHTHTHHTTTHHTHTHHTTHTTTTTTTHHHTHHHTHHHHHTHHTHHHHTHHHHHTHTHTHHHHHTHHHHHTHHHTHHTHHHTHHTHHHHHHTHTHTHTHHTTHHHHTHHHTHTHHTHTTHHHHTHHTHHHTTHTTHTHHTHTHHTTHTTHTHHTHHHHTHHHTHTTHHHTHTHHHTHHHHHHHHHHHTHTHTTHHTTHHTTHHHHHHTHHHTHTTTHHHTHHHHTTHTHHHTTHHTTTTHHHHHHHTTHHTTHHTHHHTHTHHHHHTTTTTTHTTTHTTHHTTHHHHTHHHTHHHHTTHHHHHHTHHHHHHTHHTHTHTHHHHTHTHHTHTHTTTHHHHTHHHHHHHTHHHHHTTTTTHTHTTHTTHHHTTTHHTHTHHHHHTHHHHTHTTTTTTHHHHHHTHTTHTHHHHHTTHHTTTHHHHHHHHHHTHHHHTHHHTHHHHHTHTTHHHHHHHTHHHTHHTTHTHHHHHHHTHHTHTTHTHHHTHHHHHHHHTTHTHHHHTTHTTHHTHHHHHHTHHHTHTHHHHHTHHHHHHHHHTHHHHTHHHHHHTTTTTHHHHHHHHHHTTHTTTHTHHHTHTHTHTHHHHTTHHHHTHHTTTHHHTTHHTHHTTHHHTHTHHTTHTTHHHHHTHTTHHHHHHTHHTTHHHHHHHHHHTHHTHTHHHHTHHHHTHHTTTHHHHTTHHHTHHHTHHHHTHTHHTHHHHHHHHHTHTHHTTHHHHHTTTTHTHTHHHTHHTHTHHHHHTTTHHHHHTHHTHTHTHTTHHHTHHHHHTHHTHHTTHTHHTHTHTHHHHHTHTTTHTHTHHHTTTHHHHTHTHTHHHHHHHTTHTTHHTTHHTTTHHTTHHTHHTHHHHHTHHHHTTHHHHHTHHTHHHTHHHHHHHHTHHTTHTHTHHHTHHTTTHTHHHHHHHTHHHHHHTHTHTHHTHTHHHTHHTHHHHHTHTHTHHHHHHTHHTHHTTTHTHHHHTHHTHHHTTTHHHTHHTHHHHTTTHHTHHTTHTHTHTHTTHTHHHHHHTHHTTHTHHHHHHHHTHTTHHHTTHTTHHHHTHHTTHTHTHHHHHTTTHHHHHTHHTHTTTHTTTHTTHTTHHHHHTHHTHHHHTHHHTHHHTTTHHHHTHHHHHHHHTTHHHTHHHTHTHTHHHHHHTHTHHTHHHTHHHHHHTTHHHHHTTHHHHHHHTHHHHTHHHHTTTTTHHTHTHHHHHHHTHTTHHTHHHTHHHHHHHTHHTHHHHTHTHHTHHTHHHHTHHTHTTTHTHHHTHHTHHTTHHTHHHTHTHTTHHTHHTHHHHTHTTHHHTHHHTTHHTTTHTHHHHTHTHHHHTTHTHHHTHHTTHHTHTHHHHHTHTHTHHHHHTHHHTHTTTHTHHHHHTHHHHTHHHHTHHHTTTHHHHTHHHHTTTTHHHHTTHHHTTHTHTHHHHHHTHHHHHHHTHHHTHHTHHHHTHHTHHHHTTHHTHHHHHHTHHHHTHHHHTTHTHTHHHHTHTHTHTHHHHHTTTTHTHTTHTHTHHTHHTTTHTTHTTHTTHHTTHHHTTTHTHHHHHHTHHTHHHHHHTHTHHTTHTHHHHHHTTHHHTHTHTHHTTHTHHTTHHHHTHTHTHHTHHTTHTHTHHHHHHHTTHHHTTTTHTTTTHTHTHHTTHTTTTHHHTHHTHHHHHHHHHTHTHTTTHHHTHHTTTHTTHHTHHTTHHTHTHTHHHHHHTHHHTTTTHHHHTHTHHHHTTHHTTHHTTTHHHHHHTHTHHHHHHHTHHHHHHTHHHTTHHHHHHTHTTHTHHHHHTTHHTHTTHHTHHHHTTHHHTHTHHHTHHTHHHTHHHHTHHTHHTTTHHHHTHTTHTTTHHTTHTHHTHHHHHTTHHHHTHHHTHHHHHTTTTHHTHTHHHTTTTHHHHHHHTTTHHHHHHHHHHTTHHTHTHTTTHTHTHHTTTTHHHHTHHHHHHHTTTHHTTHHHHHTHHHTHHHHHHHTHHHHHHHHTHHHHHTTHHHHHHTHHTHHTHTTHHHHTHTHHHHHTHHHTTTTHTHTHTHTTTHTHHTTTTHHHHHTHHTTHHTHHHHTTTHHHHHHHHHHHHHTHHHHHTTHHHTTHTHTHTHHHTTHHHHHTHHHHTHTTTHHHHHHHTTHTHHHHHTHHHHTHTTTHHTHTHHHHHHTTHHHHHHTHTHHHHHTHHTHTHHHHHHHHHTHHHTHTTTTTTTHHHTTTTHHTHTHTHHTTTTTHTTHTHHHHHHHHHHHHHTHTTHHTTHHTTHTHTHHHTHHHTTTHHHHTTHHTHHHHHHHHHTHTTHTHHHHHHHTTTTHHTHHTHTHHHHTHHTTHHHHTHHHTTHHHHTHHHHHHTTHHHTHTHHHHHHHHHTTHHHHHTTTTTHTHHHHHHTTHHHTTHTHHHHTHHTHHHHHHHHHHTHHHTHTHHHHHHHTTHHTTHHHTTHHTHTHHTHHHHTHHTHHHTTHHHHHHTHHTHTTTTHHTHTTHHHHHHHTHTTTHHHTHHHHTHTTHHTHHHHTHHHHHHHTHHHHTTTHHHTHHTHHHHHHTHHTHHHTHHHHHHHHHTTTHHTHTHTHHTHTTHTHHTHHHTHTHHTHTHHHHHHTTHTHHHTHHHHTTTTHHHHTTTTTTHHTHTTHTHHTHTHHHHHTTHHHTHHHTTTHHHTHTHHHHHHHHHTTHHHTHTTHHHHHHTHTTHHTHHHHTHHTTHHHTHHTTTTTTHTHTHHHHHHHHHTHHHHTHHHHHTHHHHTHHTHTTHTTHTHTHHTTHTHTHHHTTHHTTTHHTTTHHTHTTHHTHTTHTHHHHHTHTTHTHHHHTTTHTHHHHHHTTHHHTHHTHHHHHHHHTHHTTHHHTHHTHHHTHHTTHTHHHTHTHHHHHTHHTHTHHTHHTHHHHHHHHTHTHHHTHTHTHTHTHHTHHHHHHTHHHTHHHHHHTHTHHHHHTHHHHHHTTTHHHTHHHHTTHTTHHHTHHHTTHTTHHTTHHHHHTHHHTTHHTTHTHHHTHHHTTHHTTTTTHHHTTHHTHHTHTHHTTHHHTHTHHTHTTHHTTHHHTTHHHTTHTTTHHHTHTTHTHHHHTTTHHTHTTTHTHHTHHTTHTTHHHTHHTHHHHHHHHHHTTHTHTTHHHTHHTHHTHHHHTHTTHHHTTTHTHHTTHHTTTHHHHTHTTHHHHHTHHHTHHHTHHTHTTHHHTHHHTTHTHHTHHHHHTTHHTHHHHTHHHHHTHHHHTHTTTHHHHTTHHTHHHHHHHHHHTHTHHTHHHHHTTTHHTTHHHHHTHHHTTHTHHTTTHHHTTTHTHHTTTHHHHHTHTHTHHTHTHHHHTHTHHHHTHHHTHHHTHTTTTTTHTHHTHTHHHHTHTHTHTHHHTTTHHTHHHHTHHHHHTTHTTHHHHTHTHHTTHHHHHHHTTHTHTHHTTHHTHHHHTHTTHHHHHHHTHHTHHHHTTTHTTHTHTTHHHHHHTHTHHHHTTHTHHHHTHTTTTHHHTHHTHHTHHTHHHTHHHHHTTHHTHHHHTHHHHHTHHTTHHHTHHTHTTHTHHHTTHHHHHHHTTTHTHHHHHTHHHHHHHTHHHTHHHHTTHHTTHHTHHTHHTHHHHHHTHTHTHTHTHHHHTHHHTHHHHHHHHHTTTHTHHHHHHTTTHTHTHHHHTTHTHTHTTTTTHTHHHHHHHTHTTTHHHHTHHHHHHTHHHHTTHTHTTHTHHHTHTTHTHHTHHHHTTHTHHHTHTHTTHHTHHHHTTTTHTTTHHHHHHTHTTHHHHTHHHTHHTHTTHHHHHHHHHTTHHHTTTHTTTTHTHHHTHHTTTTTHTHHHHTHHHTHTTTHTHTTHHHHHTTHTTHTHTTHHHHHTTTHHHTHHHHHHHTTTHHHTHHTHTTTHHTHHTHHHTHHHHHHHTHHTTTTHTTHTTHHHHHHHHTTHHHHHHHHTHTTHTHTHHHTHTHTHHTHHHHHTHTHHTTHHHHTHTHHTHTTHTTHTTHHHTHHHHHTHHTTTTHTHTHHHHHHTHTHHHHHHTHHHHHHTHHHTHHHTTTTTHTHHTHHHHHHTTTTHTHHHHHTTHHHHHHHHTHHTTHHHHHHHHHHTTTHTH
diff --git a/stats/distributions.py b/stats/distributions.py
@@ -0,0 +1,47 @@
+import random, pylab
+
+#set line width
+pylab.rcParams['lines.linewidth'] = 4
+#set font size for titles
+pylab.rcParams['axes.titlesize'] = 20
+#set font size for labels on axes
+pylab.rcParams['axes.labelsize'] = 20
+#set size of numbers on x-axis
+pylab.rcParams['xtick.labelsize'] = 16
+#set size of numbers on y-axis
+pylab.rcParams['ytick.labelsize'] = 16
+#set size of ticks on x-axis
+pylab.rcParams['xtick.major.size'] = 7
+#set size of ticks on y-axis
+pylab.rcParams['ytick.major.size'] = 7
+#set size of markers, e.g., circles representing points
+#set numpoints for legend
+pylab.rcParams['legend.numpoints'] = 1
+
+dist = []
+for i in range(100000):
+    dist.append(random.gauss(0, 30))
+pylab.hist(dist, 30)
+#pylab.show()
+
+import scipy.integrate
+
+def gaussian(x, mu, sigma):
+    factor1 = (1.0/(sigma*((2*pylab.pi)**0.5)))
+    factor2 = pylab.e**-(((x-mu)**2)/(2*sigma**2))
+    return factor1*factor2
+
+def checkEmpirical(numTrials):
+  for t in range(numTrials):
+     mu = random.randint(-10, 10)
+     sigma = random.randint(1, 10)
+     print('For mu =', mu, 'and sigma =', sigma)
+     for numStd in (1, 1.96, 3):
+        area = scipy.integrate.quad(gaussian,
+                                    mu-numStd*sigma,
+                                    mu+numStd*sigma,
+                                    (mu, sigma))[0]
+        print('  Fraction within', numStd, 'std =', round(area, 4))
+
+checkEmpirical(3)
+
diff --git a/stats/flipcoin.py b/stats/flipcoin.py
@@ -0,0 +1,65 @@
+import pylab, random
+random.seed(0)
+
+####################
+## Helper functions#
+####################
+def flipCoin(numFlips):
+    '''
+    Returns the result of numFlips coin flips of a biased coin.
+
+    numFlips (int): the number of times to flip the coin.
+
+    returns: a list of length numFlips, where values are either 1 or 0,
+    with 1 indicating Heads and 0 indicating Tails.
+    '''
+    with open('coin_flips.txt','r') as f:
+        all_flips = f.read()
+    flips = random.sample(all_flips, numFlips)
+    return [int(flip == 'H') for flip in flips]
+
+
+def getMeanAndStd(X):
+    mean = sum(X)/float(len(X))
+    tot = 0.0
+    for x in X:
+        tot += (x - mean)**2
+    std = (tot/len(X))**0.5
+    return mean, std
+
+
+#############################
+## CLT Hands-on		     #
+##				     #
+## Fill in the missing code #
+## Do not use numpy/pylab   #
+#############################
+meanOfMeans, stdOfMeans = [], []
+sampleSizes = range(10, 500, 50)
+
+def clt():
+    for sampleSize in sampleSizes:
+        sampleMeans = []
+        for t in range(20):
+            sample = flipCoin(sampleSize)
+            sampleMeans.append(getMeanAndStd(sample)[0])
+        meanOfMeans.append(getMeanAndStd(sampleMeans)[0])
+        stdOfMeans.append(getMeanAndStd(sampleMeans)[1])
+        ## FILL IN TWO LINES
+        ## WHAT TO DO WITH THE SAMPLE MEANS?
+
+clt()
+pylab.figure(1)
+#pylab.errorbar(sampleSizes, meanOfMeans,
+#               yerr = 1.96*pylab.array(stdOfMeans),
+#               label = "Est. mean and 95 confidence interval")
+pylab.xlim(0, max(sampleSizes) + 50)
+pylab.axhline(0.65, linestyle = '--',
+              label = 'True probability of Heads')
+pylab.title('Estimates of Probability of Heads')
+pylab.xlabel('Sample Size')
+pylab.ylabel('Fraction of Heads (minutes)')
+pylab.legend(loc = 'best')
+pylab.show()
+
+

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+THTTHTHTTHTHHHHTHHHHHHTTHTTTHHTHTTTHHTHTTHTHHHHTHHTHHTTHHTHHHHTHHTHTHTTTTHHTHHHHHHHHTTTTHHHHHHHHHTHTTHHHHHHTHHHHTHHTHHHHTTHTHHTTHHTHTHHTTHHHTHHTHTTTHHHHHTHHHHHHHHTHTTTHHTHTTHTHHTHTTTHTHTHTHHHHTHHHTHHHHHHHTTHTTHHHHHHHHHTHHHTHHHHHTHTTHTTTHHTHHTHHHHHTHHHTHTTHHHTTTHHHHHTTHTTTTHTTTHHHHHHHHHHHHTHHHHHHHHHHTTHTTHHTHHTHTTHTTHHHHHTHHHHTHTTHHTHTHHHHHHHTTHHHTHHHHHHHHTHHHHHTTHHHHHHTTHHHHHTTHHHHHTHHTHHTHHHTTHTTTHHTHTTHHTTHTHHTTTHTHHHTHHHTHTHTHHHTTHTHTTTTTHHHTHHTHHHTHHHTTTHHHTHHHHHHHTHHTHHHTTHHTTHHHTHHHHTHTHTHTTHHHTTTHHHTHTTHTHTHTHHHHHHHHHTHHTHHHTHHHHHHTHTTHTHTHHTHTHHHHTTHHHHHTHTTHTTHHHHHHTHHHHHHTTHHTHTTTTHTHHHHTHHHHHHHHHHHHTTTTTHTHHHHHHTTHHTHTTTHTHTTHHTHTTHTHTHHTHHHTTTHHHHTHHHTTHTHHTHHTHTTHHHTTTHTHTTHHHHHTHTHHHHHTHTHHTHTTHHTHTTHHHTHHHHHTHHHHHHHTHHHHTTHHHHHTHTHHHHHTTHHTHHHTHTHHHTTHTTTHTTHHHTHHTTHHHHTHHHHTHHHTTHHHTTHHTTHTHHTTHHHHTHTHHTHTTTTTHHHTHHTHHHHHTHHHHHTHTHHHTHTHTHHTHTHHHHHHHHTHTHHHHHTHHHTTTTHHHHHHHTHHHTTHTTHHHHTTHHHHHHHTHHHHTHHHHHHHHHTTHHHHHHHTHTHHTHHHHHHHTHHHHTHHHTTTTHHHHHHTHHTHTTHHTHTTTTHTHHHTHHHTHHHTTTTHHHTHTHHHHTHTHHTTHTTHHTHHTHHTHHTHHTHTTHHHHHTHTHHHHHHHTTTHTHTHTTHTHHHHTTHHHHHHHTHTHHTHTHHTHHHHTTHHHTHTHTHHTHHTTHTHTTHHTHHHHHHTTTTTTHHHTHTHTHHHTHHTHTHHHHTHHTTTHHTHHHHHHTHHHHHHHHTHHTTTHHTHTHTHHHHHHTTHHHTHHTHHHHTHTHTHTHHTHTTHTHHTHHHHHTTTHHHHHHTTHHHHHTHTHHHHTHHTHHHHHHTTHHHHHHTHHTHHHHTHHHTHHTHHHHHTHHTHHHHHTHHTTHHHHHTHTHHHTHHHHTHTHHTTTHHHTTTTHTHHTHTHHHHHHHHTTTTHTTHHHTTHTHHHTHHHHHHTHHHHHHHHHHHHHHTHTTTHHTHHHHHHHHHHTHTTHTHHHTTTTTHHTTHTTHHTHTTHHTTTHHHHHHHTHHHHHHTHHTHHHHHHTHTTHTHHHTHHHTHTTHHTHTHHHHTHTTHHHHHTTHHHTTHHHHHHTHHHHHHHHTHHHHHHHHTHTHHHTTTHHTHHHHHHHTHTHHHHHHHTHHHHHHHHTTHHHHTTHTHHHHTHHTHHTHHTHTHHTTHTHTHHTHTTTHHTHHTHTHHHHHTHTTHTHHTHHTHTHTHTTHHHHTHHHHHHHTHHHHHHHHTTHTHHTHHTHHTHTHHTHTTHHHTHHHHTHHTTHHTHHTHHTHHTHHHTHHHHTTHHHTHHTHHTTHHHTHHTTTHHHTHHHTTTTHTTTHHHHTHHHTTHTHHHHHHTTHTHHTTTHTHHHHTHTHHHTTTTHHTHHHHTHHTTHHHHHTHHHTHHHHTHHTHHHHHHHHTTHHHHHHHHHTHHHTHHHTTTTHTHHTTHHHTHTHHHTHHHHHHHHHTHHTHTTTHHHHHHHTHTHHHHTHHHHTTHHTHHTHTHTTTHHHTHHHHHTHHHHHTHTHHHHTTTHTTHHHTHTHHHTHHTHHHHHHHHTHHTHTTHHHTTHTHTHTTTHHHHTTHTTHTHTTHHTTHHHHTTHHHTTTHHHHHHHHHHHHHTHTHHTHTTTHHHHTTHHTTHHHTHTHHHHHHTTHHHTHTHHHHHHHTHHHHHHHHHTTHHHHHTTHTTHHHHTHHHHHHTHTHHHHHTHHTHTHHHTHHHHHTTHHHHTHHHTHHHHTHHHTHHTHTHHHTHHTHHHHHTTHHTTTHTHTTHHHTHTHHTHTHHHHHHTTTHTTHTTTTTHTHHHTTTHHTHTHHHTHHHHHHHHTTHTHTHHHTHHTTHHHHHHTHTHHTTTHHHHHTTHTTTHHHHHTHHHTTHTHHHHTTTHHHTTHHHHTTHHHTTHTTTHHHTHTHHHTHHHHHTHTHHHHTTHTTHTHHHHTHTHHTTTHHHHTHHHTHHHHHHHHTTHHTHTHHHTTTHHHHHTHTTHHTTTHHTHTTHHHHHHHHHHTHHTHHTHHHHTHTHHHHHTTTHTHHHTHHTTTHHTTTHHTHTHTHHHHHHHHHHHTHHHHTHTTHHTHHHTTTHHTHHHHHHTTHTTHHTHHTHHHTTHTHHHTTTHHTHHHHHHHHHHTHHHHHHTTTHHTTHHHHTTHHTHHHHTHHHHTHTHHHHHHTTTHHHTHHHHHHHTTTHHHHHTHHHHHTHHHHHHHHHHHHHHTTHHTTTHHTHHTTHTHTHHHHHTHHTHHTTHTHTTHTHTHHTHHHTHHTHHTTTTHHHTTHHHTTHTHHHTHHHHHTHHHTHTHTHHHHTHHHTHTHHHTHHTTHHHTTHHTHHHTHHTHTHTTTTHTHHHHHHTTHHHTHHTHHHHTHTHHHHTHHHTTHHHHHTTHTHTHTHHHHHHHHTHHHTHHHHHHHHHHHTHTHHHTHHHHHTTHHTHHTTTTHHHHHTTTTHTHHHHHHHHHTHHTHHHTHHHHHTHTHTTTHHTHTHHTHHHHHHHHHHHHTHHTHTTHHTHHHTHTHHTHHTHHHHHHHTHTHHHTHHHTTTTTHTTHHHHTHHTTTTHHTHHTHHTHHTHHTHHHTHTHHHTTHHHTTHTHTHHHHHHHHHTTHTHHHHHHTHHHHTTHHTHHTHTTTHHHHHHHHTTHHTTHHTTTHHHHHHTHTTHHHTHHTHTTHTHHHHHHHHHHHHHHHTHHHHHHTHHHTTTHTHTTHHHHTHHTHTHHTHHHHTHHHTHTHTHTHHTHHTHTTHTHTHTHHHTHTHTTHHTTHTHHTHTHTHHHHHTTHHHHTHHTHTTHHHTHHHHHTHHHHHTTHTHHTHTHHHHHHTHHHTHHHHHHTHHTHHHHTTHHHHTHHTHHHHTHHHHHHHHHHHTHHTTHTHHHHTTHHHTHHHHHTHHTHHHHHHTHHHHTHHTTTHHHHHTHHHHHHHHHTHTHHTTHHHHHHTTHHHTHHHTTTHHHHTHHHTHHHHHHHHHHHHTHTTTTHTTTHHTHHHHHHHHHHHHHHHHHTHTHHTTTTHHHHHTHHTTHHHHHHHTHHTHTHHHTTTHTHHTTHHTHTHTHTTTHHHHTHTHHTHTHHHHTHHTTHTHHHHTHHHHTTTHTHTTHTTHHHHHHHHHTHTHHHTHHHTHHHTHTTHHTHHHTHHHHTHTTHTHTHTHHHHHTHHHHTHTTTHHHHHTHHTHTHTTTHTHTTHTHHHTHHTHHHTHTHTHHTHHHHTHHHHHHHHHTTTTTTHHHHHHTHHHHHTHHHHHHHHTHHHHHHHHTHTHHHHHHHTHHHHHTTHHHHTHHHTHHHHTHHHHTTTHTTHHHTTHHHTHTTTHTTHTTHHTHHHTHHHHTHTTTTTTHTHHHHTHHTHHHHHTTTHHHTTHTTTHHHHHTHTHHTHHTHHHHHTHHHHHTTHHHTHTHTHHHTTHHTTHHTHHHTHHHTTHHHTHHHHHTHHTTTTTHTTHTHTHTHHHTTHHHHTTTHHHHHHTHHHHHHHHHHHTTHTHTHTTTHHTHHTHTHTHHHHTTHHTTHHHHHHHHHHHHHHTHHHTHTHHHTHHHHHHTHHTTHTTTTTTHHTTHTTTTHHHTHHTTHHTTHHTHHTHHHHHHHHTTHHTHHHHHHHHTHTHHTHHHTHHTTTHHTTHHTHHHTHHHHTHHHHHHHTTHTHTTTTTHTHHTHTTTTHTHHHTHTTTHTHTHHHHHHHHTHHHHTHTTHHTTHTHHHTHHTTHHHHHHHHTTTHHHHHTHHHHTHHTTTTTHHTTHHTTHHHTHHTHHTHHHHHHHHTTHHHHTHHHTHTHHTHHTHHHHHTTTHTTHHTHHHHHHHHHHTHTHHHTHHTHHHTTTHHTHTTTHHHTHTTHHTHHHHHTHTHTHTHHHTHHHHHHHHHHHHHHTHTHHHHHHHTHTHHTHTTHHHHTHHTTHHHHHHHTTHTHHHTTTTTHHHHHHTHHHHHHTTHHHTHHTTTHHHTHTHHHHHHHTHHHHTHHTTTTTTTHHTTTHHTHHTTTTHHTHHHHHHHTTTTTTHHTHHHHHTHHHTHHHTTHHTHHTHHTTHHHHTHHTHHTHTHHHTHHTTTTHHHHHHHHHHTTHHHHTHHTHTTHTTHHHHHHHHTTHHHHHTTHHTHHTHTHTTTHHHTHHHTHTHTHTTTHHTTTHHTHHHHHHHHTHTTTTTHHHTHTHTTHTTHHHTHTTTHTHHHTTTHHTHHHHTTTHHHTHHHTHTTTHHTTHHTHHHTHHHHHHHHHHTHHHHHHHHHTHTHHHHHTHHHTHTTTHHTHHHTTHHTHHHTHTHHHHTHHHTTHTHTHHHHTHTTTHHHHTHHTHTHHHHHHHHHTTHHHHHHTTHHTHHHHHHHTTHTHHHHHHTHHTTHHTHHHHHTHHHTHHHHHHHHHHHHHHTTHHHHHHHHTHHHHHHHHTHHTTHHHHHHHHHTTTTHTTHHHTHTHHHHHTHHTHHHHHTTTHTHHTHTHHHTHHTTHHHTTHHHTHTHHTHHHTHHHHHHHHHTTHTHTTHHTTHHTHHHHHHHHHTTHHHHHTTHHTHTTHTHTHHHTHTTTHTHTHHHTHHHHHTHHHHHHHHTTTHTHHHTHTHHHHHHHHHHTHHTHHHTHHHHHHTHTHHHTHTHHHHTHHHHTTHHTTHHHHHHHHHHHTHTHHHTHTHTHHHHTHTHHHHTHHHHHHTHTHHTHTTTHHHTHTTHTHHTTHTHHHTHTHHHTHHHTTTHHTHTTHHHHHTTTTTHTTHHHTHTHHHTTTHHHHTTHHHTHTTHHTHTHTTHHTHHHHHHHHHHHHTHHHTTHHHHTHHHHHHHTHHHTHHHHHHTHHHHHHHHHHHHTHHTHHHTTTTTHHTHHHHHHHTHHHTTTTHHHTTHHTTHTTTTTHTHHTHHTHHHHHHTHHTTTTHHHHTHHHTTHHHTTHHTHHTHTTHTHHTTHHTHTTTHHHHTHHHHHHHHHTHHTHTHTTHHHHHHTTHHTHHHHHHTHHTTHHTHHTHHHTHHHHHTTHTTTTHHHTTHTTHHHTTHHHHTHTTHHHTHHTHHHTHHHHHHHHHHTTTTHTTTTHHHHHHTTHHHHTHTHTHHHHTTTTHTHHHTHTTHHTHHHHHHHTHHHTTHHTHHTTHTTHTTHTTHHHHHHTHHHHHHHHTHHHHTTTHHTHHHTTHTHTHHTTHTHHHHHTHHTHHTTTTHHHHTHHHHTTTHHHHTHHHHHHHHTTHHHHTTHHHHHTHTHHTHHHHTTTHHHHHHHHTHTHHHHHTHTHTHHHHHHHHHHHHHHTHHHTTTHHHTHHHTHTHHTHHTHHHHTHHHHHHTTHHTTHHTHHTHHHTTHHHTHHHHTHTTHTHHHHHHHHHTHTTHTTHHHTTTTTHHTTTHHTHTHHTTTHHHHHHHHTTHHTTTTHHHTHHHTHHHHTHHHHHHTHTHTTHTHHHTHHHTTTTHHHHHHHHHHHHHTHHHTHHHHTHTTTHTTHHTHHTHHHHHHHTHTHHHHHHTHTTTTHHHTTTHTTHTHTTTTTHHHHHTTHTTTHHHHHTTHTHHTHHTHHHHHHHTTTHHHTTHHTTHTTTHHHHHHTHTTTHHHHHHTHHTTHHHHHHHHHHTTHHHHHHHHTHHHHTHTTHTTTHTTHTHHHHHHHTHHHTHHTHTHTTTHTTHTTHHHHTHHTHHHTHTHTHHTTTHHTHTHHTTHTTTTTTTHHHTHHHTHHHHHTHHTHHHHTHHHHHTHTHTHHHHHTHHHHHTHHHTHHTHHHTHHTHHHHHHTHTHTHTHHTTHHHHTHHHTHTHHTHTTHHHHTHHTHHHTTHTTHTHHTHTHHTTHTTHTHHTHHHHTHHHTHTTHHHTHTHHHTHHHHHHHHHHHTHTHTTHHTTHHTTHHHHHHTHHHTHTTTHHHTHHHHTTHTHHHTTHHTTTTHHHHHHHTTHHTTHHTHHHTHTHHHHHTTTTTTHTTTHTTHHTTHHHHTHHHTHHHHTTHHHHHHTHHHHHHTHHTHTHTHHHHTHTHHTHTHTTTHHHHTHHHHHHHTHHHHHTTTTTHTHTTHTTHHHTTTHHTHTHHHHHTHHHHTHTTTTTTHHHHHHTHTTHTHHHHHTTHHTTTHHHHHHHHHHTHHHHTHHHTHHHHHTHTTHHHHHHHTHHHTHHTTHTHHHHHHHTHHTHTTHTHHHTHHHHHHHHTTHTHHHHTTHTTHHTHHHHHHTHHHTHTHHHHHTHHHHHHHHHTHHHHTHHHHHHTTTTTHHHHHHHHHHTTHTTTHTHHHTHTHTHTHHHHTTHHHHTHHTTTHHHTTHHTHHTTHHHTHTHHTTHTTHHHHHTHTTHHHHHHTHHTTHHHHHHHHHHTHHTHTHHHHTHHHHTHHTTTHHHHTTHHHTHHHTHHHHTHTHHTHHHHHHHHHTHTHHTTHHHHHTTTTHTHTHHHTHHTHTHHHHHTTTHHHHHTHHTHTHTHTTHHHTHHHHHTHHTHHTTHTHHTHTHTHHHHHTHTTTHTHTHHHTTTHHHHTHTHTHHHHHHHTTHTTHHTTHHTTTHHTTHHTHHTHHHHHTHHHHTTHHHHHTHHTHHHTHHHHHHHHTHHTTHTHTHHHTHHTTTHTHHHHHHHTHHHHHHTHTHTHHTHTHHHTHHTHHHHHTHTHTHHHHHHTHHTHHTTTHTHHHHTHHTHHHTTTHHHTHHTHHHHTTTHHTHHTTHTHTHTHTTHTHHHHHHTHHTTHTHHHHHHHHTHTTHHHTTHTTHHHHTHHTTHTHTHHHHHTTTHHHHHTHHTHTTTHTTTHTTHTTHHHHHTHHTHHHHTHHHTHHHTTTHHHHTHHHHHHHHTTHHHTHHHTHTHTHHHHHHTHTHHTHHHTHHHHHHTTHHHHHTTHHHHHHHTHHHHTHHHHTTTTTHHTHTHHHHHHHTHTTHHTHHHTHHHHHHHTHHTHHHHTHTHHTHHTHHHHTHHTHTTTHTHHHTHHTHHTTHHTHHHTHTHTTHHTHHTHHHHTHTTHHHTHHHTTHHTTTHTHHHHTHTHHHHTTHTHHHTHHTTHHTHTHHHHHTHTHTHHHHHTHHHTHTTTHTHHHHHTHHHHTHHHHTHHHTTTHHHHTHHHHTTTTHHHHTTHHHTTHTHTHHHHHHTHHHHHHHTHHHTHHTHHHHTHHTHHHHTTHHTHHHHHHTHHHHTHHHHTTHTHTHHHHTHTHTHTHHHHHTTTTHTHTTHTHTHHTHHTTTHTTHTTHTTHHTTHHHTTTHTHHHHHHTHHTHHHHHHTHTHHTTHTHHHHHHTTHHHTHTHTHHTTHTHHTTHHHHTHTHTHHTHHTTHTHTHHHHHHHTTHHHTTTTHTTTTHTHTHHTTHTTTTHHHTHHTHHHHHHHHHTHTHTTTHHHTHHTTTHTTHHTHHTTHHTHTHTHHHHHHTHHHTTTTHHHHTHTHHHHTTHHTTHHTTTHHHHHHTHTHHHHHHHTHHHHHHTHHHTTHHHHHHTHTTHTHHHHHTTHHTHTTHHTHHHHTTHHHTHTHHHTHHTHHHTHHHHTHHTHHTTTHHHHTHTTHTTTHHTTHTHHTHHHHHTTHHHHTHHHTHHHHHTTTTHHTHTHHHTTTTHHHHHHHTTTHHHHHHHHHHTTHHTHTHTTTHTHTHHTTTTHHHHTHHHHHHHTTTHHTTHHHHHTHHHTHHHHHHHTHHHHHHHHTHHHHHTTHHHHHHTHHTHHTHTTHHHHTHTHHHHHTHHHTTTTHTHTHTHTTTHTHHTTTTHHHHHTHHTTHHTHHHHTTTHHHHHHHHHHHHHTHHHHHTTHHHTTHTHTHTHHHTTHHHHHTHHHHTHTTTHHHHHHHTTHTHHHHHTHHHHTHTTTHHTHTHHHHHHTTHHHHHHTHTHHHHHTHHTHTHHHHHHHHHTHHHTHTTTTTTTHHHTTTTHHTHTHTHHTTTTTHTTHTHHHHHHHHHHHHHTHTTHHTTHHTTHTHTHHHTHHHTTTHHHHTTHHTHHHHHHHHHTHTTHTHHHHHHHTTTTHHTHHTHTHHHHTHHTTHHHHTHHHTTHHHHTHHHHHHTTHHHTHTHHHHHHHHHTTHHHHHTTTTTHTHHHHHHTTHHHTTHTHHHHTHHTHHHHHHHHHHTHHHTHTHHHHHHHTTHHTTHHHTTHHTHTHHTHHHHTHHTHHHTTHHHHHHTHHTHTTTTHHTHTTHHHHHHHTHTTTHHHTHHHHTHTTHHTHHHHTHHHHHHHTHHHHTTTHHHTHHTHHHHHHTHHTHHHTHHHHHHHHHTTTHHTHTHTHHTHTTHTHHTHHHTHTHHTHTHHHHHHTTHTHHHTHHHHTTTTHHHHTTTTTTHHTHTTHTHHTHTHHHHHTTHHHTHHHTTTHHHTHTHHHHHHHHHTTHHHTHTTHHHHHHTHTTHHTHHHHTHHTTHHHTHHTTTTTTHTHTHHHHHHHHHTHHHHTHHHHHTHHHHTHHTHTTHTTHTHTHHTTHTHTHHHTTHHTTTHHTTTHHTHTTHHTHTTHTHHHHHTHTTHTHHHHTTTHTHHHHHHTTHHHTHHTHHHHHHHHTHHTTHHHTHHTHHHTHHTTHTHHHTHTHHHHHTHHTHTHHTHHTHHHHHHHHTHTHHHTHTHTHTHTHHTHHHHHHTHHHTHHHHHHTHTHHHHHTHHHHHHTTTHHHTHHHHTTHTTHHHTHHHTTHTTHHTTHHHHHTHHHTTHHTTHTHHHTHHHTTHHTTTTTHHHTTHHTHHTHTHHTTHHHTHTHHTHTTHHTTHHHTTHHHTTHTTTHHHTHTTHTHHHHTTTHHTHTTTHTHHTHHTTHTTHHHTHHTHHHHHHHHHHTTHTHTTHHHTHHTHHTHHHHTHTTHHHTTTHTHHTTHHTTTHHHHTHTTHHHHHTHHHTHHHTHHTHTTHHHTHHHTTHTHHTHHHHHTTHHTHHHHTHHHHHTHHHHTHTTTHHHHTTHHTHHHHHHHHHHTHTHHTHHHHHTTTHHTTHHHHHTHHHTTHTHHTTTHHHTTTHTHHTTTHHHHHTHTHTHHTHTHHHHTHTHHHHTHHHTHHHTHTTTTTTHTHHTHTHHHHTHTHTHTHHHTTTHHTHHHHTHHHHHTTHTTHHHHTHTHHTTHHHHHHHTTHTHTHHTTHHTHHHHTHTTHHHHHHHTHHTHHHHTTTHTTHTHTTHHHHHHTHTHHHHTTHTHHHHTHTTTTHHHTHHTHHTHHTHHHTHHHHHTTHHTHHHHTHHHHHTHHTTHHHTHHTHTTHTHHHTTHHHHHHHTTTHTHHHHHTHHHHHHHTHHHTHHHHTTHHTTHHTHHTHHTHHHHHHTHTHTHTHTHHHHTHHHTHHHHHHHHHTTTHTHHHHHHTTTHTHTHHHHTTHTHTHTTTTTHTHHHHHHHTHTTTHHHHTHHHHHHTHHHHTTHTHTTHTHHHTHTTHTHHTHHHHTTHTHHHTHTHTTHHTHHHHTTTTHTTTHHHHHHTHTTHHHHTHHHTHHTHTTHHHHHHHHHTTHHHTTTHTTTTHTHHHTHHTTTTTHTHHHHTHHHTHTTTHTHTTHHHHHTTHTTHTHTTHHHHHTTTHHHTHHHHHHHTTTHHHTHHTHTTTHHTHHTHHHTHHHHHHHTHHTTTTHTTHTTHHHHHHHHTTHHHHHHHHTHTTHTHTHHHTHTHTHHTHHHHHTHTHHTTHHHHTHTHHTHTTHTTHTTHHHTHHHHHTHHTTTTHTHTHHHHHHTHTHHHHHHTHHHHHHTHHHTHHHTTTTTHTHHTHHHHHHTTTTHTHHHHHTTHHHHHHHHTHHTTHHHHHHHHHHTTTHTH