{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 18.335 pset 1 solutions\n",
    "\n",
    "## Problem 1: Floating point"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As explained in the solutions, the smallest non-representable integer [Trefethen problem 13.2(c)] in IEEE double precision should be $2^{53}+1$.  Let's check $2^{53} + o$ for $o \\in {-3,-2,...,3}$, by the simple expedient of comparing to integers (using a 64-bit integer type, `Int64`, such that these integers are represented exactly; note that `Int64` is the default integer type in Julia except on 32-bit systems):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "β^p + -3 = 9007199254740989 exactly represented in Float64? true\n",
      "β^p + -2 = 9007199254740990 exactly represented in Float64? true\n",
      "β^p + -1 = 9007199254740991 exactly represented in Float64? true\n",
      "β^p + 0 = 9007199254740992 exactly represented in Float64? true\n",
      "β^p + 1 = 9007199254740993 exactly represented in Float64? false\n",
      "β^p + 2 = 9007199254740994 exactly represented in Float64? true\n",
      "β^p + 3 = 9007199254740995 exactly represented in Float64? false\n"
     ]
    }
   ],
   "source": [
    "β = Int64(2)  # make sure we are using 64-bit ints, even on 32-bit machines\n",
    "p = 53\n",
    "for o in -3:3\n",
    "    i = β^p + o\n",
    "    println(\"β^p + $o = $i exactly represented in Float64? \", i == Float64(i))\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that $2^{53}+2$ is exactly represented, because that is equal to $(2^{52}+1) \\times 2$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 2: Funny functions\n",
    "\n",
    "### part (a)\n",
    "\n",
    "Consider the following naive function to compute the $L_4$ norm $(|x|^4 + |y|^4))^{1/4}$ of $(x,y)$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "L4 (generic function with 1 method)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L4(x,y) = (abs(x)^4 + abs(y)^4)^(1/4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We should have `L4(x,0)` give $|x|$, but for very small or very large `x` we get floating-point **underflow** or **overflow**, respectively.  In the default double precision (`Float64`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L4(1e-100, 0)  # (1e-100)⁴ underflows to 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Inf"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L4(1e+100, 0)  # (1e+100)⁴ overflows to Inf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To eliminate this problem, we can simply compute $s = \\max\\{|x|,|y|\\}$ and then pull out this scale factor, since in exact arithmetic $L_4(x,y) = s L_4(x/s,y/s)$ for any $s > 0$.  In this way, we avoid underflow/overflow in the leading-order term.  (If $|y|\\ll |x|$ and $|y/x|^4$ underflows to zero, we don't care, because $1 \\oplus |y/x|^4$ will round to `1.0` long before that point.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "L4good (generic function with 1 method)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function L4good(x,y)\n",
    "    ax, ay = abs(x), abs(y)\n",
    "    s = max(ax,ay)\n",
    "    if s == 0\n",
    "        return float(s) # don't divide by zero if x==y==0\n",
    "    else\n",
    "        return s * ((ax/s)^4 + (ay/s)^4)^(1/4)\n",
    "    end\n",
    "end\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e-100"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L4good(1e-100, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0e100"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L4good(1e+100, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L4good(0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compute the maximum relative error (compared to `BigFloat`) for million random numbers with random magnitudes from $10^{-308}$ to $10^{+308}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum relative err = 1.336014039101445e-15 = 6.016872328659019 ulps.\n"
     ]
    }
   ],
   "source": [
    "maxerr = 0.0\n",
    "for i = 1:10^6\n",
    "    x = (rand() - 0.5) * 10.0^rand(-308:308)\n",
    "    y = (rand() - 0.5) * 10.0^rand(-308:308)\n",
    "    result = L4good(x,y)\n",
    "    exact = L4good(big(x), big(y)) # in 256-bit precision by default\n",
    "    maxerr = max(maxerr, Float64(abs(result - exact) / abs(exact)))\n",
    "end\n",
    "println(\"maximum relative err = \", maxerr, \" = \", maxerr/eps(Float64), \" ulps.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accurate to within 6 ulps, not too bad considering all the arithmetic required to take to the 4th power and then to the 1/4th power!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### part (b)\n",
    "\n",
    "Now we are calculating:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cotdiff (generic function with 1 method)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cotdiff(x,y) = cot(x) - cot(x+y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The problem with this naive implementation is that for $|y|\\ll|x|$ we are subtracting two *nearly equal* quantities, and so we lose all of our significant digits:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cotdiff(1.0, 1e-20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The correct answer here is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.412282927437391837141168489135572923149464055882223010816205368999992462784898e-20"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cotdiff(big(1.0), big(1e-20))ε"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can we calculate this acccurately without resorting to extra precision?\n",
    "\n",
    "One option would be to Taylor-expand around $y=0$ and analytically cancel the leading-order $\\cot(x)$ term::\n",
    "$$\n",
    "\\cot(x) - \\cot(x+y) = y \\csc^2(x) - y^2 \\cot(x)\\csc^2(x) + \\frac{y^3}{3} \\left[(\\cos(2x)+2)\\csc^4(x)\\right] - O(y^4)\n",
    "$$\n",
    "We could then use something like:\n",
    "```jl\n",
    "function cotdiff_taylor(x,y)\n",
    "    ε = ... some threshold ...\n",
    "    if abs(y) < abs(x) * ε\n",
    "         return y*csc(x)^2 + ... taylor series to some order ....\n",
    "    else\n",
    "        return cot(x) - cot(x+y)\n",
    "    end\n",
    "end\n",
    "```\n",
    "In some problems, you have no choice to do something like this, but it is a bit painful to decide on the threshold `ε` and the correct number of terms in the Taylor series in order to ensure close to machine precision everywhere.\n",
    "\n",
    "Instead, since these are trigonometric functions, we can try to exploit angle-addition identities to re-arrange the formula so as to perform the cancellation *exactly*.  In particular, you can easily show that:\n",
    "$$\n",
    "\\cot(x) - \\cot(x+y) = \\left[\\cot(x+y) \\cot(x) + 1\\right] \\tan(y)\n",
    "$$\n",
    "in which there is no delicate cancellation for $y \\to 0$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "cotdiff_better (generic function with 1 method)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cotdiff_better(x,y) = (cot(x+y)*cot(x) + 1) * tan(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4122829274373917e-20"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cotdiff_better(1.0, 1e-20)  # now this is accurate!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.738018671929406e-17"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "relerr(approx,exact) = Float64(abs(approx-exact) / abs(exact))\n",
    "\n",
    "relerr(cotdiff_better(1.0, 1e-20), cotdiff(big(1.0), big(1e-20)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it is accurate to machine precision for this example!  \n",
    "\n",
    "We can see that relative error (in ulps) is around 1ulp or better for more magnitudes, but for very small $|y|$ we need to increase our `BigFloat` precision:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum relative error is 2.2789719735542174e-16 = 1.0263577330886577 ulps\n"
     ]
    }
   ],
   "source": [
    "maxerr = 0.0\n",
    "setprecision(BigFloat, 2000) do\n",
    "    for y in 10.0 .^ (-100:1)\n",
    "       global maxerr = max(maxerr, relerr(cotdiff_better(1.0, y), cotdiff(big(1.0), big(y))))\n",
    "    end\n",
    "end\n",
    "println(\"maximum relative error is $maxerr = \", maxerr/eps(Float64), \" ulps\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 3: Newtonish methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we are trying to find a root $f(x)=0$ and we are given ways to compute $f$, $f'$, and $f''$.   We will design an algorithm to take advantage of this, and apply it to $f(x)=x^3-1$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### part (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We approximate $f(x)$ by the first two terms in the Taylor series (assuming $f$ is analytic):\n",
    "$$\n",
    "f(x - \\delta) \\approx f(x) - \\delta f'(x) + \\frac{\\delta^2}{2} f''(x) = 0\n",
    "$$\n",
    "and set the right-hand side to zero to find an approximate root.  Solving the quadratic equation and eliding the $(x)$ arguments, we obtain an approximate step to the root:\n",
    "$$\n",
    "\\delta = \\frac{f' \\pm \\sqrt{f'^2 - 2ff''}}{f''}\n",
    "$$\n",
    "Close to the root, $f$ is small and therefore the discriminant will be positive and we will get real roots.   Say $f' > 0$.  Then we want the minus root of this quadratic, because we want the *nearest* root (the smallest $\\delta$): that is where the quadratic approximation is most accurate.  But this will run into cancellation errors for subtracting two nearly equal quantities, so we rewrite the desired solution as:\n",
    "$$\n",
    "\\delta = \\frac{2f}{f' + \\sqrt{f'^2 - 2ff''}}\n",
    "$$\n",
    "Conversely, if $f' < 0$, then we need the other root $2f / (f' - \\sqrt{f'^2 - 2ff''})$.  That is, we want to copy the sign of $f'$ to the square root, which is easily done with the Julia `copysign` function.\n",
    "\n",
    "If we are not close to the root, so that the discriminant is negative, we will just take an ordinary Newton step $\\delta = f/f'$.  Notice that this is also approximately the step we take when $f$ is very small.  \n",
    "\n",
    "Here is code that implements this idea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "newtonish (generic function with 1 method)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# take n Newtonish steps starting at x, given functions f(x),f′(x),f″(x) \n",
    "function newtonish(f,f′,f″, x, n)\n",
    "    for i = 1:n\n",
    "        fx = f(x)\n",
    "        f′x = f′(x)\n",
    "        f″x = f″(x)\n",
    "        discrim = f′x^2 - 2*fx*f″x\n",
    "        δ = discrim < 0 ? fx/f′x : 2fx / (f′x + copysign(sqrt(discrim), f′x))\n",
    "        x = x - δ\n",
    "    end\n",
    "    return x\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### part (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let $x$ be the exact root, and $x_n = x(1 + \\delta_n)$ be the Newton-ish iterate.   As in class, we wish to analyze $\\delta_{n+1}$ in terms of $\\delta_n$, in the asymptotic regime where we are close to convergence ($|\\delta_n| \\ll 1$).  Taylor expanding $f$ around $x$, we obtain:\n",
    "$$\n",
    "f_n = f(x_n) = f'(x) x \\delta_n + O(\\delta_n^2) = x f'(x) \\left[1  + O(\\delta_n) \\right] \\delta_n\n",
    "$$\n",
    "or\n",
    "$$\\delta_n = \\frac{f_n}{x f'(x)} \\left[1 - O(\\delta_n)\\right].$$\n",
    "This is useful because it relates the error in $x_n$ to the error in $f_n$.  Furthermore, the iterate $x_{n+1}$ is defined, above, to set the first two terms in the Taylor series for $f(x)$ to zero, which means that $f_{n+1} = O(\\delta_n^3)$: the error in $f_{n+1}$ is dominated by the *cubic* term in the Taylor series.  Hence:\n",
    "$$\\delta_{n+1} = \\frac{O(\\delta_n^3)}{x f'(x)} \\left[1 - O(\\delta_n)\\right] = O(\\delta_n^3)$$\n",
    "and we have **cubic convergence**.  The number of digits should roughly triple on each step.\n",
    "\n",
    "Alternatively, we could explicitly plug the Taylor expansion of $f$ into our iteration formula from part (a), and then solve everything to lowest-order in $\\delta_n$.   (Be careful: the iteration formula is in terms of $f$, $f'$, and $f''$ at $x_n$, *not* at the root $x$.)   But this is a lot of messy algebra just to get the constant coefficient in the $O(\\delta_n^3)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### part (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's try it out on the cube root function, i.e. to find the root $1$ of $f(x) = x^3 - 1$.   We just pass the derivatives functions manually, though in a more practical setting we might compute them [via automatic differentiation](https://github.com/JuliaDiff/ForwardDiff.jl)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 steps: 0.38021124171160603 digits\n",
      "2 steps: 1.5113771152875048 digits\n",
      "3 steps: 5.010844388088456 digits\n",
      "4 steps: 15.509654418943718 digits\n",
      "5 steps: 47.00608451155082 digits\n",
      "6 steps: 141.4953747893721 digits\n",
      "7 steps: 424.963245622836 digits\n",
      "8 steps: 1275.3668581232278 digits\n",
      "9 steps: 3826.5776956244026 digits\n"
     ]
    }
   ],
   "source": [
    "setprecision(BigFloat, 20000) do # 20000 bits of accuracy, about 5000 decimal digits\n",
    "    for n = 1:9\n",
    "        # output the number of accurate decimal digits, via log10 of the error:\n",
    "        println(\"$n steps: \", -Float64(log10(abs(newtonish(x->x^3-1, x->3x^2, x->6x, big(2), n) - 1))), \" digits\")\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is easy to see that the number of digits is roughly tripling on each iteration: **cubic convergence** as expected from part (b).\n",
    "\n",
    "In practice, the quadratic convergence of the ordinary Newton's method is so fast that you hardly ever resort to higher-order methods.  The hard part is finding a starting point sufficiently close to the root that you want, not converging fast once you get there.  Also, in high-dimensional root-finding problems, $f'$ is replaced by the Jacobian matrix, while $f''$ is a rank-3 tensor (\"3d matrix\") that would be expensive to compute and work with.  So, this sort of high-order Newton algorithm is rarely used in practice."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Problem 4: Addition, another way"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we modified the code to a faster version, `div2sum_faster`, that simply enlarges the base case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sum x[first:last].  This function works, but is a little slower than we would like.\n",
    "function div2sum(x, first=firstindex(x), last=lastindex(x))\n",
    "    n = last - first + 1;\n",
    "    if n < 2\n",
    "        s = zero(eltype(x))\n",
    "        for i = first:last\n",
    "            s += x[i]\n",
    "        end\n",
    "        return s\n",
    "    else\n",
    "        mid = (first + last) ÷ 2 # find middle as (first+last)/2, rounding down\n",
    "        return div2sum(x, first, mid) + div2sum(x, mid+1, last)\n",
    "    end\n",
    "end\n",
    "\n",
    "# Make it faster by enlarging the base case:\n",
    "function div2sum_faster(x, first=firstindex(x), last=lastindex(x))\n",
    "    n = last - first + 1;\n",
    "    if n < 200\n",
    "        s = zero(eltype(x))\n",
    "        for i = first:last\n",
    "            s += x[i]\n",
    "        end\n",
    "        return s\n",
    "    else\n",
    "        mid = (first + last) ÷ 2 # find middle as (first+last)/2, rounding down\n",
    "        return div2sum_faster(x, first, mid) + div2sum_faster(x, mid+1, last)\n",
    "    end\n",
    "end\n",
    "\n",
    "# check its accuracy for a set logarithmically spaced n's.  Since div2sum is slow,\n",
    "# we won't go to very large n or use too many points\n",
    "N = round.(Int, 10 .^ range(1,7,length=50)) # 50 points from 10¹ to 10⁷\n",
    "err = Float64[]\n",
    "err_faster = Float64[]\n",
    "for n in N\n",
    "    x = rand(Float32, n)\n",
    "    xdouble = Float64.(x)\n",
    "    push!(err, abs(div2sum(x) - sum(xdouble)) / abs(sum(xdouble)))\n",
    "    push!(err_faster, abs(div2sum_faster(x) - sum(xdouble)) / abs(sum(xdouble)))\n",
    "end\n",
    "\n",
    "using PyPlot\n",
    "loglog(N, err, \"bo-\")\n",
    "loglog(N, err_faster, \"r.-\")\n",
    "title(\"simple div2sum vs. faster div2sum\")\n",
    "xlabel(\"number of summands\")\n",
    "ylabel(\"relative error\")\n",
    "legend([\"original div2sum\", \"faster div2sum\"])\n",
    "grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the modified version has about the same accuracy.  But is it really faster?\n",
    "\n",
    "Time it vs. the built-in `sum` (which is also written in Julia), and also write our own looping sum just so that we know exactly what it is doing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "┌ Info: Precompiling BenchmarkTools [6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf]\n",
      "└ @ Base loading.jl:1186\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  93.210 ms (0 allocations: 0 bytes)\n",
      "  10.087 ms (0 allocations: 0 bytes)\n",
      "  3.293 ms (0 allocations: 0 bytes)\n",
      "  9.353 ms (0 allocations: 0 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.0000995f6"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function loopsum(x)\n",
    "    s = zero(eltype(x))\n",
    "    for i in eachindex(x)\n",
    "        s += x[i]\n",
    "    end\n",
    "    return s\n",
    "end\n",
    "\n",
    "x = rand(Float32, 10^7)\n",
    "using BenchmarkTools # better benchmarking utilities\n",
    "@btime div2sum($x)\n",
    "@btime div2sum_faster($x)\n",
    "@btime sum($x)\n",
    "@btime loopsum($x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enlarging the base case made it about **ten times faster** and comparable in speed to `loopsum`, a naive loop.\n",
    "\n",
    "The built-in `sum` function is still about 2–3 times faster.   It is actually using a [pairwise algorithm too, written in Julia](https://github.com/JuliaLang/julia/blob/38b3c46b0423ab1862f6cee7895a44e3ec397502/base/reduce.jl#L104-L113), but it plays some tricks with the base case to get better CPU utilization.  In particular, it uses [SIMD instructions in either native Julia code](https://github.com/JuliaLang/julia/pull/6928) or via the BLAS `asum` function, depending on the array type.   **Getting the last factor of two in performance is often tricky (and sometimes extremely hard)** and involves extracting every ounce of efficiency from the CPU with low-level tricks.\n",
    "\n",
    "In this case, it turns out we can catch up with the built-in `sum` just by adding a couple of decorations that turn on [SIMD optimization](http://kristofferc.github.io/post/intrinsics/) (`@simd`) and turn off bounds checking (`@inbounds`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  3.893 ms (0 allocations: 0 bytes)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5.000501f6"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make it faster by enlarging the base case:\n",
    "function div2sum_evenfaster(x, first=firstindex(x), last=lastindex(x))\n",
    "    n = last - first + 1;\n",
    "    if n < 200\n",
    "        s = zero(eltype(x))\n",
    "        @simd for i = first:last\n",
    "            @inbounds s += x[i]\n",
    "        end\n",
    "        return s\n",
    "    else\n",
    "        mid = (first + last) ÷ 2 # find middle as (first+last)/2, rounding down\n",
    "        return div2sum_evenfaster(x, first, mid) + div2sum_evenfaster(x, mid+1, last)\n",
    "    end\n",
    "end\n",
    "\n",
    "@btime div2sum_evenfaster($x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now a lot closer to the 3.3ms of the built-in `sum` function.  (We can do a bit better by tuning the base-case size.)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.1.0",
   "language": "julia",
   "name": "julia-1.1"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.1.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}