diff --git a/ProblemSet1_Yu.pdf b/ProblemSet1_Yu.pdf
new file mode 100644
index 0000000..db5b720
Binary files /dev/null and b/ProblemSet1_Yu.pdf differ
diff --git a/ProblemSet2_Yu.ipynb b/ProblemSet2_Yu.ipynb
new file mode 100644
index 0000000..3b57266
--- /dev/null
+++ b/ProblemSet2_Yu.ipynb
@@ -0,0 +1,692 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# ProblemSet2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## ACME_StandardLibary"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem1\n",
+ "Write a function that accepts a list L and returns the minimum, maximum, and average of the entries of L (in that order). Can you implement this function in a single line?"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def max_min_avg(L):\n",
+ " '''\n",
+ " Arg:\n",
+ " L(list): a list of number\n",
+ " \n",
+ " Returns\n",
+ " a, b, c: a tuple that contains maximun, minimum, and average of the list\n",
+ " '''\n",
+ " a = max(L)\n",
+ " b = min(L)\n",
+ " c = sum(L)/len(L)\n",
+ " return a, b, c"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "L = range(1,10)\n",
+ "res1 = max_min_avg(L)\n",
+ "res1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Determine which of Python’s object types are mutable and which are immutable by repeating the following experiment for an int, str, list, tuple, and set.\n",
+ " 1. Create an object of the given type and assign a name to it.\n",
+ " 2. Assign a new name to the first name.\n",
+ " 3. Alter the object via only one of the names (for tuples, use my_tuple += (1,)).\n",
+ " 4. Check to see if the two names are equal. If they are, then since changing one name changed the other, the names refer to the same object and the object type is mutable. Otherwise, the names refer to different objects—meaning a copy was made in step 2—and therefore the object type is immutable.\n",
+ " \n",
+ "For example, the following experiment shows that dict is a mutable type.\n",
+ "[](https://imgtu.com/i/hccSVf)\n",
+ "\n",
+ "Print a statement of your conclusions that clearly indicates which object types are mutable and which are immutable."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "'''\n",
+ "Step 1: Create an int, str, list, tuple, and set\n",
+ "'''\n",
+ "int_1 = 9766 # create an int\n",
+ "str_1 = \"Lucia\" # create a str\n",
+ "list_1 = [1,2,3,4,5,6,7,7,6] # create a list\n",
+ "tuple_1 = ('a','b',1,3) # create a tuple \n",
+ "set_1 = {1,2,3,4,5} # create a set \n",
+ "\n",
+ "'''\n",
+ "Step 2: Assign it a new name\n",
+ "'''\n",
+ "int_2 = int_1\n",
+ "str_2 = str_1\n",
+ "list_2 = list_1\n",
+ "tuple_2 = tuple_1\n",
+ "set_2 = set_1\n",
+ "\n",
+ "'''\n",
+ "Step 3: Change the 'new' one\n",
+ "'''\n",
+ "int_2 = 6799\n",
+ "str_2 = \"Lucy\"\n",
+ "list_2[1] = 8\n",
+ "tuple_2 += (1,)\n",
+ "set_2 ^= {6,7}\n",
+ "\n",
+ "'''\n",
+ "Step 4: Check to see if the two names are equal, and decide whether the object is mutable\n",
+ "'''\n",
+ "if int_1 == int_2: # check the int\n",
+ " print('int is mutable')\n",
+ "else:\n",
+ " print('int is immutable')\n",
+ "\n",
+ "if str_1 == str_2: # check the str\n",
+ " print('str is mutable')\n",
+ "else:\n",
+ " print('str is immutable')\n",
+ " \n",
+ "if list_1 == list_2: # check the list\n",
+ " print('list is mutable')\n",
+ "else:\n",
+ " print('list is immutable')\n",
+ "\n",
+ "if tuple_1 == tuple_2: # check the tuple\n",
+ " print('tuple is mutable')\n",
+ "else:\n",
+ " print('tuple is immutable')\n",
+ "\n",
+ "if set_1 == set_2: # check the set\n",
+ " print('set is mutable')\n",
+ "else:\n",
+ " print('set is immutable')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem 3"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create a module called calculator.py. Write a function that returns the sum of two arguments and a function that returns the product of two arguments. Also use import to add the sqrt() function from the math module to the namespace. When this file is either run or imported, nothing should be executed.\\\n",
+ "In your solutions file, import your new custom module. Write a function that accepts two numbers representing the lengths of the sides of a right triangle. Using only the functions from calculator.py, calculate and return the length of the hypotenuse of the triangle."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "$$\n",
+ "c = \\sqrt{a^2+b^2}\n",
+ "$$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "```Python\n",
+ "from math import sqrt\n",
+ "\n",
+ "def sum_two(a,b):\n",
+ " '''\n",
+ " Arg:\n",
+ " a,b: two int\n",
+ " \n",
+ " Returns:\n",
+ " c: int that equals to the sum of two arguments\n",
+ " '''\n",
+ " c = a + b\n",
+ " return c\n",
+ "\n",
+ "def pdt_two(e,f):\n",
+ " '''\n",
+ " Arg:\n",
+ " e,f: two int\n",
+ " \n",
+ " Returns:\n",
+ " g: int that equals to the sum of two arguments\n",
+ " '''\n",
+ " g = e * f\n",
+ " return g\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import calculator as cal\n",
+ "\n",
+ "def hypotenuse_length(side1, side2): # calculate the hypotenuse length of a right triangle\n",
+ " '''\n",
+ " Arg:\n",
+ " side1(int), side2(int): represent the lengths of the sides of a right triangle\n",
+ " \n",
+ " Returns:\n",
+ " hypotenuse(int): hypotenuse length\n",
+ " '''\n",
+ " side1_2 = cal.pdt_two(side1,side1)\n",
+ " side2_2 = cal.pdt_two(side2,side2)\n",
+ " hypotenuse_2 = cal.sum_two(side1_2,side2_2)\n",
+ " hypotenuse = cal.sqrt(hypotenuse_2)\n",
+ " \n",
+ " return hypotenuse"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## ACME_NumpyIntro"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem 1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "There are two main ways to perform matrix multiplication in NumPy: with NumPy’s dot() function (np.dot(A, B)), or with the @ operator (A @ B). Write a function that defines the following matrices as NumPy arrays.\n",
+ "[](https://imagelol.com/image/ItSEUG)\n",
+ "Return the matrix product AB."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 37, 14, -32, -10],\n",
+ " [-54, -7, 58, 65]])"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import numpy as np\n",
+ "def functionAB():\n",
+ " '''\n",
+ " Step 1: define matrix A and B\n",
+ " '''\n",
+ " A = np.array([[3, -1, 4], \n",
+ " [1, 5, -9]])\n",
+ " B = np.array([[2, 6, -5, 3], \n",
+ " [5, -8, 9, 7], \n",
+ " [9, -3, -2, -3]])\n",
+ " \n",
+ " '''\n",
+ " Step2: get the matrix product of A and B, and name it AB\n",
+ " '''\n",
+ " AB = np.dot(A,B)\n",
+ " \n",
+ " '''\n",
+ " Step3: return AB\n",
+ " '''\n",
+ " return AB\n",
+ "\n",
+ "functionAB() # call the function I defined"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem 2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Write a function that defines the following matrix as a NumPy array.\n",
+ "[](https://imagelol.com/image/ItSFw4)\n",
+ "Return the matrix $-A^3 + 9A^2 - 15A$"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[0, 0, 0],\n",
+ " [0, 0, 0],\n",
+ " [0, 0, 0]])"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def fun_A():\n",
+ " '''\n",
+ " Step1: define matrix A\n",
+ " '''\n",
+ " A = np.array([[3, 1, 4],\n",
+ " [1, 5, 9],\n",
+ " [-5, 3, 1]])\n",
+ " '''\n",
+ " Step2: put matrix A into the operation, and get the result res\n",
+ " '''\n",
+ " A_2 = np.dot(A,A)\n",
+ " A_3 = np.dot(A_2, A)\n",
+ " \n",
+ " res = -A_3 + 9*A_2 - 15*A\n",
+ " \n",
+ " return res\n",
+ "\n",
+ "fun_A() # call the function I defined"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem 5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Write a function that defines the following matrices as NumPy arrays.\n",
+ "[](https://imagelol.com/image/ItSkxX)\n",
+ "Use NumPy’s stacking functions to create and return the block matrix:\n",
+ "[](https://imagelol.com/image/ItSplD)\n",
+ "where I is the 3 × 3 identity matrix and each 0 is a matrix of all zeros of appropriate size.\n",
+ "A block matrix of this form is used in the Interior Point method for linear optimization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 62,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 0., 0., 0., 0., 1., 1., 0., 0.],\n",
+ " [ 0., 0., 0., 2., 3., 0., 1., 0.],\n",
+ " [ 0., 0., 0., 4., 5., 0., 0., 1.],\n",
+ " [ 0., 2., 4., 0., 0., 0., 0., 0.],\n",
+ " [ 1., 3., 5., 0., 0., 0., 0., 0.],\n",
+ " [ 3., 0., 0., 0., 0., -2., -0., -0.],\n",
+ " [ 3., 3., 0., 0., 0., -0., -2., -0.],\n",
+ " [ 3., 3., 3., 0., 0., -0., -0., -2.]])"
+ ]
+ },
+ "execution_count": 62,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def funcBlock():\n",
+ " '''\n",
+ " Step1: define the matrix A, B, C and I\n",
+ " '''\n",
+ " A = np.array([[0, 2, 4],\n",
+ " [1, 3, 5]])\n",
+ " B = np.array([[3, 0, 0],\n",
+ " [3, 3, 0],\n",
+ " [3, 3, 3]])\n",
+ " C = -2*np.eye(3,3)\n",
+ " I = np.eye(3,3)\n",
+ " \n",
+ " '''\n",
+ " Step2: put the zero matrix of suitable shape into each row\n",
+ " '''\n",
+ " row_1 = np.hstack((np.zeros((3,3)), A.T, I))\n",
+ " row_2 = np.hstack((A, np.zeros((2,2)), np.zeros((2,3))))\n",
+ " row_3 = np.hstack((B, np.zeros((3,2)), C))\n",
+ "\n",
+ " '''\n",
+ " Srep3: get the final block matrix\n",
+ " '''\n",
+ " res5 = np.vstack((row_1, row_2, row_3))\n",
+ "\n",
+ " res5"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## ACME_ObjectOriented"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem1"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Expand the Backpack class to match the following specifications.\n",
+ " 1. Modify the constructor so that it accepts three total arguments: name, color, and max_size (in that order). Make max_size a keyword argument that defaults to 5. Store each input as an attribute.\n",
+ " 2. Modify the put() method to check that the backpack does not go over capacity. If there are already max_size items or more, print “No Room!” and do not add the item to the contents list.\n",
+ " 3. Write a new method called dump() that resets the contents of the backpack to an empty list. This method should not receive any arguments (except self).\n",
+ " 4. Documentation is especially important in classes so that the user knows what an ob- ject’s attributes represent and how to use methods appropriately. Update (or write) the docstrings for the __init__(), put(), and dump() methods, as well as the actual class docstring (under class but before __init__()) to reflect the changes from parts 1-3 of this problem.\n",
+ " \n",
+ "To ensure that your class works properly, write a test function outside outside of the\n",
+ "Backpack class that instantiates and analyzes a Backpack object."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 54,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Backpack:\n",
+ " \"\"\"A Backpack object class. Has a name and a list of contents.\n",
+ " Attributes:\n",
+ " name (str): the name of the backpack's owner.\n",
+ " color (str): the color of the backpack\n",
+ " max_size (int): the max size of the backpack\n",
+ " contents (list): the contents of the backpack.\n",
+ " Methods:\n",
+ " put (str): add 'item' to the backpack's list of contents until achieve max size\n",
+ " take (str): remove 'item' from the backpack's list of contents\n",
+ " dump (): resets the contents of the backpack to an empty list\n",
+ " \"\"\"\n",
+ " def __init__(self, name, color, max_size = 5): # This function is the constructor.\n",
+ " \"\"\"Set the name and initialize an empty list of contents.\n",
+ " Parameters:\n",
+ " name (str): the name of the backpack's owner.\n",
+ " color (str): the color of the backpack\n",
+ " max_size (int): the max size of the backpack, and its default number is 5\n",
+ " \"\"\"\n",
+ " \n",
+ " # Initialize some attributes.\n",
+ " self.name = name\n",
+ " self.color = color\n",
+ " self.max_size = max_size\n",
+ " self.contents = []\n",
+ " # ...\n",
+ " \n",
+ " def put(self, item):\n",
+ " \"\"\"Add 'item' to the backpack's list of contents.\"\"\"\n",
+ " if len(self.contents) < self.max_size:\n",
+ " self.contents.append(item) # Use 'self.contents', not just 'contents'.\n",
+ " else: # If there are already max_size items or more\n",
+ " print('No Room!')\n",
+ " \n",
+ " def take(self, item):\n",
+ " \"\"\"Remove 'item' from the backpack's list of contents.\"\"\"\n",
+ " self.contents.remove(item)\n",
+ " \n",
+ " def dump(self):\n",
+ " '''resets the contents of the backpack to an empty list'''\n",
+ " self.contents = []"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 55,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def test_backpack():\n",
+ " testpack = Backpack(\"Barry\", \"black\") # Instantiate the object.\n",
+ " if testpack.name != \"Barry\": # Test an attribute.\n",
+ " print(\"Backpack.name assigned incorrectly\")\n",
+ " for item in [\"pencil\", \"pen\", \"paper\", \"computer\"]:\n",
+ " testpack.put(item) # Test a method.\n",
+ " print(\"Contents:\", testpack.contents)\n",
+ " testpack.put('book')\n",
+ " print('Contents Update', testpack.contents)\n",
+ " testpack.put('bottle')\n",
+ " testpack.take('pen')\n",
+ " print('Contents Update', testpack.contents)\n",
+ " testpack.dump()\n",
+ " print('Contents Update', testpack.contents)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 56,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Contents: ['pencil', 'pen', 'paper', 'computer']\n",
+ "Contents Update ['pencil', 'pen', 'paper', 'computer', 'book']\n",
+ "No Room!\n",
+ "Contents Update ['pencil', 'paper', 'computer', 'book']\n",
+ "Contents Update []\n"
+ ]
+ }
+ ],
+ "source": [
+ "test_backpack()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Problem2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Write a Jetpack class that inherits from the Backpack class.\n",
+ " 1. Override the constructor so that in addition to a name, color, and maximum size, it also accepts an amount of fuel. Change the default value of max_size to 2, and set the default value of fuel to 10. Store the fuel as an attribute.\n",
+ " 2. Add a fly() method that accepts an amount of fuel to be burned and decrements the fuel attribute by that amount. If the user tries to burn more fuel than remains, print “Not enough fuel!” and do not decrement the fuel.\n",
+ " 3. Override the dump() method so that both the contents and the fuel tank are emptied.\n",
+ " 4. Write clear, detailed docstrings for the class and each of its methods."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 66,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "class Jetpack(Backpack):\n",
+ " \"\"\"\n",
+ " A jetpack object class. Inherits from the Backpack class.\n",
+ " A jetpack is smaller than a backpack and can accepts an amount of fuel.\n",
+ " Attributes:\n",
+ " name (str): the name of the jetpack's owner.\n",
+ " color (str): the color of the jetpack.\n",
+ " max_size (int): the maximum number of items that can fit inside.\n",
+ " contents (list): the contents of the jetpack.\n",
+ " fuel (float): the fuel amount of jetpack \n",
+ " Methods:\n",
+ " fly (float): decrement the amount until the fuel tank is empty\n",
+ " dump (): resets the contents of the jetpack to an empty list and set fuel to 0\n",
+ " \"\"\"\n",
+ " def __init__(self, name, color, max_size=2, fuel = 10):\n",
+ " \"\"\"\n",
+ " Use the Backpack constructor to initialize the name, color,\n",
+ " and max_size attributes. A jetpack only holds 3 item by default.\n",
+ " Parameters:\n",
+ " name (str): the name of the jetpack's owner.\n",
+ " color (str): the color of the jetpack.\n",
+ " max_size (int): the maximum number of items that can fit inside.\n",
+ " \"\"\"\n",
+ " Backpack.__init__(self, name, color, max_size)\n",
+ " self.fuel = fuel\n",
+ " \n",
+ " def fly(self, burned_fuel):\n",
+ " '''\n",
+ " accepts an amount of fuel to be burned \n",
+ " '''\n",
+ " if burned_fuel > self.fuel: # If the user tries to burn more fuel than remains\n",
+ " print('Not enough fuel!')\n",
+ " else: # decrements the fuel attribute by the amount of burned fuel\n",
+ " self.fuel -= burned_fuel\n",
+ " \n",
+ " def dump(self):\n",
+ " '''\n",
+ " empty both the contents and the fuel tank\n",
+ " '''\n",
+ " self.contents = []\n",
+ " self.fuel = 0\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 78,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def test_backpack():\n",
+ " testpack = Jetpack(\"Barry\", \"black\") # Instantiate the object.\n",
+ " if testpack.name != \"Barry\": # Test an attribute.\n",
+ " print(\"Backpack.name assigned incorrectly\")\n",
+ " for item in [\"pencil\", \"pen\"]:\n",
+ " testpack.put(item) # Test a method.\n",
+ " print(\"Contents:\", testpack.contents)\n",
+ " \n",
+ " print(' \\nPut a book into the jetpack')\n",
+ " testpack.put('book')\n",
+ " \n",
+ " print(' \\nTake out a pen from the jetpack')\n",
+ " testpack.take('pen')\n",
+ " print('Contents Update:', testpack.contents)\n",
+ "\n",
+ " print(' \\nBurn 7 amount of fuel to fly')\n",
+ " testpack.fly(7)\n",
+ " print('Fuel Tank Update:',testpack.fuel)\n",
+ " print('Burn 4 amount of fuel to fly')\n",
+ " testpack.fly(4)\n",
+ " \n",
+ " print(' \\nReset the jetpack')\n",
+ " testpack.dump()\n",
+ " print('Contents Update:', testpack.contents)\n",
+ " print('Fuel Tank Update:',testpack.fuel)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 79,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Contents: ['pencil', 'pen']\n",
+ " \n",
+ "Put a book into the jetpack\n",
+ "No Room!\n",
+ " \n",
+ "Take out a pen from the jetpack\n",
+ "Contents Update: ['pencil']\n",
+ " \n",
+ "Burn 7 amount of fuel to fly\n",
+ "Fuel Tank Update: 3\n",
+ "Burn 4 amount of fuel to fly\n",
+ "Not enough fuel!\n",
+ " \n",
+ "Reset the jetpack\n",
+ "Contents Update: []\n",
+ "Fuel Tank Update: 0\n"
+ ]
+ }
+ ],
+ "source": [
+ "test_backpack()"
+ ]
+ },
+ {
+ "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.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/ProblemSet3/Distribution_of_CL.png b/ProblemSet3/Distribution_of_CL.png
new file mode 100644
index 0000000..5ca4160
Binary files /dev/null and b/ProblemSet3/Distribution_of_CL.png differ
diff --git a/ProblemSet3/Distribution_of_CreditLine_Gender.png b/ProblemSet3/Distribution_of_CreditLine_Gender.png
new file mode 100644
index 0000000..1ffed06
Binary files /dev/null and b/ProblemSet3/Distribution_of_CreditLine_Gender.png differ
diff --git a/ProblemSet3/ProblemSet3_Yu.pdf b/ProblemSet3/ProblemSet3_Yu.pdf
new file mode 100644
index 0000000..423465a
Binary files /dev/null and b/ProblemSet3/ProblemSet3_Yu.pdf differ
diff --git a/ProblemSet3/ProblemSet3_Yu.py b/ProblemSet3/ProblemSet3_Yu.py
new file mode 100644
index 0000000..3a768b8
--- /dev/null
+++ b/ProblemSet3/ProblemSet3_Yu.py
@@ -0,0 +1,35 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import plotly.express as ex
+
+# Read in data from csv file
+df = pd.read_csv('BankChurners.csv',sep=',')
+
+data_CA = df['Credit_Limit']
+
+# hist distribution of Credit line
+plt.hist(data_CA, bins = 20, edgecolor = 'black')
+
+plt.ylabel('Number of customer in this credit line interval')
+plt.xlabel('Credit line')
+plt.title('Distribution of credit line')
+
+plt.savefig('Distribution_of_CL')
+
+# show the distribution of gender
+import plotly.io as pio
+fig1 = ex.pie(df,names='Gender',title='Distribution of gender')
+pio.write_image(file='gender.png',fig = fig1)
+
+# show the distribution of credit line for male and female customers
+data_CA_M = df[df['Gender']=='M']['Credit_Limit']
+data_CA_F = df[df['Gender']=='F']['Credit_Limit']
+
+kwargs = dict(histtype='stepfilled', alpha = 0.3, bins=20)
+plt.hist(data_CA_M, **kwargs, color='g')
+plt.hist(data_CA_F, **kwargs, color='r')
+plt.legend(['male','female'])
+plt.title('Distribution of credit line for male and female')
+plt.savefig('Distribution_of_CreditLine_Gender')
+
diff --git a/ProblemSet3/gender.png b/ProblemSet3/gender.png
new file mode 100644
index 0000000..e3f04ac
Binary files /dev/null and b/ProblemSet3/gender.png differ
diff --git a/ProblemSet4/ProblemSet4_Yu.ipynb b/ProblemSet4/ProblemSet4_Yu.ipynb
new file mode 100644
index 0000000..42b1caf
--- /dev/null
+++ b/ProblemSet4/ProblemSet4_Yu.ipynb
@@ -0,0 +1,1514 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Problem Set 4"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 297,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import scipy.optimize as opt\n",
+ "from scipy.special import factorial\n",
+ "import matplotlib.pyplot as plt\n",
+ "%matplotlib inline"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " id68 \n",
+ " year \n",
+ " intid \n",
+ " relhh \n",
+ " hannhrs \n",
+ " wannhrs \n",
+ " hlabinc \n",
+ " wlabinc \n",
+ " nochild \n",
+ " wrace \n",
+ " ... \n",
+ " redpregovinc \n",
+ " hsex \n",
+ " wsex \n",
+ " age \n",
+ " wage \n",
+ " hpersno \n",
+ " wpersno \n",
+ " hyrsed \n",
+ " wyrsed \n",
+ " pce \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 1 \n",
+ " 1967 \n",
+ " 1 \n",
+ " Head \n",
+ " 1200.0 \n",
+ " 2000.0 \n",
+ " NaN \n",
+ " NaN \n",
+ " 0 \n",
+ " NaN \n",
+ " ... \n",
+ " 5614.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 52.0 \n",
+ " 46.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 8.0 \n",
+ " 8.0 \n",
+ " 0.0 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 2 \n",
+ " 1967 \n",
+ " 2 \n",
+ " Head \n",
+ " 0.0 \n",
+ " 0.0 \n",
+ " NaN \n",
+ " NaN \n",
+ " 0 \n",
+ " NaN \n",
+ " ... \n",
+ " 0.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 56.0 \n",
+ " 57.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 3.0 \n",
+ " 3.0 \n",
+ " 0.0 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 3 \n",
+ " 1967 \n",
+ " 3 \n",
+ " Head \n",
+ " 0.0 \n",
+ " 0.0 \n",
+ " NaN \n",
+ " NaN \n",
+ " 0 \n",
+ " NaN \n",
+ " ... \n",
+ " 0.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 77.0 \n",
+ " 64.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " NaN \n",
+ " 3.0 \n",
+ " 0.0 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 4 \n",
+ " 1967 \n",
+ " 4 \n",
+ " Head \n",
+ " 1560.0 \n",
+ " 0.0 \n",
+ " NaN \n",
+ " NaN \n",
+ " 6 \n",
+ " 1.0 \n",
+ " ... \n",
+ " 3280.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 45.0 \n",
+ " 44.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 8.0 \n",
+ " 5.0 \n",
+ " 0.0 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 5 \n",
+ " 1967 \n",
+ " 5 \n",
+ " Head \n",
+ " 2500.0 \n",
+ " 2000.0 \n",
+ " NaN \n",
+ " NaN \n",
+ " 3 \n",
+ " 1.0 \n",
+ " ... \n",
+ " 7900.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 24.0 \n",
+ " 22.0 \n",
+ " 1.0 \n",
+ " 2.0 \n",
+ " 10.0 \n",
+ " 9.0 \n",
+ " 0.0 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
5 rows × 52 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " id68 \n",
+ " year \n",
+ " intid \n",
+ " relhh \n",
+ " hannhrs \n",
+ " wannhrs \n",
+ " hlabinc \n",
+ " wlabinc \n",
+ " nochild \n",
+ " wrace \n",
+ " ... \n",
+ " redpregovinc \n",
+ " hsex \n",
+ " wsex \n",
+ " age \n",
+ " wage \n",
+ " hpersno \n",
+ " wpersno \n",
+ " hyrsed \n",
+ " wyrsed \n",
+ " pce \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0 rows × 52 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " hannhrs \n",
+ " hlhrinc \n",
+ " hlabinc \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " hannhrs \n",
+ " hlhrinc \n",
+ " hlabinc \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 34947 \n",
+ " 32.0 \n",
+ " 1717.330322 \n",
+ " 54954.570312 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " id68 \n",
+ " year \n",
+ " intid \n",
+ " relhh \n",
+ " hannhrs \n",
+ " wannhrs \n",
+ " hlabinc \n",
+ " wlabinc \n",
+ " nochild \n",
+ " wrace \n",
+ " ... \n",
+ " redpregovinc \n",
+ " hsex \n",
+ " wsex \n",
+ " age \n",
+ " wage \n",
+ " hpersno \n",
+ " wpersno \n",
+ " hyrsed \n",
+ " wyrsed \n",
+ " pce \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0 rows × 52 columns
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " Black \n",
+ " Other race \n",
+ " White \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 11161 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11164 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11166 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11173 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11175 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " age \n",
+ " age2 \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 11161 \n",
+ " 51.0 \n",
+ " 2601.0 \n",
+ " \n",
+ " \n",
+ " 11164 \n",
+ " 55.0 \n",
+ " 3025.0 \n",
+ " \n",
+ " \n",
+ " 11166 \n",
+ " 25.0 \n",
+ " 625.0 \n",
+ " \n",
+ " \n",
+ " 11173 \n",
+ " 39.0 \n",
+ " 1521.0 \n",
+ " \n",
+ " \n",
+ " 11175 \n",
+ " 36.0 \n",
+ " 1296.0 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " id68 \n",
+ " year \n",
+ " lnw \n",
+ " hyrsed \n",
+ " age \n",
+ " age2 \n",
+ " hrace \n",
+ " Black \n",
+ " Other race \n",
+ " White \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 11161 \n",
+ " 402 \n",
+ " 1971 \n",
+ " 11.049758 \n",
+ " 12.0 \n",
+ " 51.0 \n",
+ " 2601.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11164 \n",
+ " 461 \n",
+ " 1971 \n",
+ " 10.028399 \n",
+ " 5.0 \n",
+ " 55.0 \n",
+ " 3025.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11166 \n",
+ " 1126 \n",
+ " 1971 \n",
+ " 10.286634 \n",
+ " 16.0 \n",
+ " 25.0 \n",
+ " 625.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11173 \n",
+ " 284 \n",
+ " 1971 \n",
+ " 11.250072 \n",
+ " 16.0 \n",
+ " 39.0 \n",
+ " 1521.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ " 11175 \n",
+ " 50 \n",
+ " 1971 \n",
+ " 10.372496 \n",
+ " 12.0 \n",
+ " 36.0 \n",
+ " 1296.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " id68 \n",
+ " year \n",
+ " lnw \n",
+ " hyrsed \n",
+ " age \n",
+ " age2 \n",
+ " hrace \n",
+ " Black \n",
+ " Other race \n",
+ " White \n",
+ " Hispanic \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 11161 \n",
+ " 402 \n",
+ " 1971 \n",
+ " 11.049758 \n",
+ " 12.0 \n",
+ " 51.0 \n",
+ " 2601.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 11164 \n",
+ " 461 \n",
+ " 1971 \n",
+ " 10.028399 \n",
+ " 5.0 \n",
+ " 55.0 \n",
+ " 3025.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 11166 \n",
+ " 1126 \n",
+ " 1971 \n",
+ " 10.286634 \n",
+ " 16.0 \n",
+ " 25.0 \n",
+ " 625.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 11173 \n",
+ " 284 \n",
+ " 1971 \n",
+ " 11.250072 \n",
+ " 16.0 \n",
+ " 39.0 \n",
+ " 1521.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 11175 \n",
+ " 50 \n",
+ " 1971 \n",
+ " 10.372496 \n",
+ " 12.0 \n",
+ " 36.0 \n",
+ " 1296.0 \n",
+ " 1.0 \n",
+ " 0 \n",
+ " 0 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(t, beta1)\n",
+ "plt.title('The change of coefficient beta1 over time')\n",
+ "plt.xlabel('year')\n",
+ "plt.ylabel('beta1(%)')\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Interpretation of the coefficient $\\beta_1$\n",
+ "The effect of eduction on annual income was strongest in year 1971, then it decreased gradually until it reached the lowest level in 1990. After this, the effect becomes stronger in 2000. "
+ ]
+ },
+ {
+ "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.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/ProblemSet5/ProblemSet5_Yu.pdf b/ProblemSet5/ProblemSet5_Yu.pdf
new file mode 100644
index 0000000..949c320
Binary files /dev/null and b/ProblemSet5/ProblemSet5_Yu.pdf differ
diff --git a/ProblemSet5/ProblemSet5_Yu.py b/ProblemSet5/ProblemSet5_Yu.py
new file mode 100644
index 0000000..2040292
--- /dev/null
+++ b/ProblemSet5/ProblemSet5_Yu.py
@@ -0,0 +1,291 @@
+# mport the packages
+import pandas as pd
+import numpy as np
+
+import scipy.optimize as opt
+import scipy.stats as stats
+
+from geopy.distance import geodesic
+
+'''
+Part1 Data Process
+'''
+# read in data
+df = pd.read_csv('radio_merger_data.csv')
+
+# combine latitude and longitude into a tuple for distance calculation
+buyer_loc = df[['buyer_lat','buyer_long']]
+df['buyer_loc'] = buyer_loc.apply(tuple,axis=1)
+
+target_loc = df[['target_lat','target_long']]
+df['target_loc'] = target_loc.apply(tuple,axis=1)
+
+# rescale the population: put population into logs of thousands of people
+df['population_target'] = np.log(df['population_target']/1000)
+
+'''
+Model 1
+
+Part2 Create a new dataset in which every buyer and target in each market can match with each other.
+Also, I only keep the data needed for the model
+'''
+
+# create empty lists to hold all the corresponding values
+x_1bim = []
+y_1tim = []
+x_2bim = []
+distance_iim = []
+
+x_1bjm = []
+y_1tjm = []
+x_2bjm = []
+distance_jjm = []
+
+distance_ijm = []
+distance_jim = []
+
+# seperate the market for different years
+mkt = df['year'].unique()
+no_mkt = len(mkt)
+
+# first loop for different year/market
+for m in range(no_mkt):
+ data = df[df['year'].isin([mkt[m]])] # this dataframe only holds data for corresponding market/year
+
+ n,_ = data.shape # get the number of buyers/targets in this market
+
+ for i in range(n-1):
+ for j in range(i,n-1):
+ j += 1 # this netted loop allows me to get all the observed and counterfactual matches
+
+ # put all the corresponding valurs into the lists
+ x_1bim.append(data.loc[(data.buyer_id==i+1),'num_stations_buyer'].values[0])
+ y_1tim.append(data.loc[(data.target_id==i+1),'population_target'].values[0])
+ x_2bim.append(data.loc[(data.buyer_id==i+1),'corp_owner_buyer'].values[0])
+
+ bi_loc = data.loc[(data.buyer_id==i+1),'buyer_loc'].values[0]
+ ti_loc = data.loc[(data.target_id==i+1),'target_loc'].values[0]
+ distance_iim.append(geodesic(bi_loc, ti_loc).miles) # calculate the distance btw the buyer and target
+
+ x_1bjm.append(data.loc[(data.buyer_id==j+1),'num_stations_buyer'].values[0])
+ y_1tjm.append(data.loc[(data.target_id==j+1),'population_target'].values[0])
+ x_2bjm.append(data.loc[(data.buyer_id==j+1),'corp_owner_buyer'].values[0])
+
+ bj_loc = data.loc[(data.buyer_id==j+1),'buyer_loc'].values[0]
+ tj_loc = data.loc[(data.target_id==j+1),'target_loc'].values[0]
+
+ distance_jjm.append(geodesic(bj_loc, tj_loc).miles)
+
+ distance_ijm.append(geodesic(bi_loc, tj_loc).miles)
+ distance_jim.append(geodesic(bj_loc, ti_loc).miles)
+
+# give these lists a suitable names
+# I use the variable names in the model
+data_match = {'x_1bim':x_1bim,
+ 'y_1tim':y_1tim,
+ 'x_2bim':x_2bim,
+ 'distance_iim':distance_iim,
+ 'x_1bjm': x_1bjm,
+ 'y_1tjm': y_1tjm,
+ 'x_2bjm': x_2bjm,
+ 'distance_jjm': distance_jjm,
+ 'distance_ijm': distance_ijm,
+ 'distance_jim':distance_jim}
+
+
+# put all the lists into a dataframe called df_match
+df_match = pd.DataFrame(data_match)
+
+'''
+Part3 Define Model1
+'''
+
+def Q(paras,df):
+ '''
+ The maximum socre objective function.
+
+ Args:
+ params (tuple): model parameters
+ data (Pandas DataFrame): data, contains covariates in model
+
+ Returns:
+ scalar: the negative value of the score function
+ We'll use a negative value so we can use a minimizer to max the sum
+ '''
+
+ # unpack tuple of parameters
+ alpha, beta = paras
+
+ # find value for each variable to calculate payoff for buyer i and target i
+ x_1bim = df['x_1bim']
+ y_1tim = df['y_1tim']
+ x_2bim = df['x_2bim']
+ distance_iim = df['distance_iim']
+
+ # calculate payoff for buyer i and target i
+ df['f_ii'] = x_1bim*y_1tim + alpha*x_2bim*y_1tim + beta*distance_iim
+
+ # find value for each variable to calculate payoff for buyer j and target j
+ x_1bjm = df['x_1bjm']
+ y_1tjm = df['y_1tjm']
+ x_2bjm = df['x_2bjm']
+ distance_jjm = df['distance_jjm']
+
+ # calculate payoff for buyer j and target j
+ df['f_jj'] = x_1bjm*y_1tjm + alpha*x_2bjm*y_1tjm + beta*distance_jjm
+
+ distance_ijm = df['distance_ijm']
+
+ # calculate payoff for buyer i and target j
+ df['f_ij'] = x_1bim*y_1tjm + alpha*x_2bim*y_1tjm + beta*distance_ijm
+
+ distance_jim = df['distance_jim']
+
+ # calculate payoff for buyer j and target i
+ df['f_ji'] = x_1bjm*y_1tim + alpha*x_2bjm*y_1tim + beta*distance_jim
+
+ df['observed'] = df['f_ii'] + df['f_jj'] # calculate payoff for the observed matches
+ df['counterfactual'] = df['f_ij'] + df['f_ji'] # calculate payoff for the counterfactual matches
+
+ # create a list where payoff of observed matches is larger than that of counterfactual matches
+ correct = (df['observed']>df['counterfactual'])
+
+ return -sum(correct) # return the negative number that satisfy that condition
+
+
+'''
+Part4 Estimate Model1
+'''
+# set initial guessess
+paras = (0.1, 0.1)
+
+# minimize the maximum socre objective function
+res = opt.minimize(Q, paras, args = (df_match,),
+ method = 'Nelder-Mead')
+
+# get the result of the estimated parameters
+est_paras = res.x
+# get the result of the estimated alpha
+est_alpha = est_paras[0]
+est_beta = est_paras[1]
+
+# use the estimated parameters to calculate the maximum score
+MS1 = Q(est_paras, df_match)
+
+# Print the resukt
+print('For the model1:')
+print('The estimate of alpha is', est_alpha)
+print('The estimate of beta is', est_beta)
+print('The maximum socre estimator is', MS1)
+
+'''
+Model 2
+Part5 Add a new varibale HHI for model2 and put all the data into new dataset df_match2
+'''
+
+HHI_im = []
+HHI_jm = []
+
+for m in range(no_mkt):
+ data = df[df['year'].isin([mkt[m]])]
+
+ n, _ = data.shape
+ for i in range(n-1):
+ for j in range(i,n-1):
+ j += 1
+ HHI_im.append(data.loc[(data.target_id==i+1),'hhi_target'].values[0])
+ HHI_jm.append(data.loc[(data.target_id==j+1),'hhi_target'].values[0])
+df_match2 = df_match
+df_match2['HHI_im'] = HHI_im
+df_match2['HHI_jm'] = HHI_jm
+
+
+'''
+Part6 Define Model2
+'''
+
+def Q2(paras,df):
+ '''
+ The maximum socre objective function.
+
+ Args:
+ params (tuple): model parameters
+ data (Pandas DataFrame): data, contains covariates in model
+
+ Returns:
+ scalar: the negative value of the score function
+ We'll use a negative value so we can use a minimizer to max the sum
+ '''
+
+ delta, alpha, gamma, beta, = paras
+
+ x_1bim = df['x_1bim']
+ y_1tim = df['y_1tim']
+ x_2bim = df['x_2bim']
+ HHI_im = df['HHI_im']
+ distance_iim = df['distance_iim']
+
+
+ df['f_ii'] = delta*x_1bim*y_1tim + alpha*x_2bim*y_1tim + gamma*HHI_im + beta*distance_iim
+
+ # calculate f_(j,j)
+ x_1bjm = df['x_1bjm']
+ y_1tjm = df['y_1tjm']
+ x_2bjm = df['x_2bjm']
+ HHI_jm = df['HHI_jm']
+ distance_jjm = df['distance_jjm']
+
+ df['f_jj'] = delta*x_1bjm*y_1tjm + alpha*x_2bjm*y_1tjm + gamma*HHI_jm + beta*distance_jjm
+
+ # calculate f_(i,j)
+
+ distance_ijm = df['distance_ijm']
+
+ df['f_ij'] = delta*x_1bim*y_1tjm + alpha*x_2bim*y_1tjm + gamma*HHI_jm + beta*distance_ijm
+
+ # calculate f_(j,i)
+
+ distance_jim = df['distance_jim']
+
+ df['f_ji'] = delta*x_1bjm*y_1tim + alpha*x_2bjm*y_1tim + gamma*HHI_im + beta*distance_jim
+
+ df['observed'] = df['f_ii'] + df['f_jj']
+ df['counterfactual'] = df['f_ij'] + df['f_ji']
+
+ correct = (df['observed']>df['counterfactual'])
+
+ return -sum(correct)
+
+
+'''
+Part7 Estimate Model2
+'''
+# initial guesses
+paras = (0.1, 0.1, 0.1, -0.1)
+
+# minimize the maximum socre objective function
+res1 = opt.minimize(Q2, paras, args = (df_match2,),
+ method = 'Nelder-Mead')
+
+# use improved parameters to estimate
+res2 = opt.minimize(Q2, res1.x, args = (df_match2,),
+ method = 'Nelder-Mead')
+
+# get the result of the estimated parameters
+est_paras2 = res2.x
+# get the result of the estimated alpha
+est_delta2 = est_paras2[0]
+est_alpha2 = est_paras2[1]
+est_gamma2 = est_paras2[2]
+est_beta2 = est_paras2[3]
+
+# use the estimated parameters to calculate the maximum score
+MS2 = Q2(est_paras2, df_match2)
+
+# Print the resukt
+print('For the model2:')
+print('The estimate of delta is', est_delta2)
+print('The estimate of alpha is', est_alpha2)
+print('The estimate of gamma is', est_gamma2)
+print('The estimate of beta is', est_beta2)
+print('The maximum socre estimator is', MS2)
diff --git a/ProblemSet6/ProblemSet6_Yu.ipynb b/ProblemSet6/ProblemSet6_Yu.ipynb
new file mode 100644
index 0000000..1efbc80
--- /dev/null
+++ b/ProblemSet6/ProblemSet6_Yu.ipynb
@@ -0,0 +1,599 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "0c9b6e7e",
+ "metadata": {},
+ "source": [
+ "# Problem Set \\#6\n",
+ "## ECON 833, Computational Methods for Economists\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a46c21f",
+ "metadata": {},
+ "source": [
+ "## 1. Setup"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "8383874d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# imports\n",
+ "from sklearn import tree\n",
+ "from sklearn.metrics import mean_squared_error\n",
+ "from sklearn.model_selection import KFold\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.tree import export_text\n",
+ "from sklearn.model_selection import RandomizedSearchCV\n",
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "from scipy.stats import randint as sp_randint\n",
+ "\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "8375f64b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " biden \n",
+ " female \n",
+ " age \n",
+ " educ \n",
+ " dem \n",
+ " rep \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 90 \n",
+ " 0 \n",
+ " 19 \n",
+ " 12 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 70 \n",
+ " 1 \n",
+ " 51 \n",
+ " 14 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 60 \n",
+ " 0 \n",
+ " 27 \n",
+ " 14 \n",
+ " 0 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 50 \n",
+ " 1 \n",
+ " 43 \n",
+ " 14 \n",
+ " 1 \n",
+ " 0 \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 60 \n",
+ " 1 \n",
+ " 38 \n",
+ " 14 \n",
+ " 0 \n",
+ " 1 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axes = plt.subplots(nrows = 1,ncols = 1,figsize = (4,4), dpi=300)\n",
+ "tree.plot_tree(biden_tree, \n",
+ " feature_names=X_var_names, ax=axes, \n",
+ " filled = True)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8bdcbd51",
+ "metadata": {},
+ "source": [
+ "### 2.3 Interpret the tree\n",
+ "- **Group1**: there are 235 male respondents who are neither Democrat nor Republican in this group. The mean value of feelings of warmth towards Biden is 56.489\n",
+ "- **Group2**: there are 233 female respondents who are neither Democrat nor Republican in this group. The mean value of feelings of warmth towards Biden is 61.266\n",
+ "- **Group3**: there are 123 male respondents who are not Democrat but Republican in this group. The mean value of feelings of warmth towards Biden is 38.333. The value is lowest in this group. i.e. Respondents in this group feel extremely cold for Biden\n",
+ "- **Group4**: there are 133 female respondents who are not Democrat but Republican in this group. The mean value of feelings of warmth towards Biden is 44.887\n",
+ "- **Group5**: there are 247 people in this group. They are Democrat, younger than 54.5 years old, and receive less than 15.5 years of formal education. The mean value of feelings of warmth towards Biden is 71.105\n",
+ "- **Group6**: there are 93 people in this group. They are Democrat, younger than 54.5 years old, and receive more than 15.5 years of formal education. The mean value of feelings of warmth towards Biden is 76.591\n",
+ "- **Group7**: there are 79 people in this group. They are male, Democrat, older than 54.5 years old. The mean value of feelings of warmth towards Biden is 75.19\n",
+ "- **Group8**: there are 121 people in this group. They are female, Democrat, older than 54.5 years old. The mean value of feelings of warmth towards Biden is 80.289. Therefore, in this sample, people with those characteristics support Biden the most.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d695dad",
+ "metadata": {},
+ "source": [
+ "### 2.4 MSE"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "fe769fb8",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# use test data to calculate the predicted y\n",
+ "y_predict = biden_tree.predict(X_test)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "63a70ebd",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The SSE of a tree of depth 3 and 8 leaves = 396.1937146321307\n"
+ ]
+ }
+ ],
+ "source": [
+ "MSE = mean_squared_error(y_test, y_predict)\n",
+ "print('The SSE of a tree of depth ', biden_tree.get_depth(), ' and ',\n",
+ " biden_tree.get_n_leaves(), ' leaves = ', MSE)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20d49474",
+ "metadata": {},
+ "source": [
+ "## 3. Optimal Tuning Parametes"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e09f91d6",
+ "metadata": {},
+ "source": [
+ "### 3.1 Set parameter distributions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "ca15d21f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_dist = {\"max_depth\": [3, 10], \n",
+ " \"min_samples_split\": sp_randint(2, 20),\n",
+ " \"min_samples_leaf\": sp_randint(2, 20)}\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "83d54b6b",
+ "metadata": {},
+ "source": [
+ "### 3.2 Fit the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "9df2987d",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "clf = RandomizedSearchCV(estimator=dtr, \n",
+ " param_distributions=param_dist, \n",
+ " n_iter=100, n_jobs=-1, cv=5, #k = 5 k-fold cross validation\n",
+ " random_state=25, \n",
+ " scoring='neg_mean_squared_error')\n",
+ "search = clf.fit(X,y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "15502a7c",
+ "metadata": {},
+ "source": [
+ "### 3.3 Find the optimal parameters and MSE for the optimal result"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "ecfca008",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimal_tuning_params = search.best_params_\n",
+ "MSE_optimalRes = -search.best_score_\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "90e229b4",
+ "metadata": {},
+ "source": [
+ "### 3.4 Report the result"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "dda41a20",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The optimal maximum depth for this model is 3\n",
+ "The optimal mininum samples split for this model is 14\n",
+ "The optimal mininum samples leaf for this model is 17\n",
+ "The MSE of the optimal results is 401.713307249986\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Report the optimal tuning parameter values\n",
+ "print(\"The optimal maximum depth for this model is %s\" % optimal_tuning_params.get('max_depth'))\n",
+ "print(\"The optimal mininum samples split for this model is %s\" % optimal_tuning_params.get('min_samples_split'))\n",
+ "print(\"The optimal mininum samples leaf for this model is %s\" % optimal_tuning_params.get('min_samples_leaf'))\n",
+ "\n",
+ "# Report the MSE of the optimal results \n",
+ "print(\"The MSE of the optimal results is %s\" % MSE_optimalRes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7e765795",
+ "metadata": {},
+ "source": [
+ "## 4. Random Forest"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88b55b87",
+ "metadata": {},
+ "source": [
+ "### 4.1 Set parameter distributions"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "60d375ec",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "param_dist_rf = {\"n_estimators\": [10, 200], \n",
+ " \"max_depth\": [3, 10],\n",
+ " \"min_samples_split\": sp_randint(2, 20), \n",
+ " \"min_samples_leaf\": sp_randint(2, 20),\n",
+ " \"max_features\": sp_randint(1, 5)}"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "31a14a6b",
+ "metadata": {},
+ "source": [
+ "### 4.2 Fit the model"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "id": "790b6a71",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "rf = RandomForestRegressor()\n",
+ "clf_randamForest = RandomizedSearchCV(estimator=rf, \n",
+ " param_distributions=param_dist_rf, \n",
+ " n_iter=100, n_jobs=-1, cv=5, #k = 5 k-fold cross validation\n",
+ " random_state=25, \n",
+ " scoring='neg_mean_squared_error')\n",
+ "search_rf = clf_randamForest.fit(X,y)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d934f129",
+ "metadata": {},
+ "source": [
+ "### 3.3 Find the optimal parameters and MSE for the optimal result"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "id": "40acbce7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "optimal_tuning_params_rf = search_rf.best_params_\n",
+ "MSE_optimalRes_rf = -search_rf.best_score_"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88da2513",
+ "metadata": {},
+ "source": [
+ "### 3.4 Report the result"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "id": "5ee86c61",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "The optimal number of estimators for this model is 200\n",
+ "The optimal maximum depth for this model is 3\n",
+ "The optimal mininum samples split for this model is 4\n",
+ "The optimal mininum samples leaf for this model is 19\n",
+ "The optimal maximum features for this model is 3\n",
+ "The MSE of the optimal results is 397.05747445504363\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Report the optimal tuning parameter values\n",
+ "print(\"The optimal number of estimators for this model is %s\" % optimal_tuning_params_rf.get('n_estimators'))\n",
+ "print(\"The optimal maximum depth for this model is %s\" % optimal_tuning_params_rf.get('max_depth'))\n",
+ "print(\"The optimal mininum samples split for this model is %s\" % optimal_tuning_params_rf.get('min_samples_split'))\n",
+ "print(\"The optimal mininum samples leaf for this model is %s\" % optimal_tuning_params_rf.get('min_samples_leaf'))\n",
+ "print(\"The optimal maximum features for this model is %s\" % optimal_tuning_params_rf.get('max_features'))\n",
+ "\n",
+ "# Report the MSE of the optimal results \n",
+ "print(\"The MSE of the optimal results is %s\" % MSE_optimalRes_rf)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "8907fc4b",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "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.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/ProblemSet8/ProblemSet8_Yu.pdf b/ProblemSet8/ProblemSet8_Yu.pdf
new file mode 100644
index 0000000..a3e65c5
Binary files /dev/null and b/ProblemSet8/ProblemSet8_Yu.pdf differ
diff --git a/ProblemSet8/execute.py b/ProblemSet8/execute.py
new file mode 100644
index 0000000..50f38a5
--- /dev/null
+++ b/ProblemSet8/execute.py
@@ -0,0 +1,124 @@
+import numpy as np
+
+from functions import bellman_operator
+from functions import profit
+import matplotlib.pyplot as plt
+
+# set the parameter
+beta = 0.6
+inv = 0.15
+R = 0.1
+
+'''
+------------------------------------------------------------------------
+Create Grid for State Space
+------------------------------------------------------------------------
+lb_w = scalar, lower bound of cake grid
+ub_w = scalar, upper bound of cake grid
+size_w = integer, number of grid points in cake state space
+w_grid = vector, size_w x 1 vector of cake grid points
+------------------------------------------------------------------------
+'''
+lb_w = 2
+ub_w = 100
+size_w = 200 # Number of grid points
+w_grid = np.linspace(lb_w, ub_w, size_w)
+
+
+'''
+------------------------------------------------------------------------
+Value Function Iteration
+------------------------------------------------------------------------
+VFtol = scalar, tolerance required for value function to converge
+VFdist = scalar, distance between last two value functions
+VFmaxiter = integer, maximum number of iterations for value function
+V = vector, the value functions at each iteration
+Vmat = matrix, the value for each possible combination of w and w'
+Vstore = matrix, stores V at each iteration
+VFiter = integer, current iteration number
+V_params = tuple, contains parameters to pass into Belman operator: beta, sigma
+TV = vector, the value function after applying the Bellman operator
+PF = vector, indicies of choices of w' for all w
+VF = vector, the "true" value function
+------------------------------------------------------------------------
+'''
+
+VFtol = 1e-5
+VFdist = 7.0
+VFmaxiter = 5000
+V = np.zeros(size_w) #true_VF # initial guess at value function
+Vstore = np.zeros((size_w, VFmaxiter)) #initialize Vstore array
+VFiter = 1
+V_params = (beta, inv, R)
+
+while VFdist > VFtol and VFiter < VFmaxiter:
+ Vstore[:, VFiter] = V
+ TV, optW = bellman_operator(V, w_grid, V_params)
+ VFdist = (np.absolute(V - TV)).max() # check distance
+
+ V = TV
+ VFiter += 1
+
+VF = V
+
+# Plot value function
+plt.figure()
+plt.plot(w_grid[1:], VF[1:])
+plt.xlabel('Amount of Oil')
+plt.ylabel('Value Function')
+plt.title('Value Function - deterministic oil sales')
+plt.show()
+
+# Plot value function at several iterations
+plt.figure()
+fig, ax = plt.subplots()
+ax.plot(w_grid, Vstore[:,0], label='1st iter')
+ax.plot(w_grid, Vstore[:,2], label='2nd iter')
+ax.plot(w_grid, Vstore[:,3], label='3rd iter')
+ax.plot(w_grid, Vstore[:,5], label='5th iter')
+ax.plot(w_grid, Vstore[:,10], label='10th iter')
+ax.plot(w_grid, Vstore[:,VFiter-1], 'k', label='Last iter')
+# Now add the legend with some customizations.
+legend = ax.legend(loc='lower right', shadow=False)
+# Set the fontsize
+for label in legend.get_texts():
+ label.set_fontsize('large')
+for label in legend.get_lines():
+ label.set_linewidth(1.5) # the legend line width
+plt.xlabel('Amount of Oil')
+plt.ylabel('Value Function')
+plt.title('Value Function - deterministic oil sales')
+plt.show()
+
+#Plot optimal consumption rule as a function of cake size
+plt.figure()
+fig, ax = plt.subplots()
+ax.plot(w_grid[1:], optS[1:], label='Sales')
+# Now add the legend with some customizations.
+legend = ax.legend(loc='upper left', shadow=False)
+# Set the fontsize
+for label in legend.get_texts():
+ label.set_fontsize('large')
+for label in legend.get_lines():
+ label.set_linewidth(1.5) # the legend line width
+plt.xlabel('Amount of Oil')
+plt.ylabel('Optimal Sales')
+plt.title('Policy Function, sales - deterministic oil sales')
+plt.show()
+
+#Plot cake to leave rule as a function of cake size
+plt.figure()
+fig, ax = plt.subplots()
+ax.plot(w_grid[1:], optW[1:], label='Storage')
+ax.plot(w_grid[1:], w_grid[1:], '--', label='45 degree line')
+# Now add the legend with some customizations.
+legend = ax.legend(loc='upper left', shadow=False)
+# Set the fontsize
+for label in legend.get_texts():
+ label.set_fontsize('large')
+for label in legend.get_lines():
+ label.set_linewidth(1.5) # the legend line width
+plt.xlabel('Amount of Oil')
+plt.ylabel('Optimal Storage')
+plt.title('Policy Function, storage - deterministic oil sales')
+plt.show()
\ No newline at end of file
diff --git a/ProblemSet8/functions.py b/ProblemSet8/functions.py
new file mode 100644
index 0000000..cfe10ad
--- /dev/null
+++ b/ProblemSet8/functions.py
@@ -0,0 +1,42 @@
+# Import packages
+import numpy as np
+
+from scipy import interpolate
+from scipy.optimize import fminbound
+
+def profit(w, wprime, inv, R):
+
+ '''
+ w: amount of oil in current period
+ wprime: amount of oil saved for next period
+ price: price of oil
+ i: return rate
+ q: amount of newly produced oil
+ '''
+
+ S = w - wprime/(R+1)
+ price = 100/np.exp(S)
+ Pi = S * price + inv * wprime
+
+ return Pi
+
+
+
+def bellman_operator(V, w_grid, params):
+ beta, inv, R = params
+
+ # Apply cubic interpolation to V
+ V_func = interpolate.interp1d(w_grid, V, kind='cubic', fill_value='extrapolate')
+
+ # Initialize array for operator and policy function
+ TV = np.empty_like(V)
+ optW = np.empty_like(TV)
+
+ for i, w in enumerate(w_grid):
+
+ def objective(wprime):
+ return - profit(w, wprime, inv, R) - beta * V_func(wprime)
+ wprime_star = fminbound(objective, 1e-6, w - 1e-6)
+ optW[i] = wprime_star
+ TV[i] = - objective(wprime_star)
+ return TV, optW
diff --git a/ProblemSet9/ProblemSet9_Yu.pdf b/ProblemSet9/ProblemSet9_Yu.pdf
new file mode 100644
index 0000000..675c4db
Binary files /dev/null and b/ProblemSet9/ProblemSet9_Yu.pdf differ
diff --git a/ProblemSet9/SS.py b/ProblemSet9/SS.py
new file mode 100644
index 0000000..08f6f60
--- /dev/null
+++ b/ProblemSet9/SS.py
@@ -0,0 +1,40 @@
+import necessary_equations as ne
+import scipy.optimize as opt
+
+
+def SS_solver(r_guess, bn_guess, alpha, delta, A, sigma, chi, l, v, b, beta):
+ '''
+ Solves for the SS of the economy
+ '''
+ xi = 0.2
+ tol = 1e-8
+ max_iter = 500
+ dist = 7
+ iter = 0
+ r = r_guess
+ bn = bn_guess
+
+ while (dist > tol) & (iter < max_iter):
+ w = ne.get_w(r, (alpha, delta, A))
+
+ sol = opt.root(
+ ne.euler_equation, bn,
+ args=(r, w, (sigma, chi, l, v, b, beta)))
+
+ bn = sol.x
+ euler_errors = sol.fun
+
+ b_s = bn[:S_set-1]
+ n_s = bn[-S_set:]
+
+ K = ne.get_K(b_s)
+ L = ne.get_L(n_s)
+ r_prime = ne.get_r(K, L, (alpha, delta, A))
+ dist = (r - r_prime) ** 2
+ iter += 1
+ r = xi * r_prime + (1 - xi) * r
+
+
+ success = iter < max_iter
+
+ return r, bn, success, euler_errors
diff --git a/ProblemSet9/execute.py b/ProblemSet9/execute.py
new file mode 100644
index 0000000..189a71d
--- /dev/null
+++ b/ProblemSet9/execute.py
@@ -0,0 +1,51 @@
+import matplotlib.pyplot as plt
+from matplotlib import style
+style.use('ggplot')
+
+# Set parameters
+alpha = 0.3
+delta = 0.1
+A = 1.0
+sigma = 1.5
+beta = 0.8
+b = 0.501
+v = 1.554
+l = 1
+# assume that this person will live for 50 years
+S_set = 50
+chi = np.ones(S_set)
+
+# Make initial guesses
+r_guess = 0.1
+b_guess = [0.01]*(S_set-1)
+n_guess = [0.2]*S_set
+bn_guess = b_guess + n_guess
+
+r, bn, success, euler_errors = SS.SS_solver(r_guess, bn_guess,alpha, delta, A,
+ sigma, chi, l, v, b, beta)
+
+C_s = (1 + r) *np.array(b_s) + w * np.array(bn_guess[-S_set:]) - np.array(b_sp1)
+
+# plot savings
+plt.figure()
+plt.plot(range(S_set+1), B_s)
+plt.xlabel('Age s')
+plt.ylabel('Savings b')
+plt.title('Steady-state distribution of saving b')
+plt.show()
+
+# plot labor supply
+plt.figure()
+plt.plot(range(S_set+1), N_s)
+plt.xlabel('Age s')
+plt.ylabel('Labor Supply')
+plt.title('Steady-state distribution of labor supply n')
+plt.show()
+
+# plot consumption
+plt. figure()
+plt.plot(range(S_set), C_s)
+plt.xlabel('Age s')
+plt.ylabel('Unit of Comsumption')
+plt.title('Steady-state distribution of consumption c')
+plt.show()
diff --git a/ProblemSet9/necessary_equations.py b/ProblemSet9/necessary_equations.py
new file mode 100644
index 0000000..40212bd
--- /dev/null
+++ b/ProblemSet9/necessary_equations.py
@@ -0,0 +1,66 @@
+import numpy as np
+
+def get_L(n):
+ '''
+ Function to compute aggregate
+ labor supplied
+ '''
+ L = n.sum()
+ return L
+
+
+def get_K(b):
+ '''
+ Function to compute aggregate
+ capital supplied
+ '''
+ K = b.sum()
+ return K
+
+def get_r(K, L, params):
+ '''
+ Compute the interest rate from
+ the firm's FOC
+ '''
+ alpha, delta, A = params
+
+ r = alpha * A * (L / K) ** (1 - alpha) - delta
+ return r
+
+
+def get_w(r, params):
+ '''
+ Solve for the w that is consistent
+ with r from the firm's FOC
+ '''
+ alpha, delta, A = params
+ w = (1 - alpha) * A * ((alpha * A) / (r + delta)) ** (alpha / (1 - alpha))
+ return w
+
+
+def euler_equation(bn_guess, w, r, params):
+ sigma, chi, l, v, b, beta = params
+
+ length = len(bn_guess)
+ S_set = int((length + 1)/2)
+
+ # assume the individuals are born with no savings and save no income in the last period
+ b_s = [0] + list(bn_guess[:S_set-1]) + [0]
+
+ # assume the labor supply of final period is 0
+ n_s = list(bn_guess[-S_set:]) + [0]
+
+ euler_error = np.zeros(2*S_set-1)
+
+ for i in range(S_set):
+ c = (1 + r) * b_s[i] + w * n_s[i] - b_s[i+1]
+ g_n = 1-(n_s[i])**v
+ euler_error[i] = w*(c**-sigma) - chi[i] * (b/l) * (n_s[i]/l)**(v-1) * g_n**((1-v)/v)
+
+ for j in range(S_set-1):
+ c_s = (1 + r) * b_s[j] + w * n_s[j] - b_s[j+1]
+ c_sp1 = (1 + r) * b_s[j+1] + w * n_s[j+1] - b_s[j+2]
+
+ euler_error[S_set+j] = c_s**-sigma - beta * (1+r) * c_sp1**-sigma
+
+ return euler_error
diff --git a/calculator.py b/calculator.py
new file mode 100644
index 0000000..0071957
--- /dev/null
+++ b/calculator.py
@@ -0,0 +1,23 @@
+from math import sqrt
+
+def sum_two(a,b):
+ '''
+ Arg:
+ a,b: two int
+
+ Returns:
+ c: int that equals to the sum of two arguments
+ '''
+ c = a + b
+ return c
+
+def pdt_two(e,f):
+ '''
+ Arg:
+ e,f: two int
+
+ Returns:
+ g: int that equals to the sum of two arguments
+ '''
+ g = e * f
+ return g
\ No newline at end of file