HW1-Randomness.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Python for Research Homework: Week 1\n",
    "\n",
    "In this homework, we will use objects, functions, and randomness to find the length of documents, approximate $\\pi$, and smooth out random noise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1\n",
    "\n",
    "In this five-part exercise, we will count the frequency of each letter in a given string.\n",
    "\n",
    "#### Exercise 1a\n",
    "\n",
    "- Import the `string` library.\n",
    "- Create a variable `alphabet` that consists of the lowercase and uppercase letters in the English alphabet using the `ascii_letters` data attribute of the `string` library."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# write your code here!\n",
    "import string\n",
    "alphabet = string.ascii_letters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1b\n",
    "- The lower and upper case letters of the English alphabet should stored as the string variable `alphabet`.\n",
    "- Consider the sentence 'Jim quickly realized that the beautiful gowns are expensive'. Create a dictionary `count_letters` with keys consisting of each unique letter in the sentence and values consisting of the number of times each letter is used in this sentence. Count upper case and lower case letters separately in the dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentence = 'Jim quickly realized that the beautiful gowns are expensive'\n",
    "\n",
    "count_letters = {}\n",
    "for i in sentence:\n",
    "    if i in alphabet:\n",
    "        count = sentence.count(i)\n",
    "        count_letters.update({i : count})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1c\n",
    "- Rewrite your code from 1b to make a function called `counter` that takes a string `input_string` and returns a dictionary of letter counts `count_letters`.\n",
    "- Use your function to call `counter(sentence)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'J': 1,\n",
       " 'i': 5,\n",
       " 'm': 1,\n",
       " 'q': 1,\n",
       " 'u': 3,\n",
       " 'c': 1,\n",
       " 'k': 1,\n",
       " 'l': 3,\n",
       " 'y': 1,\n",
       " 'r': 2,\n",
       " 'e': 8,\n",
       " 'a': 4,\n",
       " 'z': 1,\n",
       " 'd': 1,\n",
       " 't': 4,\n",
       " 'h': 2,\n",
       " 'b': 1,\n",
       " 'f': 1,\n",
       " 'g': 1,\n",
       " 'o': 1,\n",
       " 'w': 1,\n",
       " 'n': 2,\n",
       " 's': 2,\n",
       " 'x': 1,\n",
       " 'p': 1,\n",
       " 'v': 1}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def counter(input_string):\n",
    "    count_letters = {}\n",
    "    for i in input_string:\n",
    "        if i in alphabet:\n",
    "            count = input_string.count(i)\n",
    "            count_letters.update({i : count})\n",
    "    return count_letters\n",
    "\n",
    "counter(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1d\n",
    "- Abraham Lincoln was a president during the American Civil War. His famous 1863 Gettysburg Address has been stored as `address`. Use the `counter` function from 1c to return a dictionary consisting of the count of each letter in this address and save it as `address_count`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "address = \"\"\"Four score and seven years ago our fathers brought forth on this continent, a new nation, \n",
    "conceived in Liberty, and dedicated to the proposition that all men are created equal. Now we are engaged in a \n",
    "great civil war, testing whether that nation, or any nation so conceived and so dedicated, can long endure. \n",
    "We are met on a great battle-field of that war. We have come to dedicate a portion of that field, as a final \n",
    "resting place for those who here gave their lives that that nation might live. It is altogether fitting and proper \n",
    "that we should do this. But, in a larger sense, we can not dedicate -- we can not consecrate -- we can not hallow -- \n",
    "this ground. The brave men, living and dead, who struggled here, have consecrated it, far above our poor power to add \n",
    "or detract. The world will little note, nor long remember what we say here, but it can never forget what they did here. \n",
    "It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so \n",
    "nobly advanced. It is rather for us to be here dedicated to the great task remaining before us -- that from these honored \n",
    "dead we take increased devotion to that cause for which they gave the last full measure of devotion -- that we here \n",
    "highly resolve that these dead shall not have died in vain -- that this nation, under God, shall have a new birth of \n",
    "freedom -- and that government of the people, by the people, for the people, shall not perish from the earth.\"\"\"   \n",
    "\n",
    "# Write your code here!\n",
    "address_count = counter(address)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 1f\n",
    "- The frequency of each letter in the Gettysburg Address is already stored as `address_count`. Use this dictionary to find the most common letter in the Gettysburg address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mcl = Most Common Letter\n",
    "n = sorted(address_count.values(), reverse=True)[0]\n",
    "mcl = \"\"\n",
    "for (l, c) in address_count.items():\n",
    "    if c == n:\n",
    "        mcl = l\n",
    "\n",
    "mcl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 2\n",
    "\n",
    "Consider a circle inscribed in a square. The ratio of their areas (the ratio of the area of the circle to the area of the square) is $\\frac{\\pi}{4}$. In this six-part exercise, we will find a way to approximate this value.\n",
    "\n",
    "#### Exercise 2a\n",
    "- Using the `math` library, calculate and print the value of $\\frac{\\pi}{4}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7853981633974483"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# write your code here\n",
    "import math\n",
    "\n",
    "math.pi/4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2b\n",
    "- Using `random.uniform()`, create a function `rand()` that generates a single float between $-1$ and $1$.\n",
    "- Call `rand()` once. For us to be able to check your solution, we will use `random.seed()` to fix the seed value of the random number generator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.7312715117751976"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "random.seed(1) # Fixes the see of the random number generator.\n",
    "\n",
    "def rand():\n",
    "    return random.uniform(-1, 1)\n",
    "\n",
    "rand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2c\n",
    "- The distance between two points x and y is the square root of the sum of squared differences along each dimension of x and y. Write a function` distance(x, y)` that takes two vectors as its input and outputs the distance between them. Use your function to find the distance between $x=(0,0)$ and $y=(1,1)$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def distance(x, y):\n",
    "    dist = math.sqrt((x[0]-y[0])**2 + (x[1]-y[1])**2)\n",
    "    return dist\n",
    "x = (0, 0)\n",
    "y = (1, 1)\n",
    "\n",
    "distance(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2d\n",
    "\n",
    "- Write a function `in_circle(x, origin)` that determines whether a point in a two dimensional plane falls within a unit circle surrounding a given origin.\n",
    "    - Your function should return a boolean `True` if the distance between `x` and `origin` is less than 1 and `False` otherwise.\n",
    "    - Use `distance(x, y)` as defined in 2c.\n",
    "- Use your function to determine whether the point (1,1) lies within the unit circle centered at (0,0)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def in_circle(x, origin = [0,0]):\n",
    "    if distance(x, origin) < 1:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "z = (1, 1)\n",
    "\n",
    "in_circle(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2e\n",
    "\n",
    "- Create a list `inside` of `R=10000` booleans that determines whether or not a point falls within the unit circle centered at `(0,0)`. \n",
    "    - Use the `rand` function from 2b to generate `R` randomly located points.\n",
    "    - Use the function `in_circle` to test whether or not a given pint falls within the unit circle.\n",
    "- Find the proportion of points that fall within the circle by summing all `True` values in the `inside` list; then divide the answer by `R` to obtain a proportion.\n",
    "- Print your answer. This proportion is an estimate of the ratio of the two areas!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.779"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.seed(1) \n",
    "\n",
    "points = []\n",
    "R = []\n",
    "inside = []\n",
    "\n",
    "for i in range(10000):\n",
    "    p = (rand(), rand())\n",
    "    if in_circle(p):\n",
    "        R.append(True)\n",
    "        inside.append(True)\n",
    "    else:\n",
    "        R.append(False)\n",
    "\n",
    "        \n",
    "ratio = len(inside)/len(R)\n",
    "ratio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 2f\n",
    "\n",
    "- Find the difference between your estimate from part 2e and `math.pi / 4`. Note: `inside` and `R` are defined as in Exercise 2e."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.006398163397448253"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs((math.pi/4) - ratio)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 3\n",
    "\n",
    "A list of numbers representing measurements obtained from a system of interest can often be noisy. One way to deal with noise to smoothen the values by replacing each value with the average of the value and the values of its neighbors.\n",
    "\n",
    "#### Exercise 3a\n",
    "\n",
    "- Write a function `moving_window_average(x, n_neighbors)` that takes a list `x` and the number of neighbors `n_neighbors` on either side of a given member of the list to consider.\n",
    "- For each value in `x`, `moving_window_average(x, n_neighbors)` computes the average of the value and the values of its neighbors.\n",
    "- `moving_window_average` should return a list of averaged values that is the same length as the original list.\n",
    "- If there are not enough neighbors (for cases near the edge), substitute the original value for a neighbor for each missing neighbor.\n",
    "- Use your function to find the moving window sum of `x=[0,10,5,3,1,5]` and `n_neighbors=1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.3333333333333335, 5.0, 6.0, 3.0, 3.0, 3.6666666666666665]\n"
     ]
    }
   ],
   "source": [
    "def moving_window_average(x, n_neighbors=1):\n",
    "    n = len(x)\n",
    "    width = n_neighbors*2 + 1\n",
    "    x = [x[0]]*n_neighbors + x + [x[-1]]*n_neighbors\n",
    "    mov_ave = []\n",
    "    for i in range(n):\n",
    "        winsum = 0\n",
    "        for j in range(width):\n",
    "            winsum = winsum + x[i+j]\n",
    "        mov_ave.append((winsum)/width)\n",
    "    return mov_ave\n",
    "\n",
    "x = [0,10,5,3,1,5]\n",
    "\n",
    "print(moving_window_average(x, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3b\n",
    "- Compute and store `R=1000` random values from 0-1 as `x`.\n",
    "- Compute the moving window average for `x` for values of `n_neighbors` ranging from 1 to 9 inclusive.\n",
    "- Store `x` as well as each of these averages as consecutive lists in a list called `Y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.45325045824763405"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "random.seed(1) # This line fixes the value called by your function,\n",
    "               # and is used for answer-checking.\n",
    "    \n",
    "x = [random.uniform(0, 1) for i in range(1000)]\n",
    "Y = []\n",
    "Y.append(x)\n",
    "for z in range(1, 10):\n",
    "    Y.append(moving_window_average(x, z))\n",
    "    \n",
    "Y[5][9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercise 3c\n",
    "\n",
    "- For each list in `Y`, calculate and store the range (the maximum minus the minimum) in a new list ranges.\n",
    "- Print your answer. As the window width increases, does the range of each list increase or decrease? Why do you think that is?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.9128390185520854,\n",
       " 0.801645771909397,\n",
       " 0.7137391224212468,\n",
       " 0.6230146948375028,\n",
       " 0.5042284086774562,\n",
       " 0.5071013753101629,\n",
       " 0.4590090496908159,\n",
       " 0.44659549539083265,\n",
       " 0.4433696944090051]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ranges = [sorted(r)[-1]-sorted(r)[0] for r in Y]\n",
    "ranges\n",
    "\n",
    "# As we increase the window size, more numbers are included in the window and the average of window becomes closer and closer\n",
    "# to the average of the whole list, which is ~0.5, therefore, the difference between min and max of each average list\n",
    "# becomes less and less"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}