{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using DSolve \n",
    "\n",
    "In this lesson, we will use the ```sympy``` package and in particular, the ```dsolve``` function. \n",
    "The dsolve function will take a differential equation as input, and the output will be an equation involving the unknown function ```x(t)``` but none of it derivatives. In the best case scenario, the equation will explicitly give ```x(t)``` though sometimes it might only be implicit. \n",
    "\n",
    "To begin with, we do ```from sympy import *```. This imports all functions from ```sympy```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The important thing about ```dsolve``` is that it does not find a solution *numerically* but finds a solution *symbolically* (i.e. it \"knows\" the methods that we will be learning about in class.) Therefore, we must make an equation that tells ```sympy``` that certain things are symbols and should be treated that way. \n",
    "\n",
    "There are a few things going on, and we will go step-by-step looking at some more basic examples (that have nothing to do with differential equation) first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eq(y**2, 2)\n",
      " 2    \n",
      "y  = 2\n"
     ]
    }
   ],
   "source": [
    "#eq is an equation\n",
    "eq = Eq(symbols('y')**2, 2)\n",
    "print(eq)\n",
    "pprint(eq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first line encodes the equation $y^2 = 2$ in a format that ```sympy``` can understand. The ```Eq``` (equation) class is what ```sympy``` uses to represent equations. The part involving ```symbols``` tells ```sympy``` that ```y``` is a symbolic variable (instead of a normal programming variable that contains a literal value). So the \n",
    "expression ```Eq(symbols('y')**2, 2)``` stores the equation $y^2 = 2$ in a way that ```sympy``` understands. Next, \n",
    "we issu the ```print``` command so we can see what ```Eq``` is. The ```pprint``` command means \"pretty print\" and prints the equation in a slightly more readable format. \n",
    "\n",
    "Below, we see what happens if we don't tell ```sympy``` that ```x``` is a ```symbol```. If ```x=1``` (as we have below), then the line ```eq = Eq(x**2, 2)``` means \"$1^2 = 2$\" and this is of course not true, so the output given when we print (using either ```pprint``` or ```print```) is ```False```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "eq = Eq(x**2,2)\n",
    "print(eq)\n",
    "pprint(eq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The package ```sympy``` has a function called ```solve``` that can solve this equation. It is pretty straight forward. The ```solve``` function returns the list of solutions to the equation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-sqrt(2), sqrt(2)]\n",
      "[-√2, √2]\n"
     ]
    }
   ],
   "source": [
    "#eq is an equation\n",
    "eq = Eq(symbols('y')**2, 2)\n",
    "\n",
    "# soln will be the solution\n",
    "soln = solve(eq)\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The block directly below solves the equation $\\sin y + \\cos(x^2) = 1$ for $y$. The expression\n",
    "\n",
    "```soln = solve(eq, symbols('y'))```\n",
    "\n",
    "says to solve ```eq``` for the variable ```y```. In other words, it says that the solutions to this \n",
    "equation are: \n",
    "$$\n",
    "y = \\arcsin(\\cos(x^2) - 1) + \\pi\\\\\n",
    "y = -\\arcsin(\\cos(x^2) - 1).\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            ⎛ 2⎞    \n",
      "sin(y) + cos⎝x ⎠ = 1\n",
      "[asin(cos(x**2) - 1) + pi, -asin(cos(x**2) - 1)]\n",
      "⎡    ⎛   ⎛ 2⎞    ⎞           ⎛   ⎛ 2⎞    ⎞⎤\n",
      "⎣asin⎝cos⎝x ⎠ - 1⎠ + π, -asin⎝cos⎝x ⎠ - 1⎠⎦\n"
     ]
    }
   ],
   "source": [
    "eq = Eq(sin(symbols('y')) + cos(symbols('x')**2), 1)\n",
    "pprint(eq)\n",
    "soln = solve(eq, symbols('y'))\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The block below is similar, but instead of solving for ```y```, it solves for ```sin y```. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            ⎛ 2⎞    \n",
      "sin(y) + cos⎝x ⎠ = 1\n",
      "[1 - cos(x**2)]\n",
      "⎡       ⎛ 2⎞⎤\n",
      "⎣1 - cos⎝x ⎠⎦\n"
     ]
    }
   ],
   "source": [
    "eq = Eq(sin(symbols('y')) + cos(symbols('x')**2), 1)\n",
    "pprint(eq)\n",
    "soln = solve(eq, sin(symbols('y')))\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In other words, this says: \n",
    "$$\n",
    "\\sin y = 1 - \\cos(x^2).\n",
    "$$\n",
    "\n",
    "To add an assumption, like the variables are real, add the \"```real = True```\" expression. The block below asks ```solve``` to find a real solution to the equation $y^2 = -2$. Since there isn't a solution to this equation among the real numbers, an empty solution set (```[]```) is returned."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "#eq is an equation\n",
    "eq = Eq(symbols('y', real = True)**2, -2)\n",
    "\n",
    "# soln will be the solution\n",
    "soln = solve(eq)\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if we don't specify real solutions, it will give solutions over complex numbers: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-sqrt(2)*I, sqrt(2)*I]\n",
      "[-√2⋅ⅈ, √2⋅ⅈ]\n"
     ]
    }
   ],
   "source": [
    "#eq is an equation\n",
    "eq = Eq(symbols('y')**2, -2)\n",
    "\n",
    "# soln will be the solution\n",
    "soln = solve(eq)\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you might have noticed already, typing \"```symbols('y')```\" and such gets annoying. So, just like any data type, we can store these as python variables. In the code below, we first assign to the variable ```x``` the symolic variable ```symbols('x')``` and similarly to the variable ```y```, we assign the symbolic variable ```symbols('y')```. That way, when the code runs, ```sympy``` interprets the line: \n",
    "\n",
    "```\n",
    "eq = Eq(sin(y) + cos(x**2), 1)\n",
    "``` \n",
    "\n",
    "as \n",
    "\n",
    "```\n",
    "eq = Eq(sin(symbols('y')) + cos(symbols('x')**2), 1).\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            ⎛ 2⎞    \n",
      "sin(y) + cos⎝x ⎠ = 1\n",
      "[asin(cos(x**2) - 1) + pi, -asin(cos(x**2) - 1)]\n",
      "⎡    ⎛   ⎛ 2⎞    ⎞           ⎛   ⎛ 2⎞    ⎞⎤\n",
      "⎣asin⎝cos⎝x ⎠ - 1⎠ + π, -asin⎝cos⎝x ⎠ - 1⎠⎦\n"
     ]
    }
   ],
   "source": [
    "x = symbols('x')\n",
    "y = symbols('y')\n",
    "eq = Eq(sin(y) + cos(x**2), 1)\n",
    "pprint(eq)\n",
    "soln = solve(eq, y)\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In principle, the names of the variables don't have to have any connection with their symbolic representation. For example, the code below does the same thing as above (notice that the output is exactly the same), but note what names we've given the symbolic variables: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            ⎛ 2⎞    \n",
      "sin(y) + cos⎝x ⎠ = 1\n",
      "[asin(cos(x**2) - 1) + pi, -asin(cos(x**2) - 1)]\n",
      "⎡    ⎛   ⎛ 2⎞    ⎞           ⎛   ⎛ 2⎞    ⎞⎤\n",
      "⎣asin⎝cos⎝x ⎠ - 1⎠ + π, -asin⎝cos⎝x ⎠ - 1⎠⎦\n"
     ]
    }
   ],
   "source": [
    "rob = symbols('x')\n",
    "cara = symbols('y')\n",
    "eq = Eq(sin(cara) + cos(rob**2), 1)\n",
    "pprint(eq)\n",
    "soln = solve(eq, cara)\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It would be incredibly unwise to do so, but you can also do this (note that we are setting ```x``` to be ```symbols('y')```): "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            ⎛ 2⎞    \n",
      "sin(y) + cos⎝x ⎠ = 1\n",
      "[asin(cos(x**2) - 1) + pi, -asin(cos(x**2) - 1)]\n",
      "⎡    ⎛   ⎛ 2⎞    ⎞           ⎛   ⎛ 2⎞    ⎞⎤\n",
      "⎣asin⎝cos⎝x ⎠ - 1⎠ + π, -asin⎝cos⎝x ⎠ - 1⎠⎦\n"
     ]
    }
   ],
   "source": [
    "y = symbols('x')\n",
    "x = symbols('y')\n",
    "eq = Eq(sin(x) + cos(y**2), 1)\n",
    "pprint(eq)\n",
    "soln = solve(eq, x)\n",
    "print(soln)\n",
    "pprint(soln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, we get the same exact output, but the naming convention is very very bad. \n",
    "\n",
    "Now that we have some basic understanding about ```sympy``` and the ```Eq``` class, we now turn to using ```sympy``` to solve some ODEs. \n",
    "\n",
    "Below, we solve the equation: $x'(t) = x(t)$. First, we set the symolic variable ```t```. The next line, \n",
    "```x = Function('x')``` tells ```sympy``` that ```x``` represents the function whose name is ```x```. (If, \n",
    "for example, we had done ```x = Function('z')``` then ```x``` would represent the function whose name is ```z```. It's a good idea to alter the code to see what I am talking about.) \n",
    "\n",
    "The expression ```diff(x(t), t)``` is the derivative of ```x``` with respect to ```t```. So, the line: \n",
    "\n",
    "```\n",
    "deq = Eq(diff(x(t),t), x(t))\n",
    "```\n",
    "\n",
    "is the sympy ```Eq``` for $x'(t) = x(t)$. Then ```xsoln = dsolve(deq, x(t))``` says to solve the differential equation for the function ```x(t)```. If you do ```dsolve(deq)```, this will work on most examples (bascially, ```dsolve``` guesses at what we want to do) but it's probably best to be in the habit of telling ```dsolve``` exactly what we want.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           t\n",
      "z(t) = C₁⋅ℯ \n"
     ]
    }
   ],
   "source": [
    "#deq is the differential equation\n",
    "t = symbols('t')\n",
    "x = Function('z')\n",
    "\n",
    "deq = Eq(diff(x(t),t), x(t))\n",
    "xsoln = dsolve(deq, x(t))\n",
    "pprint(xsoln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now solve a slightly more complicated equation: $x'(t) = ax(t)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           a⋅t\n",
      "x(t) = C₁⋅ℯ   \n"
     ]
    }
   ],
   "source": [
    "#deq is the differential equation\n",
    "t = symbols('t')\n",
    "a = symbols('a')\n",
    "x = Function('x')\n",
    "\n",
    "deq = Eq(diff(x(t),t), a*x(t))\n",
    "xsoln = dsolve(deq, x(t))\n",
    "pprint(xsoln)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's graph some of these solution curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "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 numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def deqsoln(t,C):\n",
    "    return C*np.exp(t)\n",
    "\n",
    "T = np.arange(0,1.5,1.5/8)\n",
    "plt.figure()\n",
    "plt.title('D')\n",
    "for k in range(4):\n",
    "    plt.plot(T, deqsoln(T, -k))\n",
    "    plt.annotate(f\"x(0) = {-k}\", xy = (1.1, deqsoln(1.2,-k)) )\n",
    "    plt.plot(T, deqsoln(T, k))\n",
    "    plt.annotate(f\"x(0) = {k}\", xy = (1.1, deqsoln(1.2,k)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The field mouse example we saw in class was: \n",
    "$$\n",
    "\\frac{dp}{dt}\n",
    "= \\frac{p - 900}{2}.\n",
    "$$\n",
    "\n",
    "We also solved this in class. We will solve this now and plot some solution curves. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           t      \n",
      "           ─      \n",
      "           2      \n",
      "x(t) = C₁⋅ℯ  + 900\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import sympy \n",
    "\n",
    "t = symbols('t')\n",
    "x = Function('x')\n",
    "\n",
    "deq = Eq(diff(x(t),t), (x(t) - 900) / 2)\n",
    "xsoln = dsolve(deq, x(t))\n",
    "pprint(xsoln)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "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": [
    "def deqsoln(t,C):\n",
    "    return C*np.exp(t/2) + 900\n",
    "\n",
    "T = np.arange(0,4, .5)\n",
    "plt.figure()\n",
    "plt.title('D')\n",
    "for k in range(4):\n",
    "    plt.plot(T, deqsoln(T, 10*k))\n",
    "    plt.annotate(f\"x(0) = {10*k + 900}\", xy = (3.1, deqsoln(3.4,10*k)) )\n",
    "    plt.plot(T, deqsoln(T, -10*k))\n",
    "    plt.annotate(f\"x(0) = {-10*k + 900}\", xy = (3.1, deqsoln(3.4,-10*k)) )"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}