Introduction_Slides.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The JuMP ecosystem for mathematical optimization\n",
    "\n",
    "## JuliaCon 2018\n",
    "\n",
    "## Juan Pablo Vielma\n",
    "## MIT Sloan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Minimum # of Passports to Visit all Countries?\n",
    "[![Passport Index](img/passportindex.jpg \"Passport Index\")](https://www.passportindex.org)\n",
    "\n",
    "199 passports = $10^{33}$ times the age of the universe to enumerate at $10^{17}$ flops!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Download data from https://github.com/ilyankou/passport-index-dataset\n",
    "#;git clone https://github.com/ilyankou/passport-index-dataset.git\n",
    "data = readdlm(joinpath(\"passport-index-dataset\",\"passport-index-country-names.csv\"),',')\n",
    "cntr = data[2:end,1]\n",
    "vf = (x ->  x == -1 || x == 3 ? 1 :0).(data[2:end,2:end]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## (Constrained) Mathematical Optimization and JuMP\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "\\min_{x,y} &&\\quad \\sum_{\\operatorname{cntr} \\;\\in\\; \\operatorname{World}} \\operatorname{pass}_{\\,\\operatorname{cntr}} \\\\\n",
    "\\text{s.t.}&&\\quad  \\operatorname{vf}(\\operatorname{cntr},\\operatorname{dst}) \\cdot \\operatorname{pass}_{\\,\\operatorname{cntr}} &\\geq 1\\quad  &\\quad& \\forall \\; \\operatorname{dst} \\;\\in \\; \\operatorname{World}\\\\\n",
    " &&\\operatorname{pass}_{\\,\\operatorname{cntr}}  &\\in \\{0,1\\}&\\quad& \\forall \\; \\operatorname{cntr}\\in \\; \\operatorname{World}.\n",
    "\\end{align*}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "using JuMP, GLPK\n",
    "model = Model(with_optimizer(GLPK.GLPKOptimizerMIP))\n",
    "@variable(model, pass[1:length(cntr)], Bin)\n",
    "@constraint(model, [j=1:length(cntr)], sum( vf[i,j]*pass[i] for i in 1:length(cntr)) >= 1)\n",
    "@objective(model, Min, sum(pass))\n",
    "JuMP.optimize(model)\n",
    "print(JuMP.objectivevalue(model),\" passports: \",join(cntr[find(JuMP.resultvalue.(pass))],\", \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## JuMP: Started by Students Leading a Vibrant Community\n",
    "\n",
    "\n",
    "\n",
    " ![JuMP Community](img/jumpcommunity.png \"JuMP Community\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# You Can Learn Optimization Using JuMP\n",
    "\n",
    "![Nestor](img/nestor.png \"Nestor\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### You Can Develop New Methods Using Julia / JuMP\n",
    "\n",
    "* Mixed-Integer Nonlinear Solvers from MIT and LANL:\n",
    "    - Pajarito.jl, Juniper.jl, POD.jl and Katana.jl\n",
    "* Porting experimental Interior Point Method from Matlab in ~ week:\n",
    "    - 45x speed with linear algebra options\n",
    "    - Already good out-of-the-box performance:\n",
    "\n",
    "    \n",
    "| Instance        | Matlab           | Julia   | Instance        | Matlab           | Julia  | Instance        | Matlab           | Julia   | Instance        | Matlab           | Julia  |\n",
    "| ----------------|-----------------:|--------:|----------------:|-----------------:|-------:|----------------|-----------------:|--------:|----------------:|-----------------:|-------:|\n",
    "| dense lp        | 5.8              | 4.1     | lotka-volt      |0.47              |0.38 | butcher         | 0.63             |    0.41 | reac-diff       | 0.32             |    0.23 |\n",
    "| envelope        | 0.085            |   0.043 | motzkin         | 0.35             |    0.24 | caprasse        | 1.38             |    1.87 | robinson        | 0.34             |    0.23 |\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# JuMP is Composable and Uses the Julia Ecosystem\n",
    "\n",
    "[Drone Control Demo](https://github.com/juan-pablo-vielma/Dagstuhl-Seminar-18081/blob/master/Polynomial.ipynb) prepared in ~1 week:\n",
    "\n",
    "\n",
    "![drone](img/drone.png \"drone\")\n",
    "\n",
    "Running on Julia 0.6 / JuMP 0.18 (0.7/0.19 soon).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# JuMP is Evolving\n",
    "\n",
    "* JuMP 0.19: Towards JuMP 1.0\n",
    "    * MathOptInterface.jl replaces MathProgBase.jl\n",
    "* Pros: More \"precise\" control\n",
    "    * Extensible constraint types \n",
    "    * Flexible \"Model\" attributes (e.g. warm-starts)\n",
    "    * Clear status codes (cf. CPXMIP_OPTIMAL_INFEAS)\n",
    "    * Efficient problem modifications\n",
    "    * ...\n",
    "* \"Cons\": \n",
    "    * Syntax changes (\"no\" changes from 0.19 to 1.0)\n",
    "    * Some \"features\" dissapear \"temporarily\" (e.g. solver-independent callbacks, `norm(x)`)\n",
    "        * Correct versions will come back or may be available through extensions\n",
    "* Status:\n",
    "    * [0.19 master is passing on Julia 0.7](https://github.com/JuliaOpt/JuMP.jl/pull/1399)\n",
    "    - JuMP 0.18 in Julia 0.6 should be ok for the 2018-2019 academic year\n",
    "    - **MY** (very conservative) deadline for 1.0-like stability/documentation/etc. = March, 2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "\n",
    "![NumFocus](img/NumFocus.png \"NumFocus\")\n",
    "Pending \"branding\" transition:\n",
    "![juliaopttojump](img/juliaopttojump.png \"juliaopttojump\") \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Overview\n",
    "\n",
    "1. Introduction to JuMP, noting syntax changes for 0.19\n",
    "2. Introduction to MOI and associated concepts\n",
    "3. Some discussion on efficiency and type stability (if time permits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# More Information\n",
    "\n",
    "* [Julia Opt site](http://www.juliaopt.org) (name change soon)\n",
    "* [The Second Annual JuMP-dev Workshop Page](http://www.juliaopt.org/meetings/bordeaux2018/)\n",
    "    * Slides and Videos of talks/tutorials\n",
    "* [JuMP](https://github.com/JuliaOpt/JuMP.jl) and [MOI](https://github.com/JuliaOpt/MathOptInterface.jl) in github. \n",
    "* [JuMP-Dev channel in gitter](https://gitter.im/JuliaOpt/JuMP-dev)\n",
    "\n",
    "    \n",
    "**NOTE:** Almost everthing I know about JuMP \"internals\" I learned preparing this workshop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A step by step example\n",
    "Let's see how we translate a simple, 2 variable LP to JuMP code.\n",
    "\n",
    "$$\n",
    "\\begin{align*}\n",
    "&\\max_{x,y}& \\quad x + 2y \\\\\n",
    "&\\text{s.t.}&\\quad x + y &\\leq 1 \\\\\n",
    "&&0\\leq x, y &\\leq 1\n",
    "\\end{align*}\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Load JuMP, MathOptInterface (MOI), and GLPK (GNU LP/MIP solver):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "using JuMP  \n",
    "using MathOptInterface # Replaces MathProgBase\n",
    "# shortcuts\n",
    "const MOI = MathOptInterface\n",
    "const MOIU = MathOptInterface.Utilities\n",
    "\n",
    "using GLPK # Loading the GLPK module for using its solver"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Construct a model object (a container for variables, constraints, solver options, etc.):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP, msg_lev = 4));  \n",
    "# Old syntax: model = Model(solver=GLPKSolverLP(msg_lev = 4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Define variables $0\\leq x, y \\leq 1$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@variable(model, 0 <= x <= 1)\n",
    "@variable(model, 0 <= y <= 1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Add constraint $x + y \\leq 1$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@constraint(model, x + y <= 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Add objective $\\max x + 2y$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@objective(model, Max, x + 2y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To solve the optimization problem, call the `optimize` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "JuMP.optimize(model) # Old syntax: status = JuMP.solve(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can then check the status of the optimization call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@show JuMP.hasresultvalues(model)\n",
    "@show JuMP.terminationstatus(model) == MOI.Success\n",
    "@show JuMP.primalstatus(model) == MOI.FeasiblePoint\n",
    "@show JuMP.dualstatus(model) == MOI.FeasiblePoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# New Solver Status\n",
    "\n",
    "Much more details than old `:Optimal, :Unbounded, :Infeasible, :UserLimit, :Error, :NotSolved`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```julia \n",
    "@show JuMP.terminationstatus(model) == MOI.Success\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "display(typeof(MOI.Success))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "```julia\n",
    "@show JuMP.primalstatus(model) == MOI.FeasiblePoint\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "display(typeof(MOI.FeasiblePoint))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "We can also inspect the solution values and optimal cost:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@show JuMP.resultvalue(x)              # Old syntax: getvalue(x)\n",
    "@show JuMP.resultvalue(y)              # Old syntax: getvalue(y)\n",
    "@show JuMP.objectivevalue(model)       # Old syntax: getobjectivevalue(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "I can also \"name\" constraints for later reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP, msg_lev = 0))\n",
    "@variable(model, 0 <= x <= 1)\n",
    "@variable(model, 0 <= y <= 1)\n",
    "@constraint(model, inequality, x + y <= 1)     # <=============== constraint can be referenced later as \"inequality\"\n",
    "@objective(model, Max, x + 2y)\n",
    "JuMP.optimize(model)\n",
    "@show JuMP.terminationstatus(model) == MOI.Success"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "constraint references  can by used to delete them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "JuMP.delete!(model, inequality)\n",
    "JuMP.optimize(model)\n",
    "@show JuMP.terminationstatus(model) == MOI.Success\n",
    "@show JuMP.objectivevalue(model)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constraint references can be used to modify problem (see [MOI](MOI.ipynb#Model-modifications)) and to get duals (see [Topics notebook](Topics.ipynb#Duality))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Collections of variables/constraints and summation in JuMP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can also create collections of variables like $x_i \\geq 0 \\quad \\forall \\; i\\in\\{1,\\ldots,10\\}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model()\n",
    "@variable(model, x[1:10] >= 0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Also multidimensional indexing, separated by commas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@variable(model, y[1:10,[\"red\",\"blue\"]] <= 1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "and more complicated expressions like $\\quad\n",
    "i \\leq z_{ij} \\leq u_j \\;\\;\\; \\forall i \\in \\{1,...,10\\}, j \\in \\{i+1, ..., 10\\}\n",
    "$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "u = rand(10)\n",
    "@variable(model, i <= z[i=1:10,j=(i+1):10] <= u[j]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To specify conditions on the indexing, you can add conditionals inside the ``[...]`` block, separated by a semicolon:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@variable(model, w[i=1:10, c=[\"red\",\"blue\"]; iseven(i) || c == \"red\"] >= 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Also easy to create constrainta like $ \\sum _{i = 1}^{10} x_i \\leq 1$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@constraint(model, sum(x[i] for i in 1:10) <= 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Or more complicated ones like \n",
    "$\n",
    "\\sum_{\\substack{i\\in\\{1,...,10\\}\\\\\n",
    "                c\\in\\{\"red\",\"blue\"\\}}}\n",
    "       coef(c) \\cdot y_{ic} = 1\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "coef = Dict(\"red\" => 2, \"blue\" => 3)\n",
    "@constraint(model, sum(coef[c]*y[i,c] for i in 1:10, c in [\"red\",\"blue\"]) == 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "or $\n",
    "\\sum_{i = 1}^{10} \\sum_{j = i+1}^{10} \n",
    "       i \\cdot j \\cdot z_{ij} \\leq\n",
    "\\sum_{\\substack{i\\in\\{1,...,10\\},\n",
    "                c\\in\\{\"red\",\"blue\"\\} \\\\\n",
    "                \\text{s.t. } iseven(i) \\text{ or } c = \"red\"}}\n",
    "       i^2 \\cdot w_{ic} \n",
    "$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@constraint(model, sum(i*j*z[i,j] for i in 1:10, j in (i+1):10) <=\n",
    "               sum(i^2*w[i,c] for i in 1:10, c in [\"red\",\"blue\"] if iseven(i) || c == \"red\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Can also do collections of constraints (named or unamed):\n",
    "    $$ \n",
    "\\begin{align}\n",
    "x_i &\\leq 0.9 \\quad \\forall i \\in \\{1,2,3\\} \\quad\\text{ (large bounds)}\\\\\n",
    "x_i &\\leq 0.5 \\quad \\forall i \\in \\{4,5,6\\} \n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@constraint(model,largebounds[i=1:3], x[i] <= 0.9)\n",
    "@constraint(model,[i=4:6], x[i] <= 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# New in JuMP 0.19: New Containers and Conventions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`JuMPDict` is replaced by `Base.Dict` and `JuMPArray` was rewritten (inspired by `AxisArrays`). Conventions apply for `@variable`, `@constraint`, `@expression`, `@NLconstraint`, `@NLexpression`, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "@variable(model, x[1:5, 1:5])            # Array\n",
    "my_set = [:a, :b, :c]\n",
    "@variable(model, w[1:5, my_set])        # JuMPArray\n",
    "@variable(model, t[i = 1:5, 1:i])        # Dict\n",
    "@variable(model, h[i = 1:5; isodd(i)]);  # Dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Finally,  no more slicing error for JuMPArrays!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "set_1 = [:a, :b, :c]\n",
    "set_2 = [:x, :y, :z]\n",
    "@variable(model, x[set_1,set_2])\n",
    "x[:,:z]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A Warning on Performance and Type Stability "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "`@variable` chooses the tightest applicable container while remaining **type stable**. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "@variable(model, x[1:5, 1:5])            # Array\n",
    "set_1 = Base.OneTo(5)\n",
    "@variable(model, y[set_1, 1:5])          # Array\n",
    "set_2 = 1:5\n",
    "@variable(model, z[1:5, set_2])          # JuMPArray\n",
    "set_3 = [:a, :b, :c]\n",
    "@variable(model, w[set_2, set_3])        # JuMPArray\n",
    "@variable(model, t[i=set_2, 1:i])        # Dict\n",
    "@variable(model, h[i = 1:5; isodd(i)]);  # Dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can also request a container type (for more details see [Internals](Internals.ipynb#JuMP-Containers) notebook):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "@variable(model, x[1:5, 1:5], container = JuMPArray)\n",
    "set_1 = 1:5\n",
    "@variable(model, y[set_1, 1:5], container = Array)\n",
    "set_2 = 2:3\n",
    "# @variable(m, z[set_2, 1:5], container = Array)  # => Error instead of fallback to JuMPArray to preserve type stability"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Classes of Constraints Beyond Linear Inequalities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Broadcasted and two sided linear inequalities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "A = [1.0 2.0; 3.0 4.0]\n",
    "l = [4.0, 5.0]\n",
    "u = [2.0, 3.0]\n",
    "model = Model()\n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, l .<= A*x .<= u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Quadratic Inequalities:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Both convex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model()\n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, x[1]^2 + x[2] <= 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "and non-convex:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "@constraint(model, x[1]*x[2] - 1.0 == 0.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conic constraints including..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Semidefinite constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model()                         # using CSDP; model = Model(with_optimizer(CSDP.CSDPOptimizer))\n",
    "@variable(model, y[1:2,1:2], Symmetric)\n",
    "@constraint(model, y in PSDCone())  \n",
    "@variable(model, t)\n",
    "@variable(model, w)\n",
    "@SDconstraint(model,  [t 1; 1 -w] ⪰ [1 t; t -2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Second order cone constraints:\n",
    "$$ \n",
    "\\begin{equation}\n",
    "\\left\\| Ax+u \\right\\|_2 \\leq t\n",
    "\\end{equation}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model()\n",
    "@variable(model, x[1:2])\n",
    "@variable(model, t)\n",
    "@constraint(model, [t;A*x+u] in SecondOrderCone())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Rotated second order cone constraints:\n",
    "$$ \n",
    "\\begin{equation}\n",
    "\\left\\| Ax+u \\right\\|_2 \\leq t \\cdot w,\\quad w\\geq 0\n",
    "\\end{equation}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model()\n",
    "@variable(model, x[1:2])\n",
    "@variable(model, t)\n",
    "@variable(model, w)\n",
    "@constraint(model, [t;w;A*x+u] in RotatedSecondOrderCone())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Also \"derivative based\" nonlinear constraints\n",
    "\n",
    "Remains unchanged:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = Model()\n",
    "@variable(model, x)\n",
    "@variable(model, y)\n",
    "\n",
    "@NLobjective(model, Min, (1-x)^2 + 100(y-x^2)^2)\n",
    "@NLconstraint(model, exp(x)+sin(x) <=0)"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 0.6.2",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}