Empty-Bucket-Github.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyomo.environ import *\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random \n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "init = [3,4,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = len(init)\n",
    "BigM = sum(init)\n",
    "\n",
    "model = AbstractModel()\n",
    "model.i = RangeSet(N)\n",
    "model.j = Set(initialize = model.i)\n",
    "model.t = RangeSet(8)\n",
    "model.U = Var(model.i,model.j, model.t, initialize = 0, within=Binary)\n",
    "model.move = Var(model.i,model.j, model.t, initialize = 0, bounds=(0,BigM/2), within=NonNegativeReals)\n",
    "model.v = Var(model.i,model.t, initialize = 0, bounds=(0,BigM), within=NonNegativeReals)\n",
    "model.P = Var(model.i,model.t, initialize = 0, within=Binary)\n",
    "model.z = Var(model.t, initialize = 0, bounds=(0,1), within=NonNegativeReals)\n",
    "\n",
    "def Rule_C1(model,i,t):\n",
    "    if t>1:\n",
    "        return model.v[i,t]== model.v[i,t-1]- sum(model.move[i,j,t-1]-model.move[j,i,t-1] for j in model.j if i!=j)\n",
    "    else:\n",
    "        return model.v[i,t]==init[i-1]\n",
    "model.C1=Constraint(model.i, model.t, rule=Rule_C1)\n",
    "\n",
    "def Rule_C3(model,i,j,t):\n",
    "    if i!=j:\n",
    "        return model.move[i,j,t] <= BigM * model.U[i,j,t]\n",
    "    else:\n",
    "        return Constraint.Skip \n",
    "model.C3=Constraint(model.i, model.j, model.t, rule=Rule_C3)\n",
    "\n",
    "def Rule_C4A(model,i,t):\n",
    "    if t>1:\n",
    "        return -(model.v[i,t]-2*model.v[i,t-1]) <= BigM * (1- sum(model.U[j,i,t-1] for j in model.j if i!=j) )\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C4A=Constraint(model.i, model.t, rule=Rule_C4A)\n",
    "\n",
    "def Rule_C4B(model,i,t):\n",
    "    if t>1:\n",
    "        return model.v[i,t]-2*model.v[i,t-1] <= BigM * (1- sum(model.U[j,i,t-1] for j in model.j if i!=j) )\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C4B=Constraint(model.i, model.t, rule=Rule_C4B)\n",
    "\n",
    "def Rule_C5(model,t):\n",
    "    return sum(model.U[i,j,t] for i in model.i for j in model.j if i!=j) <= model.z[t]\n",
    "model.C5=Constraint(model.t, rule=Rule_C5)\n",
    "\n",
    "def Rule_C6(model,i,t):\n",
    "    return model.v[i,t] <= BigM * (1- model.P[i,t])\n",
    "model.C6=Constraint(model.i,model.t, rule=Rule_C6)\n",
    "\n",
    "def Rule_C7(model):\n",
    "    return sum(model.P[i,t] for i in model.i for t in model.t ) >= 1\n",
    "model.C7=Constraint( rule=Rule_C7)\n",
    "\n",
    "def Rule_C8(model,i,t):\n",
    "    return model.z[t]<= 1-model.P[i,t] \n",
    "model.C8=Constraint(model.i,model.t, rule=Rule_C8)\n",
    "\n",
    "def Rule_C9(model,t):\n",
    "    if t>1:\n",
    "        return model.z[t]<=model.z[t-1]\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C9=Constraint(model.t, rule=Rule_C9)\n",
    "\n",
    "def rule_OF(model):\n",
    "    return sum(t*model.z[t] for t in model.t)\n",
    "model.obj = Objective(rule=rule_OF, sense=minimize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "opt = SolverFactory('cbc')\n",
    "instance = model.create_instance()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "feasible\n",
      "10.0\n"
     ]
    }
   ],
   "source": [
    "results = opt.solve(instance, options={\"threads\": 8, 'rel_gap':0.1})\n",
    "if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):\n",
    "    print('feasible')\n",
    "elif (results.solver.termination_condition == TerminationCondition.infeasible):\n",
    "    print('infeasible')\n",
    "else:\n",
    "    print ('Solver Status:',  results.solver.status)\n",
    "print(value(instance.obj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}