{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulating data in Python\n",
    "\n",
    "In Python, you can manipulate your data in various ways. There are many, different functions that you can use in order to manipulate your data.\n",
    "\n",
    "At the end of this module, we will be generating the __Planck__ spectrum, which describes the intensity of a [blackbody](https://en.wikipedia.org/wiki/Black_body).\n",
    "\n",
    "Before we generate it, we need to know how to read a file, and plot its content"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reading in  and manipulating data\n",
    "\n",
    "There are a lot of modules to read in data from a file:\n",
    "\n",
    "- Numpy\n",
    "    - `genfromtxt`\n",
    "    - `loadfromtxt`\n",
    "- Pandas\n",
    "    - `read_csv`\n",
    "    - `read_table`\n",
    "- ...\n",
    "\n",
    "We will use \"`genfromtxt`\" for this exercise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "## First, you need to import your modules\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define the path to the directory that contains all of our files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_path = '../data/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have questions about the function, you can add a \"?\" at the end of your function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function genfromtxt in module numpy.lib.npyio:\n",
      "\n",
      "genfromtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, skip_header=0, skip_footer=0, converters=None, missing_values=None, filling_values=None, usecols=None, names=None, excludelist=None, deletechars=None, replace_space='_', autostrip=False, case_sensitive=True, defaultfmt='f%i', unpack=None, usemask=False, loose=True, invalid_raise=True, max_rows=None, encoding='bytes')\n",
      "    Load data from a text file, with missing values handled as specified.\n",
      "    \n",
      "    Each line past the first `skip_header` lines is split at the `delimiter`\n",
      "    character, and characters following the `comments` character are discarded.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    fname : file, str, pathlib.Path, list of str, generator\n",
      "        File, filename, list, or generator to read.  If the filename\n",
      "        extension is `.gz` or `.bz2`, the file is first decompressed. Note\n",
      "        that generators must return byte strings in Python 3k.  The strings\n",
      "        in a list or produced by a generator are treated as lines.\n",
      "    dtype : dtype, optional\n",
      "        Data type of the resulting array.\n",
      "        If None, the dtypes will be determined by the contents of each\n",
      "        column, individually.\n",
      "    comments : str, optional\n",
      "        The character used to indicate the start of a comment.\n",
      "        All the characters occurring on a line after a comment are discarded\n",
      "    delimiter : str, int, or sequence, optional\n",
      "        The string used to separate values.  By default, any consecutive\n",
      "        whitespaces act as delimiter.  An integer or sequence of integers\n",
      "        can also be provided as width(s) of each field.\n",
      "    skiprows : int, optional\n",
      "        `skiprows` was removed in numpy 1.10. Please use `skip_header` instead.\n",
      "    skip_header : int, optional\n",
      "        The number of lines to skip at the beginning of the file.\n",
      "    skip_footer : int, optional\n",
      "        The number of lines to skip at the end of the file.\n",
      "    converters : variable, optional\n",
      "        The set of functions that convert the data of a column to a value.\n",
      "        The converters can also be used to provide a default value\n",
      "        for missing data: ``converters = {3: lambda s: float(s or 0)}``.\n",
      "    missing : variable, optional\n",
      "        `missing` was removed in numpy 1.10. Please use `missing_values`\n",
      "        instead.\n",
      "    missing_values : variable, optional\n",
      "        The set of strings corresponding to missing data.\n",
      "    filling_values : variable, optional\n",
      "        The set of values to be used as default when the data are missing.\n",
      "    usecols : sequence, optional\n",
      "        Which columns to read, with 0 being the first.  For example,\n",
      "        ``usecols = (1, 4, 5)`` will extract the 2nd, 5th and 6th columns.\n",
      "    names : {None, True, str, sequence}, optional\n",
      "        If `names` is True, the field names are read from the first line after\n",
      "        the first `skip_header` lines.  This line can optionally be proceeded\n",
      "        by a comment delimeter. If `names` is a sequence or a single-string of\n",
      "        comma-separated names, the names will be used to define the field names\n",
      "        in a structured dtype. If `names` is None, the names of the dtype\n",
      "        fields will be used, if any.\n",
      "    excludelist : sequence, optional\n",
      "        A list of names to exclude. This list is appended to the default list\n",
      "        ['return','file','print']. Excluded names are appended an underscore:\n",
      "        for example, `file` would become `file_`.\n",
      "    deletechars : str, optional\n",
      "        A string combining invalid characters that must be deleted from the\n",
      "        names.\n",
      "    defaultfmt : str, optional\n",
      "        A format used to define default field names, such as \"f%i\" or \"f_%02i\".\n",
      "    autostrip : bool, optional\n",
      "        Whether to automatically strip white spaces from the variables.\n",
      "    replace_space : char, optional\n",
      "        Character(s) used in replacement of white spaces in the variables\n",
      "        names. By default, use a '_'.\n",
      "    case_sensitive : {True, False, 'upper', 'lower'}, optional\n",
      "        If True, field names are case sensitive.\n",
      "        If False or 'upper', field names are converted to upper case.\n",
      "        If 'lower', field names are converted to lower case.\n",
      "    unpack : bool, optional\n",
      "        If True, the returned array is transposed, so that arguments may be\n",
      "        unpacked using ``x, y, z = loadtxt(...)``\n",
      "    usemask : bool, optional\n",
      "        If True, return a masked array.\n",
      "        If False, return a regular array.\n",
      "    loose : bool, optional\n",
      "        If True, do not raise errors for invalid values.\n",
      "    invalid_raise : bool, optional\n",
      "        If True, an exception is raised if an inconsistency is detected in the\n",
      "        number of columns.\n",
      "        If False, a warning is emitted and the offending lines are skipped.\n",
      "    max_rows : int,  optional\n",
      "        The maximum number of rows to read. Must not be used with skip_footer\n",
      "        at the same time.  If given, the value must be at least 1. Default is\n",
      "        to read the entire file.\n",
      "    \n",
      "        .. versionadded:: 1.10.0\n",
      "    encoding : str, optional\n",
      "        Encoding used to decode the inputfile. Does not apply when `fname` is\n",
      "        a file object.  The special value 'bytes' enables backward compatibility\n",
      "        workarounds that ensure that you receive byte arrays when possible\n",
      "        and passes latin1 encoded strings to converters. Override this value to\n",
      "        receive unicode arrays and pass strings as input to converters.  If set\n",
      "        to None the system default is used. The default value is 'bytes'.\n",
      "    \n",
      "        .. versionadded:: 1.14.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        Data read from the text file. If `usemask` is True, this is a\n",
      "        masked array.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.loadtxt : equivalent function when no data is missing.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    * When spaces are used as delimiters, or when no delimiter has been given\n",
      "      as input, there should not be any missing data between two fields.\n",
      "    * When the variables are named (either by a flexible dtype or with `names`,\n",
      "      there must not be any header in the file (else a ValueError\n",
      "      exception is raised).\n",
      "    * Individual values are not stripped of spaces by default.\n",
      "      When using a custom converter, make sure the function does remove spaces.\n",
      "    \n",
      "    References\n",
      "    ----------\n",
      "    .. [1] NumPy User Guide, section `I/O with NumPy\n",
      "           <http://docs.scipy.org/doc/numpy/user/basics.io.genfromtxt.html>`_.\n",
      "    \n",
      "    Examples\n",
      "    ---------\n",
      "    >>> from io import StringIO\n",
      "    >>> import numpy as np\n",
      "    \n",
      "    Comma delimited file with mixed dtype\n",
      "    \n",
      "    >>> s = StringIO(\"1,1.3,abcde\")\n",
      "    >>> data = np.genfromtxt(s, dtype=[('myint','i8'),('myfloat','f8'),\n",
      "    ... ('mystring','S5')], delimiter=\",\")\n",
      "    >>> data\n",
      "    array((1, 1.3, 'abcde'),\n",
      "          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '|S5')])\n",
      "    \n",
      "    Using dtype = None\n",
      "    \n",
      "    >>> s.seek(0) # needed for StringIO example only\n",
      "    >>> data = np.genfromtxt(s, dtype=None,\n",
      "    ... names = ['myint','myfloat','mystring'], delimiter=\",\")\n",
      "    >>> data\n",
      "    array((1, 1.3, 'abcde'),\n",
      "          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '|S5')])\n",
      "    \n",
      "    Specifying dtype and names\n",
      "    \n",
      "    >>> s.seek(0)\n",
      "    >>> data = np.genfromtxt(s, dtype=\"i8,f8,S5\",\n",
      "    ... names=['myint','myfloat','mystring'], delimiter=\",\")\n",
      "    >>> data\n",
      "    array((1, 1.3, 'abcde'),\n",
      "          dtype=[('myint', '<i8'), ('myfloat', '<f8'), ('mystring', '|S5')])\n",
      "    \n",
      "    An example with fixed-width columns\n",
      "    \n",
      "    >>> s = StringIO(\"11.3abcde\")\n",
      "    >>> data = np.genfromtxt(s, dtype=None, names=['intvar','fltvar','strvar'],\n",
      "    ...     delimiter=[1,3,5])\n",
      "    >>> data\n",
      "    array((1, 1.3, 'abcde'),\n",
      "          dtype=[('intvar', '<i8'), ('fltvar', '<f8'), ('strvar', '|S5')])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.genfromtxt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can go ahead and read in the data, and save it to two arrays, i.e. __`x1`__ and __`y1`__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1, y1 = np.genfromtxt('../data/dataset1.txt',\n",
    "                      unpack=True,\n",
    "                      dtype=np.float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now use __`unpack`__ to tell Python to throw out the two columns and we caught them with arrays __`x`__ and __`y`__, but we could have just captured whatever came out, then it just would be a merged array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = np.genfromtxt('../data/dataset1.txt', dtype=np.float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now examine the output from `genfromtxt`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 2)\n"
     ]
    }
   ],
   "source": [
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.04826417  0.25723241  0.46084084  0.64903566  0.71677476  0.96776548\n",
      "  1.29983937  1.43387289  1.62135006  1.76059405  2.03743367  2.14958662\n",
      "  2.42060419  2.715836    2.9275557   2.9653225   3.19679942  3.4614748\n",
      "  3.54848877  3.76910315  3.98784208  4.19339365  4.4279586   4.62071517\n",
      "  4.79496323  5.00002693  5.23539664  5.37992987  5.60752551  5.93871238\n",
      "  6.08304306  6.3391359   6.56212174  6.70258117  6.84234717  7.01380281\n",
      "  7.22471216  7.42548426  7.58640829  7.93911613  8.08523514  8.27281698\n",
      "  8.50502081  8.58780099  8.97544342  9.06840145  9.32994708  9.4832187\n",
      "  9.7143636   9.9669831  10.05587739 10.24745965 10.50448738 10.64142437\n",
      " 10.97846567 11.13011018 11.30068135 11.57165861 11.65991901 11.94990211\n",
      " 12.18747631 12.4178335  12.55826718 12.82237611 12.85147113 13.04777332\n",
      " 13.42264142 13.46737614 13.81423191 13.97654878 14.1939695  14.37205959\n",
      " 14.53569893 14.66694151 14.91467005 15.22140463 15.36485266 15.59336199\n",
      " 15.69060866 15.89937533 16.23907517 16.36178348 16.54728757 16.73726968\n",
      " 17.04225118 17.24279728 17.33569323 17.56503833 17.70515795 18.02824083\n",
      " 18.23112027 18.33248662 18.62369577 18.77999396 18.89922539 19.10448361\n",
      " 19.3775723  19.56626863 19.83302568 20.05474468]\n"
     ]
    }
   ],
   "source": [
    "print(data[:,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.04826417,  0.25723241,  0.46084084,  0.64903566,  0.71677476,\n",
       "        0.96776548,  1.29983937,  1.43387289,  1.62135006,  1.76059405,\n",
       "        2.03743367,  2.14958662,  2.42060419,  2.715836  ,  2.9275557 ,\n",
       "        2.9653225 ,  3.19679942,  3.4614748 ,  3.54848877,  3.76910315,\n",
       "        3.98784208,  4.19339365,  4.4279586 ,  4.62071517,  4.79496323,\n",
       "        5.00002693,  5.23539664,  5.37992987,  5.60752551,  5.93871238,\n",
       "        6.08304306,  6.3391359 ,  6.56212174,  6.70258117,  6.84234717,\n",
       "        7.01380281,  7.22471216,  7.42548426,  7.58640829,  7.93911613,\n",
       "        8.08523514,  8.27281698,  8.50502081,  8.58780099,  8.97544342,\n",
       "        9.06840145,  9.32994708,  9.4832187 ,  9.7143636 ,  9.9669831 ,\n",
       "       10.05587739, 10.24745965, 10.50448738, 10.64142437, 10.97846567,\n",
       "       11.13011018, 11.30068135, 11.57165861, 11.65991901, 11.94990211,\n",
       "       12.18747631, 12.4178335 , 12.55826718, 12.82237611, 12.85147113,\n",
       "       13.04777332, 13.42264142, 13.46737614, 13.81423191, 13.97654878,\n",
       "       14.1939695 , 14.37205959, 14.53569893, 14.66694151, 14.91467005,\n",
       "       15.22140463, 15.36485266, 15.59336199, 15.69060866, 15.89937533,\n",
       "       16.23907517, 16.36178348, 16.54728757, 16.73726968, 17.04225118,\n",
       "       17.24279728, 17.33569323, 17.56503833, 17.70515795, 18.02824083,\n",
       "       18.23112027, 18.33248662, 18.62369577, 18.77999396, 18.89922539,\n",
       "       19.10448361, 19.3775723 , 19.56626863, 19.83302568, 20.05474468])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check that the 1st column of __`data`__ is the same as __`x1`__ with `np.array_equal`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(x1, data[:,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading in from remote data\n",
    "\n",
    "Another nice thing about `genfromtxt` is that it can read dta from a __URL__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Setting up path to remote file\n",
    "remote_file = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv'\n",
    "\n",
    "## Extracting data from file, and saving it as to variable `A`\n",
    "A = np.genfromtxt(remote_file, unpack=True, delimiter=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now `A` has the shape of 9 columns by 768 rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 768)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the shape of `A` is different than the one in the URL.\n",
    "To fix it, you can `transpose` the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  6.   , 148.   ,  72.   , ...,   0.627,  50.   ,   1.   ],\n",
       "       [  1.   ,  85.   ,  66.   , ...,   0.351,  31.   ,   0.   ],\n",
       "       [  8.   , 183.   ,  64.   , ...,   0.672,  32.   ,   1.   ],\n",
       "       ...,\n",
       "       [  5.   , 121.   ,  72.   , ...,   0.245,  30.   ,   0.   ],\n",
       "       [  1.   , 126.   ,  60.   , ...,   0.349,  47.   ,   1.   ],\n",
       "       [  1.   ,  93.   ,  70.   , ...,   0.315,  23.   ,   0.   ]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(768, 9)\n"
     ]
    }
   ],
   "source": [
    "print(A.T.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fitting a straight line\n",
    "\n",
    "Now that we've read the data, we can use to __fit__ a straight line to it.\n",
    "\n",
    "The steps to follow are:\n",
    "- Create a new function called `myline`\n",
    "- Find the best-fit parameters for the data\n",
    "- Plot the data against the fitted line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define function `myline`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myline(x, m, b):\n",
    "    \"\"\"\n",
    "    Functional form of a straight line\n",
    "    \n",
    "    Parameters\n",
    "    -----------\n",
    "    x : `float`, `int`, `np.ndarray`, list\n",
    "        Variable that tells you how far along\n",
    "    \n",
    "    m : `float`, `int`\n",
    "        Slope or gradient\n",
    "    \n",
    "    b : `float`, `int`\n",
    "        Y-intercept\n",
    "    \n",
    "    Returns\n",
    "    ---------\n",
    "    y : `float`, `int`, `np.ndarray`, list\n",
    "        Value for how far up on the y-axis\n",
    "    \"\"\"\n",
    "    y = (m * x) + b\n",
    "    \n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding best-fit parameters\n",
    "\n",
    "We can now fit a line to the data, and find the parameters (`m`, and `b`)\n",
    "that best describe our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Import `curve_fit` function from scipy\n",
    "from scipy.optimize import curve_fit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.12950289 3.72975489]\n"
     ]
    }
   ],
   "source": [
    "## Calculating best-fit parameters\n",
    "bestfit, covar_matrix = curve_fit(myline, x1, y1, p0 = [1.0, 1.0])\n",
    "\n",
    "print(bestfit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best-fit parameters: m = 3.129502893478391 and b = 3.7297548918690517\n"
     ]
    }
   ],
   "source": [
    "print(\"Best-fit parameters: m = {0} and b = {1}\".format(*bestfit))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example:\n",
    "- `myline`: Is the function used to fit the data\n",
    "- `x1`, `y1`: x- and y-values\n",
    "- `p0`: Initial guesses for the two parameters. This variable is _optional_.\n",
    "\n",
    "You can read more about `curve_fit` by typing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function curve_fit in module scipy.optimize.minpack:\n",
      "\n",
      "curve_fit(f, xdata, ydata, p0=None, sigma=None, absolute_sigma=False, check_finite=True, bounds=(-inf, inf), method=None, jac=None, **kwargs)\n",
      "    Use non-linear least squares to fit a function, f, to data.\n",
      "    \n",
      "    Assumes ``ydata = f(xdata, *params) + eps``\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    f : callable\n",
      "        The model function, f(x, ...).  It must take the independent\n",
      "        variable as the first argument and the parameters to fit as\n",
      "        separate remaining arguments.\n",
      "    xdata : An M-length sequence or an (k,M)-shaped array for functions with k predictors\n",
      "        The independent variable where the data is measured.\n",
      "    ydata : M-length sequence\n",
      "        The dependent data --- nominally f(xdata, ...)\n",
      "    p0 : None, scalar, or N-length sequence, optional\n",
      "        Initial guess for the parameters.  If None, then the initial\n",
      "        values will all be 1 (if the number of parameters for the function\n",
      "        can be determined using introspection, otherwise a ValueError\n",
      "        is raised).\n",
      "    sigma : None or M-length sequence or MxM array, optional\n",
      "        Determines the uncertainty in `ydata`. If we define residuals as\n",
      "        ``r = ydata - f(xdata, *popt)``, then the interpretation of `sigma`\n",
      "        depends on its number of dimensions:\n",
      "    \n",
      "            - A 1-d `sigma` should contain values of standard deviations of\n",
      "              errors in `ydata`. In this case, the optimized function is\n",
      "              ``chisq = sum((r / sigma) ** 2)``.\n",
      "    \n",
      "            - A 2-d `sigma` should contain the covariance matrix of\n",
      "              errors in `ydata`. In this case, the optimized function is\n",
      "              ``chisq = r.T @ inv(sigma) @ r``.\n",
      "    \n",
      "              .. versionadded:: 0.19\n",
      "    \n",
      "        None (default) is equivalent of 1-d `sigma` filled with ones.\n",
      "    absolute_sigma : bool, optional\n",
      "        If True, `sigma` is used in an absolute sense and the estimated parameter\n",
      "        covariance `pcov` reflects these absolute values.\n",
      "    \n",
      "        If False, only the relative magnitudes of the `sigma` values matter.\n",
      "        The returned parameter covariance matrix `pcov` is based on scaling\n",
      "        `sigma` by a constant factor. This constant is set by demanding that the\n",
      "        reduced `chisq` for the optimal parameters `popt` when using the\n",
      "        *scaled* `sigma` equals unity. In other words, `sigma` is scaled to\n",
      "        match the sample variance of the residuals after the fit.\n",
      "        Mathematically,\n",
      "        ``pcov(absolute_sigma=False) = pcov(absolute_sigma=True) * chisq(popt)/(M-N)``\n",
      "    check_finite : bool, optional\n",
      "        If True, check that the input arrays do not contain nans of infs,\n",
      "        and raise a ValueError if they do. Setting this parameter to\n",
      "        False may silently produce nonsensical results if the input arrays\n",
      "        do contain nans. Default is True.\n",
      "    bounds : 2-tuple of array_like, optional\n",
      "        Lower and upper bounds on independent variables. Defaults to no bounds.\n",
      "        Each element of the tuple must be either an array with the length equal\n",
      "        to the number of parameters, or a scalar (in which case the bound is\n",
      "        taken to be the same for all parameters.) Use ``np.inf`` with an\n",
      "        appropriate sign to disable bounds on all or some parameters.\n",
      "    \n",
      "        .. versionadded:: 0.17\n",
      "    method : {'lm', 'trf', 'dogbox'}, optional\n",
      "        Method to use for optimization.  See `least_squares` for more details.\n",
      "        Default is 'lm' for unconstrained problems and 'trf' if `bounds` are\n",
      "        provided. The method 'lm' won't work when the number of observations\n",
      "        is less than the number of variables, use 'trf' or 'dogbox' in this\n",
      "        case.\n",
      "    \n",
      "        .. versionadded:: 0.17\n",
      "    jac : callable, string or None, optional\n",
      "        Function with signature ``jac(x, ...)`` which computes the Jacobian\n",
      "        matrix of the model function with respect to parameters as a dense\n",
      "        array_like structure. It will be scaled according to provided `sigma`.\n",
      "        If None (default), the Jacobian will be estimated numerically.\n",
      "        String keywords for 'trf' and 'dogbox' methods can be used to select\n",
      "        a finite difference scheme, see `least_squares`.\n",
      "    \n",
      "        .. versionadded:: 0.18\n",
      "    kwargs\n",
      "        Keyword arguments passed to `leastsq` for ``method='lm'`` or\n",
      "        `least_squares` otherwise.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    popt : array\n",
      "        Optimal values for the parameters so that the sum of the squared\n",
      "        residuals of ``f(xdata, *popt) - ydata`` is minimized\n",
      "    pcov : 2d array\n",
      "        The estimated covariance of popt. The diagonals provide the variance\n",
      "        of the parameter estimate. To compute one standard deviation errors\n",
      "        on the parameters use ``perr = np.sqrt(np.diag(pcov))``.\n",
      "    \n",
      "        How the `sigma` parameter affects the estimated covariance\n",
      "        depends on `absolute_sigma` argument, as described above.\n",
      "    \n",
      "        If the Jacobian matrix at the solution doesn't have a full rank, then\n",
      "        'lm' method returns a matrix filled with ``np.inf``, on the other hand\n",
      "        'trf'  and 'dogbox' methods use Moore-Penrose pseudoinverse to compute\n",
      "        the covariance matrix.\n",
      "    \n",
      "    Raises\n",
      "    ------\n",
      "    ValueError\n",
      "        if either `ydata` or `xdata` contain NaNs, or if incompatible options\n",
      "        are used.\n",
      "    \n",
      "    RuntimeError\n",
      "        if the least-squares minimization fails.\n",
      "    \n",
      "    OptimizeWarning\n",
      "        if covariance of the parameters can not be estimated.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    least_squares : Minimize the sum of squares of nonlinear functions.\n",
      "    scipy.stats.linregress : Calculate a linear least squares regression for\n",
      "                             two sets of measurements.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    With ``method='lm'``, the algorithm uses the Levenberg-Marquardt algorithm\n",
      "    through `leastsq`. Note that this algorithm can only deal with\n",
      "    unconstrained problems.\n",
      "    \n",
      "    Box constraints can be handled by methods 'trf' and 'dogbox'. Refer to\n",
      "    the docstring of `least_squares` for more information.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> import numpy as np\n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> from scipy.optimize import curve_fit\n",
      "    \n",
      "    >>> def func(x, a, b, c):\n",
      "    ...     return a * np.exp(-b * x) + c\n",
      "    \n",
      "    Define the data to be fit with some noise:\n",
      "    \n",
      "    >>> xdata = np.linspace(0, 4, 50)\n",
      "    >>> y = func(xdata, 2.5, 1.3, 0.5)\n",
      "    >>> np.random.seed(1729)\n",
      "    >>> y_noise = 0.2 * np.random.normal(size=xdata.size)\n",
      "    >>> ydata = y + y_noise\n",
      "    >>> plt.plot(xdata, ydata, 'b-', label='data')\n",
      "    \n",
      "    Fit for the parameters a, b, c of the function `func`:\n",
      "    \n",
      "    >>> popt, pcov = curve_fit(func, xdata, ydata)\n",
      "    >>> popt\n",
      "    array([ 2.55423706,  1.35190947,  0.47450618])\n",
      "    >>> plt.plot(xdata, func(xdata, *popt), 'r-',\n",
      "    ...          label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))\n",
      "    \n",
      "    Constrain the optimization to the region of ``0 <= a <= 3``,\n",
      "    ``0 <= b <= 1`` and ``0 <= c <= 0.5``:\n",
      "    \n",
      "    >>> popt, pcov = curve_fit(func, xdata, ydata, bounds=(0, [3., 1., 0.5]))\n",
      "    >>> popt\n",
      "    array([ 2.43708906,  1.        ,  0.35015434])\n",
      "    >>> plt.plot(xdata, func(xdata, *popt), 'g--',\n",
      "    ...          label='fit: a=%5.3f, b=%5.3f, c=%5.3f' % tuple(popt))\n",
      "    \n",
      "    >>> plt.xlabel('x')\n",
      "    >>> plt.ylabel('y')\n",
      "    >>> plt.legend()\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(curve_fit)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now overplot the best-fit line to the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x151e747128>"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initializing figure (optional)\n",
    "fig = plt.figure(figsize=(10,10), facecolor='white')\n",
    "ax  = fig.add_subplot(111, facecolor='white')\n",
    "\n",
    "# Plotting values\n",
    "plt.plot(x1, myline(x1, *bestfit), 'r--', linewidth=2, label='Best fit')\n",
    "plt.plot(x1, y1, 'bo', label='Data')\n",
    "\n",
    "# Setting up limits\n",
    "plt.xlim((-1, 21)) # Limit the x-range of our plot\n",
    "\n",
    "# Axis labels\n",
    "plt.xlabel('This is the x-label', fontsize=20)\n",
    "plt.ylabel('This is the y-label', fontsize=20)\n",
    "\n",
    "# Maybe add a title\n",
    "plt.title('You can also add a title with color',\n",
    "          fontsize=20,\n",
    "          color='blue')\n",
    "\n",
    "# And finally, a legend:\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final script looks like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load ../scripts/fitting_line.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More complicated plots - Histogram\n",
    "\n",
    "Now let's plot a distribution of values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Importing modules\n",
    "import numpy as np\n",
    "import scipy\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need to define the mean and standard deviation of a normal distribution, and create an array of __random__ values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 77.35324464 113.82141577 100.03311945 ... 111.53419448 135.45606453\n",
      "  93.43486279]\n"
     ]
    }
   ],
   "source": [
    "# Mean and standard deviation\n",
    "mu, sigma = 100, 15\n",
    "\n",
    "# Array of random values\n",
    "x = mu + (sigma * np.random.randn(10000))\n",
    "\n",
    "# Printing out values of `x`\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also define a function for the PDF of the distribution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function for the PDF of distribution\n",
    "def normpdf(x, mu, sigma):\n",
    "    \"\"\"\n",
    "    PDF of a distribution with a mean and standard deviation\n",
    "    \n",
    "    Parameters\n",
    "    -----------\n",
    "    x : `np.ndarray`, list\n",
    "        List/Array of values of the distribution\n",
    "    \n",
    "    mu : `float`, `int`\n",
    "        Mean of the distribution\n",
    "    \n",
    "    sigma : `float`, `int`\n",
    "        Standard deviation of the distribution\n",
    "    \n",
    "    Returns\n",
    "    --------\n",
    "    y : `np.ndarray` or list\n",
    "        List/array of the normalized PDF values\n",
    "    \"\"\"\n",
    "    u = (x-mu)/np.abs(sigma)\n",
    "    y = (1/(np.sqrt(2*np.pi)*np.abs(sigma)))*np.exp(-u*u/2)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we construct a histogram with `plt.hist`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x15202ffdd8>"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Initialize figure\n",
    "fig = plt.figure(figsize=(8,8))\n",
    "ax = fig.add_subplot(111, facecolor='white')\n",
    "\n",
    "# Creating histogram\n",
    "n, bins, patches = plt.hist(x,\n",
    "                            bins=50,\n",
    "                            density=True,\n",
    "                            histtype='stepfilled',\n",
    "                           facecolor='green',\n",
    "                           alpha=0.75,\n",
    "                           label='Normal distr.')\n",
    "\n",
    "# Normalized PDF\n",
    "y_pdf = normpdf(x, mu, sigma)\n",
    "plt.plot(x, y_pdf, 'ro', linestyle='', label='PDF')\n",
    "\n",
    "# Adding labels and title\n",
    "plt.title(r'Histogram of IQ: $\\mu = %s, \\sigma = %s$' %(mu, sigma),\n",
    "         fontsize=20)\n",
    "\n",
    "# Setting up axis\n",
    "plt.axis([40, 160, 0, 0.03])\n",
    "\n",
    "# Adding a grid\n",
    "plt.grid(True)\n",
    "\n",
    "# Adding legend\n",
    "plt.legend(loc='best', prop={'size': 15})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The final script for this looks like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load ../scripts/histogram_pdf.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Planck Spectrum\n",
    "\n",
    "The next step is to write a script that generates the Planck spectrum (wavelength and intensity at that wavelength for many wavelenghts)\n",
    "\n",
    "> Create an equation in Python syntax such that for temperature T=300 K, and wavelenth ($\\lambda = 1cm$) it finds the intensity of a Planck Spectrum\n",
    "\n",
    "Planck Spectrum:\n",
    "\n",
    "$$\n",
    "I = \\frac{2hc^2}{\\lambda^5}\\frac{1}{e^{hc/(\\lambda\\ k T)} - 1}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write your answer here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method 1\n",
    "\n",
    "This method uses does the following:\n",
    "\n",
    "- Constructs a dictionary with known values for the constants, i.e. $h, c, k$\n",
    "- Creates a function to calculate the Planck spectrum, $I$\n",
    "- Plots the Planck spectrum at every wavelength for a given Temperature $T$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "## First import your modules\n",
    "\n",
    "import os\n",
    "import sys\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creating a dictionary with constants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Dictionary of constants\n",
    "def const_dict_func():\n",
    "    \"\"\"\n",
    "    Dictionary of constants\n",
    "\n",
    "    Returns\n",
    "    ---------\n",
    "    const_dict : `dict`\n",
    "        Dictionary of constants\n",
    "    \"\"\"\n",
    "    const_dict = {}\n",
    "    const_dict['c'] = 3.0e8    # Speed of light\n",
    "    const_dict['h'] = 6.62e-34 # Planck's constant\n",
    "    const_dict['k'] = 1.38e-23 # Boltzmann's constant\n",
    "\n",
    "    return const_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will let you call the dictionary and get the _values_ for each of the constants.\n",
    "\n",
    "Keep in mind that the we had to know the __units__ beforehand. There are other ways to do this, but\n",
    "we'll discuss them at the end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function for calculating the Power spectrum for a given wavelength $\\lambda$ and at fixed Temperature $T$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "def planck_spectrum(T, wavelen):\n",
    "    \"\"\"\n",
    "    Computes the Planck spectrum for a given Temperature and wavelength\n",
    "\n",
    "    Parameters\n",
    "    -----------\n",
    "    T : `float`, `int`\n",
    "        Temperature used. In units of `Kelvin`\n",
    "\n",
    "    wavelen : `float`, `int`\n",
    "        Wavelengths to evaluate\n",
    "\n",
    "    Returns\n",
    "    -----------\n",
    "    I : `np.ndarray`, `float`, `int`\n",
    "        Intensity of the Power spectrum at given temperature and wavelength\n",
    "    \"\"\"\n",
    "    ## Constants\n",
    "    # Calling function `const_dict_func` and saving output as a dictionary\n",
    "    const_dict = const_dict_func()\n",
    "    # Saving values of constants as new variables\n",
    "    c = const_dict['c']\n",
    "    h = const_dict['h']\n",
    "    k = const_dict['k']\n",
    "    ## Computing the Planck spectrum or 'radiance'\n",
    "    # Radiance\n",
    "    I = (2 * h * c ** 5) / (wavelen**5)\n",
    "    I *= 1./(-1. + np.exp((h * c)/(wavelen * k * T)))\n",
    "\n",
    "    return I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Function for _plotting_ the data\n",
    "\n",
    "This function will plot the spectrum for the Planck spectrum as function of wavelength $\\alpha$ at fixed Temperature $T$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Plotting data\n",
    "def plot_planck(data, T):\n",
    "    \"\"\"\n",
    "    Plots the Planck spectrum\n",
    "\n",
    "    Parameters\n",
    "    ------------\n",
    "    data : `np.ndarray`\n",
    "        Data containing wavelength and planck spectrum information.\n",
    "        Shape is (N, 2)\n",
    "    \n",
    "    T : `float`, `int`\n",
    "        Temperature, at which the Planck spectrum is analyzed.\n",
    "    \"\"\"\n",
    "    # Clearing previous figures\n",
    "    plt.clf()\n",
    "    plt.close()\n",
    "    # Initializing figure\n",
    "    fig = plt.figure(figsize=(8,8))\n",
    "    ax  = fig.add_subplot(111, facecolor='white')\n",
    "    # Plotting spectrum\n",
    "    plt.plot(data[:, 0], data[:, 1], marker='o', color='b', linestyle='--',\n",
    "                label='T={0} K'.format(T))\n",
    "    #\n",
    "    # Axis labels\n",
    "    ax.set_xlabel(r'$\\lambda$ [m]', fontsize=20)\n",
    "    ax.set_ylabel('Intensity', fontsize=20)\n",
    "    # Legend\n",
    "    ax.legend(loc='best', prop={'size':20})\n",
    "    #\n",
    "    # Showing figure\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Writing the _main_ function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    \"\"\"\n",
    "    Main function\n",
    "    \"\"\"\n",
    "    #\n",
    "    # Temperature as an input parameter\n",
    "    T = 300 ## In units Kelvin\n",
    "    #\n",
    "    # Wavelenght\n",
    "    wavelen_min = 1.e-7 # Minimum wavelength in meters\n",
    "    waveln_max  = 6.e-5 #Maximum wavelength in meters\n",
    "    samples     = 100 # Number of steps to output\n",
    "    #\n",
    "    ### List of wavelengths - Computing the wavelengths \n",
    "    # Creating array of number of samples\n",
    "    wavelen = np.arange(samples)\n",
    "    # Populating the array of wavelengths\n",
    "    wavelen = wavelen_min + (waveln_max - wavelen_min) * wavelen / float(samples)\n",
    "    #\n",
    "    # Computing the radiance\n",
    "    radiance = planck_spectrum(T, wavelen)\n",
    "    #\n",
    "    # Stacking the data\n",
    "    data = np.column_stack((wavelen, radiance))\n",
    "    # Sorting data from smallest to largest wavelength\n",
    "    data_sort_idx = np.argsort(data[:,0])\n",
    "    data_sort     = data[data_sort_idx]\n",
    "    #\n",
    "    ## Saving data to file\n",
    "    # Definiing output path and checking if it exists\n",
    "    output_path = '../datafiles'\n",
    "    if not (os.path.exists(output_path)):\n",
    "        os.makedirs(output_path)\n",
    "    # Saving data to file\n",
    "    np.savetxt('{0}/spectrum.dat'.format(output_path), data)\n",
    "    #\n",
    "    # Plotting data\n",
    "    plot_planck(data, T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Calling main function\n",
    "main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Script\n",
    "\n",
    "With all of this defined, you can put it in a single script.\n",
    "\n",
    "This code is found under `../scripts/planck_spectrum.py`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load ../scripts/planck_spectrum.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method 2 - Plotting multiple Planck spectrums\n",
    "\n",
    "Now we can try to the Planck spectrum for multiple temperatures $T$.\n",
    "\n",
    "We will have to modify the some of the functions to include $T$ as part of an argument.\n",
    "We'll modify both the `main` and `plot_planck` functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modifying the _plotting_ function\n",
    "\n",
    "We'll modify this function to:\n",
    "\n",
    "- include $T$ as an input parameter,\n",
    "- Loop over the different temperature values in `T_arr`\n",
    "- Choose the color from a colormap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Importing new modules\n",
    "from matplotlib.pyplot import cm\n",
    "\n",
    "## Plotting data\n",
    "def plot_planck_2(data, T_arr):\n",
    "    \"\"\"\n",
    "    Plots the Planck spectrum\n",
    "\n",
    "    Parameters\n",
    "    ------------\n",
    "    data : `np.ndarray`\n",
    "        Data containing wavelength and planck spectrum information.\n",
    "        Shape is ((N, 2), M)\n",
    "    \n",
    "    T_arr : `np.ndarray`\n",
    "        Array of the different temperatures.\n",
    "        Shape, (M, ), i.e. it has `M` number of elements.\n",
    "    \"\"\"\n",
    "    # Defining the colormap\n",
    "    color_arr=cm.rainbow(np.linspace(0, 1, len(T_arr)))\n",
    "    # Clearing previous figures\n",
    "    plt.clf()\n",
    "    plt.close()\n",
    "    # Initializing figure\n",
    "    fig = plt.figure(figsize=(10,10))\n",
    "    ax  = fig.add_subplot(111, facecolor='white')\n",
    "    # Plotting spectrum\n",
    "    for kk, T_kk in enumerate(T_arr):\n",
    "        plt.plot(data[kk][:, 0],\n",
    "                 data[kk][:, 1],\n",
    "                 marker='o',\n",
    "                 color=color_arr[kk],\n",
    "                 linestyle='--',\n",
    "                 label='{0} K'.format(T_kk))\n",
    "    #\n",
    "    # Axis labels\n",
    "    ax.set_xlabel(r'$\\lambda$ [m]', fontsize=20)\n",
    "    ax.set_ylabel('Intensity', fontsize=20)\n",
    "    #\n",
    "    # Legend\n",
    "    ax.legend(loc='best', prop={'size':14})\n",
    "    #\n",
    "    # Showing figure\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Modifying the main function to include $T$ as an input parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main_2():\n",
    "    \"\"\"\n",
    "    Main function\n",
    "    \"\"\"\n",
    "    #\n",
    "    # Temperature as an input parameter\n",
    "    T_arr = np.arange(300, 1000, 100) ## In units Kelvin\n",
    "    #\n",
    "    # Wavelenght\n",
    "    wavelen_min = 1.e-7 # Minimum wavelength in meters\n",
    "    waveln_max  = 6.e-5 #Maximum wavelength in meters\n",
    "    samples     = 100 # Number of steps to output\n",
    "    #\n",
    "    ### List of wavelengths - Computing the wavelengths \n",
    "    # Creating array of number of samples\n",
    "    wavelen = np.arange(samples)\n",
    "    # Populating the array of wavelengths\n",
    "    wavelen = wavelen_min + (waveln_max - wavelen_min) * wavelen / float(samples)\n",
    "    #\n",
    "    ## Computing the radiance\n",
    "    # Defining array for `data`\n",
    "    data = [[] for x in range(len(T_arr))]\n",
    "    for kk in range(len(T_arr)):\n",
    "        radiance_kk = planck_spectrum(T_arr[kk], wavelen)\n",
    "        # Stacking the data\n",
    "        data_kk = np.column_stack((wavelen, radiance_kk))\n",
    "        # Sorting data from smallest to largest wavelength\n",
    "        data_kk_sort_idx = np.argsort(data_kk[:,0])\n",
    "        data_kk_sort     = data_kk[data_kk_sort_idx]\n",
    "        # Saving to array\n",
    "        data[kk] = data_kk_sort\n",
    "    #\n",
    "    # Plotting data\n",
    "    plot_planck_2(data, T_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "main_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you see how the Planck spectrum changes as a function of wavelength $\\lambda$!\n"
   ]
  }
 ],
 "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.6.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}