HAshi puzzle-git.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "eba21227",
   "metadata": {},
   "outputs": [],
   "source": [
    "from shapely.geometry import LineString\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random \n",
    "import pandas as pd\n",
    "from pyomo.environ import *\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "30fef048",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "6 6\n",
      "0 0 1\n",
      "0 2 4\n",
      "0 5 3\n",
      "2 0 4\n",
      "2 2 7\n",
      "2 4 3\n",
      "3 1 2\n",
      "3 3 2\n",
      "3 5 3\n",
      "4 0 2\n",
      "4 2 1\n",
      "4 4 1\n",
      "5 1 3\n",
      "5 3 5\n",
      "5 5 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(     a    b    c    d    e    f\n",
       " 0  1.0  0.0  4.0  0.0  2.0  0.0\n",
       " 1  0.0  0.0  0.0  2.0  0.0  3.0\n",
       " 2  4.0  0.0  7.0  0.0  1.0  0.0\n",
       " 3  0.0  0.0  0.0  2.0  0.0  5.0\n",
       " 4  0.0  0.0  3.0  0.0  1.0  0.0\n",
       " 5  3.0  0.0  0.0  3.0  0.0  3.0,\n",
       " {(1, 'x'): 0,\n",
       "  (1, 'y'): 0,\n",
       "  (1, 'v'): 1,\n",
       "  (2, 'x'): 0,\n",
       "  (2, 'y'): 2,\n",
       "  (2, 'v'): 4,\n",
       "  (3, 'x'): 0,\n",
       "  (3, 'y'): 5,\n",
       "  (3, 'v'): 3,\n",
       "  (4, 'x'): 2,\n",
       "  (4, 'y'): 0,\n",
       "  (4, 'v'): 4,\n",
       "  (5, 'x'): 2,\n",
       "  (5, 'y'): 2,\n",
       "  (5, 'v'): 7,\n",
       "  (6, 'x'): 2,\n",
       "  (6, 'y'): 4,\n",
       "  (6, 'v'): 3,\n",
       "  (7, 'x'): 3,\n",
       "  (7, 'y'): 1,\n",
       "  (7, 'v'): 2,\n",
       "  (8, 'x'): 3,\n",
       "  (8, 'y'): 3,\n",
       "  (8, 'v'): 2,\n",
       "  (9, 'x'): 3,\n",
       "  (9, 'y'): 5,\n",
       "  (9, 'v'): 3,\n",
       "  (10, 'x'): 4,\n",
       "  (10, 'y'): 0,\n",
       "  (10, 'v'): 2,\n",
       "  (11, 'x'): 4,\n",
       "  (11, 'y'): 2,\n",
       "  (11, 'v'): 1,\n",
       "  (12, 'x'): 4,\n",
       "  (12, 'y'): 4,\n",
       "  (12, 'v'): 1,\n",
       "  (13, 'x'): 5,\n",
       "  (13, 'y'): 1,\n",
       "  (13, 'v'): 3,\n",
       "  (14, 'x'): 5,\n",
       "  (14, 'y'): 3,\n",
       "  (14, 'v'): 5,\n",
       "  (15, 'x'): 5,\n",
       "  (15, 'y'): 5,\n",
       "  (15, 'v'): 3})"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L1 = [(0, 0), (13, 1)]\n",
    "L2 = [(0.2, 3), (4.2, 3)]\n",
    "\n",
    "line = LineString([L1[0], L1[1]])\n",
    "other = LineString([L2[0], L2[1]])\n",
    "print(line.intersects(other))\n",
    "# True\n",
    "df= pd.read_csv('Hashi4.csv')\n",
    "df= pd.read_csv('Hashi3.csv')\n",
    "df= pd.read_csv('Hashi2.csv')\n",
    "\n",
    "df= df.fillna(0) \n",
    "df\n",
    "\n",
    "xmax = len(df.columns) \n",
    "ymax =len(df)\n",
    "print(xmax ,ymax)\n",
    "\n",
    "data, points, c ={}, {}, 0\n",
    "for x in range(xmax):\n",
    "    for y in range(ymax):\n",
    "        if int(df.iloc[y,x]) >0:\n",
    "            c+=1\n",
    "            data[c,'x'] =x\n",
    "            data[c,'y'] =y\n",
    "            data[c,'v'] =int(df.iloc[y,x])\n",
    "            print(x,y,int(df.iloc[y,x]))\n",
    "        \n",
    "data\n",
    "Nc = c\n",
    "\n",
    "points = [i for i in range(1,1+Nc)]\n",
    "\n",
    "lines , ALL_lines= {}, {}\n",
    "for c1 in points:\n",
    "    for c2 in points: \n",
    "        condition1 = data[c1,'x'] == data[c2,'x']\n",
    "        condition2 = data[c1,'y'] == data[c2,'y']\n",
    "        if c1!=c2 and (condition1 or condition2) and c1>c2:\n",
    "            lines[c1,c2] = 1\n",
    "        if c1!=c2 and (condition1 or condition2):\n",
    "            ALL_lines[c1,c2] = 1\n",
    "            \n",
    "lines   \n",
    "df, data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "64db34a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw(L, LW=1):\n",
    "    if LW > 1:\n",
    "        LW =8\n",
    "        plt.plot([L[0][0],L[1][0]], [L[0][1],L[1][1]], lw=LW)\n",
    "    else:\n",
    "        plt.plot([L[0][0],L[1][0]], [L[0][1],L[1][1]], lw=2, c= 'k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ae24a197",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = AbstractModel()\n",
    "model.i = RangeSet(Nc)\n",
    "model.j = Set(initialize=model.i)\n",
    "\n",
    "model.X = Var(model.i,model.j,bounds=(0,2),initialize=0, within=Integers)\n",
    "model.U = Var(model.i,model.j,bounds=(0,1),initialize=0, within=Binary)\n",
    "model.flow = Var(model.i,model.j,bounds=(0,1),initialize=0, within=Reals)\n",
    "model.s = Var(bounds=(0,1),initialize=0, within=Reals)\n",
    "\n",
    "\n",
    "def rule_C1(model,c): \n",
    "    return   data[c,'v'] == sum(model.X[c,j] for j in model.j if (c,j) in lines) +\\\n",
    "                            sum(model.X[j,c] for j in model.j if (j,c) in lines)\n",
    "model.C1 = Constraint(model.i,rule=rule_C1)\n",
    "\n",
    "\n",
    "def rule_C2(model,m,n,i,j): \n",
    "    L1 = [(data[i,'x'],data[i,'y']), (data[j,'x'],data[j,'y'])]\n",
    "    L2 = [(data[m,'x'],data[m,'y']), (data[n,'x'],data[n,'y'])]\n",
    "    line = LineString([L1[0], L1[1]])\n",
    "    other = LineString([L2[0], L2[1]])\n",
    "    a = line.intersection(other)\n",
    "    a = line.intersection(other)\n",
    "    cancel_con = len(set([i,j,m,n])) <4\n",
    "    con0 = (m,n) in lines and (i,j) in lines and (m,n)!=(i,j) and (m*n>i*j)\n",
    "    con1 = con0 and (not cancel_con) and line.intersects(other)\n",
    "    con2 = con0 and (cancel_con and a.length> 1) and line.intersects(other) and (m,n)!=(i,j) and (m*n>i*j)\n",
    "\n",
    "    if con1 or con2:\n",
    "        return   model.U[i,j]+model.U[m,n] <= 1\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C2 = Constraint(model.i,model.i,model.i,model.i, rule=rule_C2)\n",
    "\n",
    "\n",
    "def rule_C3(model,i,j):\n",
    "    if (i,j) in lines:\n",
    "        return   model.X[i,j]<= 2*model.U[i,j]\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C3 = Constraint(model.i,model.j, rule=rule_C3)\n",
    "\n",
    "def rule_C3B(model,i,j):\n",
    "    if (i,j) in lines:\n",
    "        return   model.X[i,j]>= model.U[i,j]\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C3B = Constraint(model.i,model.j, rule=rule_C3B)\n",
    "\n",
    "\n",
    "def rule_C4A(model,i):\n",
    "    if i ==1 :\n",
    "        return model.s - 0.001 == sum( model.flow[i,j]-model.flow[j,i] for j in model.j if (i,j) in ALL_lines ) \n",
    "    else:\n",
    "        return         - 0.001 == sum( model.flow[i,j]-model.flow[j,i] for j in model.j if (i,j) in ALL_lines ) \n",
    "model.C4A = Constraint(model.i, rule=rule_C4A)\n",
    "\n",
    "def rule_C4B(model,i,j):\n",
    "    if (i,j) in lines:\n",
    "        return   model.flow[i,j]<= model.U[i,j]\n",
    "    elif (j,i) in lines:\n",
    "        return   model.flow[i,j]<= model.U[j,i]\n",
    "    else:\n",
    "        return Constraint.Skip\n",
    "model.C4B = Constraint(model.i,model.j, rule=rule_C4B)\n",
    "\n",
    "def rule_OF(model):\n",
    "    return  sum(model.U[i,j] for (i,j) in lines) \n",
    "model.obj1 = Objective(rule=rule_OF, sense=minimize)\n",
    "instance = model.create_instance()  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "15ebe5ef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is feasible and optimal and nothing more\n",
      "OF=  14.0\n"
     ]
    }
   ],
   "source": [
    "opt = SolverFactory('cbc')\n",
    "opt.options = {'sec': 600, 'threads': 4, 'ratio': 0.1}\n",
    "results = opt.solve(instance)\n",
    "\n",
    "from pyomo.opt import SolverStatus, TerminationCondition\n",
    "if (results.solver.status == SolverStatus.ok) and (results.solver.termination_condition == TerminationCondition.optimal):\n",
    "     print (\"this is feasible and optimal and nothing more\")\n",
    "elif results.solver.termination_condition == TerminationCondition.infeasible:\n",
    "     print (\"do something about it? or exit?\")\n",
    "else:\n",
    "     print ('ERROR ' + str(results.solver))\n",
    "print('OF= ', value(instance.obj1) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8c04ae2a",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 1 1.0\n",
      "3 2 1.0\n",
      "5 2 2.0\n",
      "5 4 2.0\n",
      "6 5 2.0\n",
      "9 3 2.0\n",
      "10 4 2.0\n",
      "11 5 1.0\n",
      "12 6 1.0\n",
      "13 7 2.0\n",
      "14 8 2.0\n",
      "14 13 1.0\n",
      "15 9 1.0\n",
      "15 14 2.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for i in instance.i:\n",
    "    plt.scatter(data[i,'x'],data[i,'y'],s=900, c='k', zorder=3)\n",
    "    plt.text(data[i,'x']-0.1,data[i,'y'],s=str(data[i,'v']), c='w', fontweight='bold', fontsize=14)\n",
    "    \n",
    "plt.savefig(f'Sashi Base .png', format='png', dpi=400)\n",
    "\n",
    "plt.grid()\n",
    "maxx, maxy= max([data[c,'x'] for c in instance.i])+1 ,  max([data[c,'y'] for c in instance.i])+1\n",
    "counter = 1\n",
    "for (i,j) in lines:\n",
    "    if value(instance.X[i,j])>0 and counter <500:\n",
    "        print(i,j, value(instance.X[i,j]))\n",
    "        L = [(data[i,'x'],data[i,'y']), (data[j,'x'],data[j,'y'])]\n",
    "        draw(L, value(instance.X[i,j]))        \n",
    "        plt.xticks(range(maxx))\n",
    "        plt.yticks(range(maxy))\n",
    "        counter+=1\n",
    "\n",
    "plt.xticks(range(maxx))\n",
    "plt.yticks(range(maxy))\n",
    "plt.grid()\n",
    "\n",
    "plt.savefig(f'Sashi  .png', format='png', dpi=400)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1de93e68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "\n",
    "for i in instance.i:\n",
    "    plt.scatter(data[i,'x'],data[i,'y'],s=900, c='k')\n",
    "    plt.text(data[i,'x']-0.16,data[i,'y'],s=str(i), c='w', fontweight='bold', fontsize=14)\n",
    "    \n",
    "plt.grid()\n",
    "plt.xticks(range(maxx))\n",
    "plt.yticks(range(maxy))\n",
    "\n",
    "plt.show()"
   ]
  }
 ],
 "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": 5
}