{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lecture Notebook N01\n",
    "\n",
    "Thursday, September 26, 2019\n",
    "\n",
    "This is the standard import we will use in the first portion of the class. It imports the core SymPy tools and the special tools from the mechanics package. The `init_printing()` function is optional but it will increase the number of outputs that print as symbolic math."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sympy as sm\n",
    "import sympy.physics.mechanics as me\n",
    "sm.init_printing()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This creates three symbols and shows how to create expressions with them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = sm.symbols('a, b, c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAD0AAAAWCAYAAABzCZQcAAAABHNCSVQICAgIfAhkiAAAAlVJREFUWIXt1kuIz1EUB/BPjEeMGjQxJCkrGa8NS7FBSVla6E9KsVEWopSUFIksKKVQQnmVlFcslDdjNkISWXiMR5H3YyzOHU0zv/mP/zVGab51u3VO53vOuffccy49+C+wGtfxFk04gfH/NKJuwGksEonW4xieYci/DKpSLEMzFmfaV+M75rYIenVBUH8bU9J+M9N+kMjzddeE0z1owEdUZdofShy9uyyi30BJlOf0DNt++IKrmb434ynGthYWlfcC7Md9vMMb0Q0XZTr+E9SjjyjtSTiCV3iPM8p35S1YiJl4UM7JIHzFZezGxrS/FLe1KiPwkvybXppsT4pED2MTLib5C9QU2G3Hc4z7HSfVGF4grxO3frfSqP1Z0ruS7UtMbqPbl3Rr2sh3iBk9Q+TSsqoz/LsnTrZSlOQnfUPH42pq0h1oI2/uYK3ryMlgrMUV8Za/tzG81UmQj8o4LVp7ynD1wefEWdS5RyeOY53E1A6tySaI5jAM13BQzLavGCOaQmMnfNu0f2OTMA97RQKtcbsMVz36im/ktwL96LQ/7iSmsmjEJ8VluF6c6vIM3pK88l6S7FZ2oN+a9HMyYgKjEsGpAl0NniT9tAzukrykdya7DQW6OnwQYzX306I2Obgv3lILhooPfLMo8/4Z3CV5SV9Ldg8xsJW8GmdFv5mVEc+vU2rCedHmr+KcOM3ZuIAfuCPKvztQJd50AwaIt39c/NDmYwRWKK7MilArZl+TmMmXRPOaLE58dyZvSeU3PTHZ7MJIHBWz962ovEq4etCDHvzn+AngbKIakY03GAAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle a + b^{2}$"
      ],
      "text/plain": [
       "     2\n",
       "a + b "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "expr = a + b**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFYAAAAYCAYAAABgBArrAAAABHNCSVQICAgIfAhkiAAAA21JREFUaIHt2H2on2MYB/CPmZ0dO9q8xfHSIlZktrXlJSkhoqT4iz/0G0pNJP7QlEiJhsgfUycrVmLlONNSLFEIY5mlvEVtydvOvDRxxl6OP6772Nnj+b089/Nrp/H71tP9675+1/e67uu57uu+7oceeugSluND7MAo1uGsKeT5z+A1LBVBmI8R/ICjDgTPamzDrIrGpgLLMI4bM/UHsAdXFeYXJ96bavL8gyXYizur+zgleFoEYEGm/mDSv6BENoLvRdDq8ID1+BX91X2cEmzCGKZn6q9JHIeWyM4RwbqnJo95IluH8nysjIZw/KJM/T78hQ2Z+o+IjDytxX8+w1ZNAtYpz8NioZc0kV+P5/AlfsMv4mRc2sJoKzTUC+ySpL8SCzGMn/C72HmtTunH8CPObGPjvmTj8jo8G7Fb+aF1BHbhPazCQ2ncngzf3cbBMjTUC+wtSf8VEcwXsQJvp/ltmFOi96TOggqXJq5Hc3lmiaB+0kQ+gONL5gdF9n7egZNFNNQL7FDS345FBdlq5fVxpeg9LxbrmXiaHVCzE88HuTzzEsH6DhZUxBciO6qioV5gN2reap2bZM8X5sebPPe3sDMmetQsnvOTYE0T8iNxL94XtXVPgfCjFo7BlhbOlD3PtOE7DH8m3rKOYG7iGWnD0wm+Fbu5Y0x2aCyNM0v+d7bI5OPElngBP4uaewpuwOY2tp7w73q3EFfjWRGgyfi4Dd98zBBXybJFz03j1jY8naDfvvhUxgniDb9TItuMncq37ANJ79YMmw35peDmpHtXE/njSX5lBvdkTBMt6Ne5BIeIOjlamD9ZOPhqic4cfJPk52XYbMgP7FNJ98ES2SD+EG1h7sVhAmckO8NVlKZN+j2Ot3CM/RvdnWk8VdS1CRwt6vFJYiu227rdxuI0Xmf/9nBAdAR9uF3F2liCiYR5s4pS8W0O41rRDH+V5kbxhmgrNuB1kRFXJGN78al9L+BAYLqosZtwuHipa0UwrxFl7Q7lu6wqLhMH9ct1SGaItqJ4RTxWZMGo6FnfFQfWIpHpqzLtNeSVggVJbwgn4iXRU+4Qn/Oq8jXDbHFore0G2XLhdLHh/j/iNhGLC7tBNlO0KOu6QXYQox/fiWtyZZR9sdktmv0+cbPZle3awY3TxQVkhfiM2kMPPfRQFX8DBk75il2xqCQAAAAASUVORK5CYII=\n",
      "text/latex": [
       "$\\displaystyle \\left(a + b^{2}\\right)^{2}$"
      ],
      "text/plain": [
       "        2\n",
       "⎛     2⎞ \n",
       "⎝a + b ⎠ "
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr * expr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy will not simplify or expand expressions by default. You have to use various functions to do so. This shouws how to expand the expression we created above using the `expand` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_expr = expr*expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAFYAAAAYCAYAAABgBArrAAAABHNCSVQICAgIfAhkiAAAA21JREFUaIHt2H2on2MYB/CPmZ0dO9q8xfHSIlZktrXlJSkhoqT4iz/0G0pNJP7QlEiJhsgfUycrVmLlONNSLFEIY5mlvEVtydvOvDRxxl6OP6772Nnj+b089/Nrp/H71tP9675+1/e67uu57uu+7oceeugSluND7MAo1uGsKeT5z+A1LBVBmI8R/ICjDgTPamzDrIrGpgLLMI4bM/UHsAdXFeYXJ96bavL8gyXYizur+zgleFoEYEGm/mDSv6BENoLvRdDq8ID1+BX91X2cEmzCGKZn6q9JHIeWyM4RwbqnJo95IluH8nysjIZw/KJM/T78hQ2Z+o+IjDytxX8+w1ZNAtYpz8NioZc0kV+P5/AlfsMv4mRc2sJoKzTUC+ySpL8SCzGMn/C72HmtTunH8CPObGPjvmTj8jo8G7Fb+aF1BHbhPazCQ2ncngzf3cbBMjTUC+wtSf8VEcwXsQJvp/ltmFOi96TOggqXJq5Hc3lmiaB+0kQ+gONL5gdF9n7egZNFNNQL7FDS345FBdlq5fVxpeg9LxbrmXiaHVCzE88HuTzzEsH6DhZUxBciO6qioV5gN2reap2bZM8X5sebPPe3sDMmetQsnvOTYE0T8iNxL94XtXVPgfCjFo7BlhbOlD3PtOE7DH8m3rKOYG7iGWnD0wm+Fbu5Y0x2aCyNM0v+d7bI5OPElngBP4uaewpuwOY2tp7w73q3EFfjWRGgyfi4Dd98zBBXybJFz03j1jY8naDfvvhUxgniDb9TItuMncq37ANJ79YMmw35peDmpHtXE/njSX5lBvdkTBMt6Ne5BIeIOjlamD9ZOPhqic4cfJPk52XYbMgP7FNJ98ES2SD+EG1h7sVhAmckO8NVlKZN+j2Ot3CM/RvdnWk8VdS1CRwt6vFJYiu227rdxuI0Xmf/9nBAdAR9uF3F2liCiYR5s4pS8W0O41rRDH+V5kbxhmgrNuB1kRFXJGN78al9L+BAYLqosZtwuHipa0UwrxFl7Q7lu6wqLhMH9ct1SGaItqJ4RTxWZMGo6FnfFQfWIpHpqzLtNeSVggVJbwgn4iXRU+4Qn/Oq8jXDbHFore0G2XLhdLHh/j/iNhGLC7tBNlO0KOu6QXYQox/fiWtyZZR9sdktmv0+cbPZle3awY3TxQVkhfiM2kMPPfRQFX8DBk75il2xqCQAAAAASUVORK5CYII=\n",
      "text/latex": [
       "$\\displaystyle \\left(a + b^{2}\\right)^{2}$"
      ],
      "text/plain": [
       "        2\n",
       "⎛     2⎞ \n",
       "⎝a + b ⎠ "
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAJEAAAAWCAYAAADAbX5DAAAABHNCSVQICAgIfAhkiAAAA+tJREFUaIHt2X+o3XMYB/AXxsRdxgwjrUmRjA1l+Wuu5EdJ8Z/EwVayWsofy2q1lPyB/GxqRSihxlZLGYtbfsTMrlkNC10UMYbJr/1w/fF8To7v/Z577/dzztk53c67vp1zP5/v8zzv5znP5/N5Ps+ljz66jLvxAfZiNzbi3K4y6j1MpRitxCgebxw8vEWli7EGl2AQB7AZJ7SodyphsakRo0VYio87bWgAB3FNpw11EXeI1Xhrpny3Y5TD/zh8IRbBkDbvREXMSDr3tFnvRJiFJViPz/EnfsXbuE17/bwgfX6YKd+tGNWRw38t1uGN9tMZixcxjCMOhbEG3C5W17d4DvfhKfySxtfhsDbZGhZJOi1TvlsxqqMq/6Ui4Y5Kfw8p7ETtxP34DmdmytfED744Q3ZQHA/FHecUfJ30Xp/JqxHTsQ/vZ8p3M0ZU53+WuAyc3TA2ZBJJdINYzbvwG34Wt4tbxpF5EN/jnEmSK0NNawFqhvqN4rGSuaq+XpR0rcECvISf8DteM/6tqxdiVJV/3d6BhmcU/6Tv0xm7cmfgGZyBt0TGvYx54nhYUULsUdyIS7Ez07lOYn/6PFAYz/H1wvQ5F++IgD6Jbbhc1AwzS+R6JUZV+W/AfJFw9WcrXkjf95UZGRBHQBFzxEr9tDC+RvQ/BpNc/Rmo4llCTft3omnYkfReUZir6itRYI7iRywszD2b5lYWxnspRjn8ixjSQk30GX4ojI02eVZn6K9pfxI9kHS+UlGuzFdiFTa7Hl+c5p4vjPdSjHL4FzFkgiQ6HqvwnqgPDvq/49uqMB4HI5oHt+x5OsPG8iT7ifLGXlVfj8TfiXvZzWZuklufwbUMI9obo47xb1R2niiuTsYWce7tETXFPNyE7VUNNMHDxtYOC3CtqFNGCnMfVdS/DI+I+uMyY3syOb7OF9fcjcbWV8SPAF9V5NoM7Y7RIeG/HX8p3yrvEVm6rBUDE6CmPcfZnUnPDpzU5J0cX5ek8bua6HwozV9djW4l1OTHqOP8T08KXi2Zm4lv0vyiXAOTQE3rSbQi6RjGiU3eyfX1iTR+b4ncHPwhWgW5TcjJoCY/Rh3nPzsZ2CXOzjpmYVOa24+jcw1MAjWtJdGqJL/V+P/czPV1S5r7Esc2jA/gdVFTXZnJfbKoyY9Rx/jXs2636BEMim7mZpGdV+FN0VzaKY6AXsTN4hg6KHo+y0veGRHFZ46v00RNMYxjRP2xQTTbrsOp4hgt2916AYeM/2zRK9gt+iTvigJzof+aUp1ETf4qW23i28tQw/tVfT0/ja/FaaIpuTc9mzI556AmL0a9wr+PPvroo48++uhjyuJfZfGJXtX9OpkAAAAASUVORK5CYII=\n",
      "text/latex": [
       "$\\displaystyle a^{2} + 2 a b^{2} + b^{4}$"
      ],
      "text/plain": [
       " 2        2    4\n",
       "a  + 2⋅a⋅b  + b "
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm.expand(new_expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you know the name of the function you want to use you can open it's help documentation by appending the `?` symbol. This only works in the notebook or IPython terminal, not the basic Python command prompt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0msm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexpand\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdeep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmodulus\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpower_base\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpower_exp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmul\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlog\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmultinomial\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbasic\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mhints\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",
       "Expand an expression using methods given as hints.\n",
       "\n",
       "Hints evaluated unless explicitly set to False are:  ``basic``, ``log``,\n",
       "``multinomial``, ``mul``, ``power_base``, and ``power_exp`` The following\n",
       "hints are supported but not applied unless set to True:  ``complex``,\n",
       "``func``, and ``trig``.  In addition, the following meta-hints are\n",
       "supported by some or all of the other hints:  ``frac``, ``numer``,\n",
       "``denom``, ``modulus``, and ``force``.  ``deep`` is supported by all\n",
       "hints.  Additionally, subclasses of Expr may define their own hints or\n",
       "meta-hints.\n",
       "\n",
       "The ``basic`` hint is used for any special rewriting of an object that\n",
       "should be done automatically (along with the other hints like ``mul``)\n",
       "when expand is called. This is a catch-all hint to handle any sort of\n",
       "expansion that may not be described by the existing hint names. To use\n",
       "this hint an object should override the ``_eval_expand_basic`` method.\n",
       "Objects may also define their own expand methods, which are not run by\n",
       "default.  See the API section below.\n",
       "\n",
       "If ``deep`` is set to ``True`` (the default), things like arguments of\n",
       "functions are recursively expanded.  Use ``deep=False`` to only expand on\n",
       "the top level.\n",
       "\n",
       "If the ``force`` hint is used, assumptions about variables will be ignored\n",
       "in making the expansion.\n",
       "\n",
       "Hints\n",
       "=====\n",
       "\n",
       "These hints are run by default\n",
       "\n",
       "mul\n",
       "---\n",
       "\n",
       "Distributes multiplication over addition:\n",
       "\n",
       ">>> from sympy import cos, exp, sin\n",
       ">>> from sympy.abc import x, y, z\n",
       ">>> (y*(x + z)).expand(mul=True)\n",
       "x*y + y*z\n",
       "\n",
       "multinomial\n",
       "-----------\n",
       "\n",
       "Expand (x + y + ...)**n where n is a positive integer.\n",
       "\n",
       ">>> ((x + y + z)**2).expand(multinomial=True)\n",
       "x**2 + 2*x*y + 2*x*z + y**2 + 2*y*z + z**2\n",
       "\n",
       "power_exp\n",
       "---------\n",
       "\n",
       "Expand addition in exponents into multiplied bases.\n",
       "\n",
       ">>> exp(x + y).expand(power_exp=True)\n",
       "exp(x)*exp(y)\n",
       ">>> (2**(x + y)).expand(power_exp=True)\n",
       "2**x*2**y\n",
       "\n",
       "power_base\n",
       "----------\n",
       "\n",
       "Split powers of multiplied bases.\n",
       "\n",
       "This only happens by default if assumptions allow, or if the\n",
       "``force`` meta-hint is used:\n",
       "\n",
       ">>> ((x*y)**z).expand(power_base=True)\n",
       "(x*y)**z\n",
       ">>> ((x*y)**z).expand(power_base=True, force=True)\n",
       "x**z*y**z\n",
       ">>> ((2*y)**z).expand(power_base=True)\n",
       "2**z*y**z\n",
       "\n",
       "Note that in some cases where this expansion always holds, SymPy performs\n",
       "it automatically:\n",
       "\n",
       ">>> (x*y)**2\n",
       "x**2*y**2\n",
       "\n",
       "log\n",
       "---\n",
       "\n",
       "Pull out power of an argument as a coefficient and split logs products\n",
       "into sums of logs.\n",
       "\n",
       "Note that these only work if the arguments of the log function have the\n",
       "proper assumptions--the arguments must be positive and the exponents must\n",
       "be real--or else the ``force`` hint must be True:\n",
       "\n",
       ">>> from sympy import log, symbols\n",
       ">>> log(x**2*y).expand(log=True)\n",
       "log(x**2*y)\n",
       ">>> log(x**2*y).expand(log=True, force=True)\n",
       "2*log(x) + log(y)\n",
       ">>> x, y = symbols('x,y', positive=True)\n",
       ">>> log(x**2*y).expand(log=True)\n",
       "2*log(x) + log(y)\n",
       "\n",
       "basic\n",
       "-----\n",
       "\n",
       "This hint is intended primarily as a way for custom subclasses to enable\n",
       "expansion by default.\n",
       "\n",
       "These hints are not run by default:\n",
       "\n",
       "complex\n",
       "-------\n",
       "\n",
       "Split an expression into real and imaginary parts.\n",
       "\n",
       ">>> x, y = symbols('x,y')\n",
       ">>> (x + y).expand(complex=True)\n",
       "re(x) + re(y) + I*im(x) + I*im(y)\n",
       ">>> cos(x).expand(complex=True)\n",
       "-I*sin(re(x))*sinh(im(x)) + cos(re(x))*cosh(im(x))\n",
       "\n",
       "Note that this is just a wrapper around ``as_real_imag()``.  Most objects\n",
       "that wish to redefine ``_eval_expand_complex()`` should consider\n",
       "redefining ``as_real_imag()`` instead.\n",
       "\n",
       "func\n",
       "----\n",
       "\n",
       "Expand other functions.\n",
       "\n",
       ">>> from sympy import gamma\n",
       ">>> gamma(x + 1).expand(func=True)\n",
       "x*gamma(x)\n",
       "\n",
       "trig\n",
       "----\n",
       "\n",
       "Do trigonometric expansions.\n",
       "\n",
       ">>> cos(x + y).expand(trig=True)\n",
       "-sin(x)*sin(y) + cos(x)*cos(y)\n",
       ">>> sin(2*x).expand(trig=True)\n",
       "2*sin(x)*cos(x)\n",
       "\n",
       "Note that the forms of ``sin(n*x)`` and ``cos(n*x)`` in terms of ``sin(x)``\n",
       "and ``cos(x)`` are not unique, due to the identity `\\sin^2(x) + \\cos^2(x)\n",
       "= 1`.  The current implementation uses the form obtained from Chebyshev\n",
       "polynomials, but this may change.  See `this MathWorld article\n",
       "<http://mathworld.wolfram.com/Multiple-AngleFormulas.html>`_ for more\n",
       "information.\n",
       "\n",
       "Notes\n",
       "=====\n",
       "\n",
       "- You can shut off unwanted methods::\n",
       "\n",
       "    >>> (exp(x + y)*(x + y)).expand()\n",
       "    x*exp(x)*exp(y) + y*exp(x)*exp(y)\n",
       "    >>> (exp(x + y)*(x + y)).expand(power_exp=False)\n",
       "    x*exp(x + y) + y*exp(x + y)\n",
       "    >>> (exp(x + y)*(x + y)).expand(mul=False)\n",
       "    (x + y)*exp(x)*exp(y)\n",
       "\n",
       "- Use deep=False to only expand on the top level::\n",
       "\n",
       "    >>> exp(x + exp(x + y)).expand()\n",
       "    exp(x)*exp(exp(x)*exp(y))\n",
       "    >>> exp(x + exp(x + y)).expand(deep=False)\n",
       "    exp(x)*exp(exp(x + y))\n",
       "\n",
       "- Hints are applied in an arbitrary, but consistent order (in the current\n",
       "  implementation, they are applied in alphabetical order, except\n",
       "  multinomial comes before mul, but this may change).  Because of this,\n",
       "  some hints may prevent expansion by other hints if they are applied\n",
       "  first. For example, ``mul`` may distribute multiplications and prevent\n",
       "  ``log`` and ``power_base`` from expanding them. Also, if ``mul`` is\n",
       "  applied before ``multinomial`, the expression might not be fully\n",
       "  distributed. The solution is to use the various ``expand_hint`` helper\n",
       "  functions or to use ``hint=False`` to this function to finely control\n",
       "  which hints are applied. Here are some examples::\n",
       "\n",
       "    >>> from sympy import expand, expand_mul, expand_power_base\n",
       "    >>> x, y, z = symbols('x,y,z', positive=True)\n",
       "\n",
       "    >>> expand(log(x*(y + z)))\n",
       "    log(x) + log(y + z)\n",
       "\n",
       "  Here, we see that ``log`` was applied before ``mul``.  To get the mul\n",
       "  expanded form, either of the following will work::\n",
       "\n",
       "    >>> expand_mul(log(x*(y + z)))\n",
       "    log(x*y + x*z)\n",
       "    >>> expand(log(x*(y + z)), log=False)\n",
       "    log(x*y + x*z)\n",
       "\n",
       "  A similar thing can happen with the ``power_base`` hint::\n",
       "\n",
       "    >>> expand((x*(y + z))**x)\n",
       "    (x*y + x*z)**x\n",
       "\n",
       "  To get the ``power_base`` expanded form, either of the following will\n",
       "  work::\n",
       "\n",
       "    >>> expand((x*(y + z))**x, mul=False)\n",
       "    x**x*(y + z)**x\n",
       "    >>> expand_power_base((x*(y + z))**x)\n",
       "    x**x*(y + z)**x\n",
       "\n",
       "    >>> expand((x + y)*y/x)\n",
       "    y + y**2/x\n",
       "\n",
       "  The parts of a rational expression can be targeted::\n",
       "\n",
       "    >>> expand((x + y)*y/x/(x + 1), frac=True)\n",
       "    (x*y + y**2)/(x**2 + x)\n",
       "    >>> expand((x + y)*y/x/(x + 1), numer=True)\n",
       "    (x*y + y**2)/(x*(x + 1))\n",
       "    >>> expand((x + y)*y/x/(x + 1), denom=True)\n",
       "    y*(x + y)/(x**2 + x)\n",
       "\n",
       "- The ``modulus`` meta-hint can be used to reduce the coefficients of an\n",
       "  expression post-expansion::\n",
       "\n",
       "    >>> expand((3*x + 1)**2)\n",
       "    9*x**2 + 6*x + 1\n",
       "    >>> expand((3*x + 1)**2, modulus=5)\n",
       "    4*x**2 + x + 1\n",
       "\n",
       "- Either ``expand()`` the function or ``.expand()`` the method can be\n",
       "  used.  Both are equivalent::\n",
       "\n",
       "    >>> expand((x + 1)**2)\n",
       "    x**2 + 2*x + 1\n",
       "    >>> ((x + 1)**2).expand()\n",
       "    x**2 + 2*x + 1\n",
       "\n",
       "API\n",
       "===\n",
       "\n",
       "Objects can define their own expand hints by defining\n",
       "``_eval_expand_hint()``.  The function should take the form::\n",
       "\n",
       "    def _eval_expand_hint(self, **hints):\n",
       "        # Only apply the method to the top-level expression\n",
       "        ...\n",
       "\n",
       "See also the example below.  Objects should define ``_eval_expand_hint()``\n",
       "methods only if ``hint`` applies to that specific object.  The generic\n",
       "``_eval_expand_hint()`` method defined in Expr will handle the no-op case.\n",
       "\n",
       "Each hint should be responsible for expanding that hint only.\n",
       "Furthermore, the expansion should be applied to the top-level expression\n",
       "only.  ``expand()`` takes care of the recursion that happens when\n",
       "``deep=True``.\n",
       "\n",
       "You should only call ``_eval_expand_hint()`` methods directly if you are\n",
       "100% sure that the object has the method, as otherwise you are liable to\n",
       "get unexpected ``AttributeError``s.  Note, again, that you do not need to\n",
       "recursively apply the hint to args of your object: this is handled\n",
       "automatically by ``expand()``.  ``_eval_expand_hint()`` should\n",
       "generally not be used at all outside of an ``_eval_expand_hint()`` method.\n",
       "If you want to apply a specific expansion from within another method, use\n",
       "the public ``expand()`` function, method, or ``expand_hint()`` functions.\n",
       "\n",
       "In order for expand to work, objects must be rebuildable by their args,\n",
       "i.e., ``obj.func(*obj.args) == obj`` must hold.\n",
       "\n",
       "Expand methods are passed ``**hints`` so that expand hints may use\n",
       "'metahints'--hints that control how different expand methods are applied.\n",
       "For example, the ``force=True`` hint described above that causes\n",
       "``expand(log=True)`` to ignore assumptions is such a metahint.  The\n",
       "``deep`` meta-hint is handled exclusively by ``expand()`` and is not\n",
       "passed to ``_eval_expand_hint()`` methods.\n",
       "\n",
       "Note that expansion hints should generally be methods that perform some\n",
       "kind of 'expansion'.  For hints that simply rewrite an expression, use the\n",
       ".rewrite() API.\n",
       "\n",
       "Examples\n",
       "========\n",
       "\n",
       ">>> from sympy import Expr, sympify\n",
       ">>> class MyClass(Expr):\n",
       "...     def __new__(cls, *args):\n",
       "...         args = sympify(args)\n",
       "...         return Expr.__new__(cls, *args)\n",
       "...\n",
       "...     def _eval_expand_double(self, **hints):\n",
       "...         '''\n",
       "...         Doubles the args of MyClass.\n",
       "...\n",
       "...         If there more than four args, doubling is not performed,\n",
       "...         unless force=True is also used (False by default).\n",
       "...         '''\n",
       "...         force = hints.pop('force', False)\n",
       "...         if not force and len(self.args) > 4:\n",
       "...             return self\n",
       "...         return self.func(*(self.args + self.args))\n",
       "...\n",
       ">>> a = MyClass(1, 2, MyClass(3, 4))\n",
       ">>> a\n",
       "MyClass(1, 2, MyClass(3, 4))\n",
       ">>> a.expand(double=True)\n",
       "MyClass(1, 2, MyClass(3, 4, 3, 4), 1, 2, MyClass(3, 4, 3, 4))\n",
       ">>> a.expand(double=True, deep=False)\n",
       "MyClass(1, 2, MyClass(3, 4), 1, 2, MyClass(3, 4))\n",
       "\n",
       ">>> b = MyClass(1, 2, 3, 4, 5)\n",
       ">>> b.expand(double=True)\n",
       "MyClass(1, 2, 3, 4, 5)\n",
       ">>> b.expand(double=True, force=True)\n",
       "MyClass(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)\n",
       "\n",
       "See Also\n",
       "========\n",
       "\n",
       "expand_log, expand_mul, expand_multinomial, expand_complex, expand_trig,\n",
       "expand_power_base, expand_power_exp, expand_func, hyperexpand\n",
       "\u001b[0;31mFile:\u001b[0m      /opt/conda/lib/python3.6/site-packages/sympy/core/function.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sm.expand?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Greek symbols will render nicely too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "omega = sm.symbols('omega')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAABIAAAAPCAYAAADphp8SAAAABHNCSVQICAgIfAhkiAAAAPxJREFUOI3l0r8rxVEYx/GXW1I3kaI7Wgx3M/kRi8mkZGGSwSD/gsGoDDJbzLLJrphICoOU0jWJUhJhuobvo06nb30nk2d5Ou/Pc96dzjn8Ya2gja2KufuYa5SFDbziEd0Vov0QzUEtC9fRiw28V4ha0Zu5qB/LeMNuhQQ+ovflonl04SAZglHsYSIT1aN/56Kp6MfZhhks/G5Iaij6XX7UK8XlTWb8LPhAwmp4Cj6Yi1oRDCesGayNnoRPBzvNJXAe4WKsO3CIi+Ajweu4DDZbJlqL8EXxGY8ULziGT9xgE7cxt1MmgU5s41nxaicYj2wJD/jCNVbjxP+hfgCfczl/SDZktgAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle \\omega$"
      ],
      "text/plain": [
       "ω"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "omega"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create arbitrary functions of variables. In this case we make a function of $t$ to represent time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = sm.symbols('t')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = sm.Function('F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy knows how to differentiate these mathematical functions:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAADUAAAAhCAYAAAB5oeP9AAAABHNCSVQICAgIfAhkiAAAAzRJREFUWIXt10+IVlUYBvDfTJKKgYZBEhhBMpOB5OQ01MLcWC0CcdMmI6HAlbYQIVyZgUXlpqBSF2JtKigqIiITzaLIial0wKFVfygVW1RGaVJ9Lc65M9fbvefeO45+EN8DH+d+5zznPc/5877nvPRgIya6LaIO/S35t+CrSyFkJvG/nFQKgziIcxjHCP7APd0UdTEYwK94FktwL75DB9degvFexmnMa9FnRdTzcNMOH+CVQt1enGzYt5P47Svwh/EPNlfY2xz73V/S9mbUdFW+clYJcTFWC8ctj78086dbI3dHRfuBwv8ncAYvJuzBWEnbkziCR6KdSqyJoq4s1I9FIyncKKzqFzW8DAPCLu1JcCbwm+qgNiG4xhVZRRmxEwmzc3WrhBWr26nhWH5ew8vwEPrwWknbU1HLTcLx+tvUEX4gx3sV1wunC+XHbwx/YieejkZfiG0zPanVUexnFTpewnp8KvhqhsO5709ieRfeTw22Dt/jZ3yIx/G7+nvtkLCSe/FY4belwJ0nHPPxhL0N0d6GBGd+5IzWaJsW+vCL6qh3qMAfiPX7EzZ3Rc5wggNncaq95HoMRgEfNeTfEfll/pRhFOdd6N9l+FHYdbR/JqWQreaXDflnYzmnon0WluG44OMpzM3ZmwwUnYZCqtBnalJNw/npWC6saL9ZmHCdvX4swDdZRTapvoZCUmg7qZP4STi2ZVgey7qdHxT0T0bmJsevSQ7VH0Wca8DNkPnfNcL7sohsB8/U2Lk9lpOBqMmk8unGTrxbwlkqXJDjcg7bAG/Esuzlnz2LduAZ4Vq4r4R3t3DXvd1iXKN4NH4fxvYSzoPCyu9qY1h4ip0S3m9l2IivhRPQ8d/35HwhQLyVGiSVQ5134b2TujTbYGu0NzSNvpti35VVhLocaiR+j2ARrp6GiDLMieO807LfXJzA6ylSXQ61VnDamYiURdyJbdoliUsFP7uhirBY2IXbCvV78F783o6PWwzaNWTRb0iIIEcL7StMRb7lmr8WuopsUk1yqGU4dvmkXTyuEyLebiF7zQeJ7Mb/Fs9F7oLLL3F6qMuh1uEHIf1+vgv6euihhx5mDv8CijnMsMgt7PIAAAAASUVORK5CYII=\n",
      "text/latex": [
       "$\\displaystyle \\frac{d}{d t} F{\\left(t \\right)}$"
      ],
      "text/plain": [
       "d       \n",
       "──(F(t))\n",
       "dt      "
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm.diff(f(t), t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The mechanics package has a convience function for creating functions of time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_of_t = me.dynamicsymbols('f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAB8AAAAVCAYAAAC+NTVfAAAABHNCSVQICAgIfAhkiAAAAgRJREFUSInt1btvj1EcBvAPbWhTlNQmMdFWQ1wjFpPSP8AmEoPoICxdhAWJJi6b0UZsCNJIXAYhIYgiBBEGFpVK3Br38jOc8+N1nPf3a2Mx+CZvviff5zzPc855z4V/MKbhIJ7iCyrYFrEjGEbLGLWWRv7GsZoPRMIZ7MEuzMMyfEdfhtMXOesy2EkMYUo9484ocjaDnccbNGewo5HXkcGWR2xHPfPNseOmpN4uzPpQCe8hRjCxBv4MDTlwbTTNfZ3YG9urEt6+Grz1hX47Y62nWmgsgEPYLcx8BvpjvYLH6MY3XEvMB3EYG3AVFwrYpUL7SsyrcS43+wZ8wN2k3oJR3MuR0BsH2VuCQ2vsc6NaSP9Pl7CZbiX1WXFgQyXCS2JOecV4i0+YXWZeJtIW8+sa5l+Vr0w1XmFmPfPbSf1jzE0ZwUYswAN8rmPeXNDKmldwJ6kPx9zmz+iKg6q15FWv6QWt38wnYKGws0cS4hBeyl8gi2JOVyuNjujxc2JF83ZMLRGp4LLwv+YkWHU13tUxXxHzxWqheM7r7dgTwkXUgyeF+mDM/ZiP97iPYwl/jXBPnM6JHxBm2F1iPgkvcD2DbcEj4ShV/LqgqtEqbLRTJdpjiu1RfPE4eVsjb+XfmDcJj8PAODjNeI7jKZB9YWrEqLAnJuOmcLHUi7nC+d8vPMf/ww/hp3/uuuC4KgAAAABJRU5ErkJggg==\n",
      "text/latex": [
       "$\\displaystyle f{\\left(t \\right)}$"
      ],
      "text/plain": [
       "f(t)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f_of_t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy is a powerful tool. It can solve many integrals that are not that fun to solve by hand. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle \\frac{\\omega^{2} e^{- \\omega} \\sin{\\left(\\omega \\right)}}{2} - \\frac{\\omega^{2} e^{- \\omega} \\cos{\\left(\\omega \\right)}}{2} + \\omega e^{- \\omega} \\sin{\\left(\\omega \\right)} + \\frac{e^{- \\omega} \\sin{\\left(\\omega \\right)}}{2} + \\frac{e^{- \\omega} \\cos{\\left(\\omega \\right)}}{2}$"
      ],
      "text/plain": [
       " 2  -ω           2  -ω                          -ω           -ω       \n",
       "ω ⋅ℯ  ⋅sin(ω)   ω ⋅ℯ  ⋅cos(ω)      -ω          ℯ  ⋅sin(ω)   ℯ  ⋅cos(ω)\n",
       "───────────── - ───────────── + ω⋅ℯ  ⋅sin(ω) + ────────── + ──────────\n",
       "      2               2                            2            2     "
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm.integrate(sm.cos(omega)*(omega**2)/sm.exp(omega), omega)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This stores the prior result in the variable `long_expr`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_expr = _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle \\frac{\\omega^{2} e^{- \\omega} \\sin{\\left(\\omega \\right)}}{2} - \\frac{\\omega^{2} e^{- \\omega} \\cos{\\left(\\omega \\right)}}{2} + \\omega e^{- \\omega} \\sin{\\left(\\omega \\right)} + \\frac{e^{- \\omega} \\sin{\\left(\\omega \\right)}}{2} + \\frac{e^{- \\omega} \\cos{\\left(\\omega \\right)}}{2}$"
      ],
      "text/plain": [
       " 2  -ω           2  -ω                          -ω           -ω       \n",
       "ω ⋅ℯ  ⋅sin(ω)   ω ⋅ℯ  ⋅cos(ω)      -ω          ℯ  ⋅sin(ω)   ℯ  ⋅cos(ω)\n",
       "───────────── - ───────────── + ω⋅ℯ  ⋅sin(ω) + ────────── + ──────────\n",
       "      2               2                            2            2     "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_expr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "SymPy has a powerful printing system. Here it prints a latex version of the above expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\frac{\\omega^{2} e^{- \\omega} \\sin{\\left(\\omega \\right)}}{2} - \\frac{\\omega^{2} e^{- \\omega} \\cos{\\left(\\omega \\right)}}{2} + \\omega e^{- \\omega} \\sin{\\left(\\omega \\right)} + \\frac{e^{- \\omega} \\sin{\\left(\\omega \\right)}}{2} + \\frac{e^{- \\omega} \\cos{\\left(\\omega \\right)}}{2}\n"
     ]
    }
   ],
   "source": [
    "print(sm.latex(long_expr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print output for many othter programming languages too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(1.0/2.0)*pow(omega, 2)*exp(-omega)*sin(omega) - 1.0/2.0*pow(omega, 2)*exp(-omega)*cos(omega) + omega*exp(-omega)*sin(omega) + (1.0/2.0)*exp(-omega)*sin(omega) + (1.0/2.0)*exp(-omega)*cos(omega)'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm.ccode(long_expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(1_f64/2.0)*omega.powi(2)*(-omega).exp()*omega.sin() - 1_f64/2.0*omega.powi(2)*(-omega).exp()*omega.cos() + omega*(-omega).exp()*omega.sin() + (1_f64/2.0)*(-omega).exp()*omega.sin() + (1_f64/2.0)*(-omega).exp()*omega.cos()'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sm.rust_code(long_expr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The expressions can be evaluated numerically to arbitrary precision with `evalf()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle 0.0003913820565126739781137676275787977597944696435054817870349748378321660946567427066208237192789868231625679569970581440290944915692599836091829757534976768931948683746247612480641234733606521453520562923574841043130857406033692820045628056675290931363609240435045504654217112802513345703470139849077401039106140772646747841493657612911081657712486569307105406119426970143071204071199375263913166155717310542848098806881812540782254772695530221751549385743422761444871055965259292663837535005191181625745068479846174072251163700007993468771409337535757050759293241623497071621481503543989672542606002540704869498074836936428746544420849008212903289722696436577296582084018956003436729048869562401250886059005211730854778461097461545963406907313484787619620318286975262985135534281479748287445125627524884566812264535359508996746466101348478901533862840938667705750533087050325353481284406300017641653117641722854884031093930857492659965435438286569748520410867655196875749830573312927197152480211863981$"
      ],
      "text/plain": [
       "0.0003913820565126739781137676275787977597944696435054817870349748378321660946\n",
       "567427066208237192789868231625679569970581440290944915692599836091829757534976\n",
       "768931948683746247612480641234733606521453520562923574841043130857406033692820\n",
       "045628056675290931363609240435045504654217112802513345703470139849077401039106\n",
       "140772646747841493657612911081657712486569307105406119426970143071204071199375\n",
       "263913166155717310542848098806881812540782254772695530221751549385743422761444\n",
       "871055965259292663837535005191181625745068479846174072251163700007993468771409\n",
       "337535757050759293241623497071621481503543989672542606002540704869498074836936\n",
       "428746544420849008212903289722696436577296582084018956003436729048869562401250\n",
       "886059005211730854778461097461545963406907313484787619620318286975262985135534\n",
       "281479748287445125627524884566812264535359508996746466101348478901533862840938\n",
       "667705750533087050325353481284406300017641653117641722854884031093930857492659\n",
       "965435438286569748520410867655196875749830573312927197152480211863981"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "long_expr.evalf(subs={omega: 10.0}, n=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to evaluate the expressions using floating point values, it is best to use `lambdify` which generates a Python function that can be used to evaluated the expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_func = sm.lambdify(omega, long_expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function _lambdifygenerated:\n",
      "\n",
      "_lambdifygenerated(omega)\n",
      "    Created with lambdify. Signature:\n",
      "    \n",
      "    func(omega)\n",
      "    \n",
      "    Expression:\n",
      "    \n",
      "    omega**2*exp(-omega)*sin(omega)/2 - omega**2*exp(-omega)*cos(omega)/2 +...\n",
      "    \n",
      "    Source code:\n",
      "    \n",
      "    def _lambdifygenerated(omega):\n",
      "        return ((1/2)*omega**2*exp(-omega)*sin(omega) - 1/2*omega**2*exp(-omega)*cos(omega) + omega*exp(-omega)*sin(omega) + (1/2)*exp(-omega)*sin(omega) + (1/2)*exp(-omega)*cos(omega))\n",
      "    \n",
      "    \n",
      "    Imported modules:\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(num_func)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle 0.00039138205651267406$"
      ],
      "text/plain": [
       "0.00039138205651267406"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_func(10.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$\\displaystyle 1.4445446527604309e-05$"
      ],
      "text/plain": [
       "1.4445446527604309e-05"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_func(13.3434)"
   ]
  }
 ],
 "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}