5-Solving-nonlinear-equations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 5. Solving nonlinear equations using `fsolve`\n",
    "\n",
    "First, import some stuff we'll need. We give some of them nicknames to save typing later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from scipy.optimize import fsolve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `fsolve`, which is found in the `optimize` submodule of the `scipy` package, solves equations of the form\n",
    "$$\n",
    "\\newcommand{\\xx}{\\mathbf{x}}\n",
    "\\newcommand{\\ff}{\\mathbf{f}}\n",
    "\\ff(\\xx) = 0\n",
    "$$where $\\xx$ is a vector in $\\mathbb{R}^n$.\n",
    "That is, it provides a numerical solution of the roots of the equation $\\ff$.\n",
    "\n",
    "Writing $\\xx = (x_1, \\ldots, x_n)$, we have a system of the form\n",
    "\\begin{align}\n",
    "f_1(x_1) &= 0 \\\\\n",
    "f_2(x_2) &= 0 \\\\\n",
    "&\\ldots \\\\\n",
    "f_n(x_n) &= 0\n",
    "\\end{align}\n",
    "\n",
    "Note that any system of non-linear equation(s) can be written in this form.\n",
    "If we only have one equation, then it's simply\n",
    "$$f(x) = 0$$\n",
    "but by using vectors you can solve several equations simultaneously, without having to substitute them all into each other into a monolithic equation.\n",
    "\n",
    "To use `fsolve`, we must define at least the Python function `func` which implements the mathematical function $\\ff$. It must take a vector `x` and return the vector `func(x)` which, when we supply the correct values of $x_n$, will equal 0."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can  check the documentation by executing the function name followed by a question mark. A help window should pop up in a frame below when you press (shift+enter) on the following cell. You can close it when done reading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fsolve?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also search online for the [documentation](http://lmgtfy.com/?q=scipy.optimize.fsolve). It says we need to pass the `fsolve` function at least two variables: our function that we want to set equal to zero, and an initial guess for its input.\n",
    "\n",
    "You can also pass additional arguments to $f$ if needed eg. `func(x, and, other, arguments)`, and various options to the solver."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The simplest case is when we have a single equation. For example, we could wish to solve the equation\n",
    "$$\n",
    "x = -2 \\cos(x)\n",
    "$$\n",
    "First arrange it so the right hand side is zero:\n",
    "$$\n",
    "x + 2 \\cos(x) = 0\n",
    "$$\n",
    "\n",
    "We'll also need a starting guess. Without thinking very hard, let's try $x=0.5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.02986653])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(x):\n",
    "    return x + 2 * np.cos(x)\n",
    "fsolve(func, 0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that even though there's only one element, it returns a Numpy Array, because it's designed to work on Arrays. If you want to just get the number, you'll have to take the first (in this case only) element of the array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0298665293222589"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer = fsolve(func, 0.5)\n",
    "answer[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple equations\n",
    "\n",
    "You might have several equations that are all interrelated, eg.\n",
    "\\begin{align}\n",
    "a \\cos(b) &= 4 \\\\\n",
    "ab &= b + 5 \\\\\n",
    "\\end{align}\n",
    "\n",
    "First, stack all the variables in an array $\\xx = (a, b)$ (remembering Python counts array elements from 0), and make each equation equal to zero\n",
    "\\begin{align}\n",
    "x_0 \\cos(x_1) -4 &= 0 \\\\\n",
    "x_0 x_1 - x_1 - 5 &= 0 \\\\\n",
    "\\end{align}\n",
    "\n",
    "But rather than rename everything $x_0$ and $x_1$ etc. in your derivation, which makes it hard to remember what is what, it is usually better to unpack the vector to sensible names inside your function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.50409711,  0.90841421])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func2(x):\n",
    "    # if it helps clarify things, unpack the array into different names:\n",
    "    a, b = x\n",
    "    output = [] # start with an empty list, then append the equations\n",
    "    output.append(a * np.cos(b) - 4)\n",
    "    output.append(a * b - b - 5)\n",
    "    return output\n",
    "\n",
    "initial_guess = [1., 1.]\n",
    "fsolve(func2, initial_guess)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It returns an array, which we can unpack to get the values we need"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.50409710671\n",
      "0.90841420547\n"
     ]
    }
   ],
   "source": [
    "a, b = fsolve(func2, initial_guess)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can often find a way to do the same thing with fewer lines of code, but it typically makes it harder to read, write, or debug, so is usually a bad idea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.50409711,  0.90841421])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func3(x):\n",
    "    return([x[0]*np.cos(x[1])-4,x[0]*x[1]-x[1]-5])\n",
    "fsolve(func2, [1., 1.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In fact, if you *really* want to make life difficult for people reading your code (most likely your future self), you can do it in one line!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.50409711,  0.90841421])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fsolve(lambda x: [x[0]*np.cos(x[1])-4,x[0]*x[1]-x[1]-5], [1.,1.])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How ugly!\n",
    "\n",
    "For our simple example above I guess it's almost forgivable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0298665293222589"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fsolve(lambda x: x+2*np.cos(x),.5)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But in general it's better to be clear than concise.  And that way you don't need to understand `lambda` functions! Just stick to the `def` method you know already!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}