MPC_New_with_waypoints.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt \n",
    "from casadi import *\n",
    "import scipy.interpolate\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from casadi import *\n",
    "from numpy import *\n",
    "%matplotlib inline\n",
    "#import matplotlib\n",
    "#matplotlib.use('TkAgg')\n",
    "import matplotlib.pyplot as plt\n",
    "class Iteration_Callback(Callback):\n",
    "    def __init__(self, name, nx, ng, opts={}):\n",
    "        Callback.__init__(self)\n",
    "\n",
    "        self.nx = nx\n",
    "        self.ng = ng\n",
    "\n",
    "        self.x_sols = []\n",
    "        self.f_sols = []\n",
    "        self.g_sols = []\n",
    "        self.lam_x_sols = []\n",
    "        self.lam_g_sols = []\n",
    "        self.lam_p_sols = []\n",
    "        '''\n",
    "        #for plotting the graph in realtime\n",
    "        self.fig= plt.figure()\n",
    "        self.ax1= self.fig.add_subplot(1,2,1)\n",
    "        self.ax2= self.fig.add_subplot(2,2,1)\n",
    "        self.fig.show()\n",
    "        '''\n",
    "        # Initialize internal objects\n",
    "        self.construct(name, opts)\n",
    "\n",
    "    def get_n_in(self): return nlpsol_n_out()\n",
    "    def get_n_out(self): return 1\n",
    "    def get_name_in(self, i): return nlpsol_out(i)\n",
    "    def get_name_out(self, i): return \"ret\"\n",
    "\n",
    "    def get_sparsity_in(self, i):\n",
    "        n = nlpsol_out(i)\n",
    "        if n == 'f':\n",
    "            return Sparsity.scalar()\n",
    "        elif n in ('x', 'lam_x'):\n",
    "            return Sparsity.dense(self.nx)\n",
    "        elif n in ('g', 'lam_g'):\n",
    "            return Sparsity.dense(self.ng)\n",
    "        else:\n",
    "            return Sparsity(0, 0)\n",
    "\n",
    "    def eval(self, arg):\n",
    "        \n",
    "        darg = {}\n",
    "        for (i, s) in enumerate(nlpsol_out()): darg[s] = arg[i]\n",
    "        x_sol = [float(elem) for elem in darg['x'].full()]\n",
    "        \n",
    "        self.x_sols.append(x_sol)\n",
    "        self.f_sols.append(darg['f'].full()[0][0])\n",
    "        self.g_sols.append(darg['g'].full()[0][0])\n",
    "        self.lam_x_sols.append(darg['lam_x'].full())\n",
    "        self.lam_g_sols.append(darg['lam_g'].full())\n",
    "        self.lam_p_sols.append(darg['lam_p'].full())\n",
    "        #print(\"solution\",self.f_sols)\n",
    "        '''\n",
    "        #for plotting the graph in realtime\n",
    "        self.ax1.plot(self.x_sols)\n",
    "        self.ax2.plot(self.f_sols)\n",
    "        self.fig.canvas.draw()\n",
    "        self.fig.canvas.flush_events()\n",
    "        plt.show()\n",
    "        '''\n",
    "        plt.plot(self.f_sols,color='C0')\n",
    "        #plt.plot(self.g_sols,color='C0')\n",
    "        #print(self.g_sols)\n",
    "        return[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "[ang_0, ang_1, ang_2, ang_3, ang_4, ang_5, ang_6, ang_7, ang_8, ang_9, ang_10, ang_11, ang_12, ang_13, ang_14, ang_15, ang_16, ang_17, ang_18, ang_19, ang_20, ang_21, ang_22, ang_23, ang_24, ang_25, ang_26, ang_27, ang_28, ang_29]\n",
      "@1=0.00045, @2=1.2, @3=(((v/@2)*tan(ang_0))*t1), @4=(@3+(((v/@2)*tan(ang_1))*t1)), @5=(@4+(((v/@2)*tan(ang_2))*t1)), @6=(@5+(((v/@2)*tan(ang_3))*t1)), @7=(@6+(((v/@2)*tan(ang_4))*t1)), @8=(@7+(((v/@2)*tan(ang_5))*t1)), @9=(@8+(((v/@2)*tan(ang_6))*t1)), @10=(@9+(((v/@2)*tan(ang_7))*t1)), @11=(@10+(((v/@2)*tan(ang_8))*t1)), @12=(@11+(((v/@2)*tan(ang_9))*t1)), @13=(@12+(((v/@2)*tan(ang_10))*t1)), @14=(@13+(((v/@2)*tan(ang_11))*t1)), @15=(@14+(((v/@2)*tan(ang_12))*t1)), @16=(@15+(((v/@2)*tan(ang_13))*t1)), @17=(((((((((((((((v*t1)+((v*cos(@3))*t1))+((v*cos(@4))*t1))+((v*cos(@5))*t1))+((v*cos(@6))*t1))+((v*cos(@7))*t1))+((v*cos(@8))*t1))+((v*cos(@9))*t1))+((v*cos(@10))*t1))+((v*cos(@11))*t1))+((v*cos(@12))*t1))+((v*cos(@13))*t1))+((v*cos(@14))*t1))+((v*cos(@15))*t1))+((v*cos(@16))*t1)), @18=2, @19=(((((((((((((((v*sin(@3))*t1)+((v*sin(@4))*t1))+((v*sin(@5))*t1))+((v*sin(@6))*t1))+((v*sin(@7))*t1))+((v*sin(@8))*t1))+((v*sin(@9))*t1))+((v*sin(@10))*t1))+((v*sin(@11))*t1))+((v*sin(@12))*t1))+((v*sin(@13))*t1))+((v*sin(@14))*t1))+((v*sin(@15))*t1))+((v*sin(@16))*t1)), @20=(@16+(((v/@2)*tan(ang_14))*t1)), @21=(@20+(((v/@2)*tan(ang_15))*t2)), @22=(@21+(((v/@2)*tan(ang_16))*t2)), @23=(@22+(((v/@2)*tan(ang_17))*t2)), @24=(@23+(((v/@2)*tan(ang_18))*t2)), @25=(@24+(((v/@2)*tan(ang_19))*t2)), @26=(@25+(((v/@2)*tan(ang_20))*t2)), @27=(@26+(((v/@2)*tan(ang_21))*t2)), @28=(@27+(((v/@2)*tan(ang_22))*t2)), @29=(@28+(((v/@2)*tan(ang_23))*t2)), @30=(@29+(((v/@2)*tan(ang_24))*t2)), @31=(@30+(((v/@2)*tan(ang_25))*t2)), @32=(@31+(((v/@2)*tan(ang_26))*t2)), @33=(@32+(((v/@2)*tan(ang_27))*t2)), @34=(@33+(((v/@2)*tan(ang_28))*t2)), @35=-0.0177, @36=1.48, @37=3.39, ((sqrt(((@1+sq((@17-@18)))+sq((@19-1))))+sqrt(((@1+sq(((((((((((((((((@17+((v*cos(@20))*t2))+((v*cos(@21))*t2))+((v*cos(@22))*t2))+((v*cos(@23))*t2))+((v*cos(@24))*t2))+((v*cos(@25))*t2))+((v*cos(@26))*t2))+((v*cos(@27))*t2))+((v*cos(@28))*t2))+((v*cos(@29))*t2))+((v*cos(@30))*t2))+((v*cos(@31))*t2))+((v*cos(@32))*t2))+((v*cos(@33))*t2))+((v*cos(@34))*t2))-3)))+sq(((((((((((((((((@19+((v*sin(@20))*t2))+((v*sin(@21))*t2))+((v*sin(@22))*t2))+((v*sin(@23))*t2))+((v*sin(@24))*t2))+((v*sin(@25))*t2))+((v*sin(@26))*t2))+((v*sin(@27))*t2))+((v*sin(@28))*t2))+((v*sin(@29))*t2))+((v*sin(@30))*t2))+((v*sin(@31))*t2))+((v*sin(@32))*t2))+((v*sin(@33))*t2))+((v*sin(@34))*t2))-@18)))))+((((((((((((((((((((((((((((((((@35*sq(v))+(@36*v))+@37)+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37))+(((@35*sq(v))+(@36*v))+@37)))\n",
      "g 0\n",
      "F:(x0[33],p[],lbx[33],ubx[33],lbg,ubg,lam_x0[33],lam_g0)->(x[33],f,g,lam_x[33],lam_g,lam_p[]) IpoptInterface\n"
     ]
    }
   ],
   "source": [
    "from casadi import *\n",
    "import math\n",
    "dest = [3,2]\n",
    "way = [2,1]\n",
    "obs = [6,5.7]\n",
    "#t=MX.sym('t')\n",
    "#v=MX.sym('v')\n",
    "dt=30\n",
    "dt1=int(dt/2)\n",
    "print(dt1)\n",
    "rob_rad=0.1\n",
    "obs_rad=0.1\n",
    "ang=SX.sym(\"ang\",dt)\n",
    "v=SX.sym(\"v\")\n",
    "t1=SX.sym(\"t1\")\n",
    "t2=SX.sym(\"t2\")\n",
    "print(ang)\n",
    "func,func1,func2=0,0,0\n",
    "g=0\n",
    "theta=0\n",
    "fuel_cost=0\n",
    "coff=0.00045\n",
    "for i in range(0,dt1):\n",
    "    func1=func1+v*cos(theta)*t1\n",
    "    func2=func2+v*sin(theta)*t1\n",
    "    theta=theta + (v / 1.2)*tan(ang[i])*t1\n",
    "    fuel_cost+=(-0.0177*v**2+1.48*v+3.39)\n",
    "    if i==dt1-1:\n",
    "            func_con=(sqrt(coff+(func1-way[0])**2+(func2-way[1])**2))\n",
    "for i in range(dt1,dt):\n",
    "        func1=func1+v*cos(theta)*t2\n",
    "        func2=func2+v*sin(theta)*t2\n",
    "        theta=theta + (v / 1.2)*tan(ang[i])*t2\n",
    "        fuel_cost+=(-0.0177*v**2+1.48*v+3.39)\n",
    "        if i==dt-1:\n",
    "            func=func_con+(sqrt(coff+(func1-dest[0])**2+(func2-dest[1])**2))+fuel_cost\n",
    "            #g=sqrt(coff+(func1-obs[0])**2+(func2-obs[1])**2)-(rob_rad+obs_rad)\n",
    "            #g=func_con\n",
    "            print(func)     \n",
    "            print(\"g\",g)\n",
    "nlp= {}\n",
    "nlp['x']=vertcat(ang,v,t1,t2)\n",
    "#nlp['x']=vertcat(v,t) \n",
    "nlp['f']=func\n",
    "nlp['g']=g\n",
    "mycallback = Iteration_Callback('mycallback',(dt+3), 1)\n",
    "opts = {}\n",
    "opts['iteration_callback'] = mycallback\n",
    "opts['ipopt.tol'] = 1e-5\n",
    "opts[\"ipopt.max_iter\"]=50000\n",
    "#create solver instance\n",
    "F = nlpsol('F','ipopt',nlp,opts);\n",
    "#F=qpsol('F','qpoases',nlp);\n",
    "print(F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.002, 0.2, 0.2, 0.2]\n",
      "This is Ipopt version 3.12.3, running with linear solver mumps.\n",
      "NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n",
      "\n",
      "Number of nonzeros in equality constraint Jacobian...:        0\n",
      "Number of nonzeros in inequality constraint Jacobian.:        0\n",
      "Number of nonzeros in Lagrangian Hessian.............:      528\n",
      "\n",
      "Total number of variables............................:       33\n",
      "                     variables with only lower bounds:        0\n",
      "                variables with lower and upper bounds:       33\n",
      "                     variables with only upper bounds:        0\n",
      "Total number of equality constraints.................:        0\n",
      "Total number of inequality constraints...............:        1\n",
      "        inequality constraints with only lower bounds:        0\n",
      "   inequality constraints with lower and upper bounds:        0\n",
      "        inequality constraints with only upper bounds:        0\n",
      "\n",
      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
      "   0 1.1496685e+002 0.00e+000 3.77e+001  -1.0 0.00e+000    -  0.00e+000 0.00e+000   0\n",
      "   1 1.0834272e+002 0.00e+000 3.46e+001  -1.0 3.23e-001   2.0 8.81e-001 5.52e-001f  1\n",
      "   2 1.0853882e+002 0.00e+000 1.31e+001  -1.0 5.42e-001    -  3.16e-001 1.00e+000f  1\n",
      "   3 1.0790992e+002 0.00e+000 3.78e+000  -1.0 5.13e-002   1.5 9.96e-001 6.23e-001f  1\n",
      "   4 1.0501138e+002 0.00e+000 3.32e+000  -1.0 4.24e+000    -  1.23e-001 1.00e+000f  1\n",
      "   5 1.0371772e+002 0.00e+000 2.70e+002  -1.0 2.11e+000    -  6.05e-001 1.00e+000f  1\n",
      "   6 1.0310699e+002 0.00e+000 3.60e+001  -1.0 6.91e-002   1.0 1.00e+000 2.01e-001f  2\n",
      "   7 1.0316676e+002 0.00e+000 2.56e+001  -1.0 5.50e-001    -  1.00e+000 1.00e+000f  1\n",
      "   8 1.0328812e+002 0.00e+000 6.08e+000  -1.0 6.94e-002    -  1.00e+000 1.00e+000f  1\n",
      "   9 1.0328890e+002 0.00e+000 7.17e-003  -1.0 2.81e-002    -  1.00e+000 1.00e+000f  1\n",
      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
      "  10 1.0285187e+002 0.00e+000 3.21e+001  -2.5 5.86e-001    -  8.48e-001 1.00e+000f  1\n",
      "  11 1.0281870e+002 0.00e+000 2.08e+001  -2.5 5.12e-001    -  6.19e-001 5.00e-001f  2\n",
      "  12 1.0278698e+002 0.00e+000 2.35e+001  -2.5 1.74e-002   0.6 1.00e+000 1.00e+000f  1\n",
      "  13 1.0275979e+002 0.00e+000 3.88e-001  -2.5 2.32e-001    -  8.64e-001 2.50e-001f  3\n",
      "  14 1.0274185e+002 0.00e+000 3.13e+000  -2.5 2.89e-001    -  1.00e+000 3.65e-001f  2\n",
      "  15 1.0273129e+002 0.00e+000 5.31e-001  -2.5 3.56e-002    -  1.00e+000 1.00e+000f  1\n",
      "  16 1.0273090e+002 0.00e+000 3.91e-003  -2.5 2.73e-003    -  1.00e+000 1.00e+000f  1\n",
      "  17 1.0269429e+002 0.00e+000 4.87e+000  -3.8 9.32e-002    -  7.81e-001 1.00e+000f  1\n",
      "  18 1.0268226e+002 0.00e+000 8.01e-002  -3.8 9.99e-002    -  9.40e-001 1.00e+000f  1\n",
      "  19 1.0268114e+002 0.00e+000 1.38e-001  -3.8 5.19e-002    -  1.00e+000 1.00e+000f  1\n",
      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
      "  20 1.0268116e+002 0.00e+000 2.30e-002  -3.8 1.60e-002    -  1.00e+000 1.00e+000f  1\n",
      "  21 1.0268115e+002 0.00e+000 6.51e-007  -3.8 1.92e-004    -  1.00e+000 1.00e+000f  1\n",
      "  22 1.0267815e+002 0.00e+000 1.98e-001  -5.7 5.44e-002    -  7.13e-001 8.18e-001f  1\n",
      "  23 1.0267720e+002 0.00e+000 8.86e-002  -5.7 6.39e-002    -  9.01e-001 1.00e+000f  1\n",
      "  24 1.0267718e+002 0.00e+000 3.42e-004  -5.7 8.70e-003    -  1.00e+000 1.00e+000f  1\n",
      "  25 1.0267718e+002 0.00e+000 1.55e-008  -5.7 8.48e-005    -  1.00e+000 1.00e+000f  1\n",
      "\n",
      "Number of Iterations....: 25\n",
      "\n",
      "                                   (scaled)                 (unscaled)\n",
      "Objective...............:  1.0267718356884410e+002   1.0267718356884410e+002\n",
      "Dual infeasibility......:  1.5513398102523706e-008   1.5513398102523706e-008\n",
      "Constraint violation....:  0.0000000000000000e+000   0.0000000000000000e+000\n",
      "Complementarity.........:  1.8449213933308287e-006   1.8449213933308287e-006\n",
      "Overall NLP error.......:  1.8449213933308287e-006   1.8449213933308287e-006\n",
      "\n",
      "\n",
      "Number of objective function evaluations             = 47\n",
      "Number of objective gradient evaluations             = 26\n",
      "Number of equality constraint evaluations            = 0\n",
      "Number of inequality constraint evaluations          = 47\n",
      "Number of equality constraint Jacobian evaluations   = 0\n",
      "Number of inequality constraint Jacobian evaluations = 26\n",
      "Number of Lagrangian Hessian evaluations             = 25\n",
      "Total CPU secs in IPOPT (w/o function evaluations)   =      0.075\n",
      "Total CPU secs in NLP function evaluations           =      0.009\n",
      "\n",
      "EXIT: Optimal Solution Found.\n",
      "           F  :   t_proc      (avg)   t_wall      (avg)    n_eval\n",
      "callback_fun  |  61.00ms (  2.35ms)  60.70ms (  2.33ms)        26\n",
      "       nlp_f  |        0 (       0)        0 (       0)        47\n",
      "       nlp_g  |        0 (       0)        0 (       0)        47\n",
      "  nlp_grad_f  |   2.00ms ( 74.07us)   1.96ms ( 72.56us)        27\n",
      "  nlp_hess_l  |   5.00ms (200.00us)   4.87ms (194.92us)        25\n",
      "   nlp_jac_g  |        0 (       0)        0 (       0)        27\n",
      "       total  |  85.00ms ( 85.00ms)  85.10ms ( 85.10ms)         1\n",
      "solved output [DM([0.449993, 0.449992, 0.449992, 0.449991, 0.44999, 0.449989, 0.449987, 0.449985, 0.449983, 0.449978, 0.449971, 0.449957, 0.449914, 0.107517, 0.00210604, 0.00218824, 0.00220272, 0.0022196, 0.00223956, 0.0022635, 0.00229276, 0.00232933, 0.00237634, 0.002439, 0.0025267, 0.00265819, 0.00287715, 0.00331444, 0.0046211, 0.226, 0.02, 7.80628, 4.71099])]\n",
      "solved function output 102.677\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#solver=F(x0=[0.1,2],lbx=lbx,ubx=ubx)\n",
    "x0=[]\n",
    "lbx=[]\n",
    "ubx=[]\n",
    "# the loop for setting angle\n",
    "for i in range(0,dt):\n",
    "    x0.append(0.002)\n",
    "    lbx.append(0.002)\n",
    "    #ubx.append(0.5)  #previous value\n",
    "    ubx.append(0.45)\n",
    "# the loop for setting velocity  \n",
    "for i in range(0,1):\n",
    "    x0.append(0.2)\n",
    "    lbx.append(0.02)\n",
    "    ubx.append(2)\n",
    "# the loop for setting sample time \n",
    "for i in range(0,1):\n",
    "    x0.append(0.2)\n",
    "    lbx.append(0.02)\n",
    "    #ubx.append(2) #previous value\n",
    "    ubx.append(200)\n",
    "for i in range(0,1):\n",
    "    x0.append(0.2)\n",
    "    lbx.append(0.02)\n",
    "    #ubx.append(2) #previous value\n",
    "    ubx.append(200)\n",
    "\n",
    "print(x0)\n",
    "solver=F(x0=x0,lbx=lbx,ubx=ubx)\n",
    "out=[]\n",
    "out.append(solver[\"x\"])\n",
    "print(\"solved output\",out)\n",
    "print(\"solved function output\",solver[\"f\"])\n",
    "plt.legend([\"Cost\"])\n",
    "plt.xlabel(\"Iterations\")\n",
    "plt.ylabel(\"Cost Value\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.04741 0.955973\n",
      "2.99851 2.00135\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Y Coordinate')"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "ang=[]\n",
    "v=[]\n",
    "t1=[]\n",
    "t2=[]\n",
    "for i in range(0,dt):\n",
    "    ang.append(out[0][i])\n",
    "v.append(out[0][dt])\n",
    "t1.append(out[0][dt+1])\n",
    "t2.append(out[0][dt+2])\n",
    "xc,yc=[],[]\n",
    "theta=0.0\n",
    "x1,x2=0,0\n",
    "for i in range(0,dt1):\n",
    "    x1=x1+v[0]*math.cos(theta)*t1[0]\n",
    "    x2=x2+v[0]*math.sin(theta)*t1[0]\n",
    "    theta = theta + (v[0] / 1.2) * math.tan(ang[i])*t1[0]\n",
    "    xc.append(x1)\n",
    "    yc.append(x2)\n",
    "print(x1,x2)\n",
    "for i in range(dt1,dt):\n",
    "    x1=x1+v[0]*math.cos(theta)*t2[0]\n",
    "    x2=x2+v[0]*math.sin(theta)*t2[0]\n",
    "    theta = theta + (v[0] / 1.2) * math.tan(ang[i])*t2[0]\n",
    "    xc.append(x1)\n",
    "    yc.append(x2)\n",
    "print(x1,x2)\n",
    "plt.plot(xc,yc,dest[0],dest[1],\"o\",way[0],way[1],\"D\")#,obs[0],obs[1],\"s\")\n",
    "plt.legend([\"path\", \"destination\",\"waypoint\",\"obstacle\"])\n",
    "plt.xlabel(\"X Coordinate\")\n",
    "plt.ylabel(\"Y Coordinate\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.62031\n"
     ]
    }
   ],
   "source": [
    "x_opt = solver['f']\n",
    "print(x_opt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x2555054b8b0>]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "cost1=[]\n",
    "cost1=[5.1407028e+000,4.8279191e+000 ,\n",
    "    3.2988949e+000, \n",
    "    2.8788262e+000 ,\n",
    "    2.3243103e+000 ,\n",
    "    2.0325987e+000 ,\n",
    "    1.7099310e+000 ,\n",
    "   1.4452566e+000 ,\n",
    "    1.3194831e+000 ,\n",
    "    1.2617696e+000 ,\n",
    "  1.2360491e+000, 1.2009504e+000, \n",
    "   1.1934256e+000 ,\n",
    "   1.1910525e+000 ,\n",
    "   1.1910547e+000 ,\n",
    "   1.1908748e+000 ,\n",
    "   1.1908742e+000 ]\n",
    "plt.plot(cost1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 629,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.821345956502425\n",
      "3.821345956502425\n"
     ]
    }
   ],
   "source": [
    "xv=0\n",
    "x=[]\n",
    "v=0.4\n",
    "a=0.3\n",
    "out1=(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))+(v*cos(a))\n",
    "for i in range(0,10):\n",
    "    xv=xv+v*cos(a)\n",
    "    x.append(xv)\n",
    "print(xv)\n",
    "print(out1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S:(x0[3],p[],lbx[3],ubx[3],lbg,ubg,lam_x0[3],lam_g0)->(x[3],f,g,lam_x[3],lam_g,lam_p[]) IpoptInterface\n"
     ]
    }
   ],
   "source": [
    "x = SX.sym('x'); y = SX.sym('y'); z = SX.sym('z')\n",
    "nlp = {'x':vertcat(x,y,z), 'f':x**2+100*z**2, 'g':z+(1-x)**2-y}\n",
    "S = nlpsol('S', 'ipopt', nlp)\n",
    "print(S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is Ipopt version 3.12.3, running with linear solver mumps.\n",
      "NOTE: Other linear solvers might be more efficient (see Ipopt documentation).\n",
      "\n",
      "Number of nonzeros in equality constraint Jacobian...:        3\n",
      "Number of nonzeros in inequality constraint Jacobian.:        0\n",
      "Number of nonzeros in Lagrangian Hessian.............:        2\n",
      "\n",
      "Total number of variables............................:        3\n",
      "                     variables with only lower bounds:        0\n",
      "                variables with lower and upper bounds:        0\n",
      "                     variables with only upper bounds:        0\n",
      "Total number of equality constraints.................:        1\n",
      "Total number of inequality constraints...............:        0\n",
      "        inequality constraints with only lower bounds:        0\n",
      "   inequality constraints with lower and upper bounds:        0\n",
      "        inequality constraints with only upper bounds:        0\n",
      "\n",
      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
      "   0 6.2500000e+001 0.00e+000 9.00e+001  -1.0 0.00e+000    -  0.00e+000 0.00e+000   0\n",
      "   1 1.8457621e+001 1.48e-002 4.10e+001  -1.0 4.10e-001   2.0 1.00e+000 1.00e+000f  1\n",
      "   2 7.8031530e+000 3.84e-003 8.76e+000  -1.0 2.63e-001   1.5 1.00e+000 1.00e+000f  1\n",
      "   3 7.1678278e+000 9.42e-005 1.04e+000  -1.0 9.32e-002   1.0 1.00e+000 1.00e+000f  1\n",
      "   4 6.7419924e+000 6.18e-003 9.95e-001  -1.0 2.69e-001   0.6 1.00e+000 1.00e+000f  1\n",
      "   5 5.4363330e+000 7.03e-002 1.04e+000  -1.7 8.40e-001   0.1 1.00e+000 1.00e+000f  1\n",
      "   6 1.2144815e+000 1.52e+000 1.32e+000  -1.7 3.21e+000  -0.4 1.00e+000 1.00e+000f  1\n",
      "   7 1.0214718e+000 2.51e-001 1.17e+001  -1.7 1.33e+000   0.9 1.00e+000 1.00e+000h  1\n",
      "   8 3.1864085e-001 1.04e-003 7.53e-001  -1.7 3.58e-001    -  1.00e+000 1.00e+000f  1\n",
      "   9 0.0000000e+000 3.19e-001 0.00e+000  -1.7 5.64e-001    -  1.00e+000 1.00e+000f  1\n",
      "iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls\n",
      "  10 0.0000000e+000 0.00e+000 0.00e+000  -1.7 3.19e-001    -  1.00e+000 1.00e+000h  1\n",
      "\n",
      "Number of Iterations....: 10\n",
      "\n",
      "                                   (scaled)                 (unscaled)\n",
      "Objective...............:  0.0000000000000000e+000   0.0000000000000000e+000\n",
      "Dual infeasibility......:  0.0000000000000000e+000   0.0000000000000000e+000\n",
      "Constraint violation....:  0.0000000000000000e+000   0.0000000000000000e+000\n",
      "Complementarity.........:  0.0000000000000000e+000   0.0000000000000000e+000\n",
      "Overall NLP error.......:  0.0000000000000000e+000   0.0000000000000000e+000\n",
      "\n",
      "\n",
      "Number of objective function evaluations             = 11\n",
      "Number of objective gradient evaluations             = 11\n",
      "Number of equality constraint evaluations            = 11\n",
      "Number of inequality constraint evaluations          = 0\n",
      "Number of equality constraint Jacobian evaluations   = 11\n",
      "Number of inequality constraint Jacobian evaluations = 0\n",
      "Number of Lagrangian Hessian evaluations             = 10\n",
      "Total CPU secs in IPOPT (w/o function evaluations)   =      0.042\n",
      "Total CPU secs in NLP function evaluations           =      0.000\n",
      "\n",
      "EXIT: Optimal Solution Found.\n",
      "           S  :   t_proc      (avg)   t_wall      (avg)    n_eval\n",
      "       nlp_f  |        0 (       0)        0 (       0)        11\n",
      "       nlp_g  |        0 (       0)        0 (       0)        11\n",
      "  nlp_grad_f  |        0 (       0)        0 (       0)        12\n",
      "  nlp_hess_l  |        0 (       0)        0 (       0)        10\n",
      "   nlp_jac_g  |        0 (       0)        0 (       0)        12\n",
      "       total  |  50.00ms ( 50.00ms)  49.87ms ( 49.87ms)         1\n",
      "x_opt:  [0, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "r = S(x0=[2.5,3.0,0.75],lbg=0, ubg=0)\n",
    "x_opt = r['x']\n",
    "print('x_opt: ', x_opt)"
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}