Demonstration of equation class.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algebraic Equations with SymPy (using the `Equation` class)\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 \"=\". In addition it sets some convenient defaults and provides some useful controls of output formatting that may be useful even if you do not use the `Equation` class (see examples below).\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(...)`.\n",
    "\n",
    "In Jupyter/IPython there is also a shorthand `eq_name =@ lhs = rhs`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This notebook is running Algebra_with_Sympy version 1.0.0rc0.\n"
     ]
    }
   ],
   "source": [
    "from algebra_with_sympy import * # Automatically imports sympy\n",
    "print(\"This notebook is running Algebra_with_Sympy version \" + str(algwsym_version)+\".\")"
   ]
  },
  {
   "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=\"#Output-options\">Output options</a> | \n",
    "<a href=\"#Control-Interpretation-of-Integers\">Control Interpretation of Integers </a> | \n",
    "<a href=\"#Utility-operations\">Utility operations</a> | \n",
    "<a href=\"#Errors-tested-for\">Errors tested for</a> | \n",
    "<a href=\"#Atomatic-solutions-(sympy.solve)\">Automatic Solutions</a> | \n",
    "<a href=\"#Checking-version-of-Algebra-with-Sympy\">Check version</a>\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",
    "var('a b c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(a, b/c)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a simple equation.\n",
    "Eqn(a,b/c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(a, b/c)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Shorthand available in Jupyter and IPython\n",
    "=@ a = b/c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\log{\\left(a \\right)}=\\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "Equation(log(a), log(b/c))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Apply a SymPy function to an equation.\n",
    "log(Eqn(a,b/c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\log{\\left(a \\right)}=\\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "Equation(log(a), log(b/c))"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using shorthand\n",
    "eq1 =@ a = b/c\n",
    "log(eq1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$e^{a}=e^{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation(exp(a), exp(b/c))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Give an equation a name and manipulate it.\n",
    "t=Eqn(a,b/c)\n",
    "exp(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sin{\\left(a \\right)}=\\sin{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "Equation(sin(a), sin(b/c))"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{c}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{eq1})$"
      ],
      "text/plain": [
       "Equation(a, b/c)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(log(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\log{\\left(e^{a} \\right)}=\\log{\\left(e^{\\frac{b}{c}} \\right)}$"
      ],
      "text/plain": [
       "Equation(log(exp(a)), log(exp(b/c)))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reverse order does not simplify, because t could be non-real numbers.\n",
    "log(exp(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\log{\\left(a \\right)}=a \\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "Equation(a*log(a), a*log(b/c))"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a*log(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\log{\\left(a \\right)}=a \\log{\\left(\\frac{b}{c} \\right)}$"
      ],
      "text/plain": [
       "Equation(a*log(a), a*log(b/c))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(t)*a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a c=b$"
      ],
      "text/plain": [
       "Equation(a*c, b)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c*t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a c=b$"
      ],
      "text/plain": [
       "Equation(a*c, b)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t*c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{a}{b}=\\frac{1}{c}$"
      ],
      "text/plain": [
       "Equation(a/b, 1/c)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t/b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c=\\frac{b}{a}$"
      ],
      "text/plain": [
       "Equation(c, b/a)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t*c/a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c=\\frac{b}{a}$"
      ],
      "text/plain": [
       "Equation(c, b/a)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c*t/a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c=\\frac{b}{a}$"
      ],
      "text/plain": [
       "Equation(c, b/a)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c/a*t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$0=- a + \\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(0, -a + b/c)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t-a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$0=a - \\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(0, a - b/c)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a-t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\bmod c=\\frac{b}{c} \\bmod c$"
      ],
      "text/plain": [
       "Equation(Mod(a, c), Mod(b/c, c))"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t%c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c \\bmod a=c \\bmod \\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(Mod(c, a), Mod(c, b/c))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c%t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt{a}=\\sqrt{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation(sqrt(a), sqrt(b/c))"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt[3]{a}=\\sqrt[3]{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation(a**(1/3), (b/c)**(1/3))"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root(t,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left(-1\\right)^{\\frac{2}{3}} \\sqrt[3]{a}=\\left(-1\\right)^{\\frac{2}{3}} \\sqrt[3]{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation((-1)**(2/3)*a**(1/3), (-1)**(2/3)*(b/c)**(1/3))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root(t,3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left(-1\\right)^{\\frac{2}{3}} \\sqrt[3]{a}=\\frac{2 \\left(-1\\right)^{\\frac{2}{3}}}{3}$"
      ],
      "text/plain": [
       "Equation((-1)**(2/3)*a**(1/3), 2*(-1)**(2/3)/3)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root(t,3,1).subs({b:8,c:27})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt[3]{a}=\\sqrt[3]{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation(a**(1/3), (b/c)**(1/3))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root(t,3,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$- \\sqrt[3]{-1} \\sqrt[3]{a}=- \\sqrt[3]{-1} \\sqrt[3]{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation(-(-1)**(1/3)*a**(1/3), -(-1)**(1/3)*(b/c)**(1/3))"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "root(t,3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$b^{2}=\\frac{a}{c^{2}}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{r})$"
      ],
      "text/plain": [
       "Equation(b**2, a/c**2)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r=Eqn(b**2,a/c**2)\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt{b^{2}}=\\sqrt{\\frac{a}{c^{2}}}$"
      ],
      "text/plain": [
       "Equation(sqrt(b**2), sqrt(a/c**2))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt{a}=\\sqrt{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation(sqrt(a), sqrt(b/c))"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t**(1/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt{b^{2}}=\\frac{\\sqrt{2}}{4}$"
      ],
      "text/plain": [
       "Equation(sqrt(b**2), sqrt(2)/4)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(r**(1/2)).subs({a:2,c:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left(b^{2}\\right)^{0.5}=0.3536$"
      ],
      "text/plain": [
       "Equation((b**2)**0.5, 0.3536)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .evalf() also works\n",
    "(r**(1/2)).evalf(4,{a:2,c:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\sqrt{b^{2}}=\\frac{\\sqrt{2}}{4}$"
      ],
      "text/plain": [
       "Equation(sqrt(b**2), sqrt(2)/4)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(r).subs({a:2,c:4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$mat=\\left[\\begin{matrix}2 & 6\\\\3 & 5\\end{matrix}\\right]\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{mattst})$"
      ],
      "text/plain": [
       "Equation(mat, Matrix([\n",
       "[2, 6],\n",
       "[3, 5]]))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var('mat')\n",
    "mattst=Eqn(mat,Matrix([[2,6],[3,5]]))\n",
    "mattst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\operatorname{transpose}{\\left(mat \\right)}=\\left[\\begin{matrix}2 & 3\\\\6 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Equation(transpose(mat), Matrix([\n",
       "[2, 3],\n",
       "[6, 5]]))"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mattst.apply(transpose)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\operatorname{transpose}{\\left(mat \\right)}=\\left[\\begin{matrix}2 & 3\\\\6 & 5\\end{matrix}\\right]\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{trsp})$"
      ],
      "text/plain": [
       "Equation(transpose(mat), Matrix([\n",
       "[2, 3],\n",
       "[6, 5]]))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trsp = transpose(mattst)\n",
    "trsp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$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": [
       "Equation(exp(mat), Matrix([\n",
       "[2*exp(-1)/3 + exp(8)/3, -2*exp(-1)/3 + 2*exp(8)/3],\n",
       "[ -exp(-1)/3 + exp(8)/3,    exp(-1)/3 + 2*exp(8)/3]]))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# respects exponentiation of matrix\n",
    "exp(mattst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$mat \\operatorname{transpose}{\\left(mat \\right)}=\\left[\\begin{matrix}40 & 36\\\\36 & 34\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Equation(mat*transpose(mat), Matrix([\n",
       "[40, 36],\n",
       "[36, 34]]))"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mattst*trsp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simplification and Expansion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$x^{2} - 1=c\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{f})$"
      ],
      "text/plain": [
       "Equation(x**2 - 1, c)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var('x')\n",
    "f = Eqn(x**2 - 1, c)\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{x^{2} - 1}{x + 1}=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "Equation((x**2 - 1)/(x + 1), c/(x + 1))"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f/(x+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$x - 1=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "Equation(x - 1, c/(x + 1))"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(f/(x+1)).simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$x - 1=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "Equation(x - 1, c/(x + 1))"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(f/(x+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{x^{2}}{x + 1} - \\frac{1}{x + 1}=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "Equation(x**2/(x + 1) - 1/(x + 1), c/(x + 1))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(f/(x+1)).expand()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{x^{2}}{x + 1} - \\frac{1}{x + 1}=\\frac{c}{x + 1}$"
      ],
      "text/plain": [
       "Equation(x**2/(x + 1) - 1/(x + 1), c/(x + 1))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(f/(x+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left(x - 1\\right) \\left(x + 1\\right)=c$"
      ],
      "text/plain": [
       "Equation((x - 1)*(x + 1), c)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .factor() works\n",
    "f.factor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left(x - 1\\right) \\left(x + 1\\right)=c$"
      ],
      "text/plain": [
       "Equation((x - 1)*(x + 1), c)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a x^{2} + a x + b x + c + x^{2} - 1=a x^{2} + a x + b x + 2 c\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{f2})$"
      ],
      "text/plain": [
       "Equation(a*x**2 + a*x + b*x + c + x**2 - 1, a*x**2 + a*x + b*x + 2*c)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2 = f+a*x**2+b*x +c + a*x\n",
    "f2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$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": [
       "Equation(c + x**2*(a + 1) + x*(a + b) - 1, a*x**2 + 2*c + x*(a + b))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# .collect() works\n",
    "f2.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\left(x^{2} + x\\right) + b x + c + x^{2} - 1=a \\left(x^{2} + x\\right) + b x + 2 c$"
      ],
      "text/plain": [
       "Equation(a*(x**2 + x) + b*x + c + x**2 - 1, a*(x**2 + x) + b*x + 2*c)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f2.collect(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\left(x^{2} + x\\right) + b x + c + x^{2} - 1=a \\left(x^{2} + x\\right) + b x + 2 c$"
      ],
      "text/plain": [
       "Equation(a*(x**2 + x) + b*x + c + x**2 - 1, a*(x**2 + x) + b*x + 2*c)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(f2,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$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": [
       "Equation(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": 52,
     "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": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$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": [
       "Equation(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": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# or using normal Python call syntax\n",
    "addsquare(f2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c^{2} - c + x^{4} \\left(a^{2} + 2 a + 1\\right) + x^{3} \\cdot \\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} \\cdot \\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": [
       "Equation(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": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# expansion\n",
    "addsquare(f2).expand().collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c^{2} - c + x^{4} \\left(a^{2} + 2 a + 1\\right) + x^{3} \\cdot \\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} \\cdot \\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": [
       "Equation(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": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(addsquare(f2)).collect(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apply operations to only one side"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a x^{2} + b x + c x^{2}=a x^{3} + b x^{3} + c x\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{poly})$"
      ],
      "text/plain": [
       "Equation(a*x**2 + b*x + c*x**2, a*x**3 + b*x**3 + c*x)"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly = Eqn(a*x**2 + b*x + c*x**2, a*x**3 + b*x**3 + c*x)\n",
    "poly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a x^{2} + b x + c x^{2}=x \\left(c + x^{2} \\left(a + b\\right)\\right)$"
      ],
      "text/plain": [
       "Equation(a*x**2 + b*x + c*x**2, x*(c + x**2*(a + b)))"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.applyrhs(factor,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$x \\left(a x + b + c x\\right)=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "Equation(x*(a*x + b + c*x), a*x**3 + b*x**3 + c*x)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.applylhs(factor)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$b x + x^{2} \\left(a + c\\right)=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "Equation(b*x + x**2*(a + c), a*x**3 + b*x**3 + c*x)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.applylhs(collect,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b^{2}}{c^{2}} + \\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(a, b**2/c**2 + b/c)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# also works with user defined python functions\n",
    "t.applyrhs(addsquare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b^{2}}{c^{2}} + \\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(a, b**2/c**2 + b/c)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.apply(addsquare, side = 'rhs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a^{2} + a=\\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(a**2 + a, b/c)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.applylhs(addsquare)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$b x + x^{2} \\left(a + c\\right)=a x^{3} + b x^{3} + c x$"
      ],
      "text/plain": [
       "Equation(b*x + x**2*(a + c), a*x**3 + b*x**3 + c*x)"
      ]
     },
     "execution_count": 63,
     "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": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a x^{2} + b x + c x^{2}=c x + x^{3} \\left(a + b\\right)$"
      ],
      "text/plain": [
       "Equation(a*x**2 + b*x + c*x**2, c*x + x**3*(a + b))"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.dorhs.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$b x + x^{2} \\left(a + c\\right)=c x + x^{3} \\left(a + b\\right)$"
      ],
      "text/plain": [
       "Equation(b*x + x**2*(a + c), c*x + x**3*(a + b))"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.do.collect(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a x^{2} + b x + c x^{2}=x \\left(a x^{2} + b x^{2} + c\\right)$"
      ],
      "text/plain": [
       "Equation(a*x**2 + b*x + c*x**2, x*(a*x**2 + b*x**2 + c))"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly.dorhs.factor()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Expressions in the equation have no attribute `exp`. Try `.apply(exp, *args)` or pass the equation as a parameter to `exp()`.\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": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p=R T n\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{eq1})$"
      ],
      "text/plain": [
       "Equation(V*p, R*T*n)"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ideal Gas Law\n",
    "var('p V n R T')\n",
    "eq1=Eqn(p*V,n*R*T)\n",
    "eq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$p=\\frac{R T n}{V}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{eq2})$"
      ],
      "text/plain": [
       "Equation(p, R*T*n/V)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq2 =eq1/V\n",
    "eq2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V=\\frac{R T n}{p}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{eq3})$"
      ],
      "text/plain": [
       "Equation(V, R*T*n/p)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq3 = eq1/p\n",
    "eq3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{V p}{R n}=T\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{eq4})$"
      ],
      "text/plain": [
       "Equation(V*p/(R*n), T)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq4 = eq1/n/R\n",
    "eq4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$T=\\frac{V p}{R n}$"
      ],
      "text/plain": [
       "Equation(T, V*p/(R*n))"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq4.swap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Substituting in numbers and units\n",
    "Algebra_with_Sympy has a convenience operation `units(...)` which takes a string of space \n",
    "separated symbols to use as units. This simply declares the symbols \n",
    "to be positive, making them behave as units. This does not create units \n",
    "that know about conversions, prefixes or systems of units. This lack \n",
    "is on purpose to provide units that require the user to worry about \n",
    "conversions  (ideal in a teaching situation). To get units with built-in \n",
    "conversions see `sympy.physics.units`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$p=0.9334325 atm$"
      ],
      "text/plain": [
       "Equation(p, 0.9334325*atm)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "units('L atm mol K') # Liters, atmospheres, moles and Kelvin\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": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V=7.47 L$"
      ],
      "text/plain": [
       "Equation(V, 7.47*L)"
      ]
     },
     "execution_count": 75,
     "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": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$E=Eo - \\frac{R T \\log{\\left(Q \\right)}}{F z}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{N1})$"
      ],
      "text/plain": [
       "Equation(E, Eo - R*T*log(Q)/(F*z))"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Nernst Equation\n",
    "var('E Eo z F Q')\n",
    "N1=Eqn(E,Eo-(R*T/z/F)*ln(Q))\n",
    "N1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$E + \\frac{R T \\log{\\left(Q \\right)}}{F z}=Eo\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{N2})$"
      ],
      "text/plain": [
       "Equation(E + R*T*log(Q)/(F*z), Eo)"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N2 = N1+(R*T/z/F)*ln(Q)\n",
    "N2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$R T \\log{\\left(Q \\right)}=F z \\left(- E + Eo\\right)\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{N3})$"
      ],
      "text/plain": [
       "Equation(R*T*log(Q), F*z*(-E + Eo))"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N3 = (N2 -E)*F*z\n",
    "N3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\log{\\left(Q \\right)}=\\frac{F z \\left(- E + Eo\\right)}{R T}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{N4})$"
      ],
      "text/plain": [
       "Equation(log(Q), F*z*(-E + Eo)/(R*T))"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N4 = N3/T/R\n",
    "N4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$Q=e^{\\frac{F z \\left(- E + Eo\\right)}{R T}}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{N5})$"
      ],
      "text/plain": [
       "Equation(Q, exp(F*z*(-E + Eo)/(R*T)))"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N5=exp(N4)\n",
    "N5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Differentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a c=\\frac{b}{c^{2}}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{q})$"
      ],
      "text/plain": [
       "Equation(a*c, b/c**2)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=Eqn(a*c, b/c**2)\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{\\partial}{\\partial b} a c=\\frac{1}{c^{2}}$"
      ],
      "text/plain": [
       "Equation(Derivative(a*c, b), c**(-2))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Notice the assumption is that symbols on the lhs depend on the rhs\n",
    "diff(q,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=- \\frac{2 b}{c^{3}}$"
      ],
      "text/plain": [
       "Equation(a, -2*b/c**3)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# unless one of them matches the symbol of differentiation\n",
    "diff(q,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{d}{d c} a=\\frac{6 b}{c^{4}}$"
      ],
      "text/plain": [
       "Equation(Derivative(a, c), 6*b/c**4)"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(q,c,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{\\partial^{2}}{\\partial c\\partial b} a c=- \\frac{2}{c^{3}}$"
      ],
      "text/plain": [
       "Equation(Derivative(a*c, b, c), -2/c**3)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If you specify all at once it has to assume order of differentiation matters.\n",
    "diff(q,c,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{d}{d b} a=- \\frac{2}{c^{3}}$"
      ],
      "text/plain": [
       "Equation(Derivative(a, b), -2/c**3)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# If you specify the order explicitly it works as expected.\n",
    "diff(diff(q,c),b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{\\partial^{2}}{\\partial c\\partial b} a c=- \\frac{2}{c^{3}}$"
      ],
      "text/plain": [
       "Equation(Derivative(a*c, b, c), -2/c**3)"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(diff(q,b),c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{\\partial}{\\partial b} \\log{\\left(a c \\right)}=\\frac{1}{b}$"
      ],
      "text/plain": [
       "Equation(Derivative(log(a*c), b), 1/b)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(log(q),b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$0=\\frac{1}{c^{2}}$"
      ],
      "text/plain": [
       "Equation(0, c**(-2))"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using `.apply` or `.do` with differentiation always assumes all symbols are independent.\n",
    "q.apply(diff,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$0=\\frac{1}{c^{2}}$"
      ],
      "text/plain": [
       "Equation(0, c**(-2))"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.do.diff(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{d}{d c} a=b \\cos{\\left(c \\right)}$"
      ],
      "text/plain": [
       "Equation(Derivative(a, c), b*cos(c))"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt2 = Eqn(a,b*sin(c))\n",
    "diff(dt2,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "b**2/(2*c**2)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(q,b,side='rhs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a b c$"
      ],
      "text/plain": [
       "a*b*c"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(q,b,side='lhs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\int a c\\, db=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "Equation(Integral(a*c, b), b**2/(2*c**2))"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make a pretty statement of integration from an equation\n",
    "Eqn(Integral(q.lhs,b),integrate(q,b,side='rhs'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a b c=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "Equation(a*b*c, b**2/(2*c**2))"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.apply(integrate, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a b c=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "Equation(a*b*c, b**2/(2*c**2))"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.do.integrate(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{a^{2} c}{2}=\\frac{b^{2}}{2 c^{2}}$"
      ],
      "text/plain": [
       "Equation(a**2*c/2, b**2/(2*c**2))"
      ]
     },
     "execution_count": 97,
     "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": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a c=\\frac{b}{c^{2}}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{q})$"
      ],
      "text/plain": [
       "Equation(a*c, b/c**2)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{c}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{t})$"
      ],
      "text/plain": [
       "Equation(a, b/c)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a c + a=\\frac{b}{c} + \\frac{b}{c^{2}}$"
      ],
      "text/plain": [
       "Equation(a*c + a, b/c + b/c**2)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q+t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$c=\\frac{1}{c}$"
      ],
      "text/plain": [
       "Equation(c, 1/c)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q/t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{1}{c}=c$"
      ],
      "text/plain": [
       "Equation(1/c, c)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t/q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\left(c \\bmod 1\\right)=\\frac{b \\left(\\frac{1}{c} \\bmod 1\\right)}{c}$"
      ],
      "text/plain": [
       "Equation(a*(Mod(c, 1)), b*(Mod(1/c, 1))/c)"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q%t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a \\left(1 \\bmod c\\right)=\\frac{b \\left(1 \\bmod \\frac{1}{c}\\right)}{c}$"
      ],
      "text/plain": [
       "Equation(a*(Mod(1, c)), b*(Mod(1, 1/c))/c)"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t%q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a^{a c}=\\left(\\frac{b}{c}\\right)^{\\frac{b}{c^{2}}}$"
      ],
      "text/plain": [
       "Equation(a**(a*c), (b/c)**(b/c**2))"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t**q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left(a c\\right)^{a}=\\left(\\frac{b}{c^{2}}\\right)^{\\frac{b}{c}}$"
      ],
      "text/plain": [
       "Equation((a*c)**a, (b/c**2)**(b/c))"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q**t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p_{1}=R T_{1} n\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{IdG1})$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Example that might be used to solve an Ideal Gas law problem\n",
    "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": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{p_{1}}{p_{2}}=\\frac{T_{1}}{T_{2}}$"
      ],
      "text/plain": [
       "Equation(p_1/p_2, T_1/T_2)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IdG2 = eq1.subs({p:p_2,T:T_2})\n",
    "IdG1/IdG2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$p_{1}=\\frac{T_{1} p_{2}}{T_{2}}$"
      ],
      "text/plain": [
       "Equation(p_1, T_1*p_2/T_2)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IdG1/IdG2*p_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$n=\\frac{V p_{1}}{R T_{1}}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{soln1})$"
      ],
      "text/plain": [
       "Equation(n, V*p_1/(R*T_1))"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Alternative route\n",
    "soln1 = (IdG1/R/T_1).swap\n",
    "soln1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p_{2}=\\frac{T_{2} V p_{1}}{T_{1}}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{soln2})$"
      ],
      "text/plain": [
       "Equation(V*p_2, T_2*V*p_1/T_1)"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Note that subs will accept equations as parameters\n",
    "soln2 = IdG2.subs(soln1)\n",
    "soln2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$p_{1}=\\frac{T_{1} p_{2}}{T_{2}}$"
      ],
      "text/plain": [
       "Equation(p_1, T_1*p_2/T_2)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(soln2*T_1/T_2/V).swap"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Output options"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equation Labels Default\n",
    "algwsym_config.output.label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p_{1}=R T_{1} n$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn off\n",
    "algwsym_config.output.label = False\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p_{1}=R T_{1} n\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{IdG1})$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn on\n",
    "algwsym_config.output.label = True\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Show Code Default\n",
    "algwsym_config.output.show_code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code version: Equation(V*p_1, R*T_1*n)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$V p_{1}=R T_{1} n\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{IdG1})$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn on\n",
    "algwsym_config.output.show_code = True\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code version: exp(I*a)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$e^{i a}$"
      ],
      "text/plain": [
       "exp(I*a)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This also shows code for Sympy expressions\n",
    "(cos(a)+I*sin(a)).simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p_{1}=R T_{1} n\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{IdG1})$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn off\n",
    "algwsym_config.output.show_code = False\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\begin{equation}V p_{1}=R T_{1} n\\end{equation}$$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Display equation wrapped as a Latex equation in `\\begin{equation}...\\end{equation}`\n",
    "algwsym_config.output.latex_as_equations = True\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$V p_{1}=R T_{1} n\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{IdG1})$"
      ],
      "text/plain": [
       "Equation(V*p_1, R*T_1*n)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Turn it back off\n",
    "algwsym_config.output.latex_as_equations = False\n",
    "IdG1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control Interpretation of Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integers as exact flag: True\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\frac{2}{3}$"
      ],
      "text/plain": [
       "2/3"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Default behavior\n",
    "print(\"Integers as exact flag: \" + str(algwsym_config.numerics.integers_as_exact))\n",
    "2/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$x^{2} + \\frac{3 x}{2} + 1=0\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{quad})$"
      ],
      "text/plain": [
       "Equation(x**2 + 3*x/2 + 1, 0)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var('x')\n",
    "quad =@ x**2 + 3/2*x + 1 = 0\n",
    "quad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{x=- \\frac{3}{4} - \\frac{\\sqrt{7} i}{4}, x=- \\frac{3}{4} + \\frac{\\sqrt{7} i}{4}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(x, -3/4 - sqrt(7)*I/4), Equation(x, -3/4 + sqrt(7)*I/4))"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(quad,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turn off treating integers as exact\n",
    "unset_integers_as_exact()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integers as exact flag: False\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6666666666666666"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Integers as exact flag: \" + str(algwsym_config.numerics.integers_as_exact))\n",
    "2/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$x^{2} + 1.5 x + 1=0\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{quad})$"
      ],
      "text/plain": [
       "Equation(x**2 + 1.5*x + 1, 0)"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "quad =@ x**2 + 3/2*x + 1 = 0\n",
    "quad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{x=-0.75 - 0.661437827766148 i, x=-0.75 + 0.661437827766148 i\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(x, -0.75 - 0.661437827766148*I), Equation(x, -0.75 + 0.661437827766148*I))"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(quad,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Turn treating integers as exact on again\n",
    "set_integers_as_exact()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Integers as exact flag: True\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\frac{2}{3}$"
      ],
      "text/plain": [
       "2/3"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Integers as exact flag: \" + str(algwsym_config.numerics.integers_as_exact))\n",
    "2/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utility operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{c}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{t})$"
      ],
      "text/plain": [
       "Equation(a, b/c)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{b}{c}=a$"
      ],
      "text/plain": [
       "Equation(b/c, a)"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.reversed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{b}{c}=a$"
      ],
      "text/plain": [
       "Equation(b/c, a)"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.swap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a$"
      ],
      "text/plain": [
       "a"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.lhs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\frac{b}{c}$"
      ],
      "text/plain": [
       "b/c"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.rhs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a = \\frac{b}{c}$"
      ],
      "text/plain": [
       "Eq(a, b/c)"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.subs({a:1/2,b:1,c:2}).check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a = \\frac{b}{c}$"
      ],
      "text/plain": [
       "Eq(a, b/c)"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TF = t.as_Boolean()\n",
    "TF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{False}$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "TF.subs({a:1,b:2,c:3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a - \\frac{b}{c}=0$"
      ],
      "text/plain": [
       "Equation(a - b/c, 0)"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Getting everything on one side\n",
    "t - t.rhs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$0=- a + \\frac{b}{c}$"
      ],
      "text/plain": [
       "Equation(0, -a + b/c)"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t - t.lhs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a - \\frac{b}{c}=0$"
      ],
      "text/plain": [
       "Equation(a - b/c, 0)"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.rewrite(Add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Errors tested for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The argument 'a = b/c' is not comparable.\n",
      "----\n",
      "You must specify `side=\"lhs\"` or `side=\"rhs\"` when integrating an Equation\n",
      "----\n",
      "`side` must equal \"lhs\" or \"rhs\".\n",
      "----\n",
      "lhs and rhs must be valid sympy expressions.\n",
      "----\n",
      "Expressions in the equation have no attribute `log`. Try `.apply(log, *args)` or pass the equation as a parameter to `log()`.\n",
      "----\n",
      "False\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test for errors\n",
    "try:\n",
    "    Max(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",
    "print('----')\n",
    "try:\n",
    "    integrate(Eqn(a,b/c),b)\n",
    "except ValueError as e:\n",
    "    print(e)\n",
    "print('----')\n",
    "try:\n",
    "    integrate(Eqn(a,b/c),b,side='right')\n",
    "except AttributeError as e:\n",
    "    print(e)\n",
    "print('----')\n",
    "try:\n",
    "    Eqn(FiniteSet(a), FiniteSet(b, c))\n",
    "except TypeError as e:\n",
    "    print(e)\n",
    "print('----')\n",
    "try:\n",
    "    Eqn(a,b/c).do.log() # trying to apply a function as an attribute.\n",
    "except AttributeError as e:\n",
    "    print(e)\n",
    "print('----')\n",
    "# Use check to find simple logic/typographical errors\n",
    "print(Eqn(2.0,3.0).check())\n",
    "Eqn(2,2.0).check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Equation(pi*(I+2), pi*I+2*pi).check() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{False}$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eqn(a,a+1).check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{False}$"
      ],
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Equation(pi*(I+2), pi*I+2*pi+I).check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eqn(cos(a)+I*sin(a),exp(I*a)).check()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.simplify()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$-1=-1$"
      ],
      "text/plain": [
       "Equation(-1, -1)"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eqn(cos(pi)+I*sin(pi),exp(I*pi))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.check()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Atomatic solutions (sympy.solve)\n",
    "**New!** Please report problems on the [issues site](https://github.com/gutow/Algebra_with_Sympy/issues)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a - b=\\frac{c}{a}\\,\\,\\,\\,\\,\\,\\,\\,\\,\\,(\\text{eqtosolve})$"
      ],
      "text/plain": [
       "Equation(a - b, c/a)"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eqtosolve =@ a - b = c/a\n",
    "eqtosolve"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{a=\\frac{b}{2} - \\frac{\\sqrt{b^{2} + 4 c}}{2}, a=\\frac{b}{2} + \\frac{\\sqrt{b^{2} + 4 c}}{2}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(a, b/2 - sqrt(b**2 + 4*c)/2), Equation(a, b/2 + sqrt(b**2 + 4*c)/2))"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(eqtosolve,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{\\left\\{ a : \\frac{b}{2} - \\frac{\\sqrt{b^{2} + 4 c}}{2}\\right\\}, \\left\\{ a : \\frac{b}{2} + \\frac{\\sqrt{b^{2} + 4 c}}{2}\\right\\}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet({a: b/2 - sqrt(b**2 + 4*c)/2}, {a: b/2 + sqrt(b**2 + 4*c)/2})"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(eqtosolve.lhs-eqtosolve.rhs, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{c=a^{2} - a b\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(c, a**2 - a*b))"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(eqtosolve,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{b=\\frac{a^{2} - c}{a}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(b, (a**2 - c)/a))"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(eqtosolve,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{Q=e^{\\frac{F z \\left(- E + Eo\\right)}{R T}}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(Q, exp(F*z*(-E + Eo)/(R*T))))"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(N1,Q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{\\left\\{x=-3, y=3\\right\\}, \\left\\{x=-1, y=-1\\right\\}, \\left\\{x=1, y=1\\right\\}, \\left\\{x=3, y=-3\\right\\}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(FiniteSet(Equation(x, -3), Equation(y, 3)), FiniteSet(Equation(x, -1), Equation(y, -1)), FiniteSet(Equation(x, 1), Equation(y, 1)), FiniteSet(Equation(x, 3), Equation(y, -3)))"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A system of equations with multiple solutions\n",
    "var ('x y', real = True)\n",
    "eq1 =@ abs(2*x + y) = 3\n",
    "eq2 = Eqn(abs(x + 2*y), 3)\n",
    "solve([eq1,eq2],x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{\\frac{3}{2} - \\frac{y}{2}, - \\frac{y}{2} - \\frac{3}{2}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(3/2 - y/2, -y/2 - 3/2)"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Very experimental use of solveset. It has the nice property that multiple solutions pretty print well.\n",
    "# Unfortunately, I cannot get systems of equations to work.\n",
    "solveset(eq1,x,domain=S.Reals)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Controling what outputs of solve look like"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code version: FiniteSet(FiniteSet(Equation(x, -3), Equation(y, 3)), FiniteSet(Equation(x, -1), Equation(y, -1)), FiniteSet(Equation(x, 1), Equation(y, 1)), FiniteSet(Equation(x, 3), Equation(y, -3)))\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left\\{\\left\\{x=-3, y=3\\right\\}, \\left\\{x=-1, y=-1\\right\\}, \\left\\{x=1, y=1\\right\\}, \\left\\{x=3, y=-3\\right\\}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(FiniteSet(Equation(x, -3), Equation(y, 3)), FiniteSet(Equation(x, -1), Equation(y, -1)), FiniteSet(Equation(x, 1), Equation(y, 1)), FiniteSet(Equation(x, 3), Equation(y, -3)))"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algwsym_config.output.show_code = True\n",
    "solve([eq1,eq2],x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\left\\{\\left\\{x=-3, y=3\\right\\}, \\left\\{x=-1, y=-1\\right\\}, \\left\\{x=1, y=1\\right\\}, \\left\\{x=3, y=-3\\right\\}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(FiniteSet(Equation(x, -3), Equation(y, 3)), FiniteSet(Equation(x, -1), Equation(y, -1)), FiniteSet(Equation(x, 1), Equation(y, 1)), FiniteSet(Equation(x, 3), Equation(y, -3)))"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algwsym_config.output.show_code = False\n",
    "solve([eq1,eq2],x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code version: FiniteSet(Equation(a, b/2 - sqrt(b**2 + 4*c)/2), Equation(a, b/2 + sqrt(b**2 + 4*c)/2))\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left\\{a=\\frac{b}{2} - \\frac{\\sqrt{b^{2} + 4 c}}{2}, a=\\frac{b}{2} + \\frac{\\sqrt{b^{2} + 4 c}}{2}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet(Equation(a, b/2 - sqrt(b**2 + 4*c)/2), Equation(a, b/2 + sqrt(b**2 + 4*c)/2))"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algwsym_config.output.show_code = True\n",
    "solns = solve(eqtosolve,a)\n",
    "solns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code version: FiniteSet({a: b/2 - sqrt(b**2 + 4*c)/2}, {a: b/2 + sqrt(b**2 + 4*c)/2})\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$\\left\\{\\left\\{ a : \\frac{b}{2} - \\frac{\\sqrt{b^{2} + 4 c}}{2}\\right\\}, \\left\\{ a : \\frac{b}{2} + \\frac{\\sqrt{b^{2} + 4 c}}{2}\\right\\}\\right\\}$"
      ],
      "text/plain": [
       "FiniteSet({a: b/2 - sqrt(b**2 + 4*c)/2}, {a: b/2 + sqrt(b**2 + 4*c)/2})"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(eqtosolve.lhs-eqtosolve.rhs, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Code version: Equation(a, b/2 - sqrt(b**2 + 4*c)/2)\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{2} - \\frac{\\sqrt{b^{2} + 4 c}}{2}$"
      ],
      "text/plain": [
       "Equation(a, b/2 - sqrt(b**2 + 4*c)/2)"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(solns)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$a=\\frac{b}{2} + \\frac{\\sqrt{b^{2} + 4 c}}{2}$"
      ],
      "text/plain": [
       "Equation(a, b/2 + sqrt(b**2 + 4*c)/2)"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algwsym_config.output.show_code = False\n",
    "list(solns)[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Setting solve output to Python lists instead of Sympy FiniteSets\n",
    "Note this prevents pretty-printed output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Equation(a, b/2 - sqrt(b**2 + 4*c)/2), Equation(a, b/2 + sqrt(b**2 + 4*c)/2)]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algwsym_config.output.solve_to_list = True\n",
    "solve(eqtosolve, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{a: b/2 - sqrt(b**2 + 4*c)/2}, {a: b/2 + sqrt(b**2 + 4*c)/2}]"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve(eqtosolve.lhs-eqtosolve.rhs, a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[Equation(x, -3), Equation(y, 3)],\n",
       " [Equation(x, -1), Equation(y, -1)],\n",
       " [Equation(x, 1), Equation(y, 1)],\n",
       " [Equation(x, 3), Equation(y, -3)]]"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solve([eq1,eq2],x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking version of Algebra with Sympy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.0.0rc0'"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "algwsym_version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.0.0rc0'"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from algebra_with_sympy.version import __version__ as spa_version\n",
    "spa_version"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.12"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}