Demonstration of equation class in a namespace.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using the Equation class + SymPy in a namespace\n",
    "__This notebook duplicates everything in `Demonstration of equation class.ipynb` but importing the equation class and sympy into the namespace `spa`.__ Notice how much extra typing needs to be done if using this interactively.\n",
    "\n",
    "This class defines relations that all high school and college students would recognize as mathematical equations. They consist of a left hand side (lhs) and a right hand side (rhs) connected by the relation operator \"=\".\n",
    "\n",
    "This class should not be confused with the Boolean class `Equality` (abbreviated `Eq`) which evaluates to `True` or `False` if it can determine the validity of the equality. See the last example in <a href=\"#Utility-operations\">Utility operations</a>.\n",
    "    \n",
    "This class is intended to allow using the mathematical tools in SymPy to rearrange equations and perform algebra in a stepwise fashion using as close to standard mathematical notation as possible. In this way more people can successfully perform algebraic rearrangements without stumbling over missed details such as a negative sign.\n",
    "    \n",
    "Create an equation with the call `Equation(lhs,rhs)`, where `lhs` and `rhs` are any valid Sympy expression.  `Eqn(...)` is a synonym for `Equation(...)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import algebra_with_sympy as spa # Automatically imports sympy into the namespace `spa`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Index:\n",
    "<a href=\"#General-Examples\">General Examples</a> |\n",
    "<a href=\"#Rearranging-an-equation\">Rearranging an equation</a> |\n",
    "<a href =\"#Simplification-and-Expansion\">Simplification and Expansion</a> |\n",
    "<a href=\"#Apply-operations-to-only-one-side\">Apply operations to only one side</a> | \n",
    "<a href=\"#Substituting-in-numbers-and-units\">Substituting in numbers and units</a> | \n",
    "<a href=\"#Multistep-rearrangement\">Multistep rearrangement</a> |\n",
    "<a href=\"#Differentiation\">Differentiation</a> |\n",
    "<a href=\"#Integration\">Integration</a> |\n",
    "<a href=\"#Combining-Equations-(math-with-equations)\">Combining Equations</a> | \n",
    "<a href=\"#Utility-operations\">Utility operations</a> | \n",
    "<a href=\"#Errors-tested-for\">Errors tested for</a>\n",
    "\n",
    "### General Examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(a, b, c)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# declare some sympy symbolic variables\n",
    "spa.var('a b c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "a=b/c"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a simple equation.\n",
    "spa.Eqn(a,b/c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\log{\\left(a \\right)}=\\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "log(a)=log(b/c)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apply a SymPy function to an equation.\n",
    "spa.log(spa.Eqn(a,b/c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle e^{a}=e^{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "exp(a)=exp(b/c)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Give an equation a name and manipulate it.\n",
    "t=spa.Eqn(a,b/c)\n",
    "spa.exp(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sin{\\left(a \\right)}=\\sin{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "sin(a)=sin(b/c)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.sin(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "a=b/c"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.exp(spa.log(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\log{\\left(e^{a} \\right)}=\\log{\\left(e^{\\frac{b}{c}} \\right)}$"
      ],
      "text/plain": [
       "log(exp(a))=log(exp(b/c))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reverse order does not simplify, because t could be non-real numbers.\n",
    "spa.log(spa.exp(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\log{\\left(a \\right)}=a \\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "a*log(a)=a*log(b/c)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*spa.log(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\log{\\left(a \\right)}=a \\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "a*log(a)=a*log(b/c)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.log(t)*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a c=b$"
      ],
      "text/plain": [
       "a*c=b"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c*t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a c=b$"
      ],
      "text/plain": [
       "a*c=b"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t*c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a}{b}=\\frac{1}{c}$"
      ],
      "text/plain": [
       "a/b=1/c"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c=\\frac{b}{a}$"
      ],
      "text/plain": [
       "c=b/a"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t*c/a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c=\\frac{b}{a}$"
      ],
      "text/plain": [
       "c=b/a"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c*t/a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c=\\frac{b}{a}$"
      ],
      "text/plain": [
       "c=b/a"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c/a*t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0=- a + \\frac{b}{c}$"
      ],
      "text/plain": [
       "0=-a + b/c"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t-a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0=a - \\frac{b}{c}$"
      ],
      "text/plain": [
       "0=a - b/c"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a-t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a\\bmod{c}=\\frac{b}{c}\\bmod{c}$"
      ],
      "text/plain": [
       "Mod(a, c)=Mod(b/c, c)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t%c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c\\bmod{a}=c\\bmod{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Mod(c, a)=Mod(c, b/c)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c%t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/jonathan/.local/share/virtualenvs/Algebra_with_SymPy-ZtpO9pAV/lib/python3.8/site-packages/sympy/core/power.py:286: SymPyDeprecationWarning: \n",
      "\n",
      "Pow with non-Expr args has been deprecated since SymPy 1.7. Use Expr\n",
      "args instead. See https://github.com/sympy/sympy/issues/19445 for more\n",
      "info.\n",
      "\n",
      "  SymPyDeprecationWarning(\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{a}=\\sqrt{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "sqrt(a)=sqrt(b/c)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.sqrt(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b^{2}=\\frac{a}{c^{2}}$"
      ],
      "text/plain": [
       "b**2=a/c**2"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r=spa.Eqn(b**2,a/c**2)\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{b^{2}}=\\sqrt{\\frac{a}{c^{2}}}$"
      ],
      "text/plain": [
       "sqrt(b**2)=sqrt(a/c**2)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.sqrt(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{0.5}=\\left(\\frac{b}{c}\\right)^{0.5}$"
      ],
      "text/plain": [
       "a**0.5=(b/c)**0.5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t**(1/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(b^{2}\\right)^{0.5}=0.353553390593274$"
      ],
      "text/plain": [
       "(b**2)**0.5=0.353553390593274"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(r**(1/2)).subs({a:2,c:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(b^{2}\\right)^{0.5}=0.3536$"
      ],
      "text/plain": [
       "(b**2)**0.5=0.3536"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .evalf() also works\n",
    "(r**(1/2)).evalf(4,{a:2,c:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{b^{2}}=\\frac{\\sqrt{2}}{4}$"
      ],
      "text/plain": [
       "sqrt(b**2)=sqrt(2)/4"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.sqrt(r).subs({a:2,c:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle mat=\\left[\\begin{matrix}2 & 6\\\\3 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "mat=Matrix([[2, 6], [3, 5]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.var('mat')\n",
    "mattst=spa.Eqn(mat,spa.Matrix([[2,6],[3,5]]))\n",
    "mattst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{transpose}{\\left(mat \\right)}=\\left[\\begin{matrix}2 & 3\\\\6 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "transpose(mat)=Matrix([[2, 3], [6, 5]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mattst.apply(spa.transpose)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\operatorname{transpose}{\\left(mat \\right)}=\\left[\\begin{matrix}2 & 3\\\\6 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "transpose(mat)=Matrix([[2, 3], [6, 5]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.transpose(mattst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle e^{mat}=\\left[\\begin{matrix}\\frac{2}{3 e} + \\frac{e^{8}}{3} & - \\frac{2}{3 e} + \\frac{2 e^{8}}{3}\\\\- \\frac{1}{3 e} + \\frac{e^{8}}{3} & \\frac{1}{3 e} + \\frac{2 e^{8}}{3}\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "exp(mat)=Matrix([[2*exp(-1)/3 + exp(8)/3, -2*exp(-1)/3 + 2*exp(8)/3], [-exp(-1)/3 + exp(8)/3, exp(-1)/3 + 2*exp(8)/3]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# respects exponentiation of matrix\n",
    "spa.exp(mattst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simplification and Expansion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} - 1=c$"
      ],
      "text/plain": [
       "x**2 - 1=c"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.var('x')\n",
    "f = spa.Eqn(x**2 - 1, c)\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2} - 1}{x + 1}=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "(x**2 - 1)/(x + 1)=c/(x + 1)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f/(x+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x - 1=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "x - 1=c/(x + 1)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(f/(x+1)).simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x - 1=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "x - 1=c/(x + 1)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.simplify(f/(x+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{x + 1} - \\frac{1}{x + 1}=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "x**2/(x + 1) - 1/(x + 1)=c/(x + 1)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(f/(x+1)).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{x^{2}}{x + 1} - \\frac{1}{x + 1}=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "x**2/(x + 1) - 1/(x + 1)=c/(x + 1)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.expand(f/(x+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - 1\\right) \\left(x + 1\\right)=c$"
      ],
      "text/plain": [
       "(x - 1)*(x + 1)=c"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .factor() works\n",
    "f.factor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - 1\\right) \\left(x + 1\\right)=c$"
      ],
      "text/plain": [
       "(x - 1)*(x + 1)=c"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.factor(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + a x + b x + c + x^{2} - 1=a x^{2} + a x + b x + 2 c$"
      ],
      "text/plain": [
       "a*x**2 + a*x + b*x + c + x**2 - 1=a*x**2 + a*x + b*x + 2*c"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2 = f+a*x**2+b*x +c + a*x\n",
    "f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c + x^{2} \\left(a + 1\\right) + x \\left(a + b\\right) - 1=a x^{2} + 2 c + x \\left(a + b\\right)$"
      ],
      "text/plain": [
       "c + x**2*(a + 1) + x*(a + b) - 1=a*x**2 + 2*c + x*(a + b)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .collect() works\n",
    "f2.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\left(x^{2} + x\\right) + b x + c + x^{2} - 1=a \\left(x^{2} + x\\right) + b x + 2 c$"
      ],
      "text/plain": [
       "a*(x**2 + x) + b*x + c + x**2 - 1=a*(x**2 + x) + b*x + 2*c"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2.collect(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\left(x^{2} + x\\right) + b x + c + x^{2} - 1=a \\left(x^{2} + x\\right) + b x + 2 c$"
      ],
      "text/plain": [
       "a*(x**2 + x) + b*x + c + x**2 - 1=a*(x**2 + x) + b*x + 2*c"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.collect(f2,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + a x + b x + c + x^{2} + \\left(a x^{2} + a x + b x + c + x^{2} - 1\\right)^{2} - 1=a x^{2} + a x + b x + 2 c + \\left(a x^{2} + a x + b x + 2 c\\right)^{2}$"
      ],
      "text/plain": [
       "a*x**2 + a*x + b*x + c + x**2 + (a*x**2 + a*x + b*x + c + x**2 - 1)**2 - 1=a*x**2 + a*x + b*x + 2*c + (a*x**2 + a*x + b*x + 2*c)**2"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Arbitrary functions can operate on both sides of an equation using \n",
    "#  .apply(funcname, *args, **kwargs)\n",
    "def addsquare(expr):\n",
    "    return expr+expr**2\n",
    "\n",
    "f2.apply(addsquare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + a x + b x + c + x^{2} + \\left(a x^{2} + a x + b x + c + x^{2} - 1\\right)^{2} - 1=a x^{2} + a x + b x + 2 c + \\left(a x^{2} + a x + b x + 2 c\\right)^{2}$"
      ],
      "text/plain": [
       "a*x**2 + a*x + b*x + c + x**2 + (a*x**2 + a*x + b*x + c + x**2 - 1)**2 - 1=a*x**2 + a*x + b*x + 2*c + (a*x**2 + a*x + b*x + 2*c)**2"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or using normal Python call syntax\n",
    "addsquare(f2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c^{2} - c + x^{4} \\left(a^{2} + 2 a + 1\\right) + x^{3} \\left(2 a^{2} + 2 a b + 2 a + 2 b\\right) + x^{2} \\left(a^{2} + 2 a b + 2 a c - a + b^{2} + 2 c - 1\\right) + x \\left(2 a c - a + 2 b c - b\\right)=a^{2} x^{4} + 4 c^{2} + 2 c + x^{3} \\left(2 a^{2} + 2 a b\\right) + x^{2} \\left(a^{2} + 2 a b + 4 a c + a + b^{2}\\right) + x \\left(4 a c + a + 4 b c + b\\right)$"
      ],
      "text/plain": [
       "c**2 - c + x**4*(a**2 + 2*a + 1) + x**3*(2*a**2 + 2*a*b + 2*a + 2*b) + x**2*(a**2 + 2*a*b + 2*a*c - a + b**2 + 2*c - 1) + x*(2*a*c - a + 2*b*c - b)=a**2*x**4 + 4*c**2 + 2*c + x**3*(2*a**2 + 2*a*b) + x**2*(a**2 + 2*a*b + 4*a*c + a + b**2) + x*(4*a*c + a + 4*b*c + b)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# expansion\n",
    "addsquare(f2).expand().collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c^{2} - c + x^{4} \\left(a^{2} + 2 a + 1\\right) + x^{3} \\left(2 a^{2} + 2 a b + 2 a + 2 b\\right) + x^{2} \\left(a^{2} + 2 a b + 2 a c - a + b^{2} + 2 c - 1\\right) + x \\left(2 a c - a + 2 b c - b\\right)=a^{2} x^{4} + 4 c^{2} + 2 c + x^{3} \\left(2 a^{2} + 2 a b\\right) + x^{2} \\left(a^{2} + 2 a b + 4 a c + a + b^{2}\\right) + x \\left(4 a c + a + 4 b c + b\\right)$"
      ],
      "text/plain": [
       "c**2 - c + x**4*(a**2 + 2*a + 1) + x**3*(2*a**2 + 2*a*b + 2*a + 2*b) + x**2*(a**2 + 2*a*b + 2*a*c - a + b**2 + 2*c - 1) + x*(2*a*c - a + 2*b*c - b)=a**2*x**4 + 4*c**2 + 2*c + x**3*(2*a**2 + 2*a*b) + x**2*(a**2 + 2*a*b + 4*a*c + a + b**2) + x*(4*a*c + a + 4*b*c + b)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.expand(addsquare(f2)).collect(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply operations to only one side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + b x + c x^{2}=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "a*x**2 + b*x + c*x**2=a*x**3 + b*x**3 + c*x"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly = spa.Eqn(a*x**2 + b*x + c*x**2, a*x**3 + b*x**3 + c*x)\n",
    "poly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + b x + c x^{2}=x \\left(c + x^{2} \\left(a + b\\right)\\right)$"
      ],
      "text/plain": [
       "a*x**2 + b*x + c*x**2=x*(c + x**2*(a + b))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.applyrhs(spa.factor,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x \\left(a x + b + c x\\right)=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "x*(a*x + b + c*x)=a*x**3 + b*x**3 + c*x"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.applylhs(spa.factor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b x + x^{2} \\left(a + c\\right)=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "b*x + x**2*(a + c)=a*x**3 + b*x**3 + c*x"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.applylhs(spa.collect,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=\\frac{b^{2}}{c^{2}} + \\frac{b}{c}$"
      ],
      "text/plain": [
       "a=b**2/c**2 + b/c"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# also works with user defined python functions\n",
    "t.applyrhs(addsquare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=\\frac{b^{2}}{c^{2}} + \\frac{b}{c}$"
      ],
      "text/plain": [
       "a=b**2/c**2 + b/c"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.apply(addsquare, side = 'rhs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{2} + a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "a**2 + a=b/c"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.applylhs(addsquare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b x + x^{2} \\left(a + c\\right)=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "b*x + x**2*(a + c)=a*x**3 + b*x**3 + c*x"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Inaddition to `.apply...` there is also the less general `.do`,\n",
    "# `.dolhs`, `.dorhs`, which only works for operations defined on the\n",
    "# `Expr` class (e.g.``.collect(), .factor(), .expand()``, etc...).\n",
    "poly.dolhs.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + b x + c x^{2}=c x + x^{3} \\left(a + b\\right)$"
      ],
      "text/plain": [
       "a*x**2 + b*x + c*x**2=c*x + x**3*(a + b)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.dorhs.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle b x + x^{2} \\left(a + c\\right)=c x + x^{3} \\left(a + b\\right)$"
      ],
      "text/plain": [
       "b*x + x**2*(a + c)=c*x + x**3*(a + b)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.do.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + b x + c x^{2}=x \\left(a x^{2} + b x^{2} + c\\right)$"
      ],
      "text/plain": [
       "a*x**2 + b*x + c*x**2=x*(a*x**2 + b*x**2 + c)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.dorhs.factor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'NoneType' object has no attribute '__name__'\n"
     ]
    }
   ],
   "source": [
    "# Errors are raised if your try to call a function this way\n",
    "try:\n",
    "    poly.do.exp()\n",
    "except AttributeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rearranging an equation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle V p=R T n$"
      ],
      "text/plain": [
       "V*p=R*T*n"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ideal Gas Law\n",
    "spa.var('p V n R T')\n",
    "eq1=spa.Eqn(p*V,n*R*T)\n",
    "eq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle p=\\frac{R T n}{V}$"
      ],
      "text/plain": [
       "p=R*T*n/V"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq2 =eq1/V\n",
    "eq2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle V=\\frac{R T n}{p}$"
      ],
      "text/plain": [
       "V=R*T*n/p"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq3 = eq1/p\n",
    "eq3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{V p}{R n}=T$"
      ],
      "text/plain": [
       "V*p/(R*n)=T"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq4 = eq1/n/R\n",
    "eq4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle T=\\frac{V p}{R n}$"
      ],
      "text/plain": [
       "T=V*p/(R*n)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq4.swap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Substituting in numbers and units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle p=0.9334325 atm$"
      ],
      "text/plain": [
       "p=0.9334325*atm"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.var('L atm mol K', positive=True, real=True) # Some units\n",
    "eq2.subs({R:0.08206*L*atm/mol/K,T:273*K,n:1.00*mol,V:24.0*L})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle V=7.47 L$"
      ],
      "text/plain": [
       "V=7.47*L"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq3.subs({R:0.08206*L*atm/mol/K,T:273*K,n:1.00*mol,p:3.00*atm}).n(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Multistep rearrangement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle E=Eo - \\frac{R T \\ln{\\left(Q \\right)}}{F z}$"
      ],
      "text/plain": [
       "E=Eo - R*T*ln(Q)/(F*z)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nernst Equation\n",
    "spa.var('E Eo z F Q')\n",
    "N1=spa.Eqn(E,Eo-(R*T/z/F)*spa.ln(Q))\n",
    "N1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle E + \\frac{R T \\ln{\\left(Q \\right)}}{F z}=Eo$"
      ],
      "text/plain": [
       "E + R*T*ln(Q)/(F*z)=Eo"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N2 = N1+(R*T/z/F)*spa.ln(Q)\n",
    "N2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle R T \\ln{\\left(Q \\right)}=F z \\left(- E + Eo\\right)$"
      ],
      "text/plain": [
       "R*T*ln(Q)=F*z*(-E + Eo)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N3 = (N2 -E)*F*z\n",
    "N3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\ln{\\left(Q \\right)}=\\frac{F z \\left(- E + Eo\\right)}{R T}$"
      ],
      "text/plain": [
       "ln(Q)=F*z*(-E + Eo)/(R*T)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N4 = N3/T/R\n",
    "N4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle Q=e^{\\frac{F z \\left(- E + Eo\\right)}{R T}}$"
      ],
      "text/plain": [
       "Q=exp(F*z*(-E + Eo)/(R*T))"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N5=spa.exp(N4)\n",
    "N5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Differentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a c=\\frac{b}{c^{2}}$"
      ],
      "text/plain": [
       "a*c=b/c**2"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=spa.Eqn(a*c, b/c**2)\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial b} a c=\\frac{1}{c^{2}}$"
      ],
      "text/plain": [
       "Derivative(a*c, b)=c**(-2)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notice the assumption is that symbols on the lhs depend on the rhs\n",
    "spa.diff(q,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=- \\frac{2 b}{c^{3}}$"
      ],
      "text/plain": [
       "a=-2*b/c**3"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# unless one of them matches the symbol of differentiation\n",
    "spa.diff(q,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{d}{d c} a=\\frac{6 b}{c^{4}}$"
      ],
      "text/plain": [
       "Derivative(a, c)=6*b/c**4"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.diff(q,c,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial c\\partial b} a c=- \\frac{2}{c^{3}}$"
      ],
      "text/plain": [
       "Derivative(a*c, b, c)=-2/c**3"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If you specify all at once it has to assume order of differentiation matters.\n",
    "spa.diff(q,c,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{d}{d b} a=- \\frac{2}{c^{3}}$"
      ],
      "text/plain": [
       "Derivative(a, b)=-2/c**3"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If you specify the order explicitly it works as expected.\n",
    "spa.diff(spa.diff(q,c),b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial^{2}}{\\partial c\\partial b} a c=- \\frac{2}{c^{3}}$"
      ],
      "text/plain": [
       "Derivative(a*c, b, c)=-2/c**3"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.diff(spa.diff(q,b),c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\partial}{\\partial b} \\log{\\left(a c \\right)}=\\frac{1}{b}$"
      ],
      "text/plain": [
       "Derivative(log(a*c), b)=1/b"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.diff(spa.log(q),b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0=\\frac{1}{c^{2}}$"
      ],
      "text/plain": [
       "0=c**(-2)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using `.apply` or `.do` with differentiation always assumes all symbols are independent.\n",
    "q.apply(spa.diff,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0=\\frac{1}{c^{2}}$"
      ],
      "text/plain": [
       "0=c**(-2)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.do.diff(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{d}{d c} a=b \\cos{\\left(c \\right)}$"
      ],
      "text/plain": [
       "Derivative(a, c)=b*cos(c)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt2 = spa.Eqn(a,b*spa.sin(c))\n",
    "spa.diff(dt2,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "b**2/(2*c**2)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.integrate(q,b,side='rhs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a b c$"
      ],
      "text/plain": [
       "a*b*c"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.integrate(q,b,side='lhs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\int a c\\, db=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "Integral(a*c, b)=b**2/(2*c**2)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a pretty statement of integration from an equation\n",
    "spa.Eqn(spa.Integral(q.lhs,b),spa.integrate(q,b,side='rhs'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a b c=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "a*b*c=b**2/(2*c**2)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.apply(spa.integrate, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a b c=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "a*b*c=b**2/(2*c**2)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.do.integrate(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{a^{2} c}{2}=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "a**2*c/2=b**2/(2*c**2)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Integration of each side with respect to different variables\n",
    "q.dorhs.integrate(b).dolhs.integrate(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combining Equations (math with equations)\n",
    "This code operates/combines `lhs` with `lhs` and `rhs` with `rhs`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a c=\\frac{b}{c^{2}}$"
      ],
      "text/plain": [
       "a*c=b/c**2"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "a=b/c"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a c + a=\\frac{b}{c} + \\frac{b}{c^{2}}$"
      ],
      "text/plain": [
       "a*c + a=b/c + b/c**2"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q+t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c=\\frac{1}{c}$"
      ],
      "text/plain": [
       "c=1/c"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q/t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{c}=c$"
      ],
      "text/plain": [
       "1/c=c"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t/q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\left(c\\bmod{1}\\right)=\\frac{b \\left(\\frac{1}{c}\\bmod{1}\\right)}{c}$"
      ],
      "text/plain": [
       "a*Mod(c, 1)=b*Mod(1/c, 1)/c"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q%t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a \\left(1\\bmod{c}\\right)=\\frac{b \\left(1\\bmod{\\frac{1}{c}}\\right)}{c}$"
      ],
      "text/plain": [
       "a*Mod(1, c)=b*Mod(1, 1/c)/c"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t%q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{a c}=\\left(\\frac{b}{c}\\right)^{\\frac{b}{c^{2}}}$"
      ],
      "text/plain": [
       "a**(a*c)=(b/c)**(b/c**2)"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t**q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(a c\\right)^{a}=\\left(\\frac{b}{c^{2}}\\right)^{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "(a*c)**a=(b/c**2)**(b/c)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q**t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle V p_{1}=R T_{1} n$"
      ],
      "text/plain": [
       "V*p_1=R*T_1*n"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example that might be used to solve an Ideal Gas law problem\n",
    "spa.var('p_1 p_2 T_1 T_2')\n",
    "IdG1 = eq1.subs({p:p_1,T:T_1})\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{p_{1}}{p_{2}}=\\frac{T_{1}}{T_{2}}$"
      ],
      "text/plain": [
       "p_1/p_2=T_1/T_2"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IdG2 = eq1.subs({p:p_2,T:T_2})\n",
    "IdG1/IdG2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle p_{1}=\\frac{T_{1} p_{2}}{T_{2}}$"
      ],
      "text/plain": [
       "p_1=T_1*p_2/T_2"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IdG1/IdG2*p_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utility operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "a=b/c"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{b}{c}=a$"
      ],
      "text/plain": [
       "b/c=a"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.reversed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{b}{c}=a$"
      ],
      "text/plain": [
       "b/c=a"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.swap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a$"
      ],
      "text/plain": [
       "a"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.lhs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{b}{c}$"
      ],
      "text/plain": [
       "b/c"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.rhs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a = \\frac{b}{c}$"
      ],
      "text/plain": [
       "Eq(a, b/c)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TF = t.as_Boolean()\n",
    "TF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{False}$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TF.subs({a:1,b:2,c:3})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Errors tested for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The argument 'a=b/c' is not comparable.\n",
      "You must specify `side=\"lhs\"` or `side=\"rhs\"` when integrating an Equation\n",
      "`side` must equal \"lhs\" or \"rhs\".\n",
      "lhs and rhs must be valid sympy expressions.\n",
      "`lhs-rhs` evaluates to a non-zero number.\n",
      "`lhs-rhs` evaluates to a non-zero number.\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2=2.0$"
      ],
      "text/plain": [
       "2=2.00000000000000"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test for errors\n",
    "try:\n",
    "    spa.Max(spa.Eqn(a,b/c), 2) # This is just an example of an error raised by an incompatible\n",
    "                       #   operation.\n",
    "except ValueError as e:\n",
    "    print(e)\n",
    "try:\n",
    "    spa.integrate(spa.Eqn(a,b/c),b)\n",
    "except ValueError as e:\n",
    "    print(e)\n",
    "try:\n",
    "    spa.integrate(spa.Eqn(a,b/c),b,side='right')\n",
    "except AttributeError as e:\n",
    "    print(e)\n",
    "try:\n",
    "    spa.Eqn(spa.FiniteSet(a), spa.FiniteSet(b, c))\n",
    "except TypeError as e:\n",
    "    print(e)\n",
    "try:\n",
    "    spa.Eqn(2.0,3.0, check=True)\n",
    "except ValueError as e:\n",
    "    print(e)\n",
    "try:\n",
    "    spa.Eqn(2,3.0, check=True)\n",
    "except ValueError as e:\n",
    "    print(e)\n",
    "spa.Eqn(2,2.0, check=True) #does not raise an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\pi \\left(2 + i\\right)=2 \\pi + i \\pi$"
      ],
      "text/plain": [
       "pi*(2 + I)=2*pi + I*pi"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.Equation(spa.pi*(spa.I+2), spa.pi*spa.I+2*spa.pi, check=True) # should not raise warning. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`lhs-rhs` evaluates to a non-zero number.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    spa.Eqn(a,a+1, check=True)\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0=1$"
      ],
      "text/plain": [
       "0=1"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.Eqn(a,a+1)-a #should not raise warning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "`lhs-rhs` evaluates to a non-zero number.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    spa.Equation(spa.pi*(spa.I+2), spa.pi*spa.I+2*spa.pi+spa.I, check=True) # should raise warning.\n",
    "except ValueError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle i \\sin{\\left(a \\right)} + \\cos{\\left(a \\right)}=e^{i a}$"
      ],
      "text/plain": [
       "I*sin(a) + cos(a)=exp(I*a)"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.Eqn(spa.cos(a)+spa.I*spa.sin(a),spa.exp(spa.I*a), check = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle e^{i a}=e^{i a}$"
      ],
      "text/plain": [
       "exp(I*a)=exp(I*a)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1=-1$"
      ],
      "text/plain": [
       "-1=-1"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.Eqn(spa.cos(spa.pi)+spa.I*spa.sin(spa.pi),spa.exp(spa.I*spa.pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -1=-1$"
      ],
      "text/plain": [
       "-1=-1"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "spa.Eqn(spa.cos(spa.pi)+spa.I*spa.sin(spa.pi),spa.exp(spa.I*spa.pi), check=True)"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}