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": null,
   "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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "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 model (used to be a MPB model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "typeof(model.moibackend)"
   ]
  },
  {
   "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",
    "    m::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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "xx = MOI.get(model.moibackend,MOI.ListOfVariableIndices()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x[1].index == xx[1] && x[1].m == model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# MOI and JuMP constraints: First MOI constraints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "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(model.moibackend,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.html#Standard-form-problem-1) and more [constraint examples](http://www.juliaopt.org/MathOptInterface.jl/stable/apimanual.html#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",
    "    m::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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "linear = MOI.get(model.moibackend,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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "linear1.index == linear[1] && linear1.m == model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$a=(2,1)^T$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend,MOI.ConstraintFunction(),linear[1]).terms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "$b=0$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend,MOI.ConstraintFunction(),linear[1]).constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "$u=0$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend,MOI.ConstraintSet(),linear[1]).upper"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Similar for other constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend,MOI.ListOfConstraintIndices{MOI.ScalarQuadraticFunction{Float64}, MOI.LessThan{Float64}}())  #MOI.get(model.moibackend,MOI.ListOfConstraintIndices{Q...}())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend,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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "using MathOptInterface\n",
    "const MOI = MathOptInterface\n",
    "using GLPK\n",
    "\n",
    "# Solve the binary-constrained knapsack problem: 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",
    "numvariables = length(c)\n",
    "\n",
    "optimizer = GLPK.GLPKOptimizerMIP()\n",
    "\n",
    "# create the variables in the problem\n",
    "x = MOI.addvariables!(optimizer, numvariables)\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}}(), objective_function)\n",
    "MOI.set!(optimizer, MOI.ObjectiveSense(), MOI.MaxSense)\n",
    "\n",
    "# add the knapsack constraint\n",
    "knapsack_function = MOI.ScalarAffineFunction(MOI.ScalarAffineTerm.(w, x), 0.0)\n",
    "MOI.addconstraint!(optimizer, knapsack_function, MOI.LessThan(C))\n",
    "\n",
    "# add integrality constraints\n",
    "for i in 1:numvariables\n",
    "    MOI.addconstraint!(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",
    "objvalue = MOI.canget(optimizer, MOI.ObjectiveValue()) ? MOI.get(optimizer, MOI.ObjectiveValue()) : NaN\n",
    "if termination_status != MOI.Success\n",
    "    error(\"Solver terminated with status $termination_status\")\n",
    "end\n",
    "\n",
    "@assert MOI.get(optimizer, MOI.ResultCount()) > 0\n",
    "\n",
    "result_status = MOI.get(optimizer, MOI.PrimalStatus())\n",
    "if result_status != MOI.FeasiblePoint\n",
    "    error(\"Solver ran successfully did not return a feasible point. The problem may be infeasible.\")\n",
    "end\n",
    "primal_variable_result = MOI.get(optimizer, MOI.VariablePrimal(), x)\n",
    "\n",
    "@show objvalue\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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "rsocp = MOI.transform!(model.moibackend, socp.index, MOI.RotatedSecondOrderCone(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "rsocp != socp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "MOI.isvalid(model.moibackend,socp.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if MOI.candelete(model.moibackend,x[1].index)\n",
    "    MOI.delete!(model.moibackend,x[1].index)\n",
    "end\n",
    "if MOI.candelete(model.moibackend,linear1.index)\n",
    "    MOI.delete!(model.moibackend,linear1.index)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Modify constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "if MOI.canmodify(model.moibackend, typeof(linear2.index), MOI.ScalarCoefficientChange{Float64})\n",
    "    MOI.modify!(model.moibackend, linear2.index, MOI.ScalarCoefficientChange(x[1].index, 3.0))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## MOI Attributes: For MOI models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = GLPK.GLPKOptimizerMIP()\n",
    "var_index = MOI.addvariable!(model)\n",
    "constr_index = MOI.addconstraint!(model,MOI.SingleVariable(var_index),MOI.LessThan(10.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for building models..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.set!(model,MOI.ObjectiveSense(),MOI.MaxSense)\n",
    "MOI.set!(model, MOI.ObjectiveFunction{MOI.SingleVariable}(), MOI.SingleVariable(var_index))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and more..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if MOI.canset(model,MOI.VariablePrimalStart(),typeof(var_index))\n",
    "    MOI.set!(model,MOI.VariablePrimalStart(),var_index,5.0)\n",
    "end\n",
    "if MOI.canset(model,MOI.ConstraintDualStart(),typeof(constr_index))\n",
    "    MOI.set!(model,MOI.ConstraintDualStart(),constr_index,5.0)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## MOI Attributes: Also for JuMP models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "some attributes have custom macro syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@variable(model, x >= 10.0, start = 5.0)\n",
    "@objective(model, Max, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "others use MOI functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bound_ref = JuMP.LowerBoundRef(x).index\n",
    "if MOI.canset(model.moibackend,MOI.ConstraintDualStart(),typeof(bound_ref))\n",
    "    MOI.set!(model.moibackend,MOI.ConstraintDualStart(),bound_ref,10.0)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## JuMP and MOI Solver Modes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JuMP.ModelMode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default mode is `Automatic`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JuMP.mode(model) == JuMP.Automatic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = JuMP.Model(with_optimizer(GLPK.GLPKOptimizerLP, 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.terminationstatus(model) == MOI.Success"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "**Note:** \n",
    "```julia\n",
    "with_optimizer(GLPK.GLPKOptimizerLP, msg_lev = 0)\n",
    "```\n",
    "builds a factory that can create instances of \n",
    "```julia\n",
    "GLPK.GLPKOptimizerLP(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": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "model = JuMP.direct_model(GLPK.GLPKOptimizerLP(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.terminationstatus(model) == MOI.Success"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Intermediate Mode: Manual Mode = Direct Control of `CachingOptimizer`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = JuMP.Model(with_optimizer(GLPK.GLPKOptimizerLP, 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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "copt = JuMP.caching_optimizer(model)\n",
    "typeof(copt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.CachingOptimizerState"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.state(copt) == MOIU.EmptyOptimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`EmptyOptimizer` has not loaded the model. We can load it with `attachoptimizer!` and then we can solve:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.attachoptimizer!(copt);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.state(copt) == MOIU.AttachedOptimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "JuMP.optimize(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unsuported incremental modifications through an error for `AttachedOptimizer`, but not for `EmptyOptimizer`.\n",
    "We can return to `EmptyOptimizer` with `resetoptimizer`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.resetoptimizer!(copt);\n",
    "MOIU.state(copt) == MOIU.EmptyOptimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional Cbc example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using Cbc\n",
    "model = JuMP.Model(with_optimizer(Cbc.CbcOptimizer),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)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "copt = JuMP.caching_optimizer(model)\n",
    "MOIU.attachoptimizer!(copt);\n",
    "JuMP.optimize(model)\n",
    "@show JuMP.terminationstatus(model) == MOI.Success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@constraint(model, x[1]==1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOIU.resetoptimizer!(copt);\n",
    "@constraint(model, x[1]==1)\n",
    "MOIU.attachoptimizer!(copt);\n",
    "JuMP.optimize(model)"
   ]
  },
  {
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@constraint(model, interval_inequality, -2 <= sum(x) <= 1)\n",
    "#interval_inequality.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two-sided linear constraint as two `ScalarAffineFunction`-in-`LessThan`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "@constraint(model, lower_bound, -sum(x) <= 2)\n",
    "#lower_bound.index\n",
    "@constraint(model, upper_bound,  sum(x) <= 1)\n",
    "#upper_bound.index"
   ]
  },
  {
   "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": null,
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@constraint(model,quadratic, x^2 + y^2 <= t)\n",
    "#quadratic.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quadratic inequality as `VectorAffineFunction`-in-`SecondOrderCone`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@constraint(model, conic, [(1+t)/2; (1-t)/2; x; y] in SecondOrderCone())\n",
    "conic.index"
   ]
  },
  {
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using ECOS\n",
    "model = JuMP.Model(with_optimizer(ECOS.ECOSOptimizer), 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": "markdown",
   "metadata": {},
   "source": [
    "It will work once the standard bridge is [implemented](https://github.com/JuliaOpt/MathOptInterfaceBridges.jl/issues/93)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = JuMP.Model(with_optimizer(ECOS.ECOSOptimizer)) #, 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": {},
   "source": [
    "** Note: ** Bridges also should transform dual solutions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## JuMP and MOI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Need the following patch [implemented in MOI master](https://github.com/JuliaOpt/MathOptInterface.jl/pull/409), but not on release v0.4.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.canget(m::MOIU.CachingOptimizer, IdxT::Type{<:MOI.Index}, name::String) = MOI.canget(m.model_cache, IdxT, name)\n",
    "MOI.get(m::MOIU.CachingOptimizer, IdxT::Type{<:MOI.Index}, name::String) = MOI.get(m.model_cache, IdxT, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\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": null,
   "metadata": {},
   "outputs": [],
   "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.addvariable(model,[...],\"x\")\n",
    "```\n",
    "2. Save JuMP variable in symbol-keyed dictionary:\n",
    "```julia\n",
    "JuMP.registervar(model, :x, x)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.addconstraint(model,[...],\"inequality\")\n",
    "``` \n",
    "2. Save JuMP constraint in symbol-keyed dictionary:\n",
    "```julia\n",
    "JuMP.registercon(model, :inequality, inequality)\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### JuMP stores data only on MOI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```julia\n",
    "function addconstraint(m::Model, c::AbstractConstraint, name::String=\"\")\n",
    "    f, s = moi_function_and_set(c)\n",
    "    [...]\n",
    "    cindex = MOI.addconstraint!(m.moibackend, f, s)::ConstraintIndex{F,S} \n",
    "    cref = ConstraintRef(m, cindex)::ConstraintRef{ConstraintIndex{F,S}}\n",
    "    if !isempty(name)\n",
    "        MOI.set!(m.moibackend, MOI.ConstraintName(), cindex,name)\n",
    "    end\n",
    "    return cref\n",
    "end\n",
    "```\n",
    "JuMP constraint:\n",
    "```julia\n",
    "struct ConstraintRef{C}\n",
    "    m::Model\n",
    "    index::C             # C = ConstraintIndex{F,S} for some F,S\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can recover MOI constraints and variables by their \"name\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend, MOI.ConstraintIndex, \"inequality\")  == inequality.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend, MOI.VariableIndex, \"x\")  == x.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and get the name of a constraint or variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend, MOI.ConstraintName(),inequality.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend, MOI.VariableName(),x.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Simpler syntax to get name of JuMP variable will be available by [v0.19 release](https://github.com/JuliaOpt/JuMP.jl/issues/1184) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### JuMP does store dictionary to recover variables/constraints by symbol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model[:x] == x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model[:inequality] == inequality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "usefull when working with multiple models with same names:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1 = Model(with_optimizer(GLPK.GLPKOptimizerLP))\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.GLPKOptimizerLP))\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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inequality"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "we can recover `inequality` for `model1` from `model1[...]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "@variable(model, x[1:3] >= 0, basename=\"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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x[2].index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MOI variable name: a unique string associated to a MOI variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend, MOI.VariableName(),y.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.get(model.moibackend, MOI.VariableName(),x[2].index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MOI.set!(model.moibackend, MOI.VariableName(),x[3].index,\"lastXvar\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y.m == model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Container of JuMP variables: well... a container of `JuMP.VariableRef` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interesting Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "x = @variable(model, [1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "@variable(model, [1:3], basename=string(rand()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using DataStructures\n",
    "myvariables = Stack(JuMP.VariableRef)\n",
    "model = Model(with_optimizer(GLPK.GLPKOptimizerLP))\n",
    "push!(myvariables,@variable(model, y >= 0))\n",
    "push!.(myvariables,@variable(model, z[1:3] >= 0))\n",
    "pop!(myvariables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@show myvariables"
   ]
  }
 ],
 "metadata": {
  "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"
  },
  "livereveal": {
   "scroll": true
  },
  "rise": {
   "scroll": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}