1d_decelerate.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.physics.vector import (\n",
    "    ReferenceFrame,\n",
    "    dynamicsymbols,\n",
    "    get_motion_params\n",
    ")\n",
    "from sympy import symbols, Piecewise, Eq, solveset, Min, Max, Abs, latex\n",
    "\n",
    "from IPython.display import Markdown\n",
    "import numpy as np\n",
    "import plotly.graph_objects as go"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reference frame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = ReferenceFrame('N')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "$$N = \\{ \\mathbf{\\hat{n}_x}, \\mathbf{\\hat{n}_y}, \\mathbf{\\hat{n}_z} \\}$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(rf\"\"\"\n",
    "$$N = \\{{ {latex(N.x)}, {latex(N.y)}, {latex(N.z)} \\}}$$\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reference variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = symbols('T', nonnegative=True)\n",
    "R = symbols('R', nonnegative=True)\n",
    "t = symbols('t', nonnegative=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_magnitude = symbols('|a|', nonnegative=True)\n",
    "v0_magnitude = symbols('|v_{0}|', nonnegative=True) # TODO: v0 should be a 3D vector, and accept negative values\n",
    "p0_magnitude = symbols('|p_{0}|', nonnegative=True) # TODO: d0 should be a 3D vector, and accept negative values\n",
    "\n",
    "a_vector = N.x * Piecewise((-a_magnitude, T * R - dynamicsymbols._t < 0), (a_magnitude, True))\n",
    "# a_vector = N.x * a_magnitude * (T * R - dynamicsymbols._t) / Abs(T * R - dynamicsymbols._t)\n",
    "v0_vector = N.x * v0_magnitude\n",
    "p0_vector = N.x * p0_magnitude\n",
    "\n",
    "pT_magnitude = symbols('|d_{T}|', nonnegative=True) # TODO: pT should be a 3D vector, and accept negative values\n",
    "pT_vector = N.x * pT_magnitude\n",
    "\n",
    "vT_magnitude = symbols('|v_{T}|')\n",
    "vT_vector = N.x * vT_magnitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "$$\n",
       "\\begin{align*}\n",
       "|a| & \\quad & m.s^{-2} \\quad & \\text{ Acceleration magnitude} \\\\\n",
       "v_0 &= |v_{0}|\\mathbf{\\hat{n}_x} \\quad & m.s^{-1} \\quad & \\text{ Velocity at } t_0 \\\\\n",
       "v_T &= |v_{T}|\\mathbf{\\hat{n}_x} \\quad & m.s^{-1} \\quad & \\text{ Velocity at destination} \\\\\n",
       "p_0 &= |p_{0}|\\mathbf{\\hat{n}_x} \\quad & m \\quad & \\text{ Position at } t_0 \\\\\n",
       "p_T &= |d_{T}|\\mathbf{\\hat{n}_x} \\quad & m \\quad & \\text{ Position at destination}\n",
       "\\end{align*}\n",
       "$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(rf\"\"\"\n",
    "$$\n",
    "\\begin{{align*}}\n",
    "|a| & \\quad & m.s^{{-2}} \\quad & \\text{{ Acceleration magnitude}} \\\\\n",
    "v_0 &= {latex(v0_vector)} \\quad & m.s^{{-1}} \\quad & \\text{{ Velocity at }} t_0 \\\\\n",
    "v_T &= {latex(vT_vector)} \\quad & m.s^{{-1}} \\quad & \\text{{ Velocity at destination}} \\\\\n",
    "p_0 &= {latex(p0_vector)} \\quad & m \\quad & \\text{{ Position at }} t_0 \\\\\n",
    "p_T &= {latex(pT_vector)} \\quad & m \\quad & \\text{{ Position at destination}}\n",
    "\\end{{align*}}\n",
    "$$\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Motion parameters, with constant acceleration  𝑎"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def replace_max_0_RT(f):\n",
    "    # Given that T >= 0 and R in [0, 1]:\n",
    "    #  We can say that max(0, R * T) = R * T\n",
    "    #  However sympy is not able to infer this, so we replace manually\n",
    "    return f.replace(Max, lambda a, b: (b if a == 0 else a_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "original_a_fn, original_v_fn, original_d_fn = get_motion_params(\n",
    "    N,\n",
    "    acceleration=a_vector, \n",
    "    velocity=v0_vector,\n",
    "    position=p0_vector\n",
    ")\n",
    "\n",
    "a_fn = original_a_fn.subs(dynamicsymbols._t, t)\n",
    "v_fn = original_v_fn.subs(dynamicsymbols._t, t)#.applyfunc(replace_min_T)\n",
    "d_fn = original_d_fn.subs(dynamicsymbols._t, t).applyfunc(replace_max_0_RT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "These formulae depend on:\n",
       "* $T$ (in seconds): The total time to arrival\n",
       "* $R \\in [0, 1]$: The ratio at which we start decelerating\n",
       "\n",
       "$$\n",
       "\\begin{align}\n",
       "a(t) &= \\begin{cases} - |a| & \\text{for}\\: R T - t < 0 \\\\|a| & \\text{otherwise} \\end{cases}\\mathbf{\\hat{n}_x} \\\\\n",
       "v(t) &= (- t |a| + 2 |a| \\min\\left(t, R T\\right) + |v_{0}|)\\mathbf{\\hat{n}_x} \\\\\n",
       "d(t) &= (- \\frac{t^{2} |a|}{2} + t \\left(2 R T |a| + |v_{0}|\\right) + |a| \\min\\left(t, R T\\right)^{2} + |p_{0}| + |v_{0}| \\min\\left(t, R T\\right) - \\left(2 R T |a| + |v_{0}|\\right) \\min\\left(t, R T\\right))\\mathbf{\\hat{n}_x}\n",
       "\\end{align}\n",
       "$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(rf\"\"\"\n",
    "These formulae depend on:\n",
    "* $T$ (in seconds): The total time to arrival\n",
    "* $R \\in [0, 1]$: The ratio at which we start decelerating\n",
    "\n",
    "$$\n",
    "\\begin{{align}}\n",
    "a(t) &= {latex(a_fn)} \\\\\n",
    "v(t) &= {latex(v_fn)} \\\\\n",
    "d(t) &= {latex(d_fn)}\n",
    "\\end{{align}}\n",
    "$$\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def replace_min_T(f):\n",
    "    # Given that T >= 0 and R in [0, 1]:\n",
    "    #  We can say that min(t, R * T) = R * T\n",
    "    #  However sympy is not able to infer this, so we replace manually\n",
    "    return f.replace(Min(T, R*T), R*T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq_vT_x = Eq(\n",
    "    vT_vector.to_matrix(N)[0],\n",
    "    v_fn.subs(t, T).applyfunc(replace_min_T).to_matrix(N)[0]\n",
    ") # TODO: Make that equation on 3 dimensions\n",
    "\n",
    "solved_R = list(solveset(eq_vT_x, R))[0] # The solveset returns a singleton, which is also a list of size 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "$R \\in [0, 1]$: The ratio at which we start decelerating\n",
       "\n",
       "$$\n",
       "\\begin{align}\n",
       "v_T &= v(T) \\\\\n",
       "|v_{T}| &= - T |a| + 2 |a| \\min\\left(T, R T\\right) + |v_{0}| \\\\\n",
       "\\end{align}\n",
       "$$\n",
       "\n",
       "This solves into:\n",
       "\n",
       "$$R = \\frac{T |a| - |v_{0}| + |v_{T}|}{2 T |a|}$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(rf\"\"\"\n",
    "$R \\in [0, 1]$: The ratio at which we start decelerating\n",
    "\n",
    "$$\n",
    "\\begin{{align}}\n",
    "v_T &= v(T) \\\\\n",
    "{latex(vT_vector.to_matrix(N)[0])} &= {latex(v_fn.subs(t, T).to_matrix(N)[0])} \\\\\n",
    "\\end{{align}}\n",
    "$$\n",
    "\n",
    "This solves into:\n",
    "\n",
    "$$R = {latex(solved_R)}$$\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "eq_dT_x = Eq(\n",
    "    pT_vector.to_matrix(N)[0],\n",
    "    d_fn.subs({t: T}).applyfunc(replace_min_T).subs({R: solved_R}).to_matrix(N)[0]\n",
    ") # TODO: Make that equation on 3 dimensions\n",
    "\n",
    "# eq_dT_x solves as a quadratic expression, thus returns a finite set of two values.\n",
    "solved_T1, solved_T2 = solveset(eq_dT_x, T)\n",
    "solved_T = Max(solved_T1, solved_T2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "$T$ (in seconds): The total time to arrival\n",
       "\n",
       "$$\n",
       "\\begin{align}\n",
       "p_T &= p(T) \\\\\n",
       "|d_{T}| &= - \\frac{T^{2} |a|}{2} + T \\left(2 R T |a| + |v_{0}|\\right) + |a| \\min\\left(T, R T\\right)^{2} + |p_{0}| + |v_{0}| \\min\\left(T, R T\\right) - \\left(2 R T |a| + |v_{0}|\\right) \\min\\left(T, R T\\right) \\\\\n",
       "\\\\\n",
       "\\text{Given that } R &= \\frac{T |a| - |v_{0}| + |v_{T}|}{2 T |a|} \\\\\n",
       "|d_{T}| &= - \\frac{T^{2} |a|}{2} + T \\left(T |a| + |v_{T}|\\right) + |a| \\min\\left(T, \\frac{T |a| - |v_{0}| + |v_{T}|}{2 |a|}\\right)^{2} + |p_{0}| + |v_{0}| \\min\\left(T, \\frac{T |a| - |v_{0}| + |v_{T}|}{2 |a|}\\right) - \\left(T |a| + |v_{T}|\\right) \\min\\left(T, \\frac{T |a| - |v_{0}| + |v_{T}|}{2 |a|}\\right) \\\\\n",
       "\\end{align}\n",
       "$$\n",
       "\n",
       "This solves into:\n",
       "\n",
       "$$T = \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right)$$\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(rf\"\"\"\n",
    "$T$ (in seconds): The total time to arrival\n",
    "\n",
    "$$\n",
    "\\begin{{align}}\n",
    "p_T &= p(T) \\\\\n",
    "{latex(pT_vector.to_matrix(N)[0])} &= {latex(d_fn.subs({t: T}).to_matrix(N)[0])} \\\\\n",
    "\\\\\n",
    "\\text{{Given that }} R &= {latex(solved_R)} \\\\\n",
    "{latex(pT_vector.to_matrix(N)[0])} &= {latex(d_fn.subs({t: T, R: solved_R}).to_matrix(N)[0])} \\\\\n",
    "\\end{{align}}\n",
    "$$\n",
    "\n",
    "This solves into:\n",
    "\n",
    "$$T = {latex(solved_T)}$$\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Motion parameters, expand equations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "expanded_a_fn = a_fn.subs({T: solved_T, R: solved_R})\n",
    "expanded_v_fn_2 = v_fn.subs({T: solved_T, R: solved_R})\n",
    "expanded_d_fn_2 = d_fn.subs({T: solved_T, R: solved_R})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "\n",
       "After injecting $T$ and $R$, we obtain:\n",
       "\n",
       "$$\n",
       "\\begin{align}\n",
       "a(t) &= \\begin{cases} - |a| & \\text{for}\\: t - \\frac{|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) - |v_{0}| + |v_{T}|}{2 |a|} > 0 \\\\|a| & \\text{otherwise} \\end{cases}\\mathbf{\\hat{n}_x} \\\\\n",
       "v(t) &= (- t |a| + 2 |a| \\min\\left(t, \\frac{|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) - |v_{0}| + |v_{T}|}{2 |a|}\\right) + |v_{0}|)\\mathbf{\\hat{n}_x} \\\\\n",
       "d(t) &= (- \\frac{t^{2} |a|}{2} + t \\left(|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) + |v_{T}|\\right) + |a| \\min\\left(t, \\frac{|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) - |v_{0}| + |v_{T}|}{2 |a|}\\right)^{2} + |p_{0}| + |v_{0}| \\min\\left(t, \\frac{|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) - |v_{0}| + |v_{T}|}{2 |a|}\\right) - \\left(|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) + |v_{T}|\\right) \\min\\left(t, \\frac{|a| \\max\\left(- \\frac{|v_{0}| + |v_{T}|}{|a|} - \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}, - \\frac{|v_{0}| + |v_{T}|}{|a|} + \\frac{\\sqrt{2} \\sqrt{2 |a| |d_{T}| - 2 |a| |p_{0}| + |v_{0}|^{2} + |v_{T}|^{2}}}{|a|}\\right) - |v_{0}| + |v_{T}|}{2 |a|}\\right))\\mathbf{\\hat{n}_x}\n",
       "\\end{align}\n",
       "$$\n",
       "\n",
       "**Remark:** These results are not useful in practice, and are just written here as an indication\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Markdown(rf\"\"\"\n",
    "After injecting $T$ and $R$, we obtain:\n",
    "\n",
    "$$\n",
    "\\begin{{align}}\n",
    "a(t) &= {latex(expanded_a_fn)} \\\\\n",
    "v(t) &= {latex(expanded_v_fn_2)} \\\\\n",
    "d(t) &= {latex(expanded_d_fn_2)}\n",
    "\\end{{align}}\n",
    "$$\n",
    "\n",
    "**Remark:** These results are not useful in practice, and are just written here as an indication\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b962cdb78eea452da36fce8701b29ad8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "GridBox(children=(BoundedFloatText(value=1.0, description='Acceleration (m.s-2)', max=15.0, min=0.1, step=0.1)…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import ipywidgets as widgets\n",
    "from ipywidgets import interactive_output\n",
    "\n",
    "a_knob = widgets.BoundedFloatText(value=1, min=0.1, max=15.0, step=0.1, description='Acceleration (m.s-2)')\n",
    "v0_knob = widgets.IntText(value=0, step=10, description='v0 (m.s-1)')\n",
    "vT_knob = widgets.IntText(value=0, step=10, description='vT (m.s-1)')\n",
    "p0_knob = widgets.IntText(value=0, step=10, description='p0 (m)')\n",
    "pT_knob = widgets.IntText(value=100000, step=10, description='pT (m)')\n",
    "\n",
    "ui = widgets.GridBox([a_knob, v0_knob, vT_knob, p0_knob, pT_knob])\n",
    "display(ui)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "from sympy.utilities.lambdify import lambdify\n",
    "\n",
    "def make_plot(name, short_name, fn, args, line_shape=\"spline\"):\n",
    "    v_args = {a_magnitude: args[\"a_knob\"], v0_magnitude: args[\"v0_knob\"], vT_magnitude: args[\"vT_knob\"]}\n",
    "    R_val = solved_R.subs(v_args)\n",
    "    \n",
    "    p_args = {**v_args, p0_magnitude: args[\"p0_knob\"], pT_magnitude: args[\"pT_knob\"]}\n",
    "    T_val = solved_T.subs(p_args)\n",
    "    \n",
    "    t_sample = np.linspace(0, float(T_val), 99)\n",
    "    image_sample = lambdify(t, fn.subs({**p_args, T: T_val, R: R_val}).to_matrix(N)[0])\n",
    "    \n",
    "    fig = go.Figure()\n",
    "    fig.add_trace(go.Scatter(x=list(t_sample), y=[image_sample(t_val) for t_val in t_sample], line_shape=line_shape, name=name))\n",
    "\n",
    "    fig.update_layout(title=name, xaxis_title=\"t\", yaxis_title=short_name)\n",
    "    return fig\n",
    "\n",
    "def plot_position(**knob_args):\n",
    "    plot = make_plot(\"Position [x])\", \"p_x(t)\", d_fn, knob_args)\n",
    "    plot.show()\n",
    "    \n",
    "def plot_velocity(**knob_args):\n",
    "    plot = make_plot(\"Velocity [x])\", \"v_x(t)\", v_fn, knob_args)\n",
    "    plot.show()\n",
    "    \n",
    "def plot_acceleration(**knob_args):\n",
    "    plot = make_plot(\"Acceleration [x])\", \"a_x(t)\", a_fn, knob_args, line_shape=\"hv\")\n",
    "    plot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "bc0c12c29c8a48cd8bf70ca96a706722",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ccf2aefda70648c390cef3034c9b4f18",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6c6361d2cdc8443e97a3a1843011e7e2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Output()"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "knob_args = {\n",
    "    \"a_knob\": a_knob,\n",
    "    \"v0_knob\": v0_knob, \"vT_knob\": vT_knob,\n",
    "    \"p0_knob\": p0_knob, \"pT_knob\": pT_knob\n",
    "}\n",
    "\n",
    "position_plot = interactive_output(plot_position, knob_args)\n",
    "velocity_plot = interactive_output(plot_velocity, knob_args)\n",
    "acceleration_plot = interactive_output(plot_acceleration, knob_args)\n",
    "display(position_plot, velocity_plot, acceleration_plot)"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}