Lec09-solve-ivp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "11bb1de7-631f-49fe-9079-4e9e112ba2f3",
   "metadata": {},
   "source": [
    "#### In Lecture 05 we looked a scipy odeint\n",
    "\n",
    "Here we look at other Scipy builtin functions for ODE solvers.\n",
    "\n",
    "https://docs.scipy.org/doc/scipy/reference/integrate.html\n",
    "\n",
    "```\n",
    "solve_ivp\n",
    "```\n",
    "is a newer form of odeint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4089070a-b391-424c-b674-2859afe82f97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/chrishill/projects/osn/miniconda3/envs/py38/bin/python\n"
     ]
    }
   ],
   "source": [
    "!which python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "85b2aafd-c21c-4203-a182-00b4a24a21ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np\n",
    "from scipy.integrate import odeint, solve_ivp\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Circle\n",
    "from IPython.display import clear_output\n",
    "from IPython.display import Video\n",
    "from celluloid import Camera\n",
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "14b868a8-e031-437e-8d26-832c40b9df0d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 / 10\n",
      "1 / 10\n",
      "2 / 10\n",
      "3 / 10\n",
      "4 / 10\n",
      "5 / 10\n",
      "6 / 10\n",
      "7 / 10\n",
      "8 / 10\n",
      "9 / 10\n",
      "10 / 10\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<video src=\"pendu_animation.mp4\" controls  >\n",
       "      Your browser does not support the <code>video</code> element.\n",
       "    </video>"
      ],
      "text/plain": [
       "<IPython.core.display.Video object>"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pendulum rod lengths (m), bob masses (kg).\n",
    "L1, L2 = 1., 1.\n",
    "m1, m2 = 1., 1.\n",
    "# The gravitational acceleration (m.s-2).\n",
    "g = 9.81\n",
    "\n",
    "def deriv(t, y, L1, L2, m1, m2):\n",
    "# def deriv(y, t, L1, L2, m1, m2):\n",
    "    \"\"\"Return the first derivatives of y = theta1, z1, theta2, z2.\"\"\"\n",
    "    theta1, z1, theta2, z2 = y\n",
    "\n",
    "    c, s = np.cos(theta1-theta2), np.sin(theta1-theta2)\n",
    "\n",
    "    theta1dot = z1\n",
    "    z1dot = (m2*g*np.sin(theta2)*c - m2*s*(L1*z1**2*c + L2*z2**2) -\n",
    "             (m1+m2)*g*np.sin(theta1)) / L1 / (m1 + m2*s**2)\n",
    "    theta2dot = z2\n",
    "    z2dot = ((m1+m2)*(L1*z1**2*s - g*np.sin(theta2) + g*np.sin(theta1)*c) + \n",
    "             m2*L2*z2**2*s*c) / L2 / (m1 + m2*s**2)\n",
    "    return theta1dot, z1dot, theta2dot, z2dot\n",
    "\n",
    "def calc_E(y):\n",
    "    \"\"\"Return the total energy of the system.\"\"\"\n",
    "\n",
    "    th1, th1d, th2, th2d = y.T\n",
    "    V = -(m1+m2)*L1*g*np.cos(th1) - m2*L2*g*np.cos(th2)\n",
    "    T = 0.5*m1*(L1*th1d)**2 + 0.5*m2*((L1*th1d)**2 + (L2*th2d)**2 +\n",
    "            2*L1*L2*th1d*th2d*np.cos(th1-th2))\n",
    "    return T + V\n",
    "\n",
    "# Maximum time, time point spacings and the time grid (all in s).\n",
    "tmax, dt = 1., 0.01\n",
    "t = np.arange(0, tmax+dt, dt)\n",
    "# Initial conditions: theta1, dtheta1/dt, theta2, dtheta2/dt.\n",
    "y0 = np.array([3*np.pi/7, 0, 3*np.pi/4, 0])\n",
    "\n",
    "# Do the numerical integration of the equations of motion\n",
    "# y = odeint(deriv, y0, t, args=(L1, L2, m1, m2))\n",
    "\n",
    "# Do same with solve_ivp\n",
    "yy = solve_ivp(deriv,(0.,1.,),y0,t_eval=t,args=(L1,L2,m1,m2,),rtol=1.e-9)\n",
    "y=yy.y.T\n",
    "\n",
    "# Check that the calculation conserves total energy to within some tolerance.\n",
    "EDRIFT = 0.05\n",
    "# Total energy from the initial conditions\n",
    "E = calc_E(y0)\n",
    "if np.max(np.sum(np.abs(calc_E(y) - E))) > EDRIFT:\n",
    "    sys.exit('Maximum energy drift of {} exceeded.'.format(EDRIFT))\n",
    "\n",
    "# Unpack z and theta as a function of time\n",
    "theta1, theta2 = y[:,0], y[:,2]\n",
    "\n",
    "# Convert to Cartesian coordinates of the two bob positions.\n",
    "x1 = L1 * np.sin(theta1)\n",
    "y1 = -L1 * np.cos(theta1)\n",
    "x2 = x1 + L2 * np.sin(theta2)\n",
    "y2 = y1 - L2 * np.cos(theta2)\n",
    "\n",
    "# Plotted bob circle radius\n",
    "r = 0.05\n",
    "# Plot a trail of the m2 bob's position for the last trail_secs seconds.\n",
    "trail_secs = 1\n",
    "# This corresponds to max_trail time points.\n",
    "max_trail = int(trail_secs / dt)\n",
    "\n",
    "def make_plot(i):\n",
    "    # Plot and save an image of the double pendulum configuration for time\n",
    "    # point i.\n",
    "    # The pendulum rods.\n",
    "    ax.plot([0, x1[i], x2[i]], [0, y1[i], y2[i]], lw=2, c='k')\n",
    "    # Circles representing the anchor point of rod 1, and bobs 1 and 2.\n",
    "    c0 = Circle((0, 0), r/2, fc='k', zorder=10)\n",
    "    c1 = Circle((x1[i], y1[i]), r, fc='b', ec='b', zorder=10)\n",
    "    c2 = Circle((x2[i], y2[i]), r, fc='r', ec='r', zorder=10)\n",
    "    ax.add_patch(c0)\n",
    "    ax.add_patch(c1)\n",
    "    ax.add_patch(c2)\n",
    "\n",
    "    # The trail will be divided into ns segments and plotted as a fading line.\n",
    "    ns = 20\n",
    "    s = max_trail // ns\n",
    "\n",
    "    for j in range(ns):\n",
    "        imin = i - (ns-j)*s\n",
    "        if imin < 0:\n",
    "            continue\n",
    "        imax = imin + s + 1\n",
    "        # The fading looks better if we square the fractional length along the\n",
    "        # trail.\n",
    "        alpha = (j/ns)**2\n",
    "        ax.plot(x2[imin:imax], y2[imin:imax], c='r', solid_capstyle='butt',\n",
    "                lw=2, alpha=alpha)\n",
    "\n",
    "    # Centre the image on the fixed anchor point, and ensure the axes are equal\n",
    "    ax.set_xlim(-L1-L2-r, L1+L2+r)\n",
    "    ax.set_ylim(-L1-L2-r, L1+L2+r)\n",
    "    ax.set_aspect('equal', adjustable='box')\n",
    "    plt.axis('off')\n",
    "    # plt.savefig('frames/_img{:04d}.png'.format(i//di), dpi=72)\n",
    "    # plt.cla()\n",
    "\n",
    "\n",
    "# Make an image every di time points, corresponding to a frame rate of fps\n",
    "# frames per second.\n",
    "# Frame rate, s-1\n",
    "fps = 10\n",
    "di = int(1/fps/dt)\n",
    "fig = plt.figure(figsize=(8.3333, 6.25), dpi=72)\n",
    "ax = fig.add_subplot(111)\n",
    "\n",
    "camera=Camera(fig)\n",
    "\n",
    "for i in range(0, t.size, di):\n",
    "    print(i // di, '/', t.size // di)\n",
    "    make_plot(i)\n",
    "    camera.snap()\n",
    "\n",
    "animation=camera.animate()\n",
    "plt.close()\n",
    "animation.save('pendu_animation.mp4',fps=40)\n",
    "Video(\"pendu_animation.mp4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "ebdf3e84-4ae7-4dd7-8717-776b4e6185a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(101, 4)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(yy.y.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "cb876bfa-e687-445a-b7f2-ceb10bd8ebf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.34639685e+00,  0.00000000e+00,  2.35619449e+00,\n",
       "         0.00000000e+00],\n",
       "       [ 1.34594732e+00, -8.98990453e-02,  2.35608673e+00,\n",
       "        -2.15719903e-02],\n",
       "       [ 1.34459915e+00, -1.79714776e-01,  2.35576222e+00,\n",
       "        -4.33920757e-02],\n",
       "       [ 1.34235358e+00, -2.69364010e-01,  2.35521724e+00,\n",
       "        -6.57078416e-02],\n",
       "       [ 1.33921270e+00, -3.58763857e-01,  2.35444559e+00,\n",
       "        -8.87657543e-02],\n",
       "       [ 1.33517941e+00, -4.47831821e-01,  2.35343864e+00,\n",
       "        -1.12810639e-01],\n",
       "       [ 1.33025744e+00, -5.36485886e-01,  2.35218528e+00,\n",
       "        -1.38085124e-01],\n",
       "       [ 1.32445134e+00, -6.24644556e-01,  2.35067203e+00,\n",
       "        -1.64829089e-01],\n",
       "       [ 1.31776647e+00, -7.12226851e-01,  2.34888301e+00,\n",
       "        -1.93279098e-01],\n",
       "       [ 1.31020900e+00, -7.99152233e-01,  2.34679999e+00,\n",
       "        -2.23667840e-01],\n",
       "       [ 1.30178589e+00, -8.85340466e-01,  2.34440243e+00,\n",
       "        -2.56223553e-01],\n",
       "       [ 1.29250491e+00, -9.70711405e-01,  2.34166755e+00,\n",
       "        -2.91169445e-01],\n",
       "       [ 1.28237465e+00, -1.05518466e+00,  2.33857035e+00,\n",
       "        -3.28723099e-01],\n",
       "       [ 1.27140448e+00, -1.13867925e+00,  2.33508369e+00,\n",
       "        -3.69095868e-01],\n",
       "       [ 1.25960460e+00, -1.22111306e+00,  2.33117835e+00,\n",
       "        -4.12492254e-01],\n",
       "       [ 1.24698604e+00, -1.30240226e+00,  2.32682311e+00,\n",
       "        -4.59109257e-01],\n",
       "       [ 1.23356066e+00, -1.38246062e+00,  2.32198480e+00,\n",
       "        -5.09135707e-01],\n",
       "       [ 1.21934122e+00, -1.46119869e+00,  2.31662843e+00,\n",
       "        -5.62751554e-01],\n",
       "       [ 1.20434140e+00, -1.53852288e+00,  2.31071724e+00,\n",
       "        -6.20127134e-01],\n",
       "       [ 1.18857581e+00, -1.61433448e+00,  2.30421282e+00,\n",
       "        -6.81422373e-01],\n",
       "       [ 1.17206010e+00, -1.68852860e+00,  2.29707523e+00,\n",
       "        -7.46785958e-01],\n",
       "       [ 1.15481100e+00, -1.76099291e+00,  2.28926308e+00,\n",
       "        -8.16354459e-01],\n",
       "       [ 1.13684641e+00, -1.83160651e+00,  2.28073371e+00,\n",
       "        -8.90251381e-01],\n",
       "       [ 1.11818548e+00, -1.90023858e+00,  2.27144326e+00,\n",
       "        -9.68586179e-01],\n",
       "       [ 1.09884872e+00, -1.96674712e+00,  2.26134688e+00,\n",
       "        -1.05145323e+00],\n",
       "       [ 1.07885813e+00, -2.03097758e+00,  2.25039883e+00,\n",
       "        -1.13893074e+00],\n",
       "       [ 1.05823732e+00, -2.09276164e+00,  2.23855269e+00,\n",
       "        -1.23107971e+00],\n",
       "       [ 1.03701166e+00, -2.15191589e+00,  2.22576152e+00,\n",
       "        -1.32794276e+00],\n",
       "       [ 1.01520843e+00, -2.20824078e+00,  2.21197804e+00,\n",
       "        -1.42954318e+00],\n",
       "       [ 9.92856993e-01, -2.26151946e+00,  2.19715485e+00,\n",
       "        -1.53588385e+00],\n",
       "       [ 9.69988973e-01, -2.31151703e+00,  2.18124462e+00,\n",
       "        -1.64694646e+00],\n",
       "       [ 9.46638432e-01, -2.35797978e+00,  2.16420032e+00,\n",
       "        -1.76269071e+00],\n",
       "       [ 9.22842067e-01, -2.40063487e+00,  2.14597541e+00,\n",
       "        -1.88305404e+00],\n",
       "       [ 8.98639398e-01, -2.43919013e+00,  2.12652412e+00,\n",
       "        -2.00795135e+00],\n",
       "       [ 8.74072965e-01, -2.47333420e+00,  2.10580162e+00,\n",
       "        -2.13727531e+00],\n",
       "       [ 8.49188514e-01, -2.50273718e+00,  2.08376428e+00,\n",
       "        -2.27089712e+00],\n",
       "       [ 8.24035180e-01, -2.52705151e+00,  2.06036985e+00,\n",
       "        -2.40866789e+00],\n",
       "       [ 7.98665656e-01, -2.54591329e+00,  2.03557765e+00,\n",
       "        -2.55042059e+00],\n",
       "       [ 7.73136348e-01, -2.55894408e+00,  2.00934877e+00,\n",
       "        -2.69597288e+00],\n",
       "       [ 7.47507511e-01, -2.56575301e+00,  1.98164617e+00,\n",
       "        -2.84513079e+00],\n",
       "       [ 7.21843361e-01, -2.56593934e+00,  1.95243480e+00,\n",
       "        -2.99769329e+00],\n",
       "       [ 6.96212157e-01, -2.55909529e+00,  1.92168163e+00,\n",
       "        -3.15345793e+00],\n",
       "       [ 6.70686261e-01, -2.54480918e+00,  1.88935562e+00,\n",
       "        -3.31222758e+00],\n",
       "       [ 6.45342154e-01, -2.52266869e+00,  1.85542767e+00,\n",
       "        -3.47381820e+00],\n",
       "       [ 6.20260434e-01, -2.49226425e+00,  1.81987039e+00,\n",
       "        -3.63806780e+00],\n",
       "       [ 5.95525762e-01, -2.45319227e+00,  1.78265788e+00,\n",
       "        -3.80484646e+00],\n",
       "       [ 5.71226797e-01, -2.40505829e+00,  1.74376533e+00,\n",
       "        -3.97406742e+00],\n",
       "       [ 5.47456081e-01, -2.34747969e+00,  1.70316850e+00,\n",
       "        -4.14569907e+00],\n",
       "       [ 5.24309916e-01, -2.28008812e+00,  1.66084319e+00,\n",
       "        -4.31977768e+00],\n",
       "       [ 5.01888206e-01, -2.20253146e+00,  1.61676441e+00,\n",
       "        -4.49642076e+00],\n",
       "       [ 4.80294288e-01, -2.11447539e+00,  1.57090553e+00,\n",
       "        -4.67584048e+00],\n",
       "       [ 4.59634748e-01, -2.01560508e+00,  1.52323729e+00,\n",
       "        -4.85835648e+00],\n",
       "       [ 4.40019213e-01, -1.90562741e+00,  1.47372664e+00,\n",
       "        -5.04440741e+00],\n",
       "       [ 4.21560119e-01, -1.78427486e+00,  1.42233549e+00,\n",
       "        -5.23455972e+00],\n",
       "       [ 4.04372417e-01, -1.65131332e+00,  1.36901946e+00,\n",
       "        -5.42951056e+00],\n",
       "       [ 3.88573177e-01, -1.50655668e+00,  1.31372656e+00,\n",
       "        -5.63008161e+00],\n",
       "       [ 3.74280983e-01, -1.34989378e+00,  1.25639602e+00,\n",
       "        -5.83719678e+00],\n",
       "       [ 3.61614972e-01, -1.18133571e+00,  1.19695755e+00,\n",
       "        -6.05183339e+00],\n",
       "       [ 3.50693239e-01, -1.00109683e+00,  1.13533114e+00,\n",
       "        -6.27492976e+00],\n",
       "       [ 3.41630190e-01, -8.09728682e-01,  1.07142825e+00,\n",
       "        -6.50722326e+00],\n",
       "       [ 3.34532180e-01, -6.08334407e-01,  1.00515503e+00,\n",
       "        -6.74898117e+00],\n",
       "       [ 3.29490452e-01, -3.98899669e-01,  9.36419014e-01,\n",
       "        -6.99957305e+00],\n",
       "       [ 3.26570039e-01, -1.84775114e-01,  8.65141086e-01,\n",
       "        -7.25683101e+00],\n",
       "       [ 3.25793020e-01,  2.86790538e-02,  7.91275066e-01,\n",
       "        -7.51617197e+00],\n",
       "       [ 3.27114758e-01,  2.33361823e-01,  7.14836985e-01,\n",
       "        -7.76956430e+00],\n",
       "       [ 3.30393399e-01,  4.17876971e-01,  6.35944234e-01,\n",
       "        -8.00467003e+00],\n",
       "       [ 3.35356853e-01,  5.67700176e-01,  5.54859617e-01,\n",
       "        -8.20487603e+00],\n",
       "       [ 3.41578109e-01,  6.66793409e-01,  4.72026532e-01,\n",
       "        -8.35119297e+00],\n",
       "       [ 3.48475751e-01,  7.01006298e-01,  3.88073235e-01,\n",
       "        -8.42651902e+00],\n",
       "       [ 3.55354261e-01,  6.62342830e-01,  3.03766593e-01,\n",
       "        -8.42110026e+00],\n",
       "       [ 3.61482114e-01,  5.51830045e-01,  2.19917323e-01,\n",
       "        -8.33621726e+00],\n",
       "       [ 3.66182753e-01,  3.79057711e-01,  1.37268871e-01,\n",
       "        -8.18354685e+00],\n",
       "       [ 3.68904668e-01,  1.58730182e-01,  5.64137896e-02,\n",
       "        -7.98066420e+00],\n",
       "       [ 3.69251182e-01, -9.35243722e-02, -2.22377349e-02,\n",
       "        -7.74566363e+00],\n",
       "       [ 3.66973512e-01, -3.64090520e-01, -9.84428132e-02,\n",
       "        -7.49350809e+00],\n",
       "       [ 3.61943480e-01, -6.42529287e-01, -1.72086289e-01,\n",
       "        -7.23473071e+00],\n",
       "       [ 3.54121450e-01, -9.21493020e-01, -2.43137083e-01,\n",
       "        -6.97574481e+00],\n",
       "       [ 3.43528343e-01, -1.19609743e+00, -3.11611595e-01,\n",
       "        -6.71981144e+00],\n",
       "       [ 3.30224586e-01, -1.46321482e+00, -3.77547390e-01,\n",
       "        -6.46805888e+00],\n",
       "       [ 3.14295608e-01, -1.72088829e+00, -4.40986185e-01,\n",
       "        -6.22030688e+00],\n",
       "       [ 2.95842375e-01, -1.96791045e+00, -5.01963891e-01,\n",
       "        -5.97565361e+00],\n",
       "       [ 2.74975389e-01, -2.20354491e+00, -5.60505477e-01,\n",
       "        -5.73286418e+00],\n",
       "       [ 2.51810917e-01, -2.42735324e+00, -6.16622967e-01,\n",
       "        -5.49061552e+00],\n",
       "       [ 2.26468565e-01, -2.63909362e+00, -6.70315360e-01,\n",
       "        -5.24764427e+00],\n",
       "       [ 1.99069619e-01, -2.83866518e+00, -7.21569693e-01,\n",
       "        -5.00283198e+00],\n",
       "       [ 1.69735793e-01, -3.02608042e+00, -7.70362743e-01,\n",
       "        -4.75524987e+00],\n",
       "       [ 1.38588162e-01, -3.20145350e+00, -8.16663034e-01,\n",
       "        -4.50417800e+00],\n",
       "       [ 1.05746166e-01, -3.36499692e+00, -8.60432951e-01,\n",
       "        -4.24910753e+00],\n",
       "       [ 7.13266306e-02, -3.51702143e+00, -9.01630814e-01,\n",
       "        -3.98973215e+00],\n",
       "       [ 3.54427805e-02, -3.65793626e+00, -9.40212826e-01,\n",
       "        -3.72593196e+00],\n",
       "       [-1.79673986e-03, -3.78824783e+00, -9.76134840e-01,\n",
       "        -3.45775269e+00],\n",
       "       [-4.02888211e-02, -3.90855591e+00, -1.00935390e+00,\n",
       "        -3.18538214e+00],\n",
       "       [-7.99367914e-02, -4.01954676e+00, -1.03982952e+00,\n",
       "        -2.90912536e+00],\n",
       "       [-1.20651234e-01, -4.12198317e+00, -1.06752477e+00,\n",
       "        -2.62938056e+00],\n",
       "       [-1.62350688e-01, -4.21669124e+00, -1.09240706e+00,\n",
       "        -2.34661699e+00],\n",
       "       [-2.04962203e-01, -4.30454393e+00, -1.11444878e+00,\n",
       "        -2.06135679e+00],\n",
       "       [-2.48421713e-01, -4.38644107e+00, -1.13362775e+00,\n",
       "        -1.77416267e+00],\n",
       "       [-2.92674183e-01, -4.46328517e+00, -1.14992758e+00,\n",
       "        -1.48563378e+00],\n",
       "       [-3.37673498e-01, -4.53595202e+00, -1.16333811e+00,\n",
       "        -1.19641240e+00],\n",
       "       [-3.83382019e-01, -4.60525411e+00, -1.17385587e+00,\n",
       "        -9.07204958e-01],\n",
       "       [-4.29769726e-01, -4.67189442e+00, -1.18148494e+00,\n",
       "        -6.18821417e-01]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yodeint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "4dbb86d9-f99f-4c10-8145-52bbc30dc326",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.34639685e+00,  1.34594732e+00,  1.34459917e+00,\n",
       "         1.34235392e+00,  1.33921363e+00,  1.33518104e+00,\n",
       "         1.33025975e+00,  1.32445420e+00,  1.31776965e+00,\n",
       "         1.31021222e+00,  1.30178884e+00,  1.29250730e+00,\n",
       "         1.28237621e+00,  1.27140504e+00,  1.25960407e+00,\n",
       "         1.24698443e+00,  1.23355810e+00,  1.21933788e+00,\n",
       "         1.20434883e+00,  1.18861023e+00,  1.17212995e+00,\n",
       "         1.15491846e+00,  1.13698883e+00,  1.11835670e+00,\n",
       "         1.09904034e+00,  1.07906057e+00,  1.05844084e+00,\n",
       "         1.03720718e+00,  1.01538822e+00,  9.93015166e-01,\n",
       "         9.70121837e-01,  9.46744636e-01,  9.22922563e-01,\n",
       "         8.98697211e-01,  8.74112766e-01,  8.49216008e-01,\n",
       "         8.24056311e-01,  7.98685642e-01,  7.73158563e-01,\n",
       "         7.47532229e-01,  7.21865166e-01,  6.96213842e-01,\n",
       "         6.70656093e-01,  6.45275992e-01,  6.20160067e-01,\n",
       "         5.95397306e-01,  5.71079156e-01,  5.47299523e-01,\n",
       "         5.24154769e-01,  5.01743717e-01,  4.80167647e-01,\n",
       "         4.59530298e-01,  4.39937868e-01,  4.21499013e-01,\n",
       "         4.04324847e-01,  3.88528943e-01,  3.74207590e-01,\n",
       "         3.61486748e-01,  3.50531321e-01,  3.41474721e-01,\n",
       "         3.34418158e-01,  3.29430642e-01,  3.26548977e-01,\n",
       "         3.25777770e-01,  3.27089422e-01,  3.30445020e-01,\n",
       "         3.35557743e-01,  3.41842606e-01,  3.48698966e-01,\n",
       "         3.55518130e-01,  3.61683359e-01,  3.66569866e-01,\n",
       "         3.69544814e-01,  3.70028620e-01,  3.67848468e-01,\n",
       "         3.62927062e-01,  3.55219098e-01,  3.44723405e-01,\n",
       "         3.31482943e-01,  3.15584805e-01,  2.97160165e-01,\n",
       "         2.76332370e-01,  2.53201947e-01,  2.27890450e-01,\n",
       "         2.00518501e-01,  1.71205790e-01,  1.40071073e-01,\n",
       "         1.07232171e-01,  7.28059759e-02,  3.69084446e-02,\n",
       "        -3.45398371e-04, -3.88464948e-02, -7.85027414e-02,\n",
       "        -1.19225554e-01, -1.60934317e-01, -2.03556673e-01,\n",
       "        -2.47028524e-01, -2.91294032e-01, -3.36305615e-01,\n",
       "        -3.82023952e-01, -4.28417980e-01],\n",
       "       [ 0.00000000e+00, -8.98990500e-02, -1.79714381e-01,\n",
       "        -2.69358096e-01, -3.58749521e-01, -4.47809954e-01,\n",
       "        -5.36460107e-01, -6.24620105e-01, -7.12209487e-01,\n",
       "        -7.99147206e-01, -8.85351625e-01, -9.70740525e-01,\n",
       "        -1.05523110e+00, -1.13873994e+00, -1.22118308e+00,\n",
       "        -1.30247595e+00, -1.38253339e+00, -1.46126964e+00,\n",
       "        -1.53854778e+00, -1.61425396e+00, -1.68831865e+00,\n",
       "        -1.76065517e+00, -1.83115974e+00, -1.89971144e+00,\n",
       "        -1.96617223e+00, -2.03038697e+00, -2.09218337e+00,\n",
       "        -2.15137204e+00, -2.20774646e+00, -2.26108299e+00,\n",
       "        -2.31114087e+00, -2.35766222e+00, -2.40037203e+00,\n",
       "        -2.43897818e+00, -2.47317141e+00, -2.50262537e+00,\n",
       "        -2.52699656e+00, -2.54592438e+00, -2.55903109e+00,\n",
       "        -2.56592184e+00, -2.56619431e+00, -2.55949512e+00,\n",
       "        -2.54537725e+00, -2.52338752e+00, -2.49309214e+00,\n",
       "        -2.45407670e+00, -2.40594616e+00, -2.34832487e+00,\n",
       "        -2.28085657e+00, -2.20320436e+00, -2.11505073e+00,\n",
       "        -2.01609756e+00, -1.90606610e+00, -1.78469699e+00,\n",
       "        -1.65175023e+00, -1.50700522e+00, -1.35106719e+00,\n",
       "        -1.18382891e+00, -1.00397727e+00, -8.11597436e-01,\n",
       "        -6.08199968e-01, -3.96720843e-01, -1.81521439e-01,\n",
       "         3.16114575e-02,  2.35465656e-01,  4.21530397e-01,\n",
       "         5.73784166e-01,  6.73510241e-01,  7.08229813e-01,\n",
       "         6.71888172e-01,  5.64854705e-01,  3.93922897e-01,\n",
       "         1.72310332e-01, -8.12827107e-02, -3.52619195e-01,\n",
       "        -6.32513627e-01, -9.13554608e-01, -1.19011955e+00,\n",
       "        -1.45837468e+00, -1.71627505e+00, -1.96356270e+00,\n",
       "        -2.19993853e+00, -2.42439083e+00, -2.63673777e+00,\n",
       "        -2.83689344e+00, -3.02486787e+00, -3.20076705e+00,\n",
       "        -3.36479288e+00, -3.51724322e+00, -3.65851185e+00,\n",
       "        -3.78908851e+00, -3.90953228e+00, -4.02054713e+00,\n",
       "        -4.12299778e+00, -4.21774824e+00, -4.30565801e+00,\n",
       "        -4.38758198e+00, -4.46437051e+00, -4.53686937e+00,\n",
       "        -4.60591978e+00, -4.67235841e+00],\n",
       "       [ 2.35619449e+00,  2.35608673e+00,  2.35576229e+00,\n",
       "         2.35521823e+00,  2.35444798e+00,  2.35344228e+00,\n",
       "         2.35218969e+00,  2.35067657e+00,  2.34888703e+00,\n",
       "         2.34680302e+00,  2.34440425e+00,  2.34166823e+00,\n",
       "         2.33857027e+00,  2.33508346e+00,  2.33117869e+00,\n",
       "         2.32682464e+00,  2.32198778e+00,  2.31663238e+00,\n",
       "         2.31072025e+00,  2.30421055e+00,  2.29706166e+00,\n",
       "         2.28923165e+00,  2.28067822e+00,  2.27135875e+00,\n",
       "         2.26123028e+00,  2.25024953e+00,  2.23837286e+00,\n",
       "         2.22555630e+00,  2.21175554e+00,  2.19692596e+00,\n",
       "         2.18102257e+00,  2.16400005e+00,  2.14581276e+00,\n",
       "         2.12641471e+00,  2.10575958e+00,  2.08380071e+00,\n",
       "         2.06049111e+00,  2.03578343e+00,  2.00963001e+00,\n",
       "         1.98198286e+00,  1.95279622e+00,  1.92205435e+00,\n",
       "         1.88973901e+00,  1.85582661e+00,  1.82029247e+00,\n",
       "         1.78311080e+00,  1.74425473e+00,  1.70369632e+00,\n",
       "         1.66140652e+00,  1.61735517e+00,  1.57151105e+00,\n",
       "         1.52384184e+00,  1.47431412e+00,  1.42289338e+00,\n",
       "         1.36954403e+00,  1.31422937e+00,  1.25692395e+00,\n",
       "         1.19754360e+00,  1.13595283e+00,  1.07203831e+00,\n",
       "         1.00570953e+00,  9.36898804e-01,  8.65561266e-01,\n",
       "         7.91674867e-01,  7.15240381e-01,  6.36259511e-01,\n",
       "         5.55010773e-01,  4.72112256e-01,  3.88206605e-01,\n",
       "         3.03952556e-01,  2.20024936e-01,  1.37114669e-01,\n",
       "         5.59287692e-02, -2.28944663e-02, -9.92342985e-02,\n",
       "        -1.73033016e-01, -2.44246264e-01, -3.12861908e-01,\n",
       "        -3.78900036e-01, -4.42412956e-01, -5.03485130e-01,\n",
       "        -5.62160873e-01, -6.18415313e-01, -6.72238933e-01,\n",
       "        -7.23616318e-01, -7.72526165e-01, -8.18941274e-01,\n",
       "        -8.62828554e-01, -9.04149021e-01, -9.42857799e-01,\n",
       "        -9.78904117e-01, -1.01223956e+00, -1.04283063e+00,\n",
       "        -1.07063744e+00, -1.09562576e+00, -1.11776759e+00,\n",
       "        -1.13704113e+00, -1.15343084e+00, -1.16692738e+00,\n",
       "        -1.17752764e+00, -1.18523473e+00],\n",
       "       [ 0.00000000e+00, -2.15719763e-02, -4.33912402e-02,\n",
       "        -6.56960619e-02, -8.87380735e-02, -1.12769121e-01,\n",
       "        -1.38035741e-01, -1.64779160e-01, -1.93235297e-01,\n",
       "        -2.23634759e-01, -2.56202846e-01, -2.91159548e-01,\n",
       "        -3.28719543e-01, -3.69092204e-01, -4.12481591e-01,\n",
       "        -4.59086456e-01, -5.09100241e-01, -5.62711065e-01,\n",
       "        -6.20042194e-01, -6.81227697e-01, -7.46447015e-01,\n",
       "        -8.15859438e-01, -8.89604100e-01, -9.67799983e-01,\n",
       "        -1.05054592e+00, -1.13792058e+00, -1.22998250e+00,\n",
       "        -1.32677005e+00, -1.42830144e+00, -1.53457474e+00,\n",
       "        -1.64556787e+00, -1.76123859e+00, -1.88152450e+00,\n",
       "        -2.00634306e+00, -2.13559158e+00, -2.26914720e+00,\n",
       "        -2.40686693e+00, -2.54858760e+00, -2.69412591e+00,\n",
       "        -2.84327841e+00, -2.99584981e+00, -3.15180594e+00,\n",
       "        -3.31084120e+00, -3.47265323e+00, -3.63701994e+00,\n",
       "        -3.80379952e+00, -3.97293045e+00, -4.14443150e+00,\n",
       "        -4.31840169e+00, -4.49502036e+00, -4.67454711e+00,\n",
       "        -4.85732181e+00, -5.04376463e+00, -5.23437601e+00,\n",
       "        -5.42973669e+00, -5.63050765e+00, -5.83664883e+00,\n",
       "        -6.04956460e+00, -6.27216656e+00, -6.50578033e+00,\n",
       "        -6.75011547e+00, -7.00326545e+00, -7.26170770e+00,\n",
       "        -7.52030355e+00, -7.77229830e+00, -8.00943111e+00,\n",
       "        -8.21315075e+00, -8.36065344e+00, -8.43672978e+00,\n",
       "        -8.43401079e+00, -8.35296792e+00, -8.20191305e+00,\n",
       "        -7.99699848e+00, -7.76073092e+00, -7.50819747e+00,\n",
       "        -7.24823257e+00, -6.98746745e+00, -6.73022929e+00,\n",
       "        -6.47854126e+00, -6.23212250e+00, -5.98839123e+00,\n",
       "        -5.74554455e+00, -5.50333169e+00, -5.26039359e+00,\n",
       "        -5.01558058e+00, -4.76795242e+00, -4.51677826e+00,\n",
       "        -4.26153666e+00, -4.00191557e+00, -3.73781238e+00,\n",
       "        -3.46933385e+00, -3.19670883e+00, -2.92015637e+00,\n",
       "        -2.64008946e+00, -2.35697426e+00, -2.07132406e+00,\n",
       "        -1.78369927e+00, -1.49470737e+00, -1.20500297e+00,\n",
       "        -9.15287772e-01, -6.26310586e-01]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "9d787357-455f-4cbf-9361-e1acc14e38fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 1.0, 1.0, 1.0]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[*(L1,L2,m1,m2,)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f47985da-846e-4baa-b480-47a9e25ac7dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "c805b5eb-57f1-45e0-ac17-c03abc7c23a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b,c,d=y0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "e11519ab-b8ec-4240-93a0-cf15bc1a9012",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3463968515384828"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6d288433-8ed1-4697-9320-3728122e7ca1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.34639685, 0.        , 2.35619449, 0.        ])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "033331ae-e70b-43a6-b98e-6ffe54388311",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m\n",
       "\u001b[0msolve_ivp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mfun\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mt_span\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0my0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'RK45'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mt_eval\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mdense_output\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mevents\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mvectorized\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;34m**\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Solve an initial value problem for a system of ODEs.\n",
       "\n",
       "This function numerically integrates a system of ordinary differential\n",
       "equations given an initial value::\n",
       "\n",
       "    dy / dt = f(t, y)\n",
       "    y(t0) = y0\n",
       "\n",
       "Here t is a 1-D independent variable (time), y(t) is an\n",
       "N-D vector-valued function (state), and an N-D\n",
       "vector-valued function f(t, y) determines the differential equations.\n",
       "The goal is to find y(t) approximately satisfying the differential\n",
       "equations, given an initial value y(t0)=y0.\n",
       "\n",
       "Some of the solvers support integration in the complex domain, but note\n",
       "that for stiff ODE solvers, the right-hand side must be\n",
       "complex-differentiable (satisfy Cauchy-Riemann equations [11]_).\n",
       "To solve a problem in the complex domain, pass y0 with a complex data type.\n",
       "Another option always available is to rewrite your problem for real and\n",
       "imaginary parts separately.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "fun : callable\n",
       "    Right-hand side of the system. The calling signature is ``fun(t, y)``.\n",
       "    Here `t` is a scalar, and there are two options for the ndarray `y`:\n",
       "    It can either have shape (n,); then `fun` must return array_like with\n",
       "    shape (n,). Alternatively, it can have shape (n, k); then `fun`\n",
       "    must return an array_like with shape (n, k), i.e., each column\n",
       "    corresponds to a single column in `y`. The choice between the two\n",
       "    options is determined by `vectorized` argument (see below). The\n",
       "    vectorized implementation allows a faster approximation of the Jacobian\n",
       "    by finite differences (required for stiff solvers).\n",
       "t_span : 2-tuple of floats\n",
       "    Interval of integration (t0, tf). The solver starts with t=t0 and\n",
       "    integrates until it reaches t=tf.\n",
       "y0 : array_like, shape (n,)\n",
       "    Initial state. For problems in the complex domain, pass `y0` with a\n",
       "    complex data type (even if the initial value is purely real).\n",
       "method : string or `OdeSolver`, optional\n",
       "    Integration method to use:\n",
       "\n",
       "        * 'RK45' (default): Explicit Runge-Kutta method of order 5(4) [1]_.\n",
       "          The error is controlled assuming accuracy of the fourth-order\n",
       "          method, but steps are taken using the fifth-order accurate\n",
       "          formula (local extrapolation is done). A quartic interpolation\n",
       "          polynomial is used for the dense output [2]_. Can be applied in\n",
       "          the complex domain.\n",
       "        * 'RK23': Explicit Runge-Kutta method of order 3(2) [3]_. The error\n",
       "          is controlled assuming accuracy of the second-order method, but\n",
       "          steps are taken using the third-order accurate formula (local\n",
       "          extrapolation is done). A cubic Hermite polynomial is used for the\n",
       "          dense output. Can be applied in the complex domain.\n",
       "        * 'DOP853': Explicit Runge-Kutta method of order 8 [13]_.\n",
       "          Python implementation of the \"DOP853\" algorithm originally\n",
       "          written in Fortran [14]_. A 7-th order interpolation polynomial\n",
       "          accurate to 7-th order is used for the dense output.\n",
       "          Can be applied in the complex domain.\n",
       "        * 'Radau': Implicit Runge-Kutta method of the Radau IIA family of\n",
       "          order 5 [4]_. The error is controlled with a third-order accurate\n",
       "          embedded formula. A cubic polynomial which satisfies the\n",
       "          collocation conditions is used for the dense output.\n",
       "        * 'BDF': Implicit multi-step variable-order (1 to 5) method based\n",
       "          on a backward differentiation formula for the derivative\n",
       "          approximation [5]_. The implementation follows the one described\n",
       "          in [6]_. A quasi-constant step scheme is used and accuracy is\n",
       "          enhanced using the NDF modification. Can be applied in the\n",
       "          complex domain.\n",
       "        * 'LSODA': Adams/BDF method with automatic stiffness detection and\n",
       "          switching [7]_, [8]_. This is a wrapper of the Fortran solver\n",
       "          from ODEPACK.\n",
       "\n",
       "    Explicit Runge-Kutta methods ('RK23', 'RK45', 'DOP853') should be used\n",
       "    for non-stiff problems and implicit methods ('Radau', 'BDF') for\n",
       "    stiff problems [9]_. Among Runge-Kutta methods, 'DOP853' is recommended\n",
       "    for solving with high precision (low values of `rtol` and `atol`).\n",
       "\n",
       "    If not sure, first try to run 'RK45'. If it makes unusually many\n",
       "    iterations, diverges, or fails, your problem is likely to be stiff and\n",
       "    you should use 'Radau' or 'BDF'. 'LSODA' can also be a good universal\n",
       "    choice, but it might be somewhat less convenient to work with as it\n",
       "    wraps old Fortran code.\n",
       "\n",
       "    You can also pass an arbitrary class derived from `OdeSolver` which\n",
       "    implements the solver.\n",
       "t_eval : array_like or None, optional\n",
       "    Times at which to store the computed solution, must be sorted and lie\n",
       "    within `t_span`. If None (default), use points selected by the solver.\n",
       "dense_output : bool, optional\n",
       "    Whether to compute a continuous solution. Default is False.\n",
       "events : callable, or list of callables, optional\n",
       "    Events to track. If None (default), no events will be tracked.\n",
       "    Each event occurs at the zeros of a continuous function of time and\n",
       "    state. Each function must have the signature ``event(t, y)`` and return\n",
       "    a float. The solver will find an accurate value of `t` at which\n",
       "    ``event(t, y(t)) = 0`` using a root-finding algorithm. By default, all\n",
       "    zeros will be found. The solver looks for a sign change over each step,\n",
       "    so if multiple zero crossings occur within one step, events may be\n",
       "    missed. Additionally each `event` function might have the following\n",
       "    attributes:\n",
       "\n",
       "        terminal: bool, optional\n",
       "            Whether to terminate integration if this event occurs.\n",
       "            Implicitly False if not assigned.\n",
       "        direction: float, optional\n",
       "            Direction of a zero crossing. If `direction` is positive,\n",
       "            `event` will only trigger when going from negative to positive,\n",
       "            and vice versa if `direction` is negative. If 0, then either\n",
       "            direction will trigger event. Implicitly 0 if not assigned.\n",
       "\n",
       "    You can assign attributes like ``event.terminal = True`` to any\n",
       "    function in Python.\n",
       "vectorized : bool, optional\n",
       "    Whether `fun` is implemented in a vectorized fashion. Default is False.\n",
       "args : tuple, optional\n",
       "    Additional arguments to pass to the user-defined functions.  If given,\n",
       "    the additional arguments are passed to all user-defined functions.\n",
       "    So if, for example, `fun` has the signature ``fun(t, y, a, b, c)``,\n",
       "    then `jac` (if given) and any event functions must have the same\n",
       "    signature, and `args` must be a tuple of length 3.\n",
       "options\n",
       "    Options passed to a chosen solver. All options available for already\n",
       "    implemented solvers are listed below.\n",
       "first_step : float or None, optional\n",
       "    Initial step size. Default is `None` which means that the algorithm\n",
       "    should choose.\n",
       "max_step : float, optional\n",
       "    Maximum allowed step size. Default is np.inf, i.e., the step size is not\n",
       "    bounded and determined solely by the solver.\n",
       "rtol, atol : float or array_like, optional\n",
       "    Relative and absolute tolerances. The solver keeps the local error\n",
       "    estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a\n",
       "    relative accuracy (number of correct digits). But if a component of `y`\n",
       "    is approximately below `atol`, the error only needs to fall within\n",
       "    the same `atol` threshold, and the number of correct digits is not\n",
       "    guaranteed. If components of y have different scales, it might be\n",
       "    beneficial to set different `atol` values for different components by\n",
       "    passing array_like with shape (n,) for `atol`. Default values are\n",
       "    1e-3 for `rtol` and 1e-6 for `atol`.\n",
       "jac : array_like, sparse_matrix, callable or None, optional\n",
       "    Jacobian matrix of the right-hand side of the system with respect\n",
       "    to y, required by the 'Radau', 'BDF' and 'LSODA' method. The\n",
       "    Jacobian matrix has shape (n, n) and its element (i, j) is equal to\n",
       "    ``d f_i / d y_j``.  There are three ways to define the Jacobian:\n",
       "\n",
       "        * If array_like or sparse_matrix, the Jacobian is assumed to\n",
       "          be constant. Not supported by 'LSODA'.\n",
       "        * If callable, the Jacobian is assumed to depend on both\n",
       "          t and y; it will be called as ``jac(t, y)``, as necessary.\n",
       "          For 'Radau' and 'BDF' methods, the return value might be a\n",
       "          sparse matrix.\n",
       "        * If None (default), the Jacobian will be approximated by\n",
       "          finite differences.\n",
       "\n",
       "    It is generally recommended to provide the Jacobian rather than\n",
       "    relying on a finite-difference approximation.\n",
       "jac_sparsity : array_like, sparse matrix or None, optional\n",
       "    Defines a sparsity structure of the Jacobian matrix for a finite-\n",
       "    difference approximation. Its shape must be (n, n). This argument\n",
       "    is ignored if `jac` is not `None`. If the Jacobian has only few\n",
       "    non-zero elements in *each* row, providing the sparsity structure\n",
       "    will greatly speed up the computations [10]_. A zero entry means that\n",
       "    a corresponding element in the Jacobian is always zero. If None\n",
       "    (default), the Jacobian is assumed to be dense.\n",
       "    Not supported by 'LSODA', see `lband` and `uband` instead.\n",
       "lband, uband : int or None, optional\n",
       "    Parameters defining the bandwidth of the Jacobian for the 'LSODA'\n",
       "    method, i.e., ``jac[i, j] != 0 only for i - lband <= j <= i + uband``.\n",
       "    Default is None. Setting these requires your jac routine to return the\n",
       "    Jacobian in the packed format: the returned array must have ``n``\n",
       "    columns and ``uband + lband + 1`` rows in which Jacobian diagonals are\n",
       "    written. Specifically ``jac_packed[uband + i - j , j] = jac[i, j]``.\n",
       "    The same format is used in `scipy.linalg.solve_banded` (check for an\n",
       "    illustration).  These parameters can be also used with ``jac=None`` to\n",
       "    reduce the number of Jacobian elements estimated by finite differences.\n",
       "min_step : float, optional\n",
       "    The minimum allowed step size for 'LSODA' method.\n",
       "    By default `min_step` is zero.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "Bunch object with the following fields defined:\n",
       "t : ndarray, shape (n_points,)\n",
       "    Time points.\n",
       "y : ndarray, shape (n, n_points)\n",
       "    Values of the solution at `t`.\n",
       "sol : `OdeSolution` or None\n",
       "    Found solution as `OdeSolution` instance; None if `dense_output` was\n",
       "    set to False.\n",
       "t_events : list of ndarray or None\n",
       "    Contains for each event type a list of arrays at which an event of\n",
       "    that type event was detected. None if `events` was None.\n",
       "y_events : list of ndarray or None\n",
       "    For each value of `t_events`, the corresponding value of the solution.\n",
       "    None if `events` was None.\n",
       "nfev : int\n",
       "    Number of evaluations of the right-hand side.\n",
       "njev : int\n",
       "    Number of evaluations of the Jacobian.\n",
       "nlu : int\n",
       "    Number of LU decompositions.\n",
       "status : int\n",
       "    Reason for algorithm termination:\n",
       "\n",
       "        * -1: Integration step failed.\n",
       "        *  0: The solver successfully reached the end of `tspan`.\n",
       "        *  1: A termination event occurred.\n",
       "\n",
       "message : string\n",
       "    Human-readable description of the termination reason.\n",
       "success : bool\n",
       "    True if the solver reached the interval end or a termination event\n",
       "    occurred (``status >= 0``).\n",
       "\n",
       "References\n",
       "----------\n",
       ".. [1] J. R. Dormand, P. J. Prince, \"A family of embedded Runge-Kutta\n",
       "       formulae\", Journal of Computational and Applied Mathematics, Vol. 6,\n",
       "       No. 1, pp. 19-26, 1980.\n",
       ".. [2] L. W. Shampine, \"Some Practical Runge-Kutta Formulas\", Mathematics\n",
       "       of Computation,, Vol. 46, No. 173, pp. 135-150, 1986.\n",
       ".. [3] P. Bogacki, L.F. Shampine, \"A 3(2) Pair of Runge-Kutta Formulas\",\n",
       "       Appl. Math. Lett. Vol. 2, No. 4. pp. 321-325, 1989.\n",
       ".. [4] E. Hairer, G. Wanner, \"Solving Ordinary Differential Equations II:\n",
       "       Stiff and Differential-Algebraic Problems\", Sec. IV.8.\n",
       ".. [5] `Backward Differentiation Formula\n",
       "        <https://en.wikipedia.org/wiki/Backward_differentiation_formula>`_\n",
       "        on Wikipedia.\n",
       ".. [6] L. F. Shampine, M. W. Reichelt, \"THE MATLAB ODE SUITE\", SIAM J. SCI.\n",
       "       COMPUTE., Vol. 18, No. 1, pp. 1-22, January 1997.\n",
       ".. [7] A. C. Hindmarsh, \"ODEPACK, A Systematized Collection of ODE\n",
       "       Solvers,\" IMACS Transactions on Scientific Computation, Vol 1.,\n",
       "       pp. 55-64, 1983.\n",
       ".. [8] L. Petzold, \"Automatic selection of methods for solving stiff and\n",
       "       nonstiff systems of ordinary differential equations\", SIAM Journal\n",
       "       on Scientific and Statistical Computing, Vol. 4, No. 1, pp. 136-148,\n",
       "       1983.\n",
       ".. [9] `Stiff equation <https://en.wikipedia.org/wiki/Stiff_equation>`_ on\n",
       "       Wikipedia.\n",
       ".. [10] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of\n",
       "        sparse Jacobian matrices\", Journal of the Institute of Mathematics\n",
       "        and its Applications, 13, pp. 117-120, 1974.\n",
       ".. [11] `Cauchy-Riemann equations\n",
       "         <https://en.wikipedia.org/wiki/Cauchy-Riemann_equations>`_ on\n",
       "         Wikipedia.\n",
       ".. [12] `Lotka-Volterra equations\n",
       "        <https://en.wikipedia.org/wiki/Lotka%E2%80%93Volterra_equations>`_\n",
       "        on Wikipedia.\n",
       ".. [13] E. Hairer, S. P. Norsett G. Wanner, \"Solving Ordinary Differential\n",
       "        Equations I: Nonstiff Problems\", Sec. II.\n",
       ".. [14] `Page with original Fortran code of DOP853\n",
       "        <http://www.unige.ch/~hairer/software.html>`_.\n",
       "\n",
       "Examples\n",
       "--------\n",
       "Basic exponential decay showing automatically chosen time points.\n",
       "\n",
       ">>> from scipy.integrate import solve_ivp\n",
       ">>> def exponential_decay(t, y): return -0.5 * y\n",
       ">>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8])\n",
       ">>> print(sol.t)\n",
       "[ 0.          0.11487653  1.26364188  3.06061781  4.81611105  6.57445806\n",
       "  8.33328988 10.        ]\n",
       ">>> print(sol.y)\n",
       "[[2.         1.88836035 1.06327177 0.43319312 0.18017253 0.07483045\n",
       "  0.03107158 0.01350781]\n",
       " [4.         3.7767207  2.12654355 0.86638624 0.36034507 0.14966091\n",
       "  0.06214316 0.02701561]\n",
       " [8.         7.5534414  4.25308709 1.73277247 0.72069014 0.29932181\n",
       "  0.12428631 0.05403123]]\n",
       "\n",
       "Specifying points where the solution is desired.\n",
       "\n",
       ">>> sol = solve_ivp(exponential_decay, [0, 10], [2, 4, 8],\n",
       "...                 t_eval=[0, 1, 2, 4, 10])\n",
       ">>> print(sol.t)\n",
       "[ 0  1  2  4 10]\n",
       ">>> print(sol.y)\n",
       "[[2.         1.21305369 0.73534021 0.27066736 0.01350938]\n",
       " [4.         2.42610739 1.47068043 0.54133472 0.02701876]\n",
       " [8.         4.85221478 2.94136085 1.08266944 0.05403753]]\n",
       "\n",
       "Cannon fired upward with terminal event upon impact. The ``terminal`` and\n",
       "``direction`` fields of an event are applied by monkey patching a function.\n",
       "Here ``y[0]`` is position and ``y[1]`` is velocity. The projectile starts\n",
       "at position 0 with velocity +10. Note that the integration never reaches\n",
       "t=100 because the event is terminal.\n",
       "\n",
       ">>> def upward_cannon(t, y): return [y[1], -0.5]\n",
       ">>> def hit_ground(t, y): return y[0]\n",
       ">>> hit_ground.terminal = True\n",
       ">>> hit_ground.direction = -1\n",
       ">>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10], events=hit_ground)\n",
       ">>> print(sol.t_events)\n",
       "[array([40.])]\n",
       ">>> print(sol.t)\n",
       "[0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02\n",
       " 1.11088891e-01 1.11098890e+00 1.11099890e+01 4.00000000e+01]\n",
       "\n",
       "Use `dense_output` and `events` to find position, which is 100, at the apex\n",
       "of the cannonball's trajectory. Apex is not defined as terminal, so both\n",
       "apex and hit_ground are found. There is no information at t=20, so the sol\n",
       "attribute is used to evaluate the solution. The sol attribute is returned\n",
       "by setting ``dense_output=True``. Alternatively, the `y_events` attribute\n",
       "can be used to access the solution at the time of the event.\n",
       "\n",
       ">>> def apex(t, y): return y[1]\n",
       ">>> sol = solve_ivp(upward_cannon, [0, 100], [0, 10],\n",
       "...                 events=(hit_ground, apex), dense_output=True)\n",
       ">>> print(sol.t_events)\n",
       "[array([40.]), array([20.])]\n",
       ">>> print(sol.t)\n",
       "[0.00000000e+00 9.99900010e-05 1.09989001e-03 1.10988901e-02\n",
       " 1.11088891e-01 1.11098890e+00 1.11099890e+01 4.00000000e+01]\n",
       ">>> print(sol.sol(sol.t_events[1][0]))\n",
       "[100.   0.]\n",
       ">>> print(sol.y_events)\n",
       "[array([[-5.68434189e-14, -1.00000000e+01]]), array([[1.00000000e+02, 1.77635684e-15]])]\n",
       "\n",
       "As an example of a system with additional parameters, we'll implement\n",
       "the Lotka-Volterra equations [12]_.\n",
       "\n",
       ">>> def lotkavolterra(t, z, a, b, c, d):\n",
       "...     x, y = z\n",
       "...     return [a*x - b*x*y, -c*y + d*x*y]\n",
       "...\n",
       "\n",
       "We pass in the parameter values a=1.5, b=1, c=3 and d=1 with the `args`\n",
       "argument.\n",
       "\n",
       ">>> sol = solve_ivp(lotkavolterra, [0, 15], [10, 5], args=(1.5, 1, 3, 1),\n",
       "...                 dense_output=True)\n",
       "\n",
       "Compute a dense solution and plot it.\n",
       "\n",
       ">>> t = np.linspace(0, 15, 300)\n",
       ">>> z = sol.sol(t)\n",
       ">>> import matplotlib.pyplot as plt\n",
       ">>> plt.plot(t, z.T)\n",
       ">>> plt.xlabel('t')\n",
       ">>> plt.legend(['x', 'y'], shadow=True)\n",
       ">>> plt.title('Lotka-Volterra System')\n",
       ">>> plt.show()\n",
       "\u001b[0;31mFile:\u001b[0m      ~/projects/osn/miniconda3/envs/py38/lib/python3.9/site-packages/scipy/integrate/_ivp/ivp.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "?solve_ivp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec7a312d-f686-459f-a339-1b0a2f97ff7c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}