problem_sets/problem_set_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d097c3b3",
   "metadata": {},
   "source": [
    "# Problem Set 2\n",
    "\n",
    "Related lectures: [Control Flow](https://datascience.quantecon.org/../python_fundamentals/control_flow.html), [Functions](https://datascience.quantecon.org/../python_fundamentals/functions.html), and [Numpy](https://datascience.quantecon.org/../scientific/numpy_arrays.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f424d87",
   "metadata": {},
   "source": [
    "## Question 1\n",
    "For the tuple `foo` below, use a combination of `zip`, `range`, and `len` to mimic `enumerate(foo)`.\n",
    "\n",
    "Verify that your proposed solution is correct by converting each to a list and checking equality with `==`\n",
    "\n",
    "HINT: You can see what the answer should look like by starting with `list(enumerate(foo))`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4fb40791",
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = (\"good\", \"luck!\")\n",
    "# Your code goes here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad897ca8",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Question 2\n",
    "\n",
    "Write a for loop that uses the lists of cities and states to print a message saying `“{city} is in {state}”`, where `{city}` and `{state}` are replaced by different values on each iteration.  You are *not* allowed to use `zip`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a71bf1ed",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "cities = [\"Phoenix\", \"Austin\", \"San Diego\", \"New York\"]\n",
    "states = [\"Arizona\", \"Texas\", \"California\", \"New York\"]\n",
    "\n",
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0e78079",
   "metadata": {},
   "source": [
    "Now, do the same thing with a `for` loop using `zip`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e91962cf",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "cities = [\"Phoenix\", \"Austin\", \"San Diego\", \"New York\"]\n",
    "states = [\"Arizona\", \"Texas\", \"California\", \"New York\"]\n",
    "\n",
    "# Your code here\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e867e8e",
   "metadata": {},
   "source": [
    "Write a function that takes in a tuple as `(city, state)` and returns a string  `“{city} is in {state}”` with the values substituted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7b894d0d",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# Your function here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbad7a1a",
   "metadata": {},
   "source": [
    "## Question 3\n",
    "\n",
    "This exercise explores the concept of higher order functions, or functions\n",
    "that can be an input or output of another function.\n",
    "\n",
    "Below is code that implements a version of the generalized Cobb-Douglas production function which takes the form $ F(K, L) = z K^{\\alpha_1} L^{\\alpha_2} $.\n",
    "\n",
    "It takes as an argument `alpha_1`, `alpha_2`, and `z` and then\n",
    "*returns a function* that implements that parameterization of the\n",
    "Cobb-Douglas production function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "963e83d4",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "def cobb_douglas_factory(alpha_1, alpha_2, z=1.0):\n",
    "    \"\"\"\n",
    "    Return a function F(K, L) that implements the generalized Cobb-Douglas\n",
    "    production function with parameters alpha_1, alpha_2, and z\n",
    "\n",
    "    The returned function takes the form F(K, L) = z K^{\\alpha_1} L^{\\alpha_2}\n",
    "    \"\"\"\n",
    "    # I'm defining a function inside a function\n",
    "    def return_func(K, L):\n",
    "        return z * K**alpha_1 * L**alpha_2\n",
    "\n",
    "    # Notice I'm returning a function! :mind_blown:\n",
    "    return return_func"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a8b5fc9",
   "metadata": {},
   "source": [
    "We can use this function in two steps:\n",
    "\n",
    "1. Call it with `alpha_1`, `alpha_2`, and `z` and get a function in return.  \n",
    "1. Call the returned function with values of `K` and `L`.  \n",
    "\n",
    "\n",
    "Here’s how we would repeat the first Cobb-Douglas example from above:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "984e50fa",
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6285066872609142"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# step 1\n",
    "F2 = cobb_douglas_factory(0.33, 1-0.33)\n",
    "\n",
    "# step 2\n",
    "F2(1.0, 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd985d6e",
   "metadata": {},
   "source": [
    "Now, it is your turn…\n",
    "\n",
    "Re-write the `returns_to_scale` function above as we had in [Functions](https://datascience.quantecon.org/../python_fundamentals/functions.html) to accept an additional argument\n",
    "`F` that represents a production function. The function should take in `K` and `L`\n",
    "and return output.\n",
    "\n",
    "We’ve written some code below to get you started."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4b897e24",
   "metadata": {
    "hide-output": false
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "unexpected EOF while parsing (<ipython-input-4-9f510f7a9c97>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-9f510f7a9c97>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    \u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m unexpected EOF while parsing\n"
     ]
    }
   ],
   "source": [
    "def returns_to_scale2(F, K, L, gamma):\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "153b6981",
   "metadata": {},
   "source": [
    "Test out your new function using the original `F2` that we defined above and\n",
    "using the `cobb_douglas` function defined earlier in the lecture. You can use\n",
    "similar sets of values to what we used in class for `K` and `L`.\n",
    "\n",
    "Do you get the same answer?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd010414",
   "metadata": {},
   "source": [
    "## Question 4\n",
    "\n",
    "Let’s use our `cobb_douglas_factory` and `returns_to_scale2` functions\n",
    "to study returns to scale.\n",
    "\n",
    "What are the returns to scale when you set `alpha_1 = 0.3` and `alpha_2 = 0.6`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d41e1d8b",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# test with alpha_1 = 0.3 and alpha_2 = 0.6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5964f0ea",
   "metadata": {},
   "source": [
    "What about when you use `alpha_1 = 0.4` and `alpha_2 = 0.65`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e10f8658",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# test with alpha_1 = 0.4 and alpha_2 = 0.65"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a83ddd3",
   "metadata": {},
   "source": [
    "What do returns to scale have to do with the quantity $ \\alpha_1 + \\alpha_2 $? When will returns to scale be greater or less than 1?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "316b289b",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "778808d5",
   "metadata": {},
   "source": [
    "## Question 5\n",
    "\n",
    "Take a production function of only labor, `L`, with the following form\n",
    "\n",
    "$$\n",
    "f(L) = \\begin{cases} L^2 & \\text{ for } L \\in [0, 1)\\\\\n",
    "                    \\sqrt{L} & \\text{ for } L \\in [1, 2]\n",
    "        \\end{cases}\n",
    "$$\n",
    "\n",
    "Write a function to calculate the marginal product of labor (MPL) numerically by using a method similar to what we did in class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a478204c",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ece06a31",
   "metadata": {},
   "source": [
    "Plot the MPL for $ L \\in [0,2] $  (you can choose some sort of grid over those numbers with `np.linspace`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "055a0ade",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22f3e670",
   "metadata": {},
   "source": [
    "Consider the scenario where you increase the scale of production by a factor of 10 percent more labor. Plot the returns to scale for a grid on $ L \\in [0, 1.5] $.\n",
    "*Hint:* For this, you may need to write your own version of the `returns_to_scale` function specific to this production function or carefully use the one above. Either way of implementation is fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0bffdaa5",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "# your code here"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "480e83c8",
   "metadata": {},
   "source": [
    "Compare these returns to the scale of the Cobb-Douglas functions we have worked with."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0ea7bad",
   "metadata": {},
   "source": [
    "## Question 6\n",
    "\n",
    "Take the following definition for `X`. How would you do to extract the array `[[5, 6], [7, 8]]`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ceedf160",
   "metadata": {
    "hide-output": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "X = np.array([[[1, 2, 3], [3, 4, 5]], [[5, 6, 7], [7, 8, 9]]])\n",
    "\n",
    "# your code here\n"
   ]
  }
 ],
 "metadata": {
  "date": 1627429658.1807241,
  "filename": "problem_set_3.md",
  "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.11"
  },
  "title": "Problem Set 3"
 },
 "nbformat": 4,
 "nbformat_minor": 5
}