map_and_filter.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Analysis 2: Foundations of modeling 2\n",
    "\n",
    "## Higher-order functions: map and filter\n",
    "\n",
    "In mathematics we distinguish between the first order functions and higher order functions.\n",
    "We say that a function is higher-order if it either takes one or more functions as argument(s),\n",
    "or returns a function as its result.  In contrast, a first-order function can never take another\n",
    "function as an argument, nor it can return a function as its result.\n",
    "\n",
    "We've already practiced with lambda functions, and used them as either input arguments or return\n",
    "values.  Hence, we've already experimented with higher-order functions.  In this document, we will\n",
    "focus on two specific functions: `map` and `filter`, which are often used in association with lists.\n",
    "Both of them are built-in Python functions, but for better understanding, we will re-implement\n",
    "them here.\n",
    "\n",
    "This document contains:\n",
    "- [Map function](#map)\n",
    "- [Filter function](#filter)\n",
    "- [Plotting with higher order functions (optional)](#filter)\n",
    "---\n",
    "<a id='map'></a>\n",
    "### Map function\n",
    "The map function typically takes two arguments.  The first is the function that will be used for\n",
    "mapping and the second is the data on which that mapping will be applied.  Essentially, `map`\n",
    "applies the given function to each given data element. Let’s take a look at the implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def map(f, L):\n",
    "    \"\"\"re-implementation of map function;\n",
    "    function f is applied for each element in L\"\"\"\n",
    "    return (f(x) for x in L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example – using map function\n",
    "To understand the `map` function, we will create one lambda function and two different ‘lists’ to be\n",
    "used as input data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = lambda x: x*x\n",
    "L1 = [1, 2, 3, 4, 5]\n",
    "L2 = range(1, 11)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we call the `map` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res1 = map(f, L1)\n",
    "res2 = map(f, L2)\n",
    "print(res1)\n",
    "print(res2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although everything works as intended, the output is not a list, but a generator object, and\n",
    "printing `res1` and `res2` gives a memory pointer to that object. The reasoning behind this is to\n",
    "give Python an effective memory management, especially when dealing with very long lists.\n",
    "Python will conserve memory, and return only the specific element when asked. If we want to\n",
    "get the result as a list, we can just use standard type conversion:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res1 = list(map(f, L1))\n",
    "res2 = list(map(f, L2))\n",
    "print(res1)\n",
    "print(res2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Experiment\n",
    "- Try different lambdas on the same or new list values. For example, try to double all\n",
    "elements."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: Celsius-to-Fahrenheit conversion\n",
    "Assume that we have data in the form of a list, where each element is a tuple showing a city\n",
    "name and its current temperature in Celsius:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperatures = [(\"Berlin\", 29), (\"Cairo\", 36), (\"Belgrade\", 19),\n",
    "                (\"Los Angeles\", 27), (\"Amsterdam\", 20), (\"Rotterdam\", 19)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to convert these temperatures to Fahrenheit, all we have to do is write a new lambda\n",
    "function for conversion and pass it to our map function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c_to_f = lambda temp: (temp[0], (9/5)*temp[1] + 32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that this lambda will take each element from the list – and that is a tuple (example:\n",
    "`(\"Berlin\", 29)` and then just copy the first tuple element `(temp[0]= \"Berlin\", )` while the second\n",
    "element will be multiplied by 9/5 and incremented by 32, finally, packing it as a new second\n",
    "tuple element `(, 9/5 * temp[1] + 32 = 9/5 * 29 + 32 = 84.2)`. Therefore, `c_to_f` transforms\n",
    "`(\"Berlin\", 29)` to `(\"Berlin\", 84.2)`, and will do the same for every other tuple.\n",
    "\n",
    "You can find the complete code below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def map(f, L):\n",
    "    \"\"\"re-implementation of map function;\n",
    "    function f is applied for each element in L\"\"\"\n",
    "    return (f(x) for x in L)\n",
    "\n",
    "temperatures = [(\"Berlin\", 29), (\"Cairo\", 36), (\"Belgrade\", 19),\n",
    "                (\"Los Angeles\", 27), (\"Amsterdam\", 20), (\"Rotterdam\", 19)]\n",
    "\n",
    "c_to_f = lambda temp: (temp[0], (9/5)*temp[1] + 32)\n",
    "\n",
    "res3 = map(c_to_f, temperatures)\n",
    "print(list(res3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Experiment\n",
    "- Write a new lambda function that will convert all city names to uppercase letters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='filter'></a>\n",
    "### Filter function\n",
    "Similar to map function, filter function will be applied to every element of the input data, but\n",
    "the result will include only those elements that satisfy certain criteria. Let’s take a look at the\n",
    "implementation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter(f, L):\n",
    "    \"\"\"re-implementation of filter function;\n",
    "    function f is applied for each element in L\n",
    "    and a new sequence is generated where f returns True\"\"\"\n",
    "    return (x for x in L if f(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see that x will iterate through every element in L (`for x in L`) and then for each x, the\n",
    "function f will be called, passing x as the parameter (`if f(x)`). Since `f(x)` is part of an if-\n",
    "statement, whenever f returns True, current x value will be returned. Otherwise, x will be\n",
    "ignored – filtered.\n",
    "#### Example – filter even numbers\n",
    "To begin filtering, we need a lambda function that will return True if an input parameter is\n",
    "even:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2 = lambda x: x%2 == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We also need data. For this example, we create a list from 1 to 20."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L3 = [i for i in range(1, 21)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we call the `filter` function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "res4 = list(filter(f2, L3))\n",
    "print(res4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with `map`, `filter` will return a generator, so if we want to print it, the result needs to\n",
    "be converted first.\n",
    "#### Example – filter numbers greater than 10\n",
    "We can easily modify lambda expressions to get only the numbers that are greater than 10.\n",
    "Below you can find the complete code. Notice, that we use lambda as inline for demonstration\n",
    "purposes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter(f, L):\n",
    "    \"\"\"re-implementation of filter function;\n",
    "    function f is applied for each element in L\n",
    "    and a new sequence is generated where f returns True\"\"\"\n",
    "    return (x for x in L if f(x))\n",
    "\n",
    "L3 = [i for i in range(1,21)]\n",
    "res5 = list(filter(lambda x: x > 10, L3))\n",
    "print(res5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example – filter programmers\n",
    "Assume you have the following list that contains tuples of available programmers, such that,\n",
    "the first element of that tuple is a programmer’s name, the second element is their programming\n",
    "language of choice, and the third is their skill in that language:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "programmers = []\n",
    "programmers.append((\"Andrej\", \"Python\", 8))\n",
    "programmers.append((\"Jos\", \"Python\", 10))\n",
    "programmers.append((\"Francesco\", \"C#\", 10))\n",
    "programmers.append((\"Deborah\", \"C#\", 9))\n",
    "programmers.append((\"Lazy_student\", \"Python\", 1))\n",
    "print(programmers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the same filter function, and writing new filter lambda, we can easily filter only Python\n",
    "programmers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f1 = lambda data: data[1] == \"Python\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r1 = filter(f1, programmers)\n",
    "print(list(r1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or, we can find all programmers with programming skill 9 or higher:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2 = lambda data: data[2] >= 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and filter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r2 = filter(f2, programmers)\n",
    "print(list(r2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The complete code can be found below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def filter(f, L):\n",
    "    \"\"\"re-implementation of filter function;\n",
    "    function f is applied for each element in L\n",
    "    and a new sequence is generated where f returns True\"\"\"\n",
    "    return (x for x in L if f(x))\n",
    "\n",
    "programmers = []\n",
    "programmers.append((\"Andrej\", \"Python\", 8))\n",
    "programmers.append((\"Jos\", \"Python\", 10))\n",
    "programmers.append((\"Francesco\", \"C#\", 10))\n",
    "programmers.append((\"Deborah\", \"C#\", 9))\n",
    "programmers.append((\"Lazy_student\", \"Python\", 1))\n",
    "print(programmers)\n",
    "\n",
    "f1 = lambda data: data[1] == \"Python\"\n",
    "f2 = lambda data: data[2] >= 9\n",
    "\n",
    "r1 = filter(f1, programmers)\n",
    "print(list(r1))\n",
    "\n",
    "r2 = filter(f2, programmers)\n",
    "print(list(r2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Experiment\n",
    "- Modify the filter function (lambda) such that you get only Python programmers with skill\n",
    "9 or greater."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<a id='plotting'></a>\n",
    "### Plotting with higher order functions (optional)\n",
    "In this section we will combine everything learned so far about functions, matplotlib and\n",
    "pyplot, lambda functions and higher order functions, to create versatile plotting functions.\n",
    "\n",
    "Note: for precise calculations you need to use the NumPy module. As NumPy is not part of the\n",
    "standard Python library, it is not used in these examples.\n",
    "#### Example – setting up helper functions\n",
    "We start by creating helper functions. To this end we create two functions that return linear\n",
    "and quadratic functions using slope-intercept and general form. Also, we add functions for\n",
    "manipulating pyplot axes (running these will create an empty plot):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import needed modules:\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "# Globals for easy plot formatting:\n",
    "RANGE_MIN = - 10\n",
    "RANGE_MAX = 10\n",
    "\n",
    "# Create linear and quadratic func:\n",
    "def lin_func(m, b):\n",
    "    \"\"\"creates linear function mX + b\"\"\"\n",
    "    return lambda x: m*x + b\n",
    "\n",
    "def quad_func(a, b, c):\n",
    "    \"\"\"creates quadratic function a*x**2 + b*x + c\"\"\"\n",
    "    return lambda x: a*x**2 + b*x + c\n",
    "\n",
    "# Helper functions for setting pyplot axes:\n",
    "def add_cartesian_axes():\n",
    "    \"\"\"draws x and y axis that intersect at (0,0)\"\"\"\n",
    "    ax = plt.gca()\n",
    "    ax.spines['left'].set_position('zero')\n",
    "    ax.spines['right'].set_color('none')\n",
    "    ax.spines['bottom'].set_position('zero')\n",
    "    ax.spines['top'].set_color('none')\n",
    "    ax.spines['left'].set_smart_bounds(True)\n",
    "    ax.spines['bottom'].set_smart_bounds(True)\n",
    "    ax.xaxis.set_ticks_position('bottom')\n",
    "    ax.yaxis.set_ticks_position('left')\n",
    "\n",
    "def set_axis(ymin, ymax, xmin=RANGE_MIN, xmax=RANGE_MAX):\n",
    "    \"\"\"manually configure plot area\"\"\"\n",
    "    plt.axis([xmin, xmax, ymin, ymax])\n",
    "\n",
    "add_cartesian_axes()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example – plotting functions\n",
    "Next, we want to create a function that will take any linear or quadratic function and add it to\n",
    "the plot.  Remember that pyplot uses a finite number of $(x,y)$ points and by default connects\n",
    "them with lines. Therefore, we have to generate either one list of $(x,y)$ points or two lists, where\n",
    "the first contains $x$ coordinates and the second contains $y$ coordinates. Since $x$ is an independent\n",
    "variable, we can create a list of values from `RANGE_MIN` to `RANGE_MAX`.  Then, $y$ values\n",
    "will be the result of a given function for each $x$.  By default, we set $x$ values in steps of 1, but\n",
    "some non-linear functions require higher precision, so we want to include that value as a\n",
    "parameter, too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_func(f, xmin=RANGE_MIN, xmax=RANGE_MAX, step=1):\n",
    "    # To avoid using NumPy, we \"manually\" create a list of x values\n",
    "    x = []\n",
    "    el = xmin\n",
    "    while el <= xmax:\n",
    "        x.append(el)\n",
    "        el += step\n",
    "    \n",
    "    # y values are just the results of mapping f to each x\n",
    "    y = list(map(f, x))\n",
    "    plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note how we use `map` to create the list of y values by mapping given function on each x.\n",
    "To test everything, create three linear functions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a few linear functions\n",
    "lin1 = lin_func(2,-1)\n",
    "lin2 = lin_func(0.5,1)\n",
    "lin3 = lin_func(0, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And plot them:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Plot them\n",
    "plot_func(lin1)\n",
    "plot_func(lin2)\n",
    "plot_func(lin3)\n",
    "\n",
    "add_cartesian_axes()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add quadratic function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add a quadratic function\n",
    "quad1 = quad_func(1, -2, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A step size of 1 is too big for quadratic functions. To make the drawing smooth, reduce step to 0.1 or\n",
    "even 0.01:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_func(quad1, step=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since quadratic function will make the plot scale by default, you may want to restrict it to\n",
    "lower values.  Let's put the linear and quadratic functions in 1 plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_func(lin1)\n",
    "plot_func(lin2)\n",
    "plot_func(lin3)\n",
    "plot_func(quad1, step=0.1)\n",
    "\n",
    "add_cartesian_axes()\n",
    "set_axis(-20,20)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Experiment\n",
    "- Experiment plotting different functions.\n",
    "- Change step value and `xmin`, `xmax` ranges for quadratic functions and observe graph\n",
    "changes.\n",
    "- Use `set_axis` to zoom to specific area, or unzoom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example – plotting trigonometric functions\n",
    "Test versatility of created `plot_func()` to plot trigonometric functions.  With `math` module\n",
    "imported, use either `sin()` or `cos()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "trig1 = lambda x: math.sin(x)\n",
    "trig2 = lambda x: x * math.sin(x)\n",
    "\n",
    "plot_func(trig1, step=0.1)\n",
    "plot_func(trig2, step=0.1)\n",
    "\n",
    "add_cartesian_axes()\n",
    "set_axis(-10,10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example – filtering specific points\n",
    "Let’s say that we want to highlight or only draw specific points from a function that satisfy\n",
    "a certain criterion.  That criterion will be another function `g()` that must return a Boolean value.\n",
    "Therefore, for input arguments, after the required function `f()`, we will add a filtering function `g()`\n",
    "and also let the user pass specific a shape that will be rendered if the condition is met. To allow\n",
    "easier filtering, we first create a list of `(x, y)` tuples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_points(f, g, shape, xmin=-10, xmax=10, step=1):\n",
    "    # Still wanting to avoid NumPy, we create a list of xy tuples:\n",
    "    xy = []\n",
    "    \n",
    "    el = xmin\n",
    "    while el <= xmax:\n",
    "        # Each tuple contains (x, f(x))\n",
    "        xy.append((el, f(el)))\n",
    "        el += step\n",
    "    \n",
    "    filtered_xy = list( filter(lambda data: g(data[1]), xy) )\n",
    "    \n",
    "    x = list(map(lambda data: data[0], filtered_xy))\n",
    "    y = list(map(lambda data: data[1], filtered_xy))\n",
    "\n",
    "    # Plot only the filtered points with desired shape\n",
    "    plt.plot(x, y, shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explore the line:\n",
    "```Python\n",
    "filtered_xy = list( filter(lambda data: g(data[1]), xy) )\n",
    "```\n",
    "With `lambda data: data[1]`, we can extract for each `(x,y)` pair only `y` values. Then `data[1]` is\n",
    "transformed by the `g()` function that returns a Boolean value. \n",
    "If the value is `True`, that `(x, y)` pair is\n",
    "added to `filtered_xy`.\n",
    "\n",
    "With `map`, x values are extracted from `filtered_xy` and also y values one line after. Finally,\n",
    "`plot()` is called, passing x, y, and desired shape.\n",
    "\n",
    "For the test, we will use the same trigonometric functions `trig1` and `trig2` and add condition to\n",
    "mark all points on `trig2` where $f(x) < -2$ with blue circles.  Also, we will add condition to mark\n",
    "all points on `trig1` where $f(x) ≈ 0$.  We don’t use the equality operator `==` because of the\n",
    "slight imprecision of floating-point numbers.  Therefore we will approximate to a value close to zero.\n",
    "\n",
    "So we add the following lines to the code:\n",
    "```Python\n",
    "plot_points(trig2, lambda y: y<-2, 'bo', step=0.1)\n",
    "plot_points(trig1, lambda y: abs(y)<0.01, 'r^', step=0.01)\n",
    "```\n",
    "The complete code is listed here:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import needed modules\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "\n",
    "# Globals for easy plot formatting:\n",
    "RANGE_MIN = - 10\n",
    "RANGE_MAX = 10\n",
    "\n",
    "# Create linear and quadratic functions:\n",
    "def lin_func(m, b):\n",
    "    \"\"\"creates linear function mX + b\"\"\"\n",
    "    return lambda x: m*x + b\n",
    "\n",
    "def quad_func(a, b, c):\n",
    "    \"\"\"creates quadratic function a*x**2 + b*x + c\"\"\"\n",
    "    return lambda x: a*x**2 + b*x + c\n",
    "\n",
    "# Helper functions for setting pyplot axes:\n",
    "def add_cartesian_axes():\n",
    "    \"\"\"draws x and y axis that intersect at (0,0)\"\"\"\n",
    "    ax = plt.gca()\n",
    "    ax.spines['left'].set_position('zero')\n",
    "    ax.spines['right'].set_color('none')\n",
    "    ax.spines['bottom'].set_position('zero')\n",
    "    ax.spines['top'].set_color('none')\n",
    "    ax.spines['left'].set_smart_bounds(True)\n",
    "    ax.spines['bottom'].set_smart_bounds(True)\n",
    "    ax.xaxis.set_ticks_position('bottom')\n",
    "    ax.yaxis.set_ticks_position('left')\n",
    "\n",
    "def set_axis(ymin, ymax, xmin=RANGE_MIN, xmax=RANGE_MAX):\n",
    "    \"\"\"manually configure plot area\"\"\"\n",
    "    plt.axis([xmin, xmax, ymin, ymax])\n",
    "\n",
    "def plot_func(f, xmin=RANGE_MIN, xmax=RANGE_MAX, step=1):\n",
    "    # To avoid using NumPy, we \"manually\" create a list of x values\n",
    "    x = []\n",
    "    el = xmin\n",
    "    while el <= xmax:\n",
    "        x.append(el)\n",
    "        el += step\n",
    "    # y values are just the results of mapping f to each x\n",
    "    y = list(map(f, x))\n",
    "    plt.plot(x, y)\n",
    "\n",
    "def plot_points(f, g, shape, xmin=-10, xmax=10, step=1):\n",
    "    # Still wanting to avoid NumPy, we create a list of xy tuples\n",
    "    xy = []\n",
    "    el = xmin\n",
    "    while el <= xmax:\n",
    "        # Each tuple contains (x, f(x))\n",
    "        xy.append((el, f(el)))\n",
    "        el += step\n",
    "    \n",
    "    filtered_xy = list( filter(lambda data: g(data[1]), xy) )\n",
    "\n",
    "    x = list(map(lambda data: data[0], filtered_xy))\n",
    "    y = list(map(lambda data: data[1], filtered_xy))\n",
    "    \n",
    "    # Plot only the filtered points with desired shape\n",
    "    plt.plot(x, y, shape)\n",
    "\n",
    "# Create trigonometric functions\n",
    "trig1 = lambda x: math.sin(x)\n",
    "trig2 = lambda x: x * math.sin(x)\n",
    "\n",
    "# Plot them\n",
    "plot_func(trig1, step=0.1)\n",
    "plot_func(trig2, step=0.1)\n",
    "\n",
    "# Plot specific points\n",
    "plot_points(trig2, lambda y: y<-2, 'bo', step=0.1)\n",
    "plot_points(trig1, lambda y: abs(y)<0.01, 'r^', step=0.01)\n",
    "\n",
    "add_cartesian_axes()\n",
    "set_axis(-10,10)\n",
    "plt.show()"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}