MOI_Slides.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# The JuMP ecosystem for mathematical optimization: MOI\n",
    "\n",
    "## JuliaCon 2018\n",
    "\n",
    "## Juan Pablo Vielma\n",
    "## MIT Sloan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m registry at `~/.julia/registries/General`\n",
      "\u001b[32m\u001b[1m  Updating\u001b[22m\u001b[39m git-repo `https://github.com/JuliaRegistries/General.git`\n",
      "\u001b[2K\u001b[?25h[1mFetching:\u001b[22m\u001b[39m [========================================>]  100.0 %.0 %"
     ]
    }
   ],
   "source": [
    "import Pkg\n",
    "Pkg.activate(@__DIR__)\n",
    "Pkg.instantiate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "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": [
    "## MOI and JuMP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x_{1} + x_{2} $$"
      ],
      "text/plain": [
       "x[1] + x[2]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model()\n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, linear1, 2*x[1] +   x[2] <= 1)  # save reference linear1 for this constraint\n",
    "@constraint(model, 2*x[1] + 2*x[2] <= 1) \n",
    "@constraint(model, x[1]^2 + x[2]^2 <= 1)  \n",
    "@constraint(model, [1;x] in SecondOrderCone())  # ||x|| <= 1\n",
    "@objective(model, Max, x[1] + x[2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Behind every JuMP model there is a MOI *backend* (used to be a MPB model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.Utilities.CachingOptimizer{MathOptInterface.AbstractOptimizer,MathOptInterface.Utilities.UniversalFallback{JuMP._MOIModel{Float64}}}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(backend(model))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# MOI and JuMP variables\n",
    "\n",
    "```julia\n",
    "struct JuMP.VariableRef # MOI variable + owning model\n",
    "    model::Model\n",
    "    index::MOI.VariableIndex\n",
    "end\n",
    "\n",
    "struct MOI.VariableIndex  # Type-safe unique non-consecutive index\n",
    "    value::Int64\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{MathOptInterface.VariableIndex,1}:\n",
       " MathOptInterface.VariableIndex(1)\n",
       " MathOptInterface.VariableIndex(2)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xx = MOI.get(backend(model), MOI.ListOfVariableIndices()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index(x[1]) == xx[1] && x[1].model == model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# MOI and JuMP constraints: First MOI constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Tuple{DataType,DataType},1}:\n",
       " (MathOptInterface.ScalarAffineFunction{Float64}, MathOptInterface.LessThan{Float64})   \n",
       " (MathOptInterface.ScalarQuadraticFunction{Float64}, MathOptInterface.LessThan{Float64})\n",
       " (MathOptInterface.VectorAffineFunction{Float64}, MathOptInterface.SecondOrderCone)     "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model()\n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, linear1, 2*x[1] +   x[2] <= 1)  # save reference linear1 for this constraint\n",
    "@constraint(model, 2*x[1] + 2*x[2] <= 1) \n",
    "@constraint(model, x[1]^2 + x[2]^2 <= 1)  \n",
    "@constraint(model, [1;x] in SecondOrderCone()) \n",
    "\n",
    "L,Q,C = MOI.get(backend(model), MOI.ListOfConstraints())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# MOI constraints format \n",
    "$$\n",
    "f(x) \\in S\n",
    "$$\n",
    "\n",
    "were $f$ is an ``MOI.AbstractFunction`` and $S$ is an ``MOI.AbstractSet`` \n",
    "## Example:\n",
    "JuMP:\n",
    "```julia\n",
    "@constraint(model, linear1, 2*x[1] +   x[2] <= 1)\n",
    "```\n",
    "``MOI.ScalarAffineFunction``-in-``MOI.LessThan``:\n",
    "\n",
    "$$a^T x + b \\in \\{y:y\\leq u\\} \\text{ for } a=(2,1)^T,\\text{ }b=0 \\text{ and }u=0$$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# More Constraint Examples\n",
    "\n",
    "| Mathematical Constraint       | MOI Function                 | MOI Set        |\n",
    "|-------------------------------|------------------------------|----------------|\n",
    "| $a^Tx = b$                  | `ScalarAffineFunction`       | `EqualTo`      |\n",
    "| $l \\le a^Tx \\le u$          | `ScalarAffineFunction`       | `Interval`     |\n",
    "| $x_i \\le u$                 | `SingleVariable`             | `LessThan`     |\n",
    "| $Ax + b \\in \\mathbb{R}_+^n$ | `VectorAffineFunction`       | `Nonnegatives` |\n",
    "| $\\lVert Ax + b\\rVert_2 \\le c^Tx + d$                        | `VectorAffineFunction`       | `SecondOrderCone` |\n",
    "| $y \\exp (x/y) \\le z, y > 0$  | `VectorOfVariables`       | `ExponentialCone`                  |\n",
    "| $x \\in \\mathbb{R}^{d\\left(d+1\\right)/2}$,◹$(x)\\in \\text{PSD} \\subseteq \\mathbb{R}^{d\\times d}$                                       | `VectorOfVariables`          | `PositiveSemidefiniteConeTriangle` |\n",
    "| $x^TQx + a^Tx + b \\ge 0$    | `ScalarQuadraticFunction`    | `GreaterThan`                 |\n",
    "| $x_i \\in \\mathbb{Z}$                                                                     | `SingleVariable`    | `Integer`                          |\n",
    "| $x_i \\in \\{0,1\\}$                                                                        | `SingleVariable`    | `ZeroOne`                          |\n",
    "| $x_i \\in \\{0\\} \\cup [l,u]$                                                               | `SingleVariable`    | `Semicontinuous`                   |\n",
    "| At most one component of $x$ can be nonzero                                              | `VectorOfVariables` | `SOS1`                             |\n",
    "\n",
    "MOI includes standard functions and sets, and allows for some extensions. See [MOI manual](http://www.juliaopt.org/MathOptInterface.jl/stable/index.html) for more details on [supported sets and functions](http://www.juliaopt.org/MathOptInterface.jl/stable/apimanual/#Standard-form-problem-1) and more [constraint examples](http://www.juliaopt.org/MathOptInterface.jl/stable/apimanual/#Constraints-by-function-set-pairs-1)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# MOI and JuMP constraints\n",
    "\n",
    "```julia\n",
    "struct JuMP.ConstraintRef{C} # MOI constraint + owning model\n",
    "    model::Model\n",
    "    index::C             # C = ConstraintIndex{F,S} for some F,S\n",
    "end\n",
    "\n",
    "struct MOI.ConstraintIndex{F,S} # Type-safe unique (within class) non-consecutive  index for class F-in-S\n",
    "    value::Int64\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```julia\n",
    "@constraint(model, linear1, 2*x[1] +   x[2] <= 1)  # save reference linear1 for this constraint\n",
    "@constraint(model, 2*x[1] + 2*x[2] <= 1) \n",
    "@constraint(model, x[1]^2 + x[2]^2 <= 1)  \n",
    "@constraint(model, [1;x] in SecondOrderCone()) \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64},MathOptInterface.LessThan{Float64}},1}:\n",
       " MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64},MathOptInterface.LessThan{Float64}}(1)\n",
       " MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64},MathOptInterface.LessThan{Float64}}(2)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linear = MOI.get(backend(model), MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{Float64}, MOI.LessThan{Float64}}())  #MOI.get(model.moibackend,MOI.ListOfConstraintIndices{L...}())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Example: Linear inequalities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "JuMP:\n",
    "```julia\n",
    "@constraint(model, linear1, 2*x[1] +   x[2] <= 1)\n",
    "```\n",
    "``MOI.ScalarAffineFunction``-in-``MOI.LessThan``:\n",
    "\n",
    "$$a^T x + b \\in \\{y:y\\leq u\\} \\text{ for } a=(2,1)^T,\\text{ }b=0 \\text{ and }u=0$$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index(linear1) == linear[1] && linear1.model == model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$a=(2,1)^T$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2-element Array{MathOptInterface.ScalarAffineTerm{Float64},1}:\n",
       " MathOptInterface.ScalarAffineTerm{Float64}(2.0, MathOptInterface.VariableIndex(1))\n",
       " MathOptInterface.ScalarAffineTerm{Float64}(1.0, MathOptInterface.VariableIndex(2))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.get(backend(model), MOI.ConstraintFunction(),linear[1]).terms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$b=0$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.get(backend(model), MOI.ConstraintFunction(),linear[1]).constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$u=0$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.get(backend(model), MOI.ConstraintSet(),linear[1]).upper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Similar for other constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64},MathOptInterface.LessThan{Float64}},1}:\n",
       " MathOptInterface.ConstraintIndex{MathOptInterface.ScalarQuadraticFunction{Float64},MathOptInterface.LessThan{Float64}}(3)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.get(backend(model), MOI.ListOfConstraintIndices{MOI.ScalarQuadraticFunction{Float64}, MOI.LessThan{Float64}}())  #MOI.get(model.moibackend,MOI.ListOfConstraintIndices{Q...}())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1-element Array{MathOptInterface.ConstraintIndex{MathOptInterface.VectorAffineFunction{Float64},MathOptInterface.SecondOrderCone},1}:\n",
       " MathOptInterface.ConstraintIndex{MathOptInterface.VectorAffineFunction{Float64},MathOptInterface.SecondOrderCone}(4)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.get(backend(model), MOI.ListOfConstraintIndices{MOI.VectorAffineFunction{Float64}, MOI.SecondOrderCone}())  #MOI.get(model.moibackend,MOI.ListOfConstraintIndices{C...}())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MOI Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: there are multiple ways to write the same constraint. For more details and discussions see [Constraint Bridges](#Constraint-Bridges)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A Complete MOI Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "obj_value = 6.0\n",
      "primal_variable_result = [1.0, 1.0, 1.0]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3-element Array{Float64,1}:\n",
       " 1.0\n",
       " 1.0\n",
       " 1.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using MathOptInterface\n",
    "const MOI = MathOptInterface\n",
    "using GLPK\n",
    "\n",
    "# Solves the binary-constrained knapsack problem:\n",
    "# max c'x: w'x <= C, x binary using GLPK.\n",
    "\n",
    "c = [1.0, 2.0, 3.0]\n",
    "w = [0.3, 0.5, 1.0]\n",
    "C = 3.2\n",
    "\n",
    "num_variables = length(c)\n",
    "\n",
    "optimizer = GLPK.Optimizer()\n",
    "\n",
    "# Create the variables in the problem.\n",
    "x = MOI.add_variables(optimizer, num_variables)\n",
    "\n",
    "# Set the objective function.\n",
    "objective_function = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.(c, x), 0.0)\n",
    "MOI.set(optimizer, MOI.ObjectiveFunction{MOI.ScalarAffineFunction{Float64}}(),\n",
    "        objective_function)\n",
    "MOI.set(optimizer, MOI.ObjectiveSense(), MOI.MAX_SENSE)\n",
    "\n",
    "# Add the knapsack constraint.\n",
    "knapsack_function = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.(w, x), 0.0)\n",
    "MOI.add_constraint(optimizer, knapsack_function, MOI.LessThan(C))\n",
    "\n",
    "# Add integrality constraints.\n",
    "for i in 1:num_variables\n",
    "    MOI.add_constraint(optimizer, MOI.SingleVariable(x[i]), MOI.ZeroOne())\n",
    "end\n",
    "\n",
    "# All set!\n",
    "MOI.optimize!(optimizer)\n",
    "\n",
    "termination_status = MOI.get(optimizer, MOI.TerminationStatus())\n",
    "obj_value = MOI.get(optimizer, MOI.ObjectiveValue())\n",
    "if termination_status != MOI.OPTIMAL\n",
    "    error(\"Solver terminated with status $termination_status\")\n",
    "end\n",
    "\n",
    "@assert MOI.get(optimizer, MOI.ResultCount()) > 0\n",
    "\n",
    "@assert MOI.get(optimizer, MOI.PrimalStatus()) == MOI.FEASIBLE_POINT\n",
    "\n",
    "primal_variable_result = MOI.get(optimizer, MOI.VariablePrimal(), x)\n",
    "\n",
    "@show obj_value\n",
    "@show primal_variable_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Model modifications"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "You can delete variables or constraints, modify constraints or transform constraints. Modifications are as efficient as allowed by the solver.\n",
    "\n",
    "Example: Transform constraint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x_{1} + x_{2} $$"
      ],
      "text/plain": [
       "x[1] + x[2]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model() \n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, socp, [1;x] in SecondOrderCone())  # ||x|| <= 1\n",
    "@objective(model, Max, x[1] + x[2]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.ConstraintIndex{MathOptInterface.VectorAffineFunction{Float64},MathOptInterface.RotatedSecondOrderCone}(2)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsocp = MOI.transform(backend(model), index(socp), MOI.RotatedSecondOrderCone(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rsocp != socp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.is_valid(backend(model), index(socp))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x_{1} + x_{2} $$"
      ],
      "text/plain": [
       "x[1] + x[2]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model() \n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, linear1, 2 * x[1] +   x[2] <= 1)  # save reference linear1 for this constraint\n",
    "@constraint(model, linear2, 2 * x[1] + 2 * x[2] <= 1) \n",
    "@constraint(model, quadratic, x[1]^2 + x[2]^2 <= 1)  \n",
    "@constraint(model, socp, [1;x] in SecondOrderCone())  # ||x|| <= 1\n",
    "@objective(model, Max, x[1] + x[2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Delete constraint:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.delete(backend(model), index(x[1]))\n",
    "MOI.delete(backend(model), index(linear1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Modify constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(MathOptInterface.ConstraintIndex{MathOptInterface.ScalarAffineFunction{Float64},MathOptInterface.LessThan{Float64}}(2), MathOptInterface.ScalarAffineFunction{Float64}(MathOptInterface.ScalarAffineTerm{Float64}[ScalarAffineTerm{Float64}(2.0, VariableIndex(2)), ScalarAffineTerm{Float64}(3.0, VariableIndex(1))], 0.0), MathOptInterface.LessThan{Float64}(1.0))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOI.modify(backend(model), index(linear2), MOI.ScalarCoefficientChange(index(x[1]), 3.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Also JuMP modifications"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x_{1} + x_{2} $$"
      ],
      "text/plain": [
       "x[1] + x[2]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model() \n",
    "@variable(model, x[1:2])\n",
    "@constraint(model, linear1, 2 * x[1] +   x[2] <= 1)  # save reference linear1 for this constraint\n",
    "@constraint(model, linear2, 2 * x[1] + 2 * x[2] <= 1) \n",
    "@constraint(model, quadratic, x[1]^2 + x[2]^2 <= 1)  \n",
    "@constraint(model, socp, [1;x] in SecondOrderCone())  # ||x|| <= 1\n",
    "@objective(model, Max, x[1] + x[2]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "linear1 : $ 3 x_{1} + x_{2} \\leq 1.0 $"
      ],
      "text/plain": [
       "linear1 : 3 x[1] + x[2] ≤ 1.0"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set_coefficient(linear1, x[1], 3)\n",
    "linear1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ \\begin{alignat*}{1}\\max\\quad & x_{1}\\\\\n",
       "\\text{Subject to} \\quad & 3 x_{1} \\leq 1.0\\\\\n",
       " & x_{1}^2 \\leq 1.0\\\\\n",
       " & [1, x_{1}, 0] \\in MathOptInterface.SecondOrderCone(3)\\\\\n",
       "\\end{alignat*}\n",
       " $$"
      ],
      "text/plain": [
       "A JuMP Model\n",
       "Maximization problem with:\n",
       "Variable: 1\n",
       "Objective function type: GenericAffExpr{Float64,VariableRef}\n",
       "`GenericAffExpr{Float64,VariableRef}`-in-`MathOptInterface.LessThan{Float64}`: 1 constraint\n",
       "`GenericQuadExpr{Float64,VariableRef}`-in-`MathOptInterface.LessThan{Float64}`: 1 constraint\n",
       "`Array{GenericAffExpr{Float64,VariableRef},1}`-in-`MathOptInterface.SecondOrderCone`: 1 constraint\n",
       "Model mode: AUTOMATIC\n",
       "CachingOptimizer state: NO_OPTIMIZER\n",
       "Solver name: No optimizer attached.\n",
       "Names registered in the model: linear1, linear2, quadratic, socp, x"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "delete(model,linear2)\n",
    "delete(model,x[2])\n",
    "model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## MOI Attributes: For MOI models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.ConstraintIndex{MathOptInterface.SingleVariable,MathOptInterface.LessThan{Float64}}(1)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = GLPK.Optimizer()\n",
    "var_index = MOI.add_variable(model)\n",
    "constr_index = MOI.add_constraint(model,MOI.SingleVariable(var_index),MOI.LessThan(10.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for building models..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.set(model, MOI.ObjectiveSense(),MOI.MAX_SENSE)\n",
    "MOI.set(model, MOI.ObjectiveFunction{MOI.SingleVariable}(), MOI.SingleVariable(var_index))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and more ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "MathOptInterface.UnsupportedAttribute{MathOptInterface.VariablePrimalStart}",
     "evalue": "MathOptInterface.UnsupportedAttribute{MathOptInterface.VariablePrimalStart}: Attribute MathOptInterface.VariablePrimalStart() is not supported by the the model.",
     "output_type": "error",
     "traceback": [
      "MathOptInterface.UnsupportedAttribute{MathOptInterface.VariablePrimalStart}: Attribute MathOptInterface.VariablePrimalStart() is not supported by the the model.",
      "",
      "Stacktrace:",
      " [1] set(::GLPK.Optimizer, ::MathOptInterface.VariablePrimalStart, ::Array{MathOptInterface.VariableIndex,1}, ::Array{Float64,1}) at /Users/jvielma/.julia/packages/LinQuadOptInterface/ZMx9f/src/variables.jl:211",
      " [2] set(::GLPK.Optimizer, ::MathOptInterface.VariablePrimalStart, ::MathOptInterface.VariableIndex, ::Float64) at /Users/jvielma/.julia/packages/LinQuadOptInterface/ZMx9f/src/variables.jl:218",
      " [3] top-level scope at In[28]:1"
     ]
    }
   ],
   "source": [
    "MOI.set(model, MOI.VariablePrimalStart(),var_index,5.0)\n",
    "MOI.set(model, MOI.ConstraintDualStart(),constr_index,5.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## MOI Attributes: Also for JuMP models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ \\begin{alignat*}{1}\\text{feasibility}\\\\\n",
       "\\text{Subject to} \\quad\\end{alignat*}\n",
       " $$"
      ],
      "text/plain": [
       "A JuMP Model\n",
       "Feasibility problem with:\n",
       "Variables: 0\n",
       "Model mode: AUTOMATIC\n",
       "CachingOptimizer state: NO_OPTIMIZER\n",
       "Solver name: No optimizer attached."
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "some attributes have custom macro syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@variable(model, x >= 10.0, start = 5.0)\n",
    "@objective(model, Max, x)\n",
    "set_start_value(x, 3.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "others use MOI functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bound_ref = index(JuMP.LowerBoundRef(x))\n",
    "MOI.set(backend(model), MOI.ConstraintDualStart(),bound_ref,10.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## JuMP and MOI Solver Modes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x + y $$"
      ],
      "text/plain": [
       "x + y"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model(with_optimizer(GLPK.Optimizer))\n",
    "@variable(model, x >= 0)\n",
    "@variable(model, y >= 0)\n",
    "@constraint(model, inequality, x + y <= 1)\n",
    "@objective(model, Max, x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "JuMP has 3 solver modes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Enum ModelMode:\n",
       "AUTOMATIC = 0\n",
       "MANUAL = 1\n",
       "DIRECT = 2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "JuMP.ModelMode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default mode is `Automatic`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "JuMP.mode(model) == JuMP.AUTOMATIC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "c = [1; 3; 5; 2] \n",
    "\n",
    "A= [\n",
    "     1 1 9 5;\n",
    "     3 5 0 8;\n",
    "     2 0 6 13\n",
    "    ]\n",
    "\n",
    "b = [7; 3; 5] \n",
    "\n",
    "m, n = size(A); # m = number of rows of A, n = number of columns of A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# One Extreme: Automatic Mode = \"Almost\" Old JuMP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`CachingOptimizer` re-builds model when incremental modifications are not supported.\n",
    "* Pros: No need to worry about what modifications are supported.\n",
    "* Cons: No information about efficiency of modifications (may be re-creating the whole model at each `optimize` call)\n",
    "\n",
    "**Note:** Automatic mode also provides automatic constraint transformations. See [Constraint Bridges](#Constraint-Bridges)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3.716132 seconds (13.61 M allocations: 691.465 MiB, 10.61% gc time)\n",
      "JuMP.termination_status(model) == MOI.OPTIMAL = true\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = JuMP.Model(with_optimizer(GLPK.Optimizer, msg_lev = 0))\n",
    "@variable(model, x[1:n] >= 0) \n",
    "@constraint(model, [i=1:m], sum(A[i,j]*x[j] for j in 1:n) == b[i])\n",
    "@objective(model, Min, sum(c[j]*x[j] for j in 1:n)) \n",
    "@time begin\n",
    "JuMP.optimize!(model) # solves the model\n",
    "end\n",
    "@show JuMP.termination_status(model) == MOI.OPTIMAL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Note:** \n",
    "```julia\n",
    "with_optimizer(GLPK.Optimizer, msg_lev = 0)\n",
    "```\n",
    "builds a factory that can create instances of \n",
    "```julia\n",
    "GLPK.Optimizer(msg_lev = 0)\n",
    "```\n",
    "to re-build the internal model (or copy it)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### The Other Extreme: Direct Mode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Direct connection to a solver. All data is stored with solver, MOI does not save or cache anything.\n",
    "* Pros: Access to complete solver interfase (e.g. callbacks). Allowed modifications are as efficient as possible for the solver. \n",
    "* Cons: Cannot apply incremental modifications not supported by the solver. Cannot copy the model. [Constraint Bridges](#Constraint-Bridges) are not enabled by default."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.000045 seconds (7 allocations: 432 bytes)\n",
      "JuMP.termination_status(model) == MOI.OPTIMAL = true\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = JuMP.direct_model(GLPK.Optimizer(msg_lev = 0))\n",
    "@variable(model, x[1:n] >= 0) # Models x >=0\n",
    "@constraint(model, [i=1:m], sum(A[i,j]*x[j] for j in 1:n) == b[i])\n",
    "@objective(model, Min, sum(c[j]*x[j] for j in 1:n)) \n",
    "@time begin\n",
    "JuMP.optimize!(model) # solves the model\n",
    "end\n",
    "@show JuMP.termination_status(model) == MOI.OPTIMAL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Intermediate Mode: Manual Mode = Direct Control of `CachingOptimizer`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "AssertionError: m.state == ATTACHED_OPTIMIZER",
     "output_type": "error",
     "traceback": [
      "AssertionError: m.state == ATTACHED_OPTIMIZER",
      "",
      "Stacktrace:",
      " [1] optimize!(::MathOptInterface.Utilities.CachingOptimizer{MathOptInterface.AbstractOptimizer,MathOptInterface.Utilities.UniversalFallback{JuMP._MOIModel{Float64}}}) at /Users/jvielma/.julia/packages/MathOptInterface/QVlW6/src/Utilities/cachingoptimizer.jl:164",
      " [2] #optimize!#77(::Bool, ::Bool, ::Function, ::Model, ::Nothing) at /Users/jvielma/.julia/packages/JuMP/jnmGG/src/optimizer_interface.jl:132",
      " [3] optimize! at /Users/jvielma/.julia/packages/JuMP/jnmGG/src/optimizer_interface.jl:105 [inlined] (repeats 2 times)",
      " [4] top-level scope at In[38]:6"
     ]
    }
   ],
   "source": [
    "model = JuMP.Model(with_optimizer(GLPK.Optimizer, msg_lev = 4),caching_mode = MOIU.MANUAL)\n",
    "\n",
    "@variable(model, x[1:n] >= 0) \n",
    "@constraint(model, [i=1:m], sum(A[i,j]*x[j] for j in 1:n) == b[i])\n",
    "@objective(model, Min, sum(c[j]*x[j] for j in 1:n)) \n",
    "\n",
    "JuMP.optimize!(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Need to control `CachingOptimizer` directly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    " # Controlling `CachingOptimizer` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.Utilities.CachingOptimizer{MathOptInterface.AbstractOptimizer,MathOptInterface.Utilities.UniversalFallback{JuMP._MOIModel{Float64}}}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "copt = backend(model)\n",
    "typeof(copt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Enum MathOptInterface.Utilities.CachingOptimizerState:\n",
       "NO_OPTIMIZER = 0\n",
       "EMPTY_OPTIMIZER = 1\n",
       "ATTACHED_OPTIMIZER = 2"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOIU.CachingOptimizerState"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOIU.state(copt) == MOIU.EMPTY_OPTIMIZER"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`EMPTY_OPTIMIZER` has not loaded the model. We can load it with `attachoptimizer!` and then we can solve:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.attach_optimizer(copt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOIU.state(copt) == MOIU.ATTACHED_OPTIMIZER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GLPK Simplex Optimizer, v4.64\n",
      "3 rows, 4 columns, 10 non-zeros\n",
      "      0: obj =   0.000000000e+00 inf =   1.500e+01 (3)\n",
      "      3: obj =   5.035196687e+00 inf =   0.000e+00 (0)\n",
      "*     4: obj =   4.923076923e+00 inf =   0.000e+00 (0)\n",
      "OPTIMAL LP SOLUTION FOUND\n"
     ]
    }
   ],
   "source": [
    "JuMP.optimize!(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can return to `EmptyOptimizer` with `resetoptimizer`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MOIU.reset_optimizer(copt);\n",
    "MOIU.state(copt) == MOIU.EMPTY_OPTIMIZER"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Constraint Bridges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Constraint Bridges: Example 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = JuMP.Model()\n",
    "@variable(model,x[1:10]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two-sided linear constraint as one `ScalarAffineFunction`-in-`Interval`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "interval_inequality : $ x_{1} + x_{2} + x_{3} + x_{4} + x_{5} + x_{6} + x_{7} + x_{8} + x_{9} + x_{10} \\in \\[-2.0, 1.0\\] $"
      ],
      "text/plain": [
       "interval_inequality : x[1] + x[2] + x[3] + x[4] + x[5] + x[6] + x[7] + x[8] + x[9] + x[10] ∈ [-2.0, 1.0]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@constraint(model, interval_inequality, -2 <= sum(x) <= 1)\n",
    "#index(interval_inequality)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two-sided linear constraint as two `ScalarAffineFunction`-in-`LessThan`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "upper_bound : $ x_{1} + x_{2} + x_{3} + x_{4} + x_{5} + x_{6} + x_{7} + x_{8} + x_{9} + x_{10} \\leq 1.0 $"
      ],
      "text/plain": [
       "upper_bound : x[1] + x[2] + x[3] + x[4] + x[5] + x[6] + x[7] + x[8] + x[9] + x[10] ≤ 1.0"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@constraint(model, lower_bound, -sum(x) <= 2)\n",
    "#index(lower_bound)\n",
    "@constraint(model, upper_bound,  sum(x) <= 1)\n",
    "#index(upper_bound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Constraint Bridges: Example 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = JuMP.Model()\n",
    "@variable(model,x)\n",
    "@variable(model,y)\n",
    "@variable(model,t);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quadratic inequality as `ScalarQuadraticFunction`-in-`LessThan`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "quadratic : $ x^2 + y^2 - t \\leq 0.0 $"
      ],
      "text/plain": [
       "quadratic : x² + y² - t ≤ 0.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@constraint(model,quadratic, x^2 + y^2 <= t)\n",
    "#index(quadratic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quadratic inequality as `VectorAffineFunction`-in-`SecondOrderCone`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "conic : $ [0.5 t + 0.5, -0.5 t + 0.5, x, y] \\in MathOptInterface.SecondOrderCone(4) $"
      ],
      "text/plain": [
       "conic : [0.5 t + 0.5, -0.5 t + 0.5, x, y] ∈ MathOptInterface.SecondOrderCone(4)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@constraint(model, conic, [(1+t)/2; (1-t)/2; x; y] in SecondOrderCone())\n",
    "#index(conic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# [Constraint Bridges](http://www.juliaopt.org/MathOptInterface.jl/stable/apimanual.html#Constraint-bridges-1) provide automatic transformation rules."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For instance, [Automatic Mode](#One-Extreme:-Automatic-Mode-=-\"Almost\"-Old-JuMP) actually adds two intermadiate layers: \n",
    "1. `CachingOptimizer` for incremental modifications, and\n",
    "2. `LazyBridgeOptimizer <: AbstractBridgeOptimizer` for default automatic transformations\n",
    "\n",
    "`LazyBridgeOptimizer` can be disabled with the `bridge_constraints = false` keyword argument."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Example for `bridge_constraints`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ECOS does not support quadratic constraints so it fails without a bridge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "ename": "ErrorException",
     "evalue": "Constraints of type MathOptInterface.ScalarQuadraticFunction{Float64}-in-MathOptInterface.LessThan{Float64} are not supported by the solver, try using `bridge_constraints=true` in the `JuMP.Model` constructor if you believe the constraint can be reformulated to constraints supported by the solver.",
     "output_type": "error",
     "traceback": [
      "Constraints of type MathOptInterface.ScalarQuadraticFunction{Float64}-in-MathOptInterface.LessThan{Float64} are not supported by the solver, try using `bridge_constraints=true` in the `JuMP.Model` constructor if you believe the constraint can be reformulated to constraints supported by the solver.",
      "",
      "Stacktrace:",
      " [1] error(::String) at ./error.jl:33",
      " [2] moi_add_constraint(::MathOptInterface.Utilities.CachingOptimizer{MathOptInterface.AbstractOptimizer,MathOptInterface.Utilities.UniversalFallback{JuMP._MOIModel{Float64}}}, ::MathOptInterface.ScalarQuadraticFunction{Float64}, ::MathOptInterface.LessThan{Float64}) at /Users/jvielma/.julia/packages/JuMP/jnmGG/src/constraints.jl:371",
      " [3] add_constraint(::Model, ::ScalarConstraint{GenericQuadExpr{Float64,VariableRef},MathOptInterface.LessThan{Float64}}, ::String) at /Users/jvielma/.julia/packages/JuMP/jnmGG/src/constraints.jl:385",
      " [4] top-level scope at /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:621",
      " [5] top-level scope at In[51]:6"
     ]
    }
   ],
   "source": [
    "using ECOS\n",
    "model = JuMP.Model(with_optimizer(ECOS.Optimizer), bridge_constraints = false)\n",
    "@variable(model,x)\n",
    "@variable(model,y)\n",
    "@variable(model,t)\n",
    "@constraint(model,quadratic, x^2 + y^2 <= t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "quadratic : $ x^2 + y^2 - t \\leq 0.0 $"
      ],
      "text/plain": [
       "quadratic : x² + y² - t ≤ 0.0"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = JuMP.Model(with_optimizer(ECOS.Optimizer), bridge_constraints = true)\n",
    "@variable(model,x)\n",
    "@variable(model,y)\n",
    "@variable(model,t)\n",
    "@constraint(model,quadratic, x^2 + y^2 <= t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## JuMP and MOI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x + y $$"
      ],
      "text/plain": [
       "x + y"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model(with_optimizer(GLPK.Optimizer))\n",
    "@variable(model, x >= 0)\n",
    "@variable(model, y >= 0)\n",
    "@constraint(model, inequality, x + y <= 1)\n",
    "@objective(model, Max, x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:278 =#\n",
       "    (JuMP._valid_model)(model, :model)\n",
       "    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:279 =#\n",
       "    begin\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:336 =#\n",
       "        (JuMP._error_if_cannot_register)(model, :x)\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:340 =#\n",
       "        #458###516 = begin\n",
       "                #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:294 =#\n",
       "                let\n",
       "                    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:300 =#\n",
       "                    #458###516 = (JuMP.add_variable)(model, (JuMP.build_variable)(getfield(JuMP, Symbol(\"#_error#66\")){Tuple{Symbol,Expr}}((:model, :(x >= 0))), (JuMP.VariableInfo)(true, 0, false, NaN, false, NaN, false, NaN, false, false)), \"x\")\n",
       "                    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:301 =#\n",
       "                    #458###516\n",
       "                end\n",
       "            end\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:341 =#\n",
       "        ((JuMP.object_dictionary)(model))[:x] = #458###516\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:346 =#\n",
       "        x = #458###516\n",
       "    end\n",
       "end"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@macroexpand @variable(model, x >= 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`@variable(model, x >= 0)`:\n",
    "\n",
    "1. Create JuMP/MOI variable and set its attributes:\n",
    "```julia\n",
    "x = JuMP.add)variable(model,[...],\"x\")\n",
    "```\n",
    "2. Save JuMP variable in symbol-keyed dictionary:\n",
    "```julia\n",
    "((JuMP.object_dictionary)(model))[:x] = x \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "quote\n",
       "    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:278 =#\n",
       "    (JuMP._valid_model)(model, :model)\n",
       "    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:279 =#\n",
       "    begin\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:336 =#\n",
       "        (JuMP._error_if_cannot_register)(model, :inequality)\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:340 =#\n",
       "        #464###517 = begin\n",
       "                #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:294 =#\n",
       "                let\n",
       "                    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:300 =#\n",
       "                    begin\n",
       "                        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:620 =#\n",
       "                        begin\n",
       "                            #460#q = (JuMP.Val){false}()\n",
       "                            #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:410 =#\n",
       "                            begin\n",
       "                                begin\n",
       "                                    #461###520 = (JuMP._destructive_add_with_reorder!)(#460#q, x)\n",
       "                                    #462###519 = (JuMP._destructive_add_with_reorder!)(#461###520, y)\n",
       "                                end\n",
       "                                #463###518 = (JuMP._destructive_add_with_reorder!)(#462###519, -1.0, 1)\n",
       "                            end\n",
       "                        end\n",
       "                        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:621 =#\n",
       "                        #464###517 = (JuMP.add_constraint)(model, (JuMP.build_constraint)(getfield(JuMP, Symbol(\"#_error#55\")){Symbol}(Core.Box(Any[:model, :inequality, :(x + y <= 1)]), :constraint), #463###518, MathOptInterface.LessThan{Float64}(0.0)), \"inequality\")\n",
       "                    end\n",
       "                    #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:301 =#\n",
       "                    #464###517\n",
       "                end\n",
       "            end\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:341 =#\n",
       "        ((JuMP.object_dictionary)(model))[:inequality] = #464###517\n",
       "        #= /Users/jvielma/.julia/packages/JuMP/jnmGG/src/macros.jl:346 =#\n",
       "        inequality = #464###517\n",
       "    end\n",
       "end"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@macroexpand @constraint(model, inequality, x + y <= 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`@constraint(model, inequality, x + y <= 1)`:\n",
    "\n",
    "1. Create JuMP/MOI constraint (function and set):\n",
    "```julia\n",
    "inequality = JuMP.add_constraint(model,[...],\"inequality\")\n",
    "``` \n",
    "2. Save JuMP constraint in symbol-keyed dictionary:\n",
    "```julia\n",
    "((JuMP.object_dictionary)(model))[:inequality] = inequality\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### JuMP stores data only on MOI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```julia\n",
    "function moi_add_constraint(model::MOI.ModelLike, f::MOI.AbstractFunction,\n",
    "                            s::MOI.AbstractSet)\n",
    "    [...]\n",
    "    return MOI.add_constraint(model, f, s)\n",
    "end\n",
    "\n",
    "\n",
    "function add_constraint(model::Model, c::AbstractConstraint, name::String=\"\")\n",
    "    [...]\n",
    "    cindex = moi_add_constraint(backend(model), moi_function(c), moi_set(c))\n",
    "    cshape = shape(c)\n",
    "    if !(cshape isa ScalarShape) && !(cshape isa VectorShape)\n",
    "        model.shapes[cindex] = cshape\n",
    "    end\n",
    "    cref = ConstraintRef(model, cindex, cshape)\n",
    "    if !isempty(name)\n",
    "        set_name(cref, name)\n",
    "    end\n",
    "    return cref\n",
    "end\n",
    "```\n",
    "JuMP constraint:\n",
    "```julia\n",
    "struct ConstraintRef{M <: AbstractModel, C, Shape <: AbstractShape}\n",
    "    model::M\n",
    "    index::C\n",
    "    shape::Shape\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can recover constraints by their \"name\" stored in MOI:\n",
    "\n",
    "```julia\n",
    "function constraint_by_name(model::Model, name::String)\n",
    "    index = MOI.get(backend(model), MOI.ConstraintIndex, name)\n",
    "    if index isa Nothing\n",
    "        return nothing\n",
    "    else\n",
    "        return constraint_ref_with_index(model, index)\n",
    "    end\n",
    "end\n",
    "\n",
    "function name(cr::ConstraintRef{Model,<:_MOICON})\n",
    "    return MOI.get(cr.model, MOI.ConstraintName(), cr)::String\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "constraint_by_name(model, \"inequality\") == inequality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"inequality\" == name(inequality)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "also for variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variable_by_name(model, \"x\") == x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"x\" == name(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### JuMP does store dictionary to recover variables/constraints by symbol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model[:x] == x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model[:inequality] == inequality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "usefull when working with multiple models with same names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ x + y $$"
      ],
      "text/plain": [
       "x + y"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model1 = Model(with_optimizer(GLPK.Optimizer))\n",
    "@variable(model1, x >= 0)\n",
    "@variable(model1, y >= 0)\n",
    "@constraint(model1, inequality, x + y <= 1)\n",
    "@objective(model1, Max, x + y)\n",
    "\n",
    "model2 = Model(with_optimizer(GLPK.Optimizer))\n",
    "@variable(model2, x >= 0)\n",
    "@variable(model2, y >= 0)\n",
    "@constraint(model2, inequality, 2x + y <= 1)\n",
    "@objective(model2, Max, x + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`inequality` for `model1` was overwritten by `inequality` for `model2`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "inequality : $ 2 x + y \\leq 1.0 $"
      ],
      "text/plain": [
       "inequality : 2 x + y ≤ 1.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inequality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can recover `inequality` for `model1` from `model1[...]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "inequality : $ x + y \\leq 1.0 $"
      ],
      "text/plain": [
       "inequality : x + y ≤ 1.0"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model1[:inequality]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A recap of the four types of variables/constraints in JuMP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Julia variables v/s mathematical optimization variables?! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ Xvar_{1} + Xvar_{2} + Xvar_{3} + y $$"
      ],
      "text/plain": [
       "Xvar[1] + Xvar[2] + Xvar[3] + y"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model(with_optimizer(GLPK.Optimizer))\n",
    "@variable(model, x[1:3] >= 0, base_name=\"Xvar\")\n",
    "@variable(model, y >= 0)\n",
    "@constraint(model, inequality, sum(x) + y <= 1)\n",
    "@objective(model, Max, sum(x) + y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MOI variable: a unique index within a model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.VariableIndex(4)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.VariableIndex(2)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index(x[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MOI variable name: a unique string associated to a MOI variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"y\""
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Xvar[2]\""
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name(x[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "set_name(x[3],\"lastXvar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{VariableRef,1}:\n",
       " Xvar[1] \n",
       " Xvar[2] \n",
       " lastXvar"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single JuMP variable: Reference to a MOI variable in a model. A Julia variable of type `JuMP.VariableRef`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VariableRef"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MathOptInterface.VariableIndex(4)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.model == model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Container of JuMP variables: well... a container of `JuMP.VariableRef` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Array{VariableRef,1}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interesting Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{VariableRef,1}:\n",
       " noname\n",
       " noname\n",
       " noname"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model(with_optimizer(GLPK.Optimizer))\n",
    "x = @variable(model, [1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{VariableRef,1}:\n",
       " noname\n",
       " noname\n",
       " noname"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{VariableRef,1}:\n",
       " 0.5365231341120931[1]\n",
       " 0.6108445572768277[2]\n",
       " 0.8015063931975328[3]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Model(with_optimizer(GLPK.Optimizer))\n",
    "@variable(model, [1:3], base_name=string(rand()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$ z_{3} $$"
      ],
      "text/plain": [
       "z[3]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using DataStructures\n",
    "myvariables = Stack{JuMP.VariableRef}()\n",
    "model = Model(with_optimizer(GLPK.Optimizer))\n",
    "push!(myvariables,@variable(model, y >= 0))\n",
    "push!.([myvariables],@variable(model, z[1:3] >= 0))\n",
    "pop!(myvariables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "myvariables = Stack{VariableRef}(Deque [VariableRef[y, z[1], z[2]]])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Stack{VariableRef}(Deque [VariableRef[y, z[1], z[2]]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@show myvariables"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Julia 1.1.0",
   "language": "julia",
   "name": "julia-1.1"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.0"
  },
  "livereveal": {
   "scroll": true
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}