Demonstrations of pretty display of math operations using Display_Math_Operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Display Math Operations (DMO)__\n",
    "\n",
    "Easy way(s) to get pretty math output in Jupyter notebooks. Defines a wrapper function to get nice\n",
    "typesetting of math operations. Overrides most sympy functions to generate typesetting of math operations\n",
    ", not just results. There is an option to make the typesetting automatic.\n",
    "\n",
    "This is intended mostly to aid with teaching students, who often have difficulty translating code into the symbolic math operations they are used to.\n",
    "\n",
    "The utility functions are:\n",
    "\n",
    "* `dmo_auto()`: Calling this function causes dmo aware functions (most sympy functions plus `diff(expr)` and `integ(expr)`)\n",
    "to display a typeset version of the operations carried out by the function. The call `dmo_auto(status=False)` turns this off. Turned on by default by the call `from Display_Math_Operations import *`.\n",
    "* `dmo()`: Passing a valid sympy expression or assignment statement to this function causes the expression or assignment to be evaluated and the operation output as typeset math. Also takes the optional argument `code=True`, causing it to try to output the result of the operation as plain code as well. This will just yield another typeset version of the result if `sympy.init_printing(pretty_print=True)` is set rather than `sympy.init_printing(pretty_print=False)`.\n",
    "\n",
    "_To suppress the display of typeset operations pass `display_op=False` to an operation or function._\n",
    "\n",
    "__This automated operation display will only work inside a Jupyter or IPython environment__\n",
    "\n",
    "The code making this work can be viewed in the file Display_Math_Operations.py. **_As this is not yet a pip package this file must be in the same directory as the notebook you wish to use it with._**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: unable to import algebraic_equation. Defaulting to just Sympy.\n",
      "Sympy successfully imported.\n",
      "Automatic typesetting of output disabled so output code can be copied into code cells.\n",
      "    To enable automatic typesetting of output issue the command `init_printing(pretty_print=True)`.\n",
      "Automatic display of math operation activated for `dmo aware` operations.\n"
     ]
    }
   ],
   "source": [
    "# This loads everything into the global namespace. If you wish to isolate replace with:\n",
    "# `import Display_Math_Operations as <some_name>`. Sympy operations will also be in the\n",
    "# namespace <some_name>.\n",
    "from Display_Math_Operations import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Using a Sympy function that has not been extended still works__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Min(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Assignment Statements__\n",
    "`dmo()` versus bare assignments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "var('a b c')\n",
    "t=a-b/c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$r\\equiv \\frac{a}{c} - b$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$t\\equiv a - \\frac{b}{c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(r = a/c-b)\n",
    "dmo(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$r\\equiv \\frac{a}{c} - b$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "a/c - b"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dmo(r,code=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$\\sin{\\left(r \\right)}=\\sin{\\left(\\frac{a}{c} - b \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$p\\equiv \\sin{\\left(\\frac{a}{c} - b \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Wrapping dmo() around an assignment statement that includes a dmo aware function generates multiple lines.\n",
    "dmo(p=sin(r))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$p\\equiv \\sin{\\left(\\frac{a}{c} - b \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Setting the keyword `display_op=False`, suppresses the typeset output of dmo aware functions\n",
    "dmo(p=sin(r,display_op=False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can suppress all typeset output\n",
    "p=sin(r,display_op=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$\\sin{\\left(r \\right)}=\\sin{\\left(\\frac{a}{c} - b \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Assignment without `dmo()` but with a dmo aware function.\n",
    "p=sin(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$p\\equiv \\sin{\\left(\\frac{a}{c} - b \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Random sample of some dmo aware functions__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$\\log{\\left(t \\right)}=\\log{\\left(a - \\frac{b}{c} \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$\\ln{\\left(t \\right)}=\\ln{\\left(a - \\frac{b}{c} \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "ln(a - b/c)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(t)\n",
    "ln(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$\\sin{\\left(\\frac{\\pi}{2} \\right)}=1$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$\\cos{\\left(r \\right)}=\\cos{\\left(\\frac{a}{c} - b \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$\\cos{\\left(\\frac{a}{2 c} - \\frac{b}{2} \\right)}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "cos(a/(2*c) - b/2)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(pi/2)\n",
    "cos(r)\n",
    "cos(r/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$L_{2}\\left(t\\right)=L_{2}\\left(a - \\frac{b}{c}\\right)=- 2 a + \\frac{2 b}{c} + \\frac{\\left(a - \\frac{b}{c}\\right)^{2}}{2} + 1$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "-2*a + 2*b/c + (a - b/c)**2/2 + 1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "laguerre(2,t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$r!=\\left(\\frac{a}{c} - b\\right)!$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "factorial(a/c - b)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$e^{t}=e^{a - \\frac{b}{c}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "exp(a - b/c)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$Y_{2}^{-1}\\left(\\theta,\\phi\\right)=Y_{2}^{-1}\\left(\\theta,\\phi\\right)=- e^{- 2 i \\phi} Y_{2}^{1}\\left(\\theta,\\phi\\right)$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$Y_{2}^{-1}\\left(1.57,3.14\\right)=- e^{- 6.28 i} Y_{2}^{1}\\left(1.57,3.14\\right)$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$Y_{2}^{-1}\\left(1.57,3.14\\right)=- e^{- 6.28 i} Y_{2}^{1}\\left(1.57,3.14\\right)$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "0.000199081614560854*sqrt(30)*exp(-3.14*I)/sqrt(pi)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The spherical harmonics `Ynm()` uses a different syntax than most functions and will need \n",
    "#    a special override written to make it print out the expanded form as part of the dmo aware typesetting.\n",
    "var('theta,phi')\n",
    "Ynm(2,-1,theta,phi)\n",
    "Ynm(2,-1,1.57,3.14)\n",
    "Ynm(2,-1,1.57,3.14).expand(func=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$Y_{2}^{-1}\\left(\\theta,\\phi\\right)=Y_{2}^{-1}\\left(\\theta,\\phi\\right)=- e^{- 2 i \\phi} Y_{2}^{1}\\left(\\theta,\\phi\\right)$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "sqrt(30)*exp(-I*phi)*sin(theta)*cos(theta)/(4*sqrt(pi))"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ynm(2,-1,theta,phi).expand(func=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Differentiation and Integration__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$q\\equiv \\frac{a b}{c^{2}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`diffdmo(q,c)`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{}q }{\\partial c^{} }=\\frac{\\partial^{} }{\\partial c^{} }{\\left(\\frac{a b}{c^{2}}\\right)}=- \\frac{2 a b}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This generates two outputs. `dmo(diff(q,c))`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{}q }{\\partial c^{} }=\\frac{\\partial^{} }{\\partial c^{} }{\\left(\\frac{a b}{c^{2}}\\right)}=- \\frac{2 a b}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$- \\frac{2 a b}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`dmo(diff(q,c))`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$- \\frac{2 a b}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`diff(q,c)`:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-2*a*b/c**3"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dmo(q = a*b/c**2)\n",
    "print('`diffdmo(q,c)`:')\n",
    "diffdmo(q,c)\n",
    "print('This generates two outputs. `dmo(diff(q,c))`:')\n",
    "dmo(diffdmo(q,c))\n",
    "print('`dmo(diff(q,c))`:')\n",
    "dmo(diff(q,c))\n",
    "print('`diff(q,c)`:')\n",
    "diff(q,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`diffdmo(q,c,b)`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{2}q }{\\partial c^{} \\partial b^{} }=\\frac{\\partial^{2} }{\\partial c^{} \\partial b^{} }{\\left(\\frac{a b}{c^{2}}\\right)}=- \\frac{2 a}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This shows the steps. `diffdmo(diffdmo(q,c),b)`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{}q }{\\partial c^{} }=\\frac{\\partial^{} }{\\partial c^{} }{\\left(\\frac{a b}{c^{2}}\\right)}=- \\frac{2 a b}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{} }{\\partial b^{} }{\\left(- \\frac{2 a b}{c^{3}}\\right)}=- \\frac{2 a}{c^{3}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`diffdmo(q,c,b,c)`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{3}q }{\\partial c^{} \\partial b^{} \\partial c^{} }=\\frac{\\partial^{3} }{\\partial c^{} \\partial b^{} \\partial c^{} }{\\left(\\frac{a b}{c^{2}}\\right)}=\\frac{6 a}{c^{4}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`diffdmo(q,c,2)`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\frac{\\partial^{2}q }{\\partial c^{2} }=\\frac{\\partial^{2} }{\\partial c^{2} }{\\left(\\frac{a b}{c^{2}}\\right)}=\\frac{6 a b}{c^{4}}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "6*a*b/c**4"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# higher order derivatives\n",
    "print('`diffdmo(q,c,b)`:')\n",
    "diffdmo(q,c,b)\n",
    "print('This shows the steps. `diffdmo(diffdmo(q,c),b)`:')\n",
    "diffdmo(diffdmo(q,c),b)\n",
    "print('`diffdmo(q,c,b,c)`:')\n",
    "diffdmo(q,c,b,c)\n",
    "print('`diffdmo(q,c,2)`:')\n",
    "diffdmo(q,c,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`integ(q,c)`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\int q\\, dc=\\int \\frac{a b}{c^{2}}\\, dc=- \\frac{a b}{c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This generates two outputs. `dmo(integ(q,c))`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\int q\\, dc=\\int \\frac{a b}{c^{2}}\\, dc=- \\frac{a b}{c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$- \\frac{a b}{c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`dmo(integrate(q,c))`:\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$- \\frac{a b}{c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`integrate(q,c)`:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-a*b/c"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('`integ(q,c)`:')\n",
    "integ(q,c)\n",
    "print('This generates two outputs. `dmo(integ(q,c))`:')\n",
    "dmo(integ(q,c))\n",
    "print('`dmo(integrate(q,c))`:')\n",
    "dmo(integrate(q,c))\n",
    "print('`integrate(q,c)`:')\n",
    "integrate(q,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$\\int\\limits_{1}^{2} q\\, dc=\\int\\limits_{1}^{2} \\frac{a b}{c^{2}}\\, dc=\\frac{a b}{2}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$c12\\equiv \\frac{a b}{2}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$\\int\\limits_{1}^{2} q\\, dc=\\int\\limits_{1}^{2} \\frac{a b}{c^{2}}\\, dc=\\frac{a b}{2}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "a*b/2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# with limits\n",
    "dmo(c12=integ(q,(c,1,2)))\n",
    "integ(q,(c,1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In one step `integ(q,c,b)`\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\iint q\\, dc\\, db=\\iint \\frac{a b}{c^{2}}\\, dc\\, db=- \\frac{a b^{2}}{2 c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In separate steps `integ(integ(q,c),b)`\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "$$\\int q\\, dc=\\int \\frac{a b}{c^{2}}\\, dc=- \\frac{a b}{c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$\\int - \\frac{a b}{c}\\, db=- \\frac{a b^{2}}{2 c}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "-a*b**2/(2*c)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiple integrals\n",
    "print('In one step `integ(q,c,b)`')\n",
    "integ(q,c,b)\n",
    "print('In separate steps `integ(integ(q,c),b)`')\n",
    "integ(integ(q,c),b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Use with random operations__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$M\\equiv \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Matrix([\n",
       "[1, 2],\n",
       "[3, 4]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dmo(M=Matrix([[1,2],[3,4]]),code=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$M\\equiv \\left[\\begin{matrix}1 & 2\\\\3 & 4\\end{matrix}\\right]$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(M)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$T\\equiv \\left[\\begin{matrix}1 & 3\\\\2 & 4\\end{matrix}\\right]$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(T=M.transpose())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$Meigvals\\equiv \\left\\{ \\frac{5}{2} - \\frac{\\sqrt{33}}{2} : 1, \\  \\frac{5}{2} + \\frac{\\sqrt{33}}{2} : 1\\right\\}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$Meigvecs\\equiv \\left[ \\left( \\frac{5}{2} - \\frac{\\sqrt{33}}{2}, \\  1, \\  \\left[ \\left[\\begin{matrix}- \\frac{2}{- \\frac{3}{2} + \\frac{\\sqrt{33}}{2}}\\\\1\\end{matrix}\\right]\\right]\\right), \\  \\left( \\frac{5}{2} + \\frac{\\sqrt{33}}{2}, \\  1, \\  \\left[ \\left[\\begin{matrix}- \\frac{2}{- \\frac{\\sqrt{33}}{2} - \\frac{3}{2}}\\\\1\\end{matrix}\\right]\\right]\\right)\\right]$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(Meigvals=M.eigenvals())\n",
    "dmo(Meigvecs=M.eigenvects())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$e^{- i b}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "$$psi\\equiv e^{- i b}$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(psi=exp(-I*b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "$$psi1\\equiv -0.7027 - 0.7115 i$$"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dmo(psi1=psi.evalf(4,subs={b:2.35}))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}