Class Scheduling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CS/ECE/ISyE 524 &mdash; Introduction to Optimization &mdash; Spring 2017 ###\n",
    "\n",
    "# Optimizing Class Scheduling #\n",
    "\n",
    "#### Marcus Millin (marcus.millin@wisc.edu) and Ahad Zaman ( ahad.zaman@wisc.edu)\n",
    "\n",
    "*****\n",
    "\n",
    "### Table of Contents\n",
    "\n",
    "1. [Introduction](#1.-Introduction)\n",
    "1. [Mathematical Model](#2.-Mathematical-model)\n",
    "1. [Solution](#3.-Solution)\n",
    "1. [Results and Discussion](#4.-Results-and-discussion)\n",
    "  1. [Optional Subsection](#4.A.-Feel-free-to-add-subsections)\n",
    "1. [Conclusion](#5.-Conclusion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 1. Introduction ##\n",
    "\n",
    "<!-- The first few sentences should give a quick overview of the entire project. Then, elaborate with a description of the problem that will be solved, a brief history (with [citations](https://en.wikipedia.org/wiki/Citation)) of how the problem came about, why it's important/interesting, and any other interesting facts you'd like to talk about. You should address and explain where the problem data is coming from (research? the internet? synthetically generated?) Also give an outline of the rest of the report.\n",
    "\n",
    "This section should be 300-600 words long, and **should be accessible to a general audience** (don't assume your reader has taken the class!). Feel free to include images if you think it'll be helpful:\n",
    "\n",
    "![fixit flowchart][flow]\n",
    "\n",
    "For more help on using Markdown, see [this reference](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).\n",
    "\n",
    "[flow]: https://s-media-cache-ak0.pinimg.com/736x/f5/75/c5/f575c53b93724808c6f0211890a54900.jpg -->\n",
    "\n",
    "When scheduling classes for a semester at UW-Madison, a lot of options are presented; even after having selected which courses you would like to take, you still need to find a combination of discussion sections, lectures, and labs which both is possible to do, and works well for your extra cirricular schedule. The first part of this problem is solved by the UW-Madison Schedule Planner, which will take your selected courses and generate a list of schedules which have all of the courses you selected without any overlap (if possible). However, due to the wide variety of times for discussion sections and lectures for a course, and only needing to take one of them a large number of potential schedules may be available. This can result in hundreds of possible schedules with no way to easily sort through them or determine which is the best for you.\n",
    "\n",
    "While \"which is best\" varies from person to person, there are a few things that are often targeted by students when looking for a schedule. One of the things that makes one schedule better than another is the starting time of the first class and the ending time of the last class. Some people like to group their classes all in the morning to get them out of the way, and have their afternoons as free as possible, while others like to sleep in and would rather their day start later and might care less about when their final class gets done (within reason!).\n",
    "\n",
    "With our model, we attempt to optimize class selection, keeping these in mind to find the \"best\" possible schedule for a selection of courses. We will be using data from the UW-Madison course guide for the Fall 2017 semester. In order to generate a large number of possible schedules, we have selected five classes with lots of options for discussion sections and lectures, representing a possible freshmen-level courseload. The classes are Comp Sci 240, Math 320, Philosophy 101, and Philosophy 210. Using the UW-Madison scheduling tool, this gives a total of over 1000 viable schedules assuming every class had seats available."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 2. Mathematical model ##\n",
    "\n",
    "<!-- A discussion of the modeling assumptions made in the problem (e.g. is it from physics? economics? something else?). Explain the decision variables, the constraints, and the objective function. Finally, show the optimization problem written in standard form. Discuss the model type (LP, QP, MIP, etc.). Equations should be formatted in $\\LaTeX$ within the IJulia notebook. For this section you may **assume the reader is familiar with the material covered in class**. -->\n",
    "\n",
    "First, in order to get a better grasp of the problem, we have listed the constraints and goals of this problem in plain english.\n",
    "#### Constraints\n",
    "* If a discussion is taken, its corresponding lecture must be taken.\n",
    "* Take exactly one discussion for each course.\n",
    "    * Implicit: Take all courses\n",
    "* Classes taken must not overlap.\n",
    "\n",
    "####  Goals\n",
    "* Finish days as early as possible to give free time in the afternoon\n",
    "* Limit the number of \n",
    "\n",
    "### Model\n",
    "Our model is a Mixed Integer Program with \n",
    "\n",
    "#### Variables\n",
    "$\\forall classes \\in course$\n",
    "\n",
    "#### Constraints\n",
    "$\\forall $\n",
    "\n",
    "#### Goals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 3. Solution ##\n",
    "\n",
    "Here, you should code up your model in Julia + JuMP and solve it. Your code should be clean, easy to read, well annotated and commented, and it should compile! You are not allowed to use other programming languages or DCP packages such as `convex.jl`. **I will be running your code**. I suggest having multiple code blocks separated by text blocks that explain the various parts of your solution. You may also solve several versions of your problem with different models/assumptions.\n",
    "\n",
    "It's fine to call external packages such as `Gurobi`, but try to minimize the use of exotic libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cs240raw = readcsv(\"CS240.csv\");\n",
    "math320raw = readcsv(\"MATH320.csv\");\n",
    "phil101raw = readcsv(\"PHILOS101.csv\");\n",
    "phil210raw = readcsv(\"PHILOS210.csv\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c240t = map(x -> (x == \"\") ? DateTime(0) : DateTime(x, \"HH:MM\"), cs240raw[:, 8:end]);\n",
    "m320t = map(x -> (x == \"\") ? DateTime(0) : DateTime(x, \"HH:MM\"), math320raw[:, 8:end]);\n",
    "p101t = map(x -> (x == \"\") ? DateTime(0) : DateTime(x, \"HH:MM\"), phil101raw[:, 8:end]);\n",
    "p210t = map(x -> (x == \"\") ? DateTime(0) : DateTime(x, \"HH:MM\"), phil210raw[:, 8:end]);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Method definition findCollisions(Any, Any) in module Main at In[36]:2 overwritten at In[40]:2.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "findCollisions (generic function with 1 method)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function findCollisions(arg1, arg2)\n",
    "    clashes = []\n",
    "    for d in 1:2:10 # Day\n",
    "        for i in 1:size(arg1, 1)\n",
    "            for j in 1:size(arg2, 1)\n",
    "                if arg1[i, d] != DateTime(0) &&\n",
    "                    arg2[j, d] != DateTime(0) &&\n",
    "                    ((arg1[i, d] - arg2[j, d + 1]).value <= 0) &&\n",
    "                    ((arg1[i, d + 1] - arg2[j, d]).value >= 0)\n",
    "                    push!(clashes, [i j])\n",
    "                end\n",
    "            end\n",
    "        end\n",
    "    end\n",
    "    vcat(clashes...)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the above and below code we are able to precompute all of the potential collisions between two courses with all of their classes. With this information, we can set up our constraints so that we only produce valid schedules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# c240 & m320\n",
    "c2m3 = findCollisions(c240t, m320t)\n",
    "# c240 & p101\n",
    "c2p1 = findCollisions(c240t, p101t)\n",
    "# c240 & p210\n",
    "c2p2 = findCollisions(c240t, p210t)\n",
    "# m320 & p101\n",
    "m3p1 = findCollisions(m320t, p101t)\n",
    "# m320 & p210\n",
    "m3p2 = findCollisions(m320t, p210t)\n",
    "# p101 & p210\n",
    "p1p2 = findCollisions(p101t, p210t);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Method definition getDiscIndex(Any, Any) in module Main at In[22]:2 overwritten at In[42]:2.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "getDiscIndex (generic function with 1 method)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function getDiscIndex(csvIndex, numDiscsPer)\n",
    "    lectureNum = 0\n",
    "    discNum = 0\n",
    "    lectureNum = find(x->(x > csvIndex), 1:(numDiscsPer + 1):(csvIndex + numDiscsPer +1))[1] - 1\n",
    "    \n",
    "    discNum = csvIndex - (lectureNum - 1)*(numDiscsPer +  1) - 1\n",
    "    [lectureNum discNum]\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Method definition getEndTimes(Any, Any, Any) in module Main at In[23]:2 overwritten at In[43]:2.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "getEndTimes (generic function with 1 method)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function getEndTimes(class, LecCsvIndex, DiscCsvIndex)\n",
    "    if DiscCsvIndex == 0\n",
    "        println(\"DiscCsvIndex was 0. Please only call this for discussions\")\n",
    "    end\n",
    "    MonEndTime\n",
    "    \n",
    "    TueEndTime\n",
    "    WedEndTime\n",
    "    ThuEndTime\n",
    "    FriEndTime\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimize a model with 174 rows, 74 columns and 468 nonzeros\n",
      "Variable types: 0 continuous, 74 integer (74 binary)\n",
      "Coefficient statistics:\n",
      "  Matrix range     [1e+00, 1e+00]\n",
      "  Objective range  [0e+00, 0e+00]\n",
      "  Bounds range     [1e+00, 1e+00]\n",
      "  RHS range        [1e+00, 2e+00]\n",
      "Found heuristic solution: objective -0\n",
      "\n",
      "Explored 0 nodes (0 simplex iterations) in 0.00 seconds\n",
      "Thread count was 1 (of 8 available processors)\n",
      "\n",
      "Solution count 1: -0 \n",
      "Pool objective bound 0\n",
      "\n",
      "Optimal solution found (tolerance 1.00e-04)\n",
      "Best objective -0.000000000000e+00, best bound -0.000000000000e+00, gap 0.0000%\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       ":Optimal"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using JuMP, Gurobi\n",
    "m = Model(solver=GurobiSolver())\n",
    "\n",
    "@variable(m, cs240[1:16], Bin)  # 2 Lectures, 7 discussions each\n",
    "@variable(m, math320[1:28], Bin) # 4 Lectuers, 6 discussions each\n",
    "@variable(m, phil101[1:20], Bin) # 4 Lectures, 4 discussions each\n",
    "@variable(m, phil210[1:10], Bin) # 2 Lectures, 4 discussions each\n",
    "\n",
    "# Must take a discussion and a lecture\n",
    "@constraint(m, sum(cs240) == 2)\n",
    "@constraint(m, sum(math320) == 2)\n",
    "@constraint(m, sum(phil101) == 2) \n",
    "@constraint(m, sum(phil210) == 2)\n",
    "\n",
    "# If you take a discussion, you must take its corresponding lecture\n",
    "A = 1:(7 + 1):(16)\n",
    "@constraint(m, sum(cs240[A])==1)\n",
    "for i in 1:size(A, 1)\n",
    "    @constraint(m, sum(cs240[(A[i] + 1):(A[i] + 7)]) <= cs240[A[i]])\n",
    "end\n",
    "A = 1:(6 + 1):(28)\n",
    "@constraint(m, sum(math320[A])==1)\n",
    "for i in 1:size(A, 1)\n",
    "    @constraint(m, sum(math320[(A[i] + 1):(A[i] + 6)]) <= math320[A[i]])\n",
    "end\n",
    "A = 1:(4 + 1):(20)\n",
    "@constraint(m, sum(phil101[A])==1)\n",
    "for i in 1:size(A, 1)\n",
    "    @constraint(m, sum(phil101[(A[i] + 1):(A[i] + 4)]) <= phil101[A[i]])\n",
    "end\n",
    "A = 1:(4 + 1):(10)\n",
    "@constraint(m, sum(phil210[A])==1)\n",
    "for i in 1:size(A, 1)\n",
    "    @constraint(m, sum(phil210[(A[i] + 1):(A[i] + 4)]) <= phil210[A[i]])\n",
    "end\n",
    "\n",
    "# Overlapping classes constraints\n",
    "# c240 & m320\n",
    "for i in 1:size(c2m3, 1)\n",
    "    c1 = c2m3[i, 1]\n",
    "    c2 = c2m3[i, 2]\n",
    "    @constraint(m, cs240[c1] + math320[c2] <= 1)\n",
    "end\n",
    "# c240 & p101\n",
    "for i in 1:size(c2p1, 1)\n",
    "    c1 = c2p1[i, 1]\n",
    "    c2 = c2p1[i, 2]\n",
    "    @constraint(m, cs240[c1] + phil101[c2] <= 1)\n",
    "end\n",
    "# c240 & p210\n",
    "for i in 1:size(c2p2, 1)\n",
    "    c1 = c2p2[i, 1]\n",
    "    c2 = c2p2[i, 2]\n",
    "    @constraint(m, cs240[c1] + phil210[c2] <= 1)\n",
    "end\n",
    "# m320 & p101\n",
    "for i in 1:size(m3p1, 1)\n",
    "    c1 = m3p1[i, 1]\n",
    "    c2 = m3p1[i, 2]\n",
    "    @constraint(m, math320[c1] + phil101[c2] <= 1)\n",
    "end\n",
    "# m320 & p210\n",
    "for i in 1:size(m3p2, 1)\n",
    "    c1 = m3p2[i, 1]\n",
    "    c2 = m3p2[i, 2]\n",
    "    @constraint(m, math320[c1] + phil210[c2] <= 1)\n",
    "end\n",
    "# p101 & p210\n",
    "for i in 1:size(p1p2, 1)\n",
    "    c1 = p1p2[i, 1]\n",
    "    c2 = p1p2[i, 2]\n",
    "    @constraint(m, phil101[c1] + phil210[c2] <= 1)\n",
    "end\n",
    "\n",
    "@objective(m, Max, 1)\n",
    "\n",
    "solve(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## getDiscIndex(8,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Take CS 240 Lecture #1 Disc #4\n",
      "Take Math 320 Lecture #4 Disc #3\n",
      "Take Philos 101 Lecture #1 Disc #1\n",
      "Take Philos 210 Lecture #2 Disc #1\n"
     ]
    }
   ],
   "source": [
    "cscsv = find(x->(x > 0), getvalue(cs240))\n",
    "mathcsv = find(x->(x > 0), getvalue(math320))\n",
    "phil1csv = find(x->(x > 0), getvalue(phil101))\n",
    "phil2csv = find(x->(x > 0), getvalue(phil210))\n",
    "cs = getDiscIndex(cscsv[2], 7)\n",
    "math = getDiscIndex(mathcsv[2], 6)\n",
    "phil1 = getDiscIndex(phil1csv[2], 4)\n",
    "phil2 = getDiscIndex(phil2csv[2], 4)\n",
    "println(\"Take CS 240 Lecture #\", cs[1], \" Disc #\", cs[2] )\n",
    "println(\"Take Math 320 Lecture #\", math[1], \" Disc #\", math[2] )\n",
    "println(\"Take Philos 101 Lecture #\", phil1[1], \" Disc #\", phil1[2] )\n",
    "println(\"Take Philos 210 Lecture #\", phil2[1], \" Disc #\", phil2[2] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BASIC SCHEDULE\n",
      "\n",
      "CS 240\n",
      "\n",
      "    Lecture Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t11:00\t00:00\t11:00\t00:00\t11:00\n",
      "\tEnd:\t11:50\t00:00\t11:50\t00:00\t11:50\n",
      "\n",
      "    Discussion Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t00:00\t00:00\t00:00\t09:55\t00:00\n",
      "\tEnd:\t00:00\t00:00\t00:00\t10:45\t00:00\n",
      "\n",
      "Math 320\n",
      "\n",
      "    Lecture Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t13:20\t00:00\t13:20\t00:00\t13:20\n",
      "\tEnd:\t14:10\t00:00\t14:10\t00:00\t14:10\n",
      "\n",
      "    Discussion Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t00:00\t09:55\t00:00\t00:00\t00:00\n",
      "\tEnd:\t00:00\t10:45\t00:00\t00:00\t00:00\n",
      "\n",
      "Philos 101\n",
      "\n",
      "    Lecture Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t09:55\t00:00\t09:55\t00:00\t09:55\n",
      "\tEnd:\t10:45\t00:00\t10:45\t00:00\t10:45\n",
      "\n",
      "    Discussion Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t00:00\t11:00\t00:00\t00:00\t00:00\n",
      "\tEnd:\t00:00\t11:50\t00:00\t00:00\t00:00\n",
      "\n",
      "Philos 210\n",
      "\n",
      "    Lecture Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t00:00\t08:00\t00:00\t08:00\t00:00\n",
      "\tEnd:\t00:00\t09:15\t00:00\t09:15\t00:00\n",
      "\n",
      "    Discussion Times:\n",
      "\n",
      "\t\tMon\tTue\tWed\tThu\tFri\n",
      "\n",
      "\tStart:\t00:00\t12:05\t00:00\t00:00\t00:00\n",
      "\tEnd:\t00:00\t12:55\t00:00\t00:00\t00:00\n"
     ]
    }
   ],
   "source": [
    "println(\"BASIC SCHEDULE\")\n",
    "println()\n",
    "println(\"CS 240\")\n",
    "println()\n",
    "println(\"    Lecture Times:\")\n",
    "c240lst = Dates.format(c240t[cscsv[1], 1:2:end], \"HH:MM\")\n",
    "c240let = Dates.format(c240t[cscsv[1], 2:2:end], \"HH:MM\")\n",
    "c240dst = Dates.format(c240t[cscsv[2], 1:2:end], \"HH:MM\")\n",
    "c240det = Dates.format(c240t[cscsv[2], 2:2:end], \"HH:MM\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\",join(c240lst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(c240let, \"\\t\"))\n",
    "println()\n",
    "println(\"    Discussion Times:\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(c240dst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(c240det, \"\\t\"))\n",
    "println()\n",
    "println(\"Math 320\")\n",
    "println()\n",
    "println(\"    Lecture Times:\")\n",
    "m320lst = Dates.format(m320t[mathcsv[1], 1:2:end], \"HH:MM\")\n",
    "m320let = Dates.format(m320t[mathcsv[1], 2:2:end], \"HH:MM\")\n",
    "m320dst = Dates.format(m320t[mathcsv[2], 1:2:end], \"HH:MM\")\n",
    "m320det = Dates.format(m320t[mathcsv[2], 2:2:end], \"HH:MM\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(m320lst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(m320let, \"\\t\"))\n",
    "println()\n",
    "println(\"    Discussion Times:\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(m320dst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(m320det, \"\\t\"))\n",
    "println()\n",
    "println(\"Philos 101\")\n",
    "println()\n",
    "println(\"    Lecture Times:\")\n",
    "p101lst = Dates.format(p101t[phil1csv[1], 1:2:end], \"HH:MM\")\n",
    "p101let = Dates.format(p101t[phil1csv[1], 2:2:end], \"HH:MM\")\n",
    "p101dst = Dates.format(p101t[phil1csv[2], 1:2:end], \"HH:MM\")\n",
    "p101det = Dates.format(p101t[phil1csv[2], 2:2:end], \"HH:MM\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(p101lst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(p101let, \"\\t\"))\n",
    "println()\n",
    "println(\"    Discussion Times:\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(p101dst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(p101det, \"\\t\"))\n",
    "println()\n",
    "println(\"Philos 210\")\n",
    "p210lst = Dates.format(p210t[phil2csv[1], 1:2:end], \"HH:MM\")\n",
    "p210let = Dates.format(p210t[phil2csv[1], 2:2:end], \"HH:MM\")\n",
    "p210dst = Dates.format(p210t[phil2csv[2], 1:2:end], \"HH:MM\")\n",
    "p210det = Dates.format(p210t[phil2csv[2], 2:2:end], \"HH:MM\")\n",
    "println()\n",
    "println(\"    Lecture Times:\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(p210lst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(p210let, \"\\t\"))\n",
    "println()\n",
    "println(\"    Discussion Times:\")\n",
    "println()\n",
    "println(\"\\t\\tMon\\tTue\\tWed\\tThu\\tFri\")\n",
    "println()\n",
    "println(\"\\tStart:\\t\", join(p210dst, \"\\t\"))\n",
    "println(\"\\tEnd:\\t\", join(p210det, \"\\t\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember to make sure your code compiles! I will be running your code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 4. Results and discussion ##\n",
    "\n",
    "Here, you display and discuss the results. Show figures, plots, images, trade-off curves, or whatever else you can think of to best illustrate your results. The discussion should explain what the results mean, and how to interpret them. You should also explain the limitations of your approach/model and how sensitive your results are to the assumptions you made.\n",
    "\n",
    "Use plots (see `PyPlot` examples from class), or you can display results in a table like this:\n",
    "\n",
    "| Tables        | Are           | Cool  |\n",
    "| ------------- |:-------------:| -----:|\n",
    "| col 3 is      | right-aligned |\\$1600 |\n",
    "| col 2 is      | centered      |  \\$12 |\n",
    "| zebra stripes | are neat      |   \\$1 |\n",
    "\n",
    "### 4.A. Feel free to add subsections\n",
    "\n",
    "#### 4.A.a. or subsubsections\n",
    "\n",
    "Our first result that we printed (BASIC SCHEDULE) was a standard optimized schedule that does the purpose of the current UW Schedule Planner. It avoids conflicts with other classes and makes sure that all classes one signs up for are in the schedule, including one lecture and one discussion. \n",
    "Below is a readable version:\n",
    "<div style=\"width:image width px; font-size:80%; text-align:center;\"><img title=\"Ion thruster\" src=\"Basic.png\" alt=\"Missing Image\" width=\"width\" height=\"height\" style=\"padding-bottom:0.5em;\" />BASIC SCHEDULE</div>\n",
    "\n",
    "After optimizing our schedule for a student who would like to finish their classes as early as possible we get the schedule below.\n",
    "\n",
    "After optimizing our schedule for a student who would like to start their classes as late as possible we get the schedule below.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 5. Conclusion ##\n",
    "\n",
    "Summarize your findings and your results, and talk about at least one possible future direction; something that might be interesting to pursue as a follow-up to your project.\n",
    "\n",
    "Our findings gave us viable schedule options for students who want to specialize their schedule for their own specific lifestyle. Whether its to sleep in and attend courses later in the day or to get all their courses out of the way as early in the day as possible, our project allows them to choose their preference. We did this by taking in data directly from the MyUW course guide, creating a schedulizer that found a schedule for a student taking our sample classes, one avoids conflicts and includes all necessary times for that class, and finally adding functions that use the classes start and end times in order to find a best fit for that student based on his or her preferences. \n",
    "\n",
    "One possible future direction would be to add a feature that would detect the location of where a certain class is and factor that in to the time between classes. The reason that is sometimes a problem is because the current UW Schedule Planner can give you a class that start 5 minutes after a previous class ends, without factoring in the 15 minute walk between buildings, and thus students end up being late to their second class or leaving early from their first class. Future work would include an optimizer taking into account the location for each class, calculating the distance between two consecutive classes, and constraining this distance to be walkable at an average human walking speed (about 3.1 miles per hour according to TranSafety, Inc) within the alotted time for those classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 0.5.0",
   "language": "julia",
   "name": "julia-0.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}