Section 2.6 - Zeros of polynomials.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# 2.6 Zeros of polynomials and Horner's method \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A polynomial of degree $n$ has the form\n",
    "$$P(x)=P_n(x)=a_nx^n+a_{n-1}x^{n-1}+\\cdots +a_1x+a_0$$\n",
    "where the $a_i$’s, called the coefficients of $P_n$ and $a_n\\neq 0$. \n",
    "\n",
    "The problem is as follows: Find $x$ such that\n",
    "\n",
    "$$P(x) = 0.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> ### Fundamental Theorem of Algebra\n",
    "> If $P(x)$ is a polynomial of degree $n \\ge 1$ with real or complex coefficients, \n",
    ">then $P(x) = 0$ has at least one ( possibly complex) root."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: \n",
    "Determine all the zeros of the polynomial $P(x) = x^3 - 5x^2 + 17x - 13$.\n",
    "\n",
    "Note that $P(1)=0.$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "P (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "P(x) = x^3 - 5x^2 + 17x - 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x12a3883d0>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "using PyPlot\n",
    "x = linspace(-5, 10, 1000)\n",
    "plot(x, P.(x))\n",
    "hlines(0, -5, 10)\n",
    "plot(1, 0, \"ro\")\n",
    "#xlim(-5, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Horner's Method\n",
    "To use Newton’s method, we need to evaluate $P(x)$ and $P^\\prime(x)$ at specified values. \n",
    "\n",
    "Computational efficiency requires that the evaluation of polynomials be done in the **nested** manner discussed before. Horner’s (Ruffini) method incorporates this nesting technique, and, as a consequence, requires only $n$ multiplications and $n$ additions to evaluate an arbitrary $n$th-degree polynomial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">## Theorem (Horner’s Method)\n",
    ">Let $$P(x)=a_nx^n+a_{n-1}x^{n-1}+\\cdots +a_1x+a_0.$$\n",
    "Define $b_n = a_n$ and\n",
    "$$ b_k =a_k +b_{k+1}x_0,\\qquad k=n−1,n−2,\\ldots,1,0.$$\n",
    "Then $b_0 = P(x_0)$. Moreover, if\n",
    "$$Q(x)=b_nx^{n−1} +b_{n−1}x^{n−2} +\\cdots+b_2x+b_1,$$\n",
    "then $$P(x)=(x-x_0)Q(x)+b_0.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "using Polynomials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[1mP\u001b[22m\u001b[1mo\u001b[22m\u001b[1ml\u001b[22m\u001b[1my\u001b[22m\u001b[1mn\u001b[22m\u001b[1mo\u001b[22m\u001b[1mm\u001b[22m\u001b[1mi\u001b[22m\u001b[1ma\u001b[22m\u001b[1ml\u001b[22m\u001b[1ms\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "No documentation found.\n",
       "\n",
       "Displaying the `README.md` for the module instead.\n",
       "\n",
       "---\n",
       "\n",
       "# Polynomials\n",
       "\n",
       "Basic arithmetic, integration, differentiation, evaluation, and root finding over dense univariate polynomials.\n",
       "\n",
       "[![Polynomials](http://pkg.julialang.org/badges/Polynomials_0.6.svg)](http://pkg.julialang.org/?pkg=Polynomials)\n",
       "\n",
       "Master branch: [![Build Status](https://travis-ci.org/JuliaMath/Polynomials.jl.svg?branch=master)](https://travis-ci.org/JuliaMath/Polynomials.jl) [![Coverage Status](https://coveralls.io/repos/github/JuliaMath/Polynomials.jl/badge.svg)](https://coveralls.io/github/JuliaMath/Polynomials.jl)\n",
       "\n",
       "Documentation: [![](https://img.shields.io/badge/docs-stable-blue.svg)](https://JuliaMath.github.io/Polynomials.jl/stable) [![](https://img.shields.io/badge/docs-latest-blue.svg)](https://JuliaMath.github.io/Polynomials.jl/latest)\n",
       "\n",
       "#### Poly(a::Vector) where {T<:Number}\n",
       "\n",
       "Construct a polynomial from its coefficients, lowest order first.\n",
       "\n",
       "```julia\n",
       "julia> Poly([1,0,3,4])\n",
       "Poly(1 + 3x^2 + 4x^3)\n",
       "```\n",
       "\n",
       "An optional variable parameter can be added.\n",
       "\n",
       "```julia\n",
       "julia> Poly([1,2,3], :s)\n",
       "Poly(1 + 2s + 3s^2)\n",
       "```\n",
       "\n",
       "#### poly(r::AbstractVector)\n",
       "\n",
       "Construct a polynomial from its roots. This is in contrast to the `Poly` constructor, which constructs a polynomial from its coefficients.\n",
       "\n",
       "```julia\n",
       "// Represents (x-1)*(x-2)*(x-3)\n",
       "julia> poly([1,2,3])\n",
       "Poly(-6 + 11x - 6x^2 + x^3)\n",
       "```\n",
       "\n",
       "#### +, -, *, /, div, ==\n",
       "\n",
       "The usual arithmetic operators are overloaded to work on polynomials, and combinations of polynomials and scalars.\n",
       "\n",
       "```julia\n",
       "julia> p = Poly([1,2])\n",
       "Poly(1 + 2x)\n",
       "\n",
       "julia> q = Poly([1, 0, -1])\n",
       "Poly(1 - x^2)\n",
       "\n",
       "julia> 2p\n",
       "Poly(2 + 4x)\n",
       "\n",
       "julia> 2+p\n",
       "Poly(3 + 2x)\n",
       "\n",
       "julia> p - q\n",
       "Poly(2x + x^2)\n",
       "\n",
       "julia> p * q\n",
       "Poly(1 + 2x - x^2 - 2x^3)\n",
       "\n",
       "julia> q / 2\n",
       "Poly(0.5 - 0.5x^2)\n",
       "\n",
       "julia> q ÷ p      # `div`, also `rem` and `divrem`\n",
       "Poly(0.25 - 0.5x)\n",
       "```\n",
       "\n",
       "Note that operations involving polynomials with different variables will error.\n",
       "\n",
       "```julia\n",
       "julia> p = Poly([1, 2, 3], :x)\n",
       "julia> q = Poly([1, 2, 3], :s)\n",
       "julia> p + q\n",
       "ERROR: Polynomials must have same variable.\n",
       "```\n",
       "\n",
       "To get the degree of the polynomial use the `degree` method\n",
       "\n",
       "```\n",
       "julia> degree(p)\n",
       "1\n",
       "\n",
       "julia> degree(p^2)\n",
       "2\n",
       "\n",
       "julia> degree(p-p)\n",
       "0\n",
       "```\n",
       "\n",
       "#### polyval(p::Poly, x::Number)\n",
       "\n",
       "Evaluate the polynomial `p` at `x`.\n",
       "\n",
       "```julia\n",
       "julia> p = Poly([1, 0, -1])\n",
       "julia> polyval(p, 0.1)\n",
       "0.99\n",
       "```\n",
       "\n",
       "A call method is also available:\n",
       "\n",
       "```julia\n",
       "julia> p(0.1)\n",
       "0.99\n",
       "```\n",
       "\n",
       "#### polyint(p::Poly, k::Number=0)\n",
       "\n",
       "Integrate the polynomial `p` term by term, optionally adding constant term `k`. The order of the resulting polynomial is one higher than the order of `p`.\n",
       "\n",
       "```julia\n",
       "julia> polyint(Poly([1, 0, -1]))\n",
       "Poly(x - 0.3333333333333333x^3)\n",
       "\n",
       "julia> polyint(Poly([1, 0, -1]), 2)\n",
       "Poly(2.0 + x - 0.3333333333333333x^3)\n",
       "```\n",
       "\n",
       "#### polyder(p::Poly)\n",
       "\n",
       "Differentiate the polynomial `p` term by term. The order of the resulting polynomial is one lower than the order of `p`.\n",
       "\n",
       "```julia\n",
       "julia> polyder(Poly([1, 3, -1]))\n",
       "Poly(3 - 2x)\n",
       "```\n",
       "\n",
       "#### roots(p::Poly)\n",
       "\n",
       "Return the roots (zeros) of `p`, with multiplicity. The number of roots returned is equal to the order of `p`. By design, this is not type-stable, the returned roots may be real or complex.\n",
       "\n",
       "```julia\n",
       "julia> roots(Poly([1, 0, -1]))\n",
       "2-element Array{Float64,1}:\n",
       " -1.0\n",
       "  1.0\n",
       "\n",
       "julia> roots(Poly([1, 0, 1]))\n",
       "2-element Array{Complex{Float64},1}:\n",
       " 0.0+1.0im\n",
       " 0.0-1.0im\n",
       "\n",
       "julia> roots(Poly([0, 0, 1]))\n",
       "2-element Array{Float64,1}:\n",
       " 0.0\n",
       " 0.0\n",
       "```\n",
       "\n",
       "#### Polyfit\n",
       "\n",
       "  * `polyfit`: fits a polynomial of minimal degree fitting the points specified by `x` and `y` using the least-squares fit.\n",
       "\n",
       "```julia\n",
       "julia> xs = 1:4; ys = exp(xs); polyfit(xs, ys)\n",
       "Poly(-7.717211620141281 + 17.9146616149694x - 9.77757245502143x^2 + 2.298404288652356x^3)\n",
       "```\n",
       "\n",
       "#### Other methods\n",
       "\n",
       "Polynomial objects also have other methods:\n",
       "\n",
       "  * 0-based indexing is used to extract the coefficients of $a_0 + a_1 x + a_2 x^2 + ...$, coefficients may be changed using indexing notation.\n",
       "  * `coeffs`: returns the entire coefficient vector\n",
       "  * `degree`: returns the polynomial degree, `length` is 1 plus the degree\n",
       "  * `variable`: returns the polynomial symbol as a degree 1 polynomial\n",
       "  * `norm`: find the `p`-norm of a polynomial\n",
       "  * `conj`: finds the conjugate of a polynomial over a complex fiel\n",
       "  * `truncate`: set to 0 all small terms in a polynomial; `chop` chops off any small leading values that may arise due to floating point operations.\n",
       "  * `gcd`: greatest common divisor of two polynomials.\n",
       "  * `Pade`: Return the [Pade approximant](https://en.wikipedia.org/wiki/Pad%C3%A9_approximant) of order `m/n` for a polynomial as a `Pade` object.\n",
       "\n",
       "## See also\n",
       "\n",
       "  * [MultiPoly.jl](https://github.com/daviddelaat/MultiPoly.jl) for sparse multivariate polynomials\n",
       "  * [MultivariatePolynomials.jl](https://github.com/blegat/MultivariatePolynomials.jl) for multivariate polynomials and moments of commutative or non-commutative variables\n",
       "  * [Nemo.jl](https://github.com/wbhart/Nemo.jl) for generic polynomial rings, matrix spaces, fraction fields, residue rings, power series\n",
       "  * [PolynomialRoots.jl](https://github.com/giordano/PolynomialRoots.jl) for a fast complex polynomial root finder\n"
      ],
      "text/plain": [
       "No documentation found.\n",
       "\n",
       "Displaying the `README.md` for the module instead.\n",
       "\n",
       "---\n",
       "\n",
       "# Polynomials\n",
       "\n",
       "Basic arithmetic, integration, differentiation, evaluation, and root finding over dense univariate polynomials.\n",
       "\n",
       "[![Polynomials](http://pkg.julialang.org/badges/Polynomials_0.6.svg)](http://pkg.julialang.org/?pkg=Polynomials)\n",
       "\n",
       "Master branch: [![Build Status](https://travis-ci.org/JuliaMath/Polynomials.jl.svg?branch=master)](https://travis-ci.org/JuliaMath/Polynomials.jl) [![Coverage Status](https://coveralls.io/repos/github/JuliaMath/Polynomials.jl/badge.svg)](https://coveralls.io/github/JuliaMath/Polynomials.jl)\n",
       "\n",
       "Documentation: [![](https://img.shields.io/badge/docs-stable-blue.svg)](https://JuliaMath.github.io/Polynomials.jl/stable) [![](https://img.shields.io/badge/docs-latest-blue.svg)](https://JuliaMath.github.io/Polynomials.jl/latest)\n",
       "\n",
       "#### Poly(a::Vector) where {T<:Number}\n",
       "\n",
       "Construct a polynomial from its coefficients, lowest order first.\n",
       "\n",
       "```julia\n",
       "julia> Poly([1,0,3,4])\n",
       "Poly(1 + 3x^2 + 4x^3)\n",
       "```\n",
       "\n",
       "An optional variable parameter can be added.\n",
       "\n",
       "```julia\n",
       "julia> Poly([1,2,3], :s)\n",
       "Poly(1 + 2s + 3s^2)\n",
       "```\n",
       "\n",
       "#### poly(r::AbstractVector)\n",
       "\n",
       "Construct a polynomial from its roots. This is in contrast to the `Poly` constructor, which constructs a polynomial from its coefficients.\n",
       "\n",
       "```julia\n",
       "// Represents (x-1)*(x-2)*(x-3)\n",
       "julia> poly([1,2,3])\n",
       "Poly(-6 + 11x - 6x^2 + x^3)\n",
       "```\n",
       "\n",
       "#### +, -, *, /, div, ==\n",
       "\n",
       "The usual arithmetic operators are overloaded to work on polynomials, and combinations of polynomials and scalars.\n",
       "\n",
       "```julia\n",
       "julia> p = Poly([1,2])\n",
       "Poly(1 + 2x)\n",
       "\n",
       "julia> q = Poly([1, 0, -1])\n",
       "Poly(1 - x^2)\n",
       "\n",
       "julia> 2p\n",
       "Poly(2 + 4x)\n",
       "\n",
       "julia> 2+p\n",
       "Poly(3 + 2x)\n",
       "\n",
       "julia> p - q\n",
       "Poly(2x + x^2)\n",
       "\n",
       "julia> p * q\n",
       "Poly(1 + 2x - x^2 - 2x^3)\n",
       "\n",
       "julia> q / 2\n",
       "Poly(0.5 - 0.5x^2)\n",
       "\n",
       "julia> q ÷ p      # `div`, also `rem` and `divrem`\n",
       "Poly(0.25 - 0.5x)\n",
       "```\n",
       "\n",
       "Note that operations involving polynomials with different variables will error.\n",
       "\n",
       "```julia\n",
       "julia> p = Poly([1, 2, 3], :x)\n",
       "julia> q = Poly([1, 2, 3], :s)\n",
       "julia> p + q\n",
       "ERROR: Polynomials must have same variable.\n",
       "```\n",
       "\n",
       "To get the degree of the polynomial use the `degree` method\n",
       "\n",
       "```\n",
       "julia> degree(p)\n",
       "1\n",
       "\n",
       "julia> degree(p^2)\n",
       "2\n",
       "\n",
       "julia> degree(p-p)\n",
       "0\n",
       "```\n",
       "\n",
       "#### polyval(p::Poly, x::Number)\n",
       "\n",
       "Evaluate the polynomial `p` at `x`.\n",
       "\n",
       "```julia\n",
       "julia> p = Poly([1, 0, -1])\n",
       "julia> polyval(p, 0.1)\n",
       "0.99\n",
       "```\n",
       "\n",
       "A call method is also available:\n",
       "\n",
       "```julia\n",
       "julia> p(0.1)\n",
       "0.99\n",
       "```\n",
       "\n",
       "#### polyint(p::Poly, k::Number=0)\n",
       "\n",
       "Integrate the polynomial `p` term by term, optionally adding constant term `k`. The order of the resulting polynomial is one higher than the order of `p`.\n",
       "\n",
       "```julia\n",
       "julia> polyint(Poly([1, 0, -1]))\n",
       "Poly(x - 0.3333333333333333x^3)\n",
       "\n",
       "julia> polyint(Poly([1, 0, -1]), 2)\n",
       "Poly(2.0 + x - 0.3333333333333333x^3)\n",
       "```\n",
       "\n",
       "#### polyder(p::Poly)\n",
       "\n",
       "Differentiate the polynomial `p` term by term. The order of the resulting polynomial is one lower than the order of `p`.\n",
       "\n",
       "```julia\n",
       "julia> polyder(Poly([1, 3, -1]))\n",
       "Poly(3 - 2x)\n",
       "```\n",
       "\n",
       "#### roots(p::Poly)\n",
       "\n",
       "Return the roots (zeros) of `p`, with multiplicity. The number of roots returned is equal to the order of `p`. By design, this is not type-stable, the returned roots may be real or complex.\n",
       "\n",
       "```julia\n",
       "julia> roots(Poly([1, 0, -1]))\n",
       "2-element Array{Float64,1}:\n",
       " -1.0\n",
       "  1.0\n",
       "\n",
       "julia> roots(Poly([1, 0, 1]))\n",
       "2-element Array{Complex{Float64},1}:\n",
       " 0.0+1.0im\n",
       " 0.0-1.0im\n",
       "\n",
       "julia> roots(Poly([0, 0, 1]))\n",
       "2-element Array{Float64,1}:\n",
       " 0.0\n",
       " 0.0\n",
       "```\n",
       "\n",
       "#### Polyfit\n",
       "\n",
       "  * `polyfit`: fits a polynomial of minimal degree fitting the points specified by `x` and `y` using the least-squares fit.\n",
       "\n",
       "```julia\n",
       "julia> xs = 1:4; ys = exp(xs); polyfit(xs, ys)\n",
       "Poly(-7.717211620141281 + 17.9146616149694x - 9.77757245502143x^2 + 2.298404288652356x^3)\n",
       "```\n",
       "\n",
       "#### Other methods\n",
       "\n",
       "Polynomial objects also have other methods:\n",
       "\n",
       "  * 0-based indexing is used to extract the coefficients of $a_0 + a_1 x + a_2 x^2 + ...$, coefficients may be changed using indexing notation.\n",
       "  * `coeffs`: returns the entire coefficient vector\n",
       "  * `degree`: returns the polynomial degree, `length` is 1 plus the degree\n",
       "  * `variable`: returns the polynomial symbol as a degree 1 polynomial\n",
       "  * `norm`: find the `p`-norm of a polynomial\n",
       "  * `conj`: finds the conjugate of a polynomial over a complex fiel\n",
       "  * `truncate`: set to 0 all small terms in a polynomial; `chop` chops off any small leading values that may arise due to floating point operations.\n",
       "  * `gcd`: greatest common divisor of two polynomials.\n",
       "  * `Pade`: Return the [Pade approximant](https://en.wikipedia.org/wiki/Pad%C3%A9_approximant) of order `m/n` for a polynomial as a `Pade` object.\n",
       "\n",
       "## See also\n",
       "\n",
       "  * [MultiPoly.jl](https://github.com/daviddelaat/MultiPoly.jl) for sparse multivariate polynomials\n",
       "  * [MultivariatePolynomials.jl](https://github.com/blegat/MultivariatePolynomials.jl) for multivariate polynomials and moments of commutative or non-commutative variables\n",
       "  * [Nemo.jl](https://github.com/wbhart/Nemo.jl) for generic polynomial rings, matrix spaces, fraction fields, residue rings, power series\n",
       "  * [PolynomialRoots.jl](https://github.com/giordano/PolynomialRoots.jl) for a fast complex polynomial root finder\n"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "? Polynomials"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "&#45;13 &#43; 17&#8729;x &#45; 5&#8729;x^2 &#43; x^3"
      ],
      "text/plain": [
       "Poly(-13 + 17*x - 5*x^2 + x^3)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Poly([-13,17,-5,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3-element Array{Complex{Float64},1}:\n",
       "      1.0+0.0im     \n",
       " 0.153846+0.230769im\n",
       " 0.153846-0.230769im"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roots(Poly([1, -5, 17, -13]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.683"
      ],
      "text/plain": [
       "1.683"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Poly([1, -5, 17, -13])\n",
    "polyval(p, -0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "horner (generic function with 1 method)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function horner(coefs, x)\n",
    "    s = copy(coefs[end])\n",
    "    for k in length(coefs)-1:-1:1\n",
    "        s = copy(coefs[k]) + x * s  # b_k = a_k + x_0*b_{k+1}\n",
    "    end\n",
    "    return s\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1 &#45; 5&#8729;x &#43; 17&#8729;x^2 &#45; 13&#8729;x^3"
      ],
      "text/plain": [
       "Poly(1 - 5*x + 17*x^2 - 13*x^3)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Poly([1, -5, 17, -13])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.683"
      ],
      "text/plain": [
       "1.683"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "horner([1, -5, 17, -13], -0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.018490 seconds (3.84 k allocations: 215.779 KiB)\n",
      "  0.007126 seconds (130 allocations: 8.828 KiB)\n",
      "  0.014899 seconds (2.31 k allocations: 128.214 KiB)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "-0.07427507055456554"
      ],
      "text/plain": [
       "-0.07427507055456554"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We are beating JULIA!!!\n",
    "coefs=rand(1000001)\n",
    "p = Poly(coefs)\n",
    "x0=-0.2345\n",
    "@time polyval(p, x0)\n",
    "@time p(x0)\n",
    "@time horner(coefs, x0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: \n",
    "Use Horner's method to evaluate\n",
    "$$P(x) = 2x^4 − 3x^2 + 3x − 4 \\qquad \\mbox{at}\\quad x_0 = −2.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An additional advantage of using the Horner  procedure is that, since\n",
    "$$P(x) = (x − x_0)Q(x) + b_0,$$ \n",
    "\n",
    "$$P^\\prime(x)=Q(x)+(x−x )Q^\\prime(x)\\qquad \\mbox{and} \\qquad\n",
    "P^\\prime(x_0)=Q(x_0).$$\n",
    "\n",
    "When the Newton's method is being used to find an approximate zero of a polynomial, $P(x)$ and $P^\\prime(x)$ can be evaluated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "hornerVect (generic function with 1 method)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function hornerVect(coefs, x)\n",
    "    coefsnew = copy(coefs)\n",
    "    for k in length(coefs)-1:-1:1\n",
    "        coefsnew[k] = copy(coefs[k]) + x * coefsnew[k+1]  # b_k = a_k + x_0*b_{k+1}\n",
    "    end\n",
    "    return coefsnew\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5-element Array{Int64,1}:\n",
       " 10\n",
       " -7\n",
       "  5\n",
       " -4\n",
       "  2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = Poly([-4,3, -3,0, 2])\n",
    "b=hornerVect([-4,3, -3,0, 2],-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "10"
      ],
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "10"
      ],
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p(-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "&#45;7 &#43; 5&#8729;x &#45; 4&#8729;x^2 &#43; 2&#8729;x^3"
      ],
      "text/plain": [
       "Poly(-7 + 5*x - 4*x^2 + 2*x^3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = Poly(b[2:length(b)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "-49"
      ],
      "text/plain": [
       "-49"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = horner(b[2:length(b)],-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "-49"
      ],
      "text/plain": [
       "-49"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q(-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "plotnewtonH (generic function with 1 method)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using PyPlot\n",
    "function plotnewtonH(p,q, x0, a, b; tol=1e-6, maxiter=10)    \n",
    "    xspan = linspace(a, b, 1000)\n",
    "    plot(xspan, p.(xspan), \"b\")\n",
    "    hlines(0, a, b)\n",
    "    xlim(a, b)    \n",
    "    k = 0\n",
    "    x = x0\n",
    "    px = p(x)\n",
    "    #q=polyder(p)\n",
    "    #qx = q(x)\n",
    "    xold, xnew = x, Inf\n",
    "    @printf \"%4s %22s %22s\\n\" \"k\" \"x\" \"p(x)\"\n",
    "    while abs(xnew - xold) > tol*(1 + abs(xold)) && k < maxiter\n",
    "        k += 1\n",
    "        xnew = x - px/q(x)\n",
    "        vlines(x, 0, px, linestyles=\":\")\n",
    "        plot([xnew, x], [0, px], \"r\")\n",
    "        plot(x, px, \"bo\")\n",
    "        xold = x\n",
    "        x = xnew\n",
    "        px = p(x)\n",
    "        #qx = q(x)\n",
    "        @printf \"%4d %22.15e %22.15e\\n\" k x px\n",
    "    end  \n",
    "    return x  \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "&#45;4 &#43; 3&#8729;x &#45; 3&#8729;x^2 &#43; 2&#8729;x^4"
      ],
      "text/plain": [
       "Poly(-4 + 3*x - 3*x^2 + 2*x^4)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p=Poly([-4,3, -3,0, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "3 &#45; 6&#8729;x &#43; 8&#8729;x^3"
      ],
      "text/plain": [
       "Poly(3 - 6*x + 8*x^3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=polyder(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   k                      x                   p(x)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x114ea8210>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   1 -1.795918367346939e+00  1.741690649859379e+00\n",
      "   2 -1.742432916750542e+00  9.995592022432565e-02\n",
      "   3 -1.738970235336167e+00  4.002870896355759e-04\n",
      "   4 -1.738956256679049e+00  6.504574656673867e-09\n",
      "   5 -1.738956256451892e+00  8.881784197001252e-16\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "-1.738956256451892"
      ],
      "text/plain": [
       "-1.738956256451892"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = plotnewtonH(p,q, -2.0, -2.5, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Complex{Float64},1}:\n",
       " -1.73896+0.0im     \n",
       "  1.25488+0.0im     \n",
       " 0.242037+0.926245im\n",
       " 0.242037-0.926245im"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "roots(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "newtonH (generic function with 1 method)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Polynomials\n",
    "function newtonH(pcoefs, x0; tol=1e-6, maxiter=10)   \n",
    "    k=0\n",
    "    @printf \"%4s %22s %22s  %22s\\n\" \"k\" \"x\" \"p(x)\" \"q(x)\" \n",
    "    x = x0\n",
    "    p=Poly(pcoefs)\n",
    "    q=polyder(p)\n",
    "    px = p(x)\n",
    "    qx = q(x)   \n",
    "    xold, xnew = x, Inf\n",
    "    @printf \"%4d %22.15e %22.15e\\n\" k x px \n",
    "    while abs(xnew - xold) > tol*(1 + abs(xold)) && k < maxiter\n",
    "        k += 1\n",
    "        xnew = x - px/qx\n",
    "        xold = x\n",
    "        x = xnew\n",
    "        px = p(x)\n",
    "        qx = q(x) \n",
    "        @printf \"%4d %22.15e %22.15e\\n\" k x px \n",
    "    end  \n",
    "    return x  \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   k                      x                   p(x)                    q(x)\n",
      "   0  2.000000000000000e+01  3.900000000000000e+02\n",
      "   1  1.025000000000000e+01  9.506250000000000e+01\n",
      "   2  5.612804878048781e+00  2.150357859904819e+01\n",
      "   3  3.697222645433951e+00  3.669455289909621e+00\n",
      "   4  3.200977809537825e+00  2.462589371535735e-01\n",
      "   5  3.162511604551991e+00  1.479648926011379e-03\n",
      "   6  3.162277668821308e+00  5.472592690125566e-08\n",
      "   7  3.162277660168380e+00  1.776356839400250e-15\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "3.1622776601683795"
      ],
      "text/plain": [
       "3.1622776601683795"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=[-10,0, 1]\n",
    "newtonH(a, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An application: Minimizing a function in one variable\n",
    "\n",
    "We can use the root-finding methods described above to find the **minimum** or **maximum** value of a function $\\phi \\in C^2[a,b]$.\n",
    "\n",
    "Recall that $x^* \\in (a,b)$ is a **critical point** of $\\phi$ if \n",
    "\n",
    "$$\\phi'(x^*) = 0.$$\n",
    "\n",
    "We can find $x^*$ by applying Newton's method to this nonlinear equation to obtain:\n",
    "\n",
    "$$x_{k+1} = x_k - \\frac{\\phi'(x_k)}{\\phi''(x_k)}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Another interpretation for Newton's method\n",
    "\n",
    "We can also obtain this by considering the **second-order (quadratic) approximation** of $\\phi$ around the point $x_k$:\n",
    "\n",
    "$$\\phi(x) \\approx \\phi(x_k) + \\phi'(x_k)(x-x_k) + \\frac{\\phi''(x_k)}{2}(x-x_k)^2, \\quad \\text{for all $x \\approx x_k$}.$$\n",
    "\n",
    "If $x_k$ is close to $x^*$, we expect the minimum/maximum of $\\phi$ to be near the minimum/maximum of the **quadratic approximation** of $\\phi$:\n",
    "\n",
    "$$q(x) = \\phi(x_k) + \\phi'(x_k)(x-x_k) + \\frac{\\phi''(x_k)}{2}(x-x_k)^2.$$\n",
    "\n",
    "Thus we should choose $x_{k+1}$ to be the critical point of $q$, so we want to find $x_{k+1}$ such that $q'(x_{k+1}) = 0$. Note that\n",
    "\n",
    "$$q'(x) = \\phi'(x_k) + \\phi''(x_k)(x-x_k).$$\n",
    "\n",
    "Thus $q'(x_{k+1}) = 0$ gives us\n",
    "\n",
    "$$x_{k+1} = x_k - \\frac{\\phi'(x_k)}{\\phi''(x_k)}.$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example\n",
    "\n",
    "Let's find the minimum value of \n",
    "\n",
    "$$\\phi(x) = 10\\cosh(x/4) - x$$\n",
    "\n",
    "by applying Newton's method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "plotnewton (generic function with 1 method)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using PyPlot\n",
    "\n",
    "function plotnewton(f, fp, x0, a, b; tol=1e-6, maxiter=10)\n",
    "    \n",
    "    xspan = linspace(a, b, 1000)\n",
    "    plot(xspan, f.(xspan), \"b\")\n",
    "    hlines(0, a, b)\n",
    "    xlim(a, b)\n",
    "    \n",
    "    k = 0\n",
    "    x = x0\n",
    "    fx = f(x)\n",
    "    xold, xnew = x, Inf\n",
    "    @printf \"%4s %22s %22s\\n\" \"k\" \"x\" \"f(x)\"\n",
    "    while abs(xnew - xold) > tol*(1 + abs(xold)) && k < maxiter\n",
    "        k += 1\n",
    "        xnew = x - fx/fp(x)\n",
    "        \n",
    "        # Plotting stuff\n",
    "        vlines(x, 0, fx, linestyles=\":\")\n",
    "        plot([xnew, x], [0, fx], \"r\")\n",
    "        plot(x, fx, \"bo\")\n",
    "        \n",
    "        xold = x\n",
    "        x = xnew\n",
    "        fx = f(x)\n",
    "        @printf \"%4d %22.15e %22.15e\\n\" k x fx\n",
    "    end\n",
    "    \n",
    "    return x\n",
    "    \n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ϕ (generic function with 1 method)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ϕ(x) = 10cosh(x/4) - x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ϕp (generic function with 1 method)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ϕp(x) = 2.5sinh(x/4) - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ϕpp (generic function with 1 method)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ϕpp(x) = 0.625cosh(x/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  "
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x12a4c1ed0>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " k                      x                   f(x)\n",
      "   1  2.454132846259612e+00  6.318888130288225e-01\n",
      "   2  1.607515395183571e+00  3.196055878741744e-02\n",
      "   3  1.560247213739166e+00  7.130979857405961e-05\n",
      "   4  1.560141279603856e+00  3.507054646689767e-10\n",
      "   5  1.560141279082861e+00 -1.110223024625157e-16\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "1.560141279082861"
      ],
      "text/plain": [
       "1.560141279082861"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x0, a, b = 5., 0., 10.\n",
    "\n",
    "x = plotnewton(ϕp, ϕpp, x0, a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "0.673145600891813"
      ],
      "text/plain": [
       "0.673145600891813"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ϕpp(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0x114ed1310>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "xspan = linspace(-3, 7, 1000)\n",
    "\n",
    "plot(xspan, ϕ.(xspan))\n",
    "plot(x, ϕ(x), \"o\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus \n",
    "\n",
    "$$x^* = 1.560141279082861\\ldots.$$ \n",
    "\n",
    "Note that $\\phi'(x^*) = 0$, as required. Since $\\phi''(x^*) > 0$, we know that \n",
    "\n",
    "$$\\phi(x^*) = 9.210188335186146\\ldots$$ \n",
    "\n",
    "is a **local minimum value** of $\\phi$.\n",
    "\n",
    "In fact, since $\\phi''(x) > 0$ for all $x$, we know that $\\phi(x^*)$ is the **global minimum value** of $\\phi$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Julia 0.6.0",
   "language": "julia",
   "name": "julia-0.6"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}