NDA_Notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\newcommand{\\calf}{{\\cal F}}\n",
    "\\newcommand{\\dnu}{d \\nu}\n",
    "\\newcommand{\\dmu}{d \\mu}\n",
    "\\newcommand{\\dmup}{d \\mu'}\n",
    "\\newcommand{\\vf}{{\\bf f}}\n",
    "\\newcommand{\\vq}{{\\bf q}}\n",
    "\\newcommand{\\mg}{{\\bf G}}\n",
    "\\newcommand{\\mK}{{\\bf K}}\n",
    "$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "include(\"nda_note.jl\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using the notebook\n",
    "\n",
    "The first cell in this notebook is an invisible markdown cell with LaTeX commands. The second is a code cell that sets up the packages you'll need to load. It's best to do a __run all__ before experimenting with the solvers.\n",
    "\n",
    "## Contents\n",
    "\n",
    "[The equation and discretization](#The-Equation)\n",
    "\n",
    "[Solvers](#Solvers)\n",
    "\n",
    "- [Source Iteration and Krylov Methods](#Source-Iteration-and-Krylov-Methods)\n",
    "\n",
    "- [NDA Formulation](#NDA)\n",
    "\n",
    "[QMC](#QMC)\n",
    "\n",
    "  - [Validation and Calibration Study](#Validation-and-calibration-study)\n",
    "  \n",
    "  - [Timings](#Timings)\n",
    "  \n",
    "  - [QMC Questions](#QMC-questions)\n",
    "  \n",
    "  - [QMC and Krylov Linear Solvers](#QMC-and-Krylov-Linear-Solvers)\n",
    "\n",
    "  - [QMC and NDA](#QMC-and-NDA)\n",
    "  \n",
    "[Docstrings for the Solvers](#Docstrings-for-the-Solvers)\n",
    "\n",
    "  - [Docstrings for kl\\_gmres](#Docstrings-for-kl\\_gmres.jl)\n",
    "  \n",
    "  - [Docstrings for kl\\_bicgstab](#Docstrings-for-kl\\_bicgstab.jl)\n",
    "  \n",
    "  - [Docstrings for nsoli](#Docstrings-for-nsoli.jl)\n",
    "\n",
    "[References](ndaqmc.html)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The equation\n",
    "\n",
    "This note book compares various solvers for the problem in the Garcia/Siewert \n",
    "paper <cite data-cite=\"cesinh\"><a href=\"ndaqmc.html#cesinh\">(GS82)</cite>.  My formulation of the transport problem is taken from <cite data-cite=\"ctk:jeff1\"><a href=\"ndaqmc.html#ctk:jeff1\">(WKKP13b)</cite>. The equation for the angular flux $\\psi$ is \n",
    "\n",
    "$$\n",
    "\\mu \\frac{\\partial \\psi}{\\partial x} (x,\\mu) + \\Sigma_t(x) \\psi(x,\\mu) =\n",
    "\\frac{1}{2} \\left[ \\Sigma_s(x) \\int_{-1}^1 \\psi(x, \\mu') \\dmup + q(x) \\right]\n",
    " \\mbox{ for } 0 \\le x \\le \\tau\n",
    "$$\n",
    "\n",
    "The boundary conditions are\n",
    "\n",
    "$$\n",
    "\\psi(0, \\mu) = \\psi_l(\\mu), \\mu > 0; \\psi(\\tau, \\mu) = \\psi_r(\\mu),\n",
    "\\mu < 0.\n",
    "$$\n",
    "    \n",
    "The notation is\n",
    "    \n",
    "   - $\\psi$ is intensity of radiation or angular flux at point $x$ at angle $\\cos^{-1} (\\mu)$\n",
    "   - $\\phi = \\phi(x) = \\int_{-1}^{1}\\psi(x,\\mu) \\ d\\mu$ is the scalar flux, the $0^{th}$ angular moment of the angular flux.\n",
    "    - $\\tau < \\infty$, length of the spatial domain.\n",
    "    - $\\Sigma_s \\in C([0,\\tau])$ is the scattering cross section at $x$\n",
    "    - $\\Sigma_t \\in C([0,\\tau])$ is the total cross section at $x$\n",
    "    - $\\psi_l$ and $\\psi_r$ are incoming intensities at the bounds\n",
    "    - $q \\in C([0,\\tau])$ is the fixed source\n",
    "    \n",
    "## Discretization    \n",
    "\n",
    "The discretization is plain vanilla $S_N$ with diamond differencing. I'm storing fluxes (and later currents) at cell edges to make the boundary conditions for NDA a bit easier to deal with.\n",
    "\n",
    "I'm using double Gaussian quadratures for the angular mesh. \n",
    "This means that the angles are N-point Gaussian quadratures on (-1,0) and on (0,1) for a total of 2N angles. The function __sn_angles.jl__ in the /src directory sets up the angular mesh. It uses the package __FastGaussQuadrature.jl__. We will denote the weights and notes of the angluar mesh by $w_j$ and $\\mu_j$ for $j=1, ..., 2N$.\n",
    "\n",
    "I'm using a uniform spatial mesh $\\{ x_i \\}_{i=1}^{N_x}$ where\n",
    "$$\n",
    "x_i = (i -1) dx \\mbox{ and } dx = \\tau/(N_x - 1).\n",
    "$$\n",
    "The function __sn_init.jl__ in /src sets up all the mesh data and boundary conditions. It builds a Julia named tuple for me to pass around to the solvers.\n",
    "\n",
    "The disretization approximates the angular flux $\\psi_i^j \\approx \\psi(x_i, \\mu_j)$ and the scalar flux \n",
    "$$\n",
    "\\phi_i \\approx \\phi(x_i).\n",
    "$$\n",
    "The two approximations are related (in my cell-edge oriented code) by\n",
    "$$\n",
    "\\mbox{Flux Equation:        } \\phi_i =  \\sum_{j=1}^{2N} \\psi_i^j w_j \n",
    "$$\n",
    "\n",
    "The discrete equation is, with source $S_i = \\Sigma_s(x_i) f_i + q(s_i)$\n",
    "\n",
    "$$\n",
    "\\begin{array}{ll}\n",
    "\\mbox{Transport Sweep:}\n",
    "\\\\\n",
    "\\mu_j \\frac{\\psi_i^j - \\psi_{i-1}^j}{dx} + \\Sigma_t(x_i+dx/2) \\frac{\\psi_i^j + \\psi_{i-1}^j}{2}\n",
    "& = \\frac{S_i + S_{i-1}}{2}\n",
    "\\mbox{ for $\\mu_j > 0$ and $\\psi_1^j = \\psi(0,\\mu_j)$}\n",
    "\\\\\n",
    "\\mu_j \\frac{\\psi_i^j - \\psi_{i+1}^j}{dx} + \\frac{\\psi_i^j + \\psi_{i+1}^j}{2}\n",
    "& = \\frac{S_i + S_{i+1}}{2}\n",
    " \\mbox{ for $\\mu_j < 0$ and $\\psi_{N_x}^j = \\psi(\\tau,\\mu_j)$}\n",
    "\\end{array}\n",
    "$$\n",
    "\n",
    "So, source iteration begins with an initial iterate for the scalar flux $\\phi$, computes the discrete scalar flux with the equations __Transport_Sweep__, treating $\\vf$ as input data, and updates the scalar flux \n",
    "with the formula __Flux_Equation__. This can also be viewed as a linear equation for $\\phi$\n",
    "$$\n",
    "\\phi - \\mK  \\phi = f\n",
    "$$\n",
    "and solved with a Krylov method like GMRES. The right side of the integral equation depends on the source $q$ and the boundary data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The Garcia-Siewert Example\n",
    "\n",
    "In this example\n",
    "$$\n",
    "\\tau=5, \\Sigma_s(x) =\\omega_0 e^{-x/s},  \\Sigma_t(x) = 1, q(x) = 0, \\psi_l(\\mu) = 1, \\psi_r(\\mu) = 0.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solvers\n",
    "\n",
    "The linear and nonlinear solvers come from my Julia package \n",
    "[SIAMFANLEQ.jl](https://github.com/ctkelley/SIAMFANLEquations.jl)\n",
    "<cite data-cite=\"ctk:siamfanl\"><a href=\"ndaqmc.html#ctk:siamfanl\">(Kel20b)</cite>. \n",
    "The documentation for these codes is in the [Juila notebooks](https://github.com/ctkelley/NotebookSIAMFANL)\n",
    "that accompany the package <cite data-cite=\"ctk:notebooknl\"><a href=\"ndaqmc.html#ctk:notebooknl\">(Kel20a)</cite>.\n",
    "All of this is part of a book project\n",
    "<cite data-cite=\"ctk:fajulia\"><a href=\"ndaqmc.html#ctk:fajulia\">(Kel20c)</cite>. The citations for these things may change as the book gets closer to publication. Please ask me before citing this stuff.\n",
    "    \n",
    "The important solvers for this notebook are the GMRES linear solver __kl_gmres.jl__ and the Newton-Krylov nonlinear solver __nsoli.jl__. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Source Iteration and Krylov Methods\n",
    "\n",
    "We use two krylov methods <cite data-cite=\"ctk:roots\"><a href=\"ndaqmc.html#ctk:roots\">(Kel95)</cite>, \n",
    "GMRES <cite data-cite=\"gmres\"><a href=\"ndaqmc.html#gmres\">(SS86)</cite> and\n",
    "Bi-CGSTAB <cite data-cite=\"bicgstab\"><a href=\"ndaqmc.html#bicgstab\">(vdV92)</cite>.\n",
    "\n",
    "The function \n",
    "```compare.jl``` in the __src__ directory runs the source iteration, GMRES, and Bi-CGSTAB, plots the residual histories, and tabulates the exit disbributions for comparision with Tables 1 and 2 in the paper. As a sanity check I print the $L^\\infty$ norm of the differences in the results from the two solvers. \n",
    "\n",
    "Here is a run for the first columns in the tables. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " mu         I(0,-mu)        I(tau,mu) \n",
      " 0.05     5.89670e-01     6.07486e-06 \n",
      " 0.10     5.31120e-01     6.92514e-06 \n",
      " 0.20     4.43280e-01     9.64229e-06 \n",
      " 0.30     3.80307e-01     1.62338e-05 \n",
      " 0.40     3.32965e-01     4.38575e-05 \n",
      " 0.50     2.96091e-01     1.69371e-04 \n",
      " 0.60     2.66564e-01     5.73462e-04 \n",
      " 0.70     2.42390e-01     1.51281e-03 \n",
      " 0.80     2.22235e-01     3.24369e-03 \n",
      " 0.90     2.05175e-01     5.96035e-03 \n",
      " 1.00     1.90547e-01     9.77122e-03 \n",
      "Norm of result differences: GMRES = 9.32897e-09,    Bi-CGSTAB = 1.57024e-08\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "compare(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions all use precomputed data for the angles, spatial mesh, storage allocationf the angular flux, and various problem paramaters. The precomputed data lives in a named tuple ```sn_data``` which I create with ```ns_init.jl```. \n",
    "\n",
    "The iterations themselves use a transport sweep to do both source iteration and the liner residual computation for GMRES. In both cases a function ```flux_map!``` takes an input flux, does the transport sweep, and then takes the zeroth moment to return and output flux. The transport sweep is ```transport_sweep.jl``` it computes the angular flux from a given input flux and boundary conditions. \n",
    "\n",
    "Here is function for the source iteration solver. It's pretty simple if you believe ```flux_map.jl``` does what I say it does. I think the QMC version of ```flux_map.jl``` would fit in with this pretty easiliy. \n",
    "\n",
    "```\n",
    "\"\"\"\n",
    " source_iteration(sn_data,s,tol)\n",
    " Source iteration example script for transport equation.\n",
    "\n",
    " This is one of the test cases from\n",
    "\n",
    " Radiative transfer in finite inhomogeneous plane-parallel atmospheres\n",
    " by Garcia and Siewert\n",
    " JQSRT (27), 1982 pp 141-148.\n",
    "\n",
    "\"\"\"\n",
    "function source_iteration(sn_data,s,tol=1.e-8)\n",
    "    nx = 2001\n",
    "    #\n",
    "    # precomputed data\n",
    "    #\n",
    "    angles=sn_data.angles\n",
    "    weihts=sn_data.weights\n",
    "    itt = 0\n",
    "    delflux = 1\n",
    "    phi = zeros(nx)\n",
    "    flux = zeros(nx)\n",
    "    reshist = []\n",
    "    while itt < 200 && delflux > tol\n",
    "        flux = flux_map!(flux, sn_data)\n",
    "        delflux = norm(flux - phi, Inf)\n",
    "        itt = itt + 1\n",
    "        push!(reshist, delflux)\n",
    "        phi .= flux\n",
    "    end\n",
    "    #\n",
    "    # Tabulate the exit distributions to check results.\n",
    "    #\n",
    "    return ( flux = flux, history= reshist)\n",
    "end\n",
    "\n",
    "```\n",
    "\n",
    "Here are the results for the final column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " mu         I(0,-mu)        I(tau,mu) \n",
      " 0.05     8.97799e-01     1.02201e-01 \n",
      " 0.10     8.87836e-01     1.12164e-01 \n",
      " 0.20     8.69581e-01     1.30419e-01 \n",
      " 0.30     8.52299e-01     1.47701e-01 \n",
      " 0.40     8.35503e-01     1.64497e-01 \n",
      " 0.50     8.18996e-01     1.81004e-01 \n",
      " 0.60     8.02676e-01     1.97324e-01 \n",
      " 0.70     7.86493e-01     2.13507e-01 \n",
      " 0.80     7.70429e-01     2.29571e-01 \n",
      " 0.90     7.54496e-01     2.45504e-01 \n",
      " 1.00     7.38721e-01     2.61279e-01 \n",
      "Norm of result differences: GMRES = 3.97115e-07,    Bi-CGSTAB = 3.91114e-07\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "Figure(PyObject <Figure size 640x480 with 1 Axes>)"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "compare(Inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NDA\n",
    "\n",
    "\n",
    "NDA (nonlinear diffusion acceleration) turns the linear problem into a nonlinear one. One gets an equation for the (__low-order__) flux $f$ in terms of the moments of $\\psi$. It is easier for me to explain this for the continuous problem. Be warned that my __boundary conditions are not standard__.\n",
    "\n",
    "I'm taking this from \n",
    "<cite data-cite=\"ctk:jeff1\"><a href=\"ndaqmc.html#ctk:jeff1\">(WKKP13b)</cite>,\n",
    "<cite data-cite=\"knollnda\"><a href=\"ndaqmc.html#knollnda\">(KPS11)</cite>, and\n",
    "<cite data-cite=\"knoll08\"><a href=\"ndaqmc.html#knoll08\">(KPS08)</cite>.\n",
    "\n",
    "\n",
    "Given a flux $\\phi(x)$ we begin by solving a __high-order__ problem for an angular flux\n",
    "\n",
    "$$\n",
    "\\mu \\frac{\\partial \\psi^{HO}}{\\partial x} + \\Sigma_t\\psi^{HO}(x,\\mu)\n",
    "= \\frac{1}{2}\\left[\\Sigma_s \\phi^{LO}(x) + q(x)\\right],\n",
    "$$\n",
    "with the same boundary conditions we used in the original problem.\n",
    "\n",
    "The next step is to compute high-order fluxes\n",
    "$$\n",
    "f^{HO}(x)= \\int_{-1}^1 \\psi(x, \\mu') \\dmu'\n",
    "$$\n",
    "and currents\n",
    "$$\n",
    "J^{HO}(x)= \\int_{-1}^1 \\psi(x, \\mu') \\mu' \\dmu'.\n",
    "$$\n",
    "\n",
    "We use these to compute \n",
    "$$\n",
    "{\\hat D} = \\frac{ J^{HO} + \\frac{1}{3} \\frac{d \\phi^{HO}}{dx} } {\\phi^{HO}},\n",
    "$$\n",
    "If $\\phi$ is the solution to the __low-order__ problem, \n",
    "$$\n",
    "\\frac{d}{dx}\\left[ -\\frac{1}{3\\Sigma_t} \\frac{d\\phi}{dx} + \\hat{D} \\phi\\right] + (\\Sigma_t - \\Sigma_s)\\phi = q,\n",
    "$$\n",
    "then $\\phi$ is the scalar flux and we have solved the transport equation. The boundary conditions are tricky if we store fluxes and currents at cell centers. If we have cell edge fluxes, then boundary conditions\n",
    "$$\n",
    "\\phi(0) = \\phi^{HO}(0), \\phi(\\tau) = \\phi^{HO}(\\tau)\n",
    "$$\n",
    "work well.\n",
    "    \n",
    "The low-order prolbem is nonlinear because $\\phi^{HO}$, $J^{HO}$ and $\\hat D$ depend on $\\phi$. We can make this explicit (writing ${\\hat D}(\\phi)$ and that helps when it's time to write code. Write the nonlinear equation as $F(\\phi) = 0$ where\n",
    "$$\n",
    "F (\\phi) = \\frac{d}{dx}\\left[ -\\frac{1}{3\\Sigma_t} \\frac{d\\phi}{dx} + \\hat{D}(\\phi) \\phi\\right] + (\\Sigma_t - \\Sigma_s)\\phi - q.\n",
    "$$\n",
    "\n",
    "We can solve this equation efficiently with Newton-GMRES if we have a good preconditioner. We use fast solver for the high-order term in the low-order equation. The preconditioner in \n",
    "<cite data-cite=\"ctk:jeff1\"><a href=\"ndaqmc.html#ctk:jeff1\">(WKKP13b)</cite>,\n",
    "<cite data-cite=\"knollnda\"><a href=\"ndaqmc.html#knollnda\">(KPS11)</cite>, \n",
    "<cite data-cite=\"knoll08\"><a href=\"ndaqmc.html#knoll08\">(KPS08)</cite>, is a bit more complicated. \n",
    "\n",
    "We can also formulate the low-order problem as a fixed point problem by viewing the solution of the low-order problem $\\phi^{LO}$ as a transformation of $\\phi$. So given $\\phi^{LO}$ compute the high-order flux, current, and ${\\hat D} = {\\hat D}(\\phi^{LO})$. Then solve \n",
    "$$\n",
    "\\frac{d}{dx}\\left[ -\\frac{1}{3\\Sigma_t} \\frac{d\\phi}{dx} + \\hat{D}(\\phi^{LO}) \\phi\\right] + (\\Sigma_t - \\Sigma_s)\\phi = q,\n",
    "$$\n",
    "For $\\phi$. This is a __linear__ equation for $\\phi$ because $\\phi^{LO}$ is input. Express this as \n",
    "$$\n",
    "\\phi = G(\\phi^{LO})\n",
    "$$\n",
    "We have solved the problem if $\\phi=\\phi^{LO}$. So a Picare or fixed point iteration is\n",
    "$$\n",
    "\\phi_{n+1} = G(\\phi_n).\n",
    "$$\n",
    "\n",
    "One can also solve\n",
    "$$\n",
    "F(\\phi) = \\phi - G(\\phi)\n",
    "$$\n",
    "with a Newton-Krylov method. This is __not what we did__ in \n",
    "<cite data-cite=\"ctk:jeff1\"><a href=\"ndaqmc.html#ctk:jeff1\">(WKKP13b)</cite> because MC is not deterministic and we had to use a formula for the derivative of ${\\hat D}$ with respect to $\\phi$. Using that formula to differentiate $G$ would be a real pain. We can do this for QMC and use a finite-difference Jacobian-vector product. The advantage is that the conditioning of the linear system is better because we precondition when we solve low-order problem.\n",
    "    \n",
    "One subtle point for Newton is that we take one Picard iteration before starting Newton. The reason we do this is that the initial iterate $\\phi = 0$ is really bad and Newton, while converging, takes many iterations to fix that. A single Picard sorts that out. \n",
    "    \n",
    "The plots below compare the two approaches. The limited data in this note book indicate that a Krylov method is best for the $s=1$ case and NDA-Newton is best for $s = \\infty$. The iteration histories overlap at the start because the first step for both is that single Picard. Note that I'm not counting Newton iterations but transport sweeps.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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": [
    "# Run for s=1\n",
    "nda_compare(1.0);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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": [
    "# and for s=Inf\n",
    "nda_compare(Inf);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QMC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Validation and calibration study\n",
    "\n",
    "I'll compare the results from the SN computation to what I get from Sam's QMC code. My SN results are for a very fine spatial mesh and fine enough angular mesh. They are good to at least six figures and I will regard them as exact for this study.\n",
    "\n",
    "I will use the SN results for the table in the Garcia-Siewert paper and get results from QMC in the following way\n",
    "\n",
    "- For a give N and Nx I will get cell average fluxes from Sam's code.\n",
    "- I will use the same code to generate the tables that I used for the SN fluxes. That code is __src/sn_tabulate.jl__\n",
    "- I will take the two 11 x 2 arrays of results DataSN and DataQMC and compoute componentwise relative error with\n",
    "\n",
    "```\n",
    "Derr = (DataSN-DataQMC)./DataSN\n",
    "```\n",
    "- I report the value ```norm(Derr,Inf)``` to measure the difference. \n",
    "\n",
    "Here one example. I have put the results from SN in two data files and can get the data by\n",
    "```\n",
    "DataSN = readdata(s)\n",
    "```\n",
    "where ```s=1``` or ```s=Inf```. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11×4 Matrix{Float64}:\n",
       " 5.89664e-01  6.07488e-06  5.71197e-01  5.85487e-06\n",
       " 5.31120e-01  6.92516e-06  5.22137e-01  6.66741e-06\n",
       " 4.43280e-01  9.64232e-06  4.41567e-01  9.25261e-06\n",
       " 3.80306e-01  1.62339e-05  3.81029e-01  1.54416e-05\n",
       " 3.32964e-01  4.38580e-05  3.34673e-01  4.09691e-05\n",
       " 2.96090e-01  1.69372e-04  2.98224e-01  1.57373e-04\n",
       " 2.66563e-01  5.73465e-04  2.68871e-01  5.35989e-04\n",
       " 2.42390e-01  1.51282e-03  2.44749e-01  1.42448e-03\n",
       " 2.22235e-01  3.24369e-03  2.24583e-01  3.07431e-03\n",
       " 2.05174e-01  5.96036e-03  2.07478e-01  5.67991e-03\n",
       " 1.90546e-01  9.77123e-03  1.92789e-01  9.35351e-03"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=1.0; N=10^3; Nx=100;\n",
    "# Data from SN\n",
    "DataSN=readdata(s);\n",
    "# Results from QMC\n",
    "DataQMC=tab_test(N, Nx;s=1.0)\n",
    "# Results\n",
    "[DataSN DataQMC]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two columns on the left are the SN data and the ones on the right are the QMC results. It looks like there's about one figure accuracy. To find out we'll look at the component wise relative errors and take the max."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11×2 Matrix{Float64}:\n",
       "  3.13179e-02  3.62150e-02\n",
       "  1.69139e-02  3.72189e-02\n",
       "  3.86253e-03  4.04169e-02\n",
       " -1.90183e-03  4.88018e-02\n",
       " -5.13137e-03  6.58713e-02\n",
       " -7.20598e-03  7.08438e-02\n",
       " -8.65777e-03  6.53506e-02\n",
       " -9.73420e-03  5.83942e-02\n",
       " -1.05661e-02  5.22191e-02\n",
       " -1.12295e-02  4.70516e-02\n",
       " -1.17715e-02  4.27503e-02"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Derr = (DataSN-DataQMC)./DataSN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looks like one to two figures. Taking the max gives me"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.08438e-02"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm(Derr, Inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So a bit better than one figure is what it is. The final part of this study is to make tables of these errors for varying N and Nx. The tables make some sense, as I will explain after I show the results for ```s=1.0```. The code I use for this is the __qmc_vs_sn__ function in the file __src/validate.jl__. This thing takes a while to run and I'm not completely sure why. The next section on benchmarking explains my confusion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nx\\N :      1000         2000         4000         8000   \n",
      "  50 :  1.41162e-01  1.36428e-01  1.34747e-01  1.35736e-01  \n",
      " 100 :  7.08438e-02  6.60744e-02  6.52017e-02  6.51605e-02  \n",
      " 200 :  4.17171e-02  3.30480e-02  3.23088e-02  3.21432e-02  \n",
      " 400 :  4.55590e-02  1.73115e-02  1.63072e-02  1.61542e-02  \n",
      " 800 :  4.83754e-02  1.93087e-02  1.29178e-02  8.30117e-03  \n",
      "1600 :  5.07584e-02  2.03691e-02  1.44681e-02  4.52388e-03  \n"
     ]
    }
   ],
   "source": [
    "qmc_vs_sn();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand the table we should first think of the idealized situation where the cell averages are from the __exact__ scalar flux. In that case all the collumns would be the same because $N = \\infty$ in that case. The row error would decay by a factor of __four__ as Nx doubles because the fixed source problem I solve to make the tables is essentially a second order integration rule. But when you look at the __last__ column, you see only first order convergence. __Why is that?__ I may have a bug in my code, but the same table made for SN looks exactly like second order convergence.\n",
    "\n",
    "For the earlier columns, there are not enough samples to fully populate the cells for the larger values of Nx, so the error stagnates. You see this on row three of the first column, for example. \n",
    "\n",
    "If you look at the rows, you'll see the O(1/N) error reduction from QMC. The last row (Nx=1600) does this well. The row just above (Nx = 800) shows that there is no benefit in increasing N once the fixed Nx has done the integration as well as it can. The Nx = 800 row shows reductios by roughly a factor as N --> 2N until N = 4000, then it stops because you've extracted all Nx=800 is able to give.\n",
    "\n",
    "So the tables make some sense, but there are still things I do not understand.\n",
    "\n",
    "The case $s = \\infty$ is the same. Here's the table."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nx\\N :      1000         2000         4000         8000   \n",
      "  50 :  5.95648e-02  2.42755e-02  1.36521e-02  1.29509e-02  \n",
      " 100 :  5.60749e-02  2.31030e-02  1.31680e-02  6.45949e-03  \n",
      " 200 :  5.62864e-02  2.32524e-02  1.42149e-02  4.77319e-03  \n",
      " 400 :  5.30954e-02  2.17854e-02  1.48225e-02  4.73260e-03  \n",
      " 800 :  7.66264e-02  1.88155e-02  1.60082e-02  4.34610e-03  \n",
      "1600 :  5.99376e-02  2.15675e-02  1.56784e-02  4.21636e-03  \n"
     ]
    }
   ],
   "source": [
    "qmc_vs_sn(;s=Inf);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $s = \\infty$ case is a harder problem and we need larger values of $N$ to make progress. That last entry in column 1 tells me that I can't make sense of the results for the low value of $N$. The bottom line on this section is that things look reasonable, but ...\n",
    "\n",
    "__Why does the error look first order in 1/Nx?__ This is what would happen if I left something out of a sum or missed and index in loop. But when I use the cell average fluxes from SN, I get second order and when I use the QMC cell averages fluxes (and change nothing else!) I get first order. Have I missed something?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Timings\n",
    "\n",
    "I use benchmark tools to see how the cost of QMC varies with N and Nx. The timings seem to tell me that the compute time is $O(N \\times Nx)$. I do not understand why it's the product and not the sum? __Can someone explain this to me?__ In the experiment I increase N by a factor of two and the time goes up by that factor. Same results with Nx, so it looks like the time is proportional to the product."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Base Case\n",
      "  18.094 ms (80367 allocations: 13.93 MiB)\n",
      "Double N\n",
      "  36.309 ms (160367 allocations: 27.72 MiB)\n",
      "Double Nx\n",
      "  36.462 ms (80369 allocations: 20.33 MiB)\n"
     ]
    }
   ],
   "source": [
    "N=1000; Nx=50;\n",
    "println(\"Base Case\")\n",
    "@btime tab_test($N,$Nx);\n",
    "N=2000; Nx=50;\n",
    "println(\"Double N\")\n",
    "@btime tab_test($N,$Nx);\n",
    "N=1000; Nx=100;\n",
    "println(\"Double Nx\")\n",
    "@btime tab_test($N,$Nx);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QMC questions\n",
    "\n",
    "So I've got a few questions about these results. Most of this is coming from my ignorance of the details of QMC.\n",
    "\n",
    "- I expected the errors to be $O(1/N) + O((1/Nx)^2)$, with very different prefactors in the $O$-terms, of course. Instead I see $O(1/N) + O(1/Nx)$. Is there theory for this?\n",
    "\n",
    "- The timings tell me that the cost of the computation is $O(N \\times Nx)$. I expected $O(N)$ with $Nx$ haveing very little effect. Why is this? \n",
    "    - __Ryan answers:__ _Each sample crosses the entire mesh in the direction it is moving.  So on average a particle will cross Nx/2 zones, tallying into the scattering source in each._\n",
    "\n",
    "- Sam, the benchmark runs tell me QMC is allocating a lot. Can you fix this by, for example, preallocating some storage in the initialization. You might also look at the performance part of the Julia documentation to see if things like ```@inbounds``` and ```@simd``` might help the code run faster. The relevant part of the Julia manual is at https://docs.julialang.org/en/v1/manual/performance-tips/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QMC and Krylov Linear Solvers\n",
    "\n",
    "I've reorganized what Sam gave me to make his __qmc_sweep__ function easy for me to call. I now have a file __src/Tim_QMC/krylov_iteration.jl__ that has most of the stuff I will need. The directory is not fully ready for prime time, but does do some useful work. \n",
    "\n",
    "I can solve the QMC linear problem with both Krylov methods now and, just like the classical case, I'm seeing fewer than half of the number of transport sweeps. Herewith the results for N=1000 and Nx= 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "BoundsError: attempt to access 0-element Vector{Any} at index [1]",
     "output_type": "error",
     "traceback": [
      "BoundsError: attempt to access 0-element Vector{Any} at index [1]",
      "",
      "Stacktrace:",
      " [1] getindex",
      "   @ ./array.jl:924 [inlined]",
      " [2] compare(s::Float64; qmc::Bool)",
      "   @ NDA_QMC ~/Dropbox/Julia/dev/NDA_QMC/ctk_nda_src/compare.jl:46",
      " [3] top-level scope",
      "   @ In[33]:1"
     ]
    }
   ],
   "source": [
    "compare(1.0; qmc=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "BoundsError: attempt to access 0-element Vector{Any} at index [1]",
     "output_type": "error",
     "traceback": [
      "BoundsError: attempt to access 0-element Vector{Any} at index [1]",
      "",
      "Stacktrace:",
      " [1] getindex",
      "   @ ./array.jl:924 [inlined]",
      " [2] compare(s::Float64; qmc::Bool)",
      "   @ NDA_QMC ~/Dropbox/Julia/dev/NDA_QMC/ctk_nda_src/compare.jl:46",
      " [3] top-level scope",
      "   @ In[34]:1"
     ]
    }
   ],
   "source": [
    "compare(Inf; qmc=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## QMC and NDA\n",
    "\n",
    "What we need from QMC are\n",
    "\n",
    "- cell average fluxes and currents, which I think we have and \n",
    "- cell average spatial derivatives for the high-order flux. \n",
    "\n",
    "As you can see from \n",
    "<cite data-cite=\"ctk:jeff1\"><a href=\"ndaqmc.html#ctk:jeff1\">(WKKP13b)</cite>,\n",
    "it was not entirely trivial to get the spatial derivatives. \n",
    "    \n",
    "I think Sam has given me what I need for this and I should get something done pretty soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Docstrings for the Solvers\n",
    "\n",
    "Nothing exciting here. I'll just fire up the help screens."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstrings for kl\\_gmres.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mk\u001b[22m\u001b[0m\u001b[1ml\u001b[22m\u001b[0m\u001b[1m_\u001b[22m\u001b[0m\u001b[1mg\u001b[22m\u001b[0m\u001b[1mm\u001b[22m\u001b[0m\u001b[1mr\u001b[22m\u001b[0m\u001b[1me\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "kl\\_gmres(x0, b, atv, V, eta, ptv=nothing; kl\\_store=nothing;               orth = \"cgs2\", side=\"right\", lmaxit=-1, pdata=nothing)\n",
       "\n",
       "C. T. Kelley, 2022\n",
       "\n",
       "Gmres linear solver. Handles preconditioning and restarts.  Uses gmres\\_base which is completely oblivious to these things.\n",
       "\n",
       "The deal is\n",
       "\n",
       "Input:\n",
       "\n",
       "x0:  initial iterate, this is usually zero for nonlinear solvers\n",
       "\n",
       "b: right hand side (duh!)\n",
       "\n",
       "atv:  matrix-vector product which depends on precomputed data pdta       I expect you to use pdata most or all of the time, so it is not       an optional argument, even if it's nothing (at least for now).        If your mat-vec is just A*v, you have to write a function where        A is the precomputed data.       API for atv is \\texttt{av=atv(v,pdata)}\n",
       "\n",
       "V:  Preallocated n x K array for the Krylov vectors. I store the initial     normalized residual in column 1, so  you have at most K-1 iterations     before gmres\\_base returns a failure. kl\\_gmres will handle the      restarts and, if lmaxit > 0, keep going until you hit lmaxit GMRES     iterations. You may allocate V in Float32 and save on storage. The     benefit from doing this is not dramatic in terms of CPU time.\n",
       "\n",
       "eta: Termination happens when ||b - Ax|| <= eta || b ||\n",
       "\n",
       "ptv:  preconditioner-vector product, which will also use pdata. The       default is nothing, which is no preconditioning at all.       API for ptv is px=ptv(x,pdata)\n",
       "\n",
       "Keyword arguments\n",
       "\n",
       "kl\\_store: You have the option (don't do it!) of giving me some room          for the vectors gmres needs. These include copies of x0 and b,          which I will not overwrite and a couple of vectors I use          in the iteration. If you're only doing a linear solve, PLEASE          let me allocate those vectores in kl\\_gmres. For computing a          Newton step or for repeated solves,          the way to do this is \\texttt{kl\\_store=kstore(n,\"gmres\")} where n          is the number of unknows. I call this myself in the initialization          phase if you don't do it ahead of me.\n",
       "\n",
       "\\begin{verbatim}\n",
       "     Be very careful with this. kl_store is use to store the solution\n",
       "     to avoid overwriting the initial iterate. This means that\n",
       "     two calls to kl_gmres with the same kl_store will step on the\n",
       "     solution coming from the first call. If you let me allocate it\n",
       "     then it happens in local scope and will do no harm.\n",
       "\\end{verbatim}\n",
       "pdata: precomputed data. The default is nothing, but that ain't gonna         work well for nonlinear equations.\n",
       "\n",
       "orth: your choice of the wise default, classical Gram-Schmidt twice,        or something slower and less stable. Those are classical once (really        bad) or a couple variants of modified Gram-Schmidt. mgs2 is what I        used in my old matlab codes. Not terrible, but far from great.\n",
       "\n",
       "side: left or right preconditioning. The default is \"right\".\n",
       "\n",
       "lmaxit: maximum number of linear iterations. The default is -1, which         means that the maximum number of linear iterations is K-1, which         is all V will allow without restarts. If lmaxit > K-1, then the         iteration will restart until you consume lmaxit iterations or         terminate successfully.\n",
       "\n",
       "Other parameters on the way.\n",
       "\n",
       "Output:\n",
       "\n",
       "A named tuple (sol, reshist, lits, idid)\n",
       "\n",
       "where\n",
       "\n",
       "sol= final result reshist = residual norm history lits = number of iterations idid = status of the iteration        true -> converged         false -> failed to converge\n",
       "\n",
       "\\subsubsection{Examples from the docstrings for kl\\_gmres}\n",
       "In these examples you have the matrix and use \n",
       "\n",
       "\\begin{verbatim}\n",
       "function atv(x, A)\n",
       "    return A * x\n",
       "end\n",
       "\\end{verbatim}\n",
       "to compute the matvec.\n",
       "\n",
       "\\paragraph{Three dimensional problem.}\n",
       "Will converge in the correct three iterations only if you orthogonalize with CGS twice. \n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> function atv(x, A)\n",
       "           return A * x\n",
       "       end\n",
       "atv (generic function with 1 method)\n",
       "\n",
       "julia> A = [0.001 0 0; 0 0.0011 0; 0 0 1.e4];\n",
       "\n",
       "julia> V = zeros(3, 10); b = [1.0; 1.0; 1.0]; x0 = zeros(3);\n",
       "\n",
       "julia> gout = kl_gmres(x0, b, atv, V, 1.e-10; pdata = A);\n",
       "\n",
       "julia> gout.reshist\n",
       "4-element Array{Float64,1}:\n",
       " 1.73205e+00\n",
       " 1.41421e+00\n",
       " 6.72673e-02\n",
       " 1.97712e-34\n",
       "\n",
       "julia> norm(b - A*gout.sol,Inf)\n",
       "1.28536e-10\n",
       "\\end{verbatim}\n",
       "\\paragraph{Integral equation. Notice that pdata has the kernel of the}\n",
       "operator and we do the matvec directly. Just like the previous example. We put the grid information and, for this artifical example, the solution in the precomputed data.\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> function integop(u, pdata)\n",
       "           K = pdata.K\n",
       "           return u - K * u\n",
       "       end\n",
       "integop (generic function with 1 method)\n",
       "\n",
       "julia> function integopinit(n)\n",
       "           h = 1 / n\n",
       "           X = collect(0.5*h:h:1.0-0.5*h)\n",
       "           K = [ker(x, y) for x in X, y in X]\n",
       "           K .*= h\n",
       "           sol = [usol(x) for x in X]\n",
       "           f = sol - K * sol\n",
       "           pdata = (K = K, xe = sol, f = f)\n",
       "           return pdata\n",
       "       end\n",
       "integopinit (generic function with 1 method)\n",
       "\n",
       "julia> function usol(x)\n",
       "           return exp.(x) .* log.(2.0 * x .+ 1.0)\n",
       "       end\n",
       "usol (generic function with 1 method)\n",
       "\n",
       "julia> function ker(x, y)\n",
       "           ker = 0.1 * sin(x + exp(y))\n",
       "       end\n",
       "ker (generic function with 1 method)\n",
       "\n",
       "julia> n=100; pdata = integopinit(n); ue = pdata.xe; f=pdata.f;\n",
       "\n",
       "julia> u0 = zeros(size(f)); V = zeros(n, 20); V32=zeros(Float32,n,20);\n",
       "\n",
       "julia> gout = kl_gmres(u0, f, integop, V, 1.e-10; pdata = pdata);\n",
       "\n",
       "julia> gout32 = kl_gmres(u0, f, integop, V32, 1.e-10; pdata = pdata);\n",
       "\n",
       "julia> [norm(gout.sol-ue,Inf) norm(gout32.sol-ue,Inf)]\n",
       "1×2 Array{Float64,2}:\n",
       " 4.44089e-16  2.93700e-07\n",
       "\n",
       "julia> [gout.reshist gout32.reshist]\n",
       "4×2 Array{Float64,2}:\n",
       " 1.48252e+01  1.48252e+01\n",
       " 5.52337e-01  5.52337e-01\n",
       " 1.77741e-03  1.77742e-03\n",
       " 1.29876e-19  8.73568e-11\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "kl_gmres(x0, b, atv, V, eta, ptv=nothing; kl_store=nothing;               orth = \"cgs2\", side=\"right\", lmaxit=-1, pdata=nothing)\n",
       "\n",
       "C. T. Kelley, 2022\n",
       "\n",
       "Gmres linear solver. Handles preconditioning and restarts.  Uses gmres_base which is completely oblivious to these things.\n",
       "\n",
       "The deal is\n",
       "\n",
       "Input:\n",
       "\n",
       "x0:  initial iterate, this is usually zero for nonlinear solvers\n",
       "\n",
       "b: right hand side (duh!)\n",
       "\n",
       "atv:  matrix-vector product which depends on precomputed data pdta       I expect you to use pdata most or all of the time, so it is not       an optional argument, even if it's nothing (at least for now).        If your mat-vec is just A*v, you have to write a function where        A is the precomputed data.       API for atv is `av=atv(v,pdata)`\n",
       "\n",
       "V:  Preallocated n x K array for the Krylov vectors. I store the initial     normalized residual in column 1, so  you have at most K-1 iterations     before gmres_base returns a failure. kl_gmres will handle the      restarts and, if lmaxit > 0, keep going until you hit lmaxit GMRES     iterations. You may allocate V in Float32 and save on storage. The     benefit from doing this is not dramatic in terms of CPU time.\n",
       "\n",
       "eta: Termination happens when ||b - Ax|| <= eta || b ||\n",
       "\n",
       "ptv:  preconditioner-vector product, which will also use pdata. The       default is nothing, which is no preconditioning at all.       API for ptv is px=ptv(x,pdata)\n",
       "\n",
       "Keyword arguments\n",
       "\n",
       "kl_store: You have the option (don't do it!) of giving me some room          for the vectors gmres needs. These include copies of x0 and b,          which I will not overwrite and a couple of vectors I use          in the iteration. If you're only doing a linear solve, PLEASE          let me allocate those vectores in kl_gmres. For computing a          Newton step or for repeated solves,          the way to do this is `kl_store=kstore(n,\"gmres\")` where n          is the number of unknows. I call this myself in the initialization          phase if you don't do it ahead of me.\n",
       "\n",
       "```\n",
       "     Be very careful with this. kl_store is use to store the solution\n",
       "     to avoid overwriting the initial iterate. This means that\n",
       "     two calls to kl_gmres with the same kl_store will step on the\n",
       "     solution coming from the first call. If you let me allocate it\n",
       "     then it happens in local scope and will do no harm.\n",
       "```\n",
       "\n",
       "pdata: precomputed data. The default is nothing, but that ain't gonna         work well for nonlinear equations.\n",
       "\n",
       "orth: your choice of the wise default, classical Gram-Schmidt twice,        or something slower and less stable. Those are classical once (really        bad) or a couple variants of modified Gram-Schmidt. mgs2 is what I        used in my old matlab codes. Not terrible, but far from great.\n",
       "\n",
       "side: left or right preconditioning. The default is \"right\".\n",
       "\n",
       "lmaxit: maximum number of linear iterations. The default is -1, which         means that the maximum number of linear iterations is K-1, which         is all V will allow without restarts. If lmaxit > K-1, then the         iteration will restart until you consume lmaxit iterations or         terminate successfully.\n",
       "\n",
       "Other parameters on the way.\n",
       "\n",
       "Output:\n",
       "\n",
       "A named tuple (sol, reshist, lits, idid)\n",
       "\n",
       "where\n",
       "\n",
       "sol= final result reshist = residual norm history lits = number of iterations idid = status of the iteration        true -> converged         false -> failed to converge\n",
       "\n",
       "### Examples from the docstrings for kl_gmres\n",
       "\n",
       "In these examples you have the matrix and use \n",
       "\n",
       "```\n",
       "function atv(x, A)\n",
       "    return A * x\n",
       "end\n",
       "```\n",
       "\n",
       "to compute the matvec.\n",
       "\n",
       "#### Three dimensional problem.\n",
       "\n",
       "Will converge in the correct three iterations only if you orthogonalize with CGS twice. \n",
       "\n",
       "```jldoctest\n",
       "julia> function atv(x, A)\n",
       "           return A * x\n",
       "       end\n",
       "atv (generic function with 1 method)\n",
       "\n",
       "julia> A = [0.001 0 0; 0 0.0011 0; 0 0 1.e4];\n",
       "\n",
       "julia> V = zeros(3, 10); b = [1.0; 1.0; 1.0]; x0 = zeros(3);\n",
       "\n",
       "julia> gout = kl_gmres(x0, b, atv, V, 1.e-10; pdata = A);\n",
       "\n",
       "julia> gout.reshist\n",
       "4-element Array{Float64,1}:\n",
       " 1.73205e+00\n",
       " 1.41421e+00\n",
       " 6.72673e-02\n",
       " 1.97712e-34\n",
       "\n",
       "julia> norm(b - A*gout.sol,Inf)\n",
       "1.28536e-10\n",
       "```\n",
       "\n",
       "#### Integral equation. Notice that pdata has the kernel of the\n",
       "\n",
       "operator and we do the matvec directly. Just like the previous example. We put the grid information and, for this artifical example, the solution in the precomputed data.\n",
       "\n",
       "```jldoctest\n",
       "julia> function integop(u, pdata)\n",
       "           K = pdata.K\n",
       "           return u - K * u\n",
       "       end\n",
       "integop (generic function with 1 method)\n",
       "\n",
       "julia> function integopinit(n)\n",
       "           h = 1 / n\n",
       "           X = collect(0.5*h:h:1.0-0.5*h)\n",
       "           K = [ker(x, y) for x in X, y in X]\n",
       "           K .*= h\n",
       "           sol = [usol(x) for x in X]\n",
       "           f = sol - K * sol\n",
       "           pdata = (K = K, xe = sol, f = f)\n",
       "           return pdata\n",
       "       end\n",
       "integopinit (generic function with 1 method)\n",
       "\n",
       "julia> function usol(x)\n",
       "           return exp.(x) .* log.(2.0 * x .+ 1.0)\n",
       "       end\n",
       "usol (generic function with 1 method)\n",
       "\n",
       "julia> function ker(x, y)\n",
       "           ker = 0.1 * sin(x + exp(y))\n",
       "       end\n",
       "ker (generic function with 1 method)\n",
       "\n",
       "julia> n=100; pdata = integopinit(n); ue = pdata.xe; f=pdata.f;\n",
       "\n",
       "julia> u0 = zeros(size(f)); V = zeros(n, 20); V32=zeros(Float32,n,20);\n",
       "\n",
       "julia> gout = kl_gmres(u0, f, integop, V, 1.e-10; pdata = pdata);\n",
       "\n",
       "julia> gout32 = kl_gmres(u0, f, integop, V32, 1.e-10; pdata = pdata);\n",
       "\n",
       "julia> [norm(gout.sol-ue,Inf) norm(gout32.sol-ue,Inf)]\n",
       "1×2 Array{Float64,2}:\n",
       " 4.44089e-16  2.93700e-07\n",
       "\n",
       "julia> [gout.reshist gout32.reshist]\n",
       "4×2 Array{Float64,2}:\n",
       " 1.48252e+01  1.48252e+01\n",
       " 5.52337e-01  5.52337e-01\n",
       " 1.77741e-03  1.77742e-03\n",
       " 1.29876e-19  8.73568e-11\n",
       "```\n"
      ],
      "text/plain": [
       "  kl_gmres(x0, b, atv, V, eta, ptv=nothing; kl_store=nothing; orth = \"cgs2\",\n",
       "  side=\"right\", lmaxit=-1, pdata=nothing)\n",
       "\n",
       "  C. T. Kelley, 2022\n",
       "\n",
       "  Gmres linear solver. Handles preconditioning and restarts. Uses gmres_base\n",
       "  which is completely oblivious to these things.\n",
       "\n",
       "  The deal is\n",
       "\n",
       "  Input:\n",
       "\n",
       "  x0: initial iterate, this is usually zero for nonlinear solvers\n",
       "\n",
       "  b: right hand side (duh!)\n",
       "\n",
       "  atv: matrix-vector product which depends on precomputed data pdta I expect\n",
       "  you to use pdata most or all of the time, so it is not an optional argument,\n",
       "  even if it's nothing (at least for now). If your mat-vec is just A*v, you\n",
       "  have to write a function where A is the precomputed data. API for atv is\n",
       "  \u001b[36mav=atv(v,pdata)\u001b[39m\n",
       "\n",
       "  V: Preallocated n x K array for the Krylov vectors. I store the initial\n",
       "  normalized residual in column 1, so you have at most K-1 iterations before\n",
       "  gmres_base returns a failure. kl_gmres will handle the restarts and, if\n",
       "  lmaxit > 0, keep going until you hit lmaxit GMRES iterations. You may\n",
       "  allocate V in Float32 and save on storage. The benefit from doing this is\n",
       "  not dramatic in terms of CPU time.\n",
       "\n",
       "  eta: Termination happens when ||b - Ax|| <= eta || b ||\n",
       "\n",
       "  ptv: preconditioner-vector product, which will also use pdata. The default\n",
       "  is nothing, which is no preconditioning at all. API for ptv is\n",
       "  px=ptv(x,pdata)\n",
       "\n",
       "  Keyword arguments\n",
       "\n",
       "  kl_store: You have the option (don't do it!) of giving me some room for the\n",
       "  vectors gmres needs. These include copies of x0 and b, which I will not\n",
       "  overwrite and a couple of vectors I use in the iteration. If you're only\n",
       "  doing a linear solve, PLEASE let me allocate those vectores in kl_gmres. For\n",
       "  computing a Newton step or for repeated solves, the way to do this is\n",
       "  \u001b[36mkl_store=kstore(n,\"gmres\")\u001b[39m where n is the number of unknows. I call this\n",
       "  myself in the initialization phase if you don't do it ahead of me.\n",
       "\n",
       "\u001b[36m       Be very careful with this. kl_store is use to store the solution\u001b[39m\n",
       "\u001b[36m       to avoid overwriting the initial iterate. This means that\u001b[39m\n",
       "\u001b[36m       two calls to kl_gmres with the same kl_store will step on the\u001b[39m\n",
       "\u001b[36m       solution coming from the first call. If you let me allocate it\u001b[39m\n",
       "\u001b[36m       then it happens in local scope and will do no harm.\u001b[39m\n",
       "\n",
       "  pdata: precomputed data. The default is nothing, but that ain't gonna work\n",
       "  well for nonlinear equations.\n",
       "\n",
       "  orth: your choice of the wise default, classical Gram-Schmidt twice, or\n",
       "  something slower and less stable. Those are classical once (really bad) or a\n",
       "  couple variants of modified Gram-Schmidt. mgs2 is what I used in my old\n",
       "  matlab codes. Not terrible, but far from great.\n",
       "\n",
       "  side: left or right preconditioning. The default is \"right\".\n",
       "\n",
       "  lmaxit: maximum number of linear iterations. The default is -1, which means\n",
       "  that the maximum number of linear iterations is K-1, which is all V will\n",
       "  allow without restarts. If lmaxit > K-1, then the iteration will restart\n",
       "  until you consume lmaxit iterations or terminate successfully.\n",
       "\n",
       "  Other parameters on the way.\n",
       "\n",
       "  Output:\n",
       "\n",
       "  A named tuple (sol, reshist, lits, idid)\n",
       "\n",
       "  where\n",
       "\n",
       "  sol= final result reshist = residual norm history lits = number of\n",
       "  iterations idid = status of the iteration true -> converged false -> failed\n",
       "  to converge\n",
       "\n",
       "\u001b[1m  Examples from the docstrings for kl_gmres\u001b[22m\n",
       "\u001b[1m  –––––––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "  In these examples you have the matrix and use\n",
       "\n",
       "\u001b[36m  function atv(x, A)\u001b[39m\n",
       "\u001b[36m      return A * x\u001b[39m\n",
       "\u001b[36m  end\u001b[39m\n",
       "\n",
       "  to compute the matvec.\n",
       "\n",
       "\u001b[1m  Three dimensional problem.\u001b[22m\n",
       "\u001b[1m  ----------------------------\u001b[22m\n",
       "\n",
       "  Will converge in the correct three iterations only if you orthogonalize with\n",
       "  CGS twice.\n",
       "\n",
       "\u001b[36m  julia> function atv(x, A)\u001b[39m\n",
       "\u001b[36m             return A * x\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  atv (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> A = [0.001 0 0; 0 0.0011 0; 0 0 1.e4];\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> V = zeros(3, 10); b = [1.0; 1.0; 1.0]; x0 = zeros(3);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> gout = kl_gmres(x0, b, atv, V, 1.e-10; pdata = A);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> gout.reshist\u001b[39m\n",
       "\u001b[36m  4-element Array{Float64,1}:\u001b[39m\n",
       "\u001b[36m   1.73205e+00\u001b[39m\n",
       "\u001b[36m   1.41421e+00\u001b[39m\n",
       "\u001b[36m   6.72673e-02\u001b[39m\n",
       "\u001b[36m   1.97712e-34\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> norm(b - A*gout.sol,Inf)\u001b[39m\n",
       "\u001b[36m  1.28536e-10\u001b[39m\n",
       "\n",
       "\u001b[1m  Integral equation. Notice that pdata has the kernel of the\u001b[22m\n",
       "\u001b[1m  ------------------------------------------------------------\u001b[22m\n",
       "\n",
       "  operator and we do the matvec directly. Just like the previous example. We\n",
       "  put the grid information and, for this artifical example, the solution in\n",
       "  the precomputed data.\n",
       "\n",
       "\u001b[36m  julia> function integop(u, pdata)\u001b[39m\n",
       "\u001b[36m             K = pdata.K\u001b[39m\n",
       "\u001b[36m             return u - K * u\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  integop (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function integopinit(n)\u001b[39m\n",
       "\u001b[36m             h = 1 / n\u001b[39m\n",
       "\u001b[36m             X = collect(0.5*h:h:1.0-0.5*h)\u001b[39m\n",
       "\u001b[36m             K = [ker(x, y) for x in X, y in X]\u001b[39m\n",
       "\u001b[36m             K .*= h\u001b[39m\n",
       "\u001b[36m             sol = [usol(x) for x in X]\u001b[39m\n",
       "\u001b[36m             f = sol - K * sol\u001b[39m\n",
       "\u001b[36m             pdata = (K = K, xe = sol, f = f)\u001b[39m\n",
       "\u001b[36m             return pdata\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  integopinit (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function usol(x)\u001b[39m\n",
       "\u001b[36m             return exp.(x) .* log.(2.0 * x .+ 1.0)\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  usol (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function ker(x, y)\u001b[39m\n",
       "\u001b[36m             ker = 0.1 * sin(x + exp(y))\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  ker (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> n=100; pdata = integopinit(n); ue = pdata.xe; f=pdata.f;\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> u0 = zeros(size(f)); V = zeros(n, 20); V32=zeros(Float32,n,20);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> gout = kl_gmres(u0, f, integop, V, 1.e-10; pdata = pdata);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> gout32 = kl_gmres(u0, f, integop, V32, 1.e-10; pdata = pdata);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> [norm(gout.sol-ue,Inf) norm(gout32.sol-ue,Inf)]\u001b[39m\n",
       "\u001b[36m  1×2 Array{Float64,2}:\u001b[39m\n",
       "\u001b[36m   4.44089e-16  2.93700e-07\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> [gout.reshist gout32.reshist]\u001b[39m\n",
       "\u001b[36m  4×2 Array{Float64,2}:\u001b[39m\n",
       "\u001b[36m   1.48252e+01  1.48252e+01\u001b[39m\n",
       "\u001b[36m   5.52337e-01  5.52337e-01\u001b[39m\n",
       "\u001b[36m   1.77741e-03  1.77742e-03\u001b[39m\n",
       "\u001b[36m   1.29876e-19  8.73568e-11\u001b[39m"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?kl_gmres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstrings for kl_bicgstab.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mk\u001b[22m\u001b[0m\u001b[1ml\u001b[22m\u001b[0m\u001b[1m_\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\u001b[0m\u001b[1mi\u001b[22m\u001b[0m\u001b[1mc\u001b[22m\u001b[0m\u001b[1mg\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mt\u001b[22m\u001b[0m\u001b[1ma\u001b[22m\u001b[0m\u001b[1mb\u001b[22m\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "kl\\_bicgstab( x0, b, atv, V, eta, ptv = nothing;       kl\\_store=nothing, side = \"right\", lmaxit = 10, pdata = nothing) \n",
       "\n",
       "C. T. Kelley, 2022\n",
       "\n",
       "BiCGSTAB linear solver. Deals with preconditioning.  Uses bicgstab\\_base with is oblivious to that.\n",
       "\n",
       "The code works and does what it needs to do, but ...\n",
       "\n",
       "The user interface is unstable and, even worse, the nonlinear solvers are not hooked up yet.\n",
       "\n",
       "The way this works it \n",
       "\n",
       "Input:\n",
       "\n",
       "x0:  initial iterate, this is usually zero for nonlinear solvers\n",
       "\n",
       "b: right hand side (duh!)\n",
       "\n",
       "atv:  matrix-vector product which depends on precomputed data pdta       I expect you to use pdata most or all of the time, so it is not       an optional argument, even if it's nothing (at least for now).       If your mat-vec is just A*v, you have to write a function where       A is the precomputed data.       API for atv is av=atv(v,pdata)\n",
       "\n",
       "V: a vector for me to store a Jacobian-vector product. It goes where     FPS would go in gmres. You are best served if V is Float64.\n",
       "\n",
       "eta: Termination happens when ||b - Ax|| <= eta || b ||\n",
       "\n",
       "ptv:  preconditioner-vector product, which will also use pdata. The       default is nothing, which is no preconditioning at all.       API for ptv is px=ptv(x,pdat) just like kl\\_gmres\n",
       "\n",
       "Keyword arguments\n",
       "\n",
       "kl\\_store: You have the option of giving me some room          for the vectors bicgstab needs to do its work. These in          which I will not overwrite and a couple of vectors I use          in the iteration. If you're only doing a linear solve, it          does no harm to let me allocate those vectores in kl\\_bicgstab.          The way to preallocate is \\texttt{kl\\_store=kstore(n,\"bicgstab\")} where n          is the number of unknows. I call this myself in the initialization          phase if you don't do it ahead of me.\n",
       "\n",
       "side: left or right preconditioning. The default is \"right\".\n",
       "\n",
       "lmaxit: maximum number of linear iterations. The default is 10.\n",
       "\n",
       "pdata: precomputed data. The default is nothing, but that ain't gonna         work well for nonlinear equations.\n",
       "\n",
       "Output:\n",
       "\n",
       "A named tuple (sol, reshist, lits, idid)\n",
       "\n",
       "where\n",
       "\n",
       "sol= final result reshist = residual norm history lits = number of iterations idid = status of the iteration        true -> converged        false -> failed to converge\n",
       "\n",
       "\\subsubsection{Examples from the docstrings for kl\\_bicgstab}\n",
       "In these examples you have the matrix and use\n",
       "\n",
       "\\begin{verbatim}\n",
       "function atv(x, A)\n",
       "    return A * x\n",
       "end\n",
       "\\end{verbatim}\n",
       "to compute the matvec.\n",
       "\n",
       "\\paragraph{Three dimensional problem.}\n",
       "Will converge in the four iterations (worse than kl\\_gmres)\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> function atv(x, A)\n",
       "           return A * x\n",
       "       end\n",
       "atv (generic function with 1 method)\n",
       "\n",
       "julia> A = [0.001 0 0; 0 0.0011 0; 0 0 1.e4];\n",
       "\n",
       "julia> V = zeros(3); b = [1.0; 1.0; 1.0]; x0 = zeros(3);\n",
       "\n",
       "julia> gout.reshist\n",
       "5-element Vector{Any}:\n",
       " 1.73205e+00\n",
       " 1.41421e+00\n",
       " 3.21642e-03\n",
       " 3.20321e-03\n",
       " 4.98049e-13\n",
       "\n",
       "julia> norm(b - A*gout.sol,Inf)\n",
       "3.68594e-13\n",
       "\\end{verbatim}\n",
       "\\paragraph{Integral equation. Notice that pdata has the kernel of the}\n",
       "operator and we do the matvec directly. Just like the previous example. We put the grid information and, for this artifical example, the solution in the precomputed data.\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> function integop(u, pdata)\n",
       "                  K = pdata.K\n",
       "                  return u - K * u\n",
       "              end\n",
       "integop (generic function with 1 method)\n",
       "\n",
       "julia> function integopinit(n)\n",
       "                  h = 1 / n\n",
       "                  X = collect(0.5*h:h:1.0-0.5*h)\n",
       "                  K = [ker(x, y) for x in X, y in X]\n",
       "                  K .*= h\n",
       "                  sol = [usol(x) for x in X]\n",
       "                  f = sol - K * sol\n",
       "                  pdata = (K = K, xe = sol, f = f)\n",
       "                  return pdata\n",
       "              end\n",
       "integopinit (generic function with 1 method)\n",
       "\n",
       "julia> function usol(x)\n",
       "                  return exp.(x) .* log.(2.0 * x .+ 1.0)\n",
       "              end\n",
       "usol (generic function with 1 method)\n",
       "\n",
       "julia> function ker(x, y)\n",
       "                  ker = 0.1 * sin(x + exp(y))\n",
       "              end\n",
       "ker (generic function with 1 method)\n",
       "\n",
       "julia> n=100; pdata = integopinit(n); ue = pdata.xe; f=pdata.f;\n",
       "\n",
       "julia> u0 = zeros(size(f)); V = zeros(size(f));\n",
       "\n",
       "julia> gout.reshist\n",
       "4-element Vector{Any}:\n",
       " 1.48252e+01\n",
       " 2.90538e-02\n",
       " 2.07823e-07\n",
       " 2.17107e-17\n",
       "\n",
       "julia> norm(gout.sol-ue,Inf)\n",
       "8.88178e-16\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "kl_bicgstab( x0, b, atv, V, eta, ptv = nothing;       kl_store=nothing, side = \"right\", lmaxit = 10, pdata = nothing) \n",
       "\n",
       "C. T. Kelley, 2022\n",
       "\n",
       "BiCGSTAB linear solver. Deals with preconditioning.  Uses bicgstab_base with is oblivious to that.\n",
       "\n",
       "The code works and does what it needs to do, but ...\n",
       "\n",
       "The user interface is unstable and, even worse, the nonlinear solvers are not hooked up yet.\n",
       "\n",
       "The way this works it \n",
       "\n",
       "Input:\n",
       "\n",
       "x0:  initial iterate, this is usually zero for nonlinear solvers\n",
       "\n",
       "b: right hand side (duh!)\n",
       "\n",
       "atv:  matrix-vector product which depends on precomputed data pdta       I expect you to use pdata most or all of the time, so it is not       an optional argument, even if it's nothing (at least for now).       If your mat-vec is just A*v, you have to write a function where       A is the precomputed data.       API for atv is av=atv(v,pdata)\n",
       "\n",
       "V: a vector for me to store a Jacobian-vector product. It goes where     FPS would go in gmres. You are best served if V is Float64.\n",
       "\n",
       "eta: Termination happens when ||b - Ax|| <= eta || b ||\n",
       "\n",
       "ptv:  preconditioner-vector product, which will also use pdata. The       default is nothing, which is no preconditioning at all.       API for ptv is px=ptv(x,pdat) just like kl_gmres\n",
       "\n",
       "Keyword arguments\n",
       "\n",
       "kl_store: You have the option of giving me some room          for the vectors bicgstab needs to do its work. These in          which I will not overwrite and a couple of vectors I use          in the iteration. If you're only doing a linear solve, it          does no harm to let me allocate those vectores in kl_bicgstab.          The way to preallocate is `kl_store=kstore(n,\"bicgstab\")` where n          is the number of unknows. I call this myself in the initialization          phase if you don't do it ahead of me.\n",
       "\n",
       "side: left or right preconditioning. The default is \"right\".\n",
       "\n",
       "lmaxit: maximum number of linear iterations. The default is 10.\n",
       "\n",
       "pdata: precomputed data. The default is nothing, but that ain't gonna         work well for nonlinear equations.\n",
       "\n",
       "Output:\n",
       "\n",
       "A named tuple (sol, reshist, lits, idid)\n",
       "\n",
       "where\n",
       "\n",
       "sol= final result reshist = residual norm history lits = number of iterations idid = status of the iteration        true -> converged        false -> failed to converge\n",
       "\n",
       "### Examples from the docstrings for kl_bicgstab\n",
       "\n",
       "In these examples you have the matrix and use\n",
       "\n",
       "```\n",
       "function atv(x, A)\n",
       "    return A * x\n",
       "end\n",
       "```\n",
       "\n",
       "to compute the matvec.\n",
       "\n",
       "#### Three dimensional problem.\n",
       "\n",
       "Will converge in the four iterations (worse than kl_gmres)\n",
       "\n",
       "```jldoctest\n",
       "julia> function atv(x, A)\n",
       "           return A * x\n",
       "       end\n",
       "atv (generic function with 1 method)\n",
       "\n",
       "julia> A = [0.001 0 0; 0 0.0011 0; 0 0 1.e4];\n",
       "\n",
       "julia> V = zeros(3); b = [1.0; 1.0; 1.0]; x0 = zeros(3);\n",
       "\n",
       "julia> gout.reshist\n",
       "5-element Vector{Any}:\n",
       " 1.73205e+00\n",
       " 1.41421e+00\n",
       " 3.21642e-03\n",
       " 3.20321e-03\n",
       " 4.98049e-13\n",
       "\n",
       "julia> norm(b - A*gout.sol,Inf)\n",
       "3.68594e-13\n",
       "```\n",
       "\n",
       "#### Integral equation. Notice that pdata has the kernel of the\n",
       "\n",
       "operator and we do the matvec directly. Just like the previous example. We put the grid information and, for this artifical example, the solution in the precomputed data.\n",
       "\n",
       "```jldoctest\n",
       "julia> function integop(u, pdata)\n",
       "                  K = pdata.K\n",
       "                  return u - K * u\n",
       "              end\n",
       "integop (generic function with 1 method)\n",
       "\n",
       "julia> function integopinit(n)\n",
       "                  h = 1 / n\n",
       "                  X = collect(0.5*h:h:1.0-0.5*h)\n",
       "                  K = [ker(x, y) for x in X, y in X]\n",
       "                  K .*= h\n",
       "                  sol = [usol(x) for x in X]\n",
       "                  f = sol - K * sol\n",
       "                  pdata = (K = K, xe = sol, f = f)\n",
       "                  return pdata\n",
       "              end\n",
       "integopinit (generic function with 1 method)\n",
       "\n",
       "julia> function usol(x)\n",
       "                  return exp.(x) .* log.(2.0 * x .+ 1.0)\n",
       "              end\n",
       "usol (generic function with 1 method)\n",
       "\n",
       "julia> function ker(x, y)\n",
       "                  ker = 0.1 * sin(x + exp(y))\n",
       "              end\n",
       "ker (generic function with 1 method)\n",
       "\n",
       "julia> n=100; pdata = integopinit(n); ue = pdata.xe; f=pdata.f;\n",
       "\n",
       "julia> u0 = zeros(size(f)); V = zeros(size(f));\n",
       "\n",
       "julia> gout.reshist\n",
       "4-element Vector{Any}:\n",
       " 1.48252e+01\n",
       " 2.90538e-02\n",
       " 2.07823e-07\n",
       " 2.17107e-17\n",
       "\n",
       "julia> norm(gout.sol-ue,Inf)\n",
       "8.88178e-16\n",
       "```\n"
      ],
      "text/plain": [
       "  kl_bicgstab( x0, b, atv, V, eta, ptv = nothing; kl_store=nothing, side =\n",
       "  \"right\", lmaxit = 10, pdata = nothing)\n",
       "\n",
       "  C. T. Kelley, 2022\n",
       "\n",
       "  BiCGSTAB linear solver. Deals with preconditioning. Uses bicgstab_base with\n",
       "  is oblivious to that.\n",
       "\n",
       "  The code works and does what it needs to do, but ...\n",
       "\n",
       "  The user interface is unstable and, even worse, the nonlinear solvers are\n",
       "  not hooked up yet.\n",
       "\n",
       "  The way this works it\n",
       "\n",
       "  Input:\n",
       "\n",
       "  x0: initial iterate, this is usually zero for nonlinear solvers\n",
       "\n",
       "  b: right hand side (duh!)\n",
       "\n",
       "  atv: matrix-vector product which depends on precomputed data pdta I expect\n",
       "  you to use pdata most or all of the time, so it is not an optional argument,\n",
       "  even if it's nothing (at least for now). If your mat-vec is just A*v, you\n",
       "  have to write a function where A is the precomputed data. API for atv is\n",
       "  av=atv(v,pdata)\n",
       "\n",
       "  V: a vector for me to store a Jacobian-vector product. It goes where FPS\n",
       "  would go in gmres. You are best served if V is Float64.\n",
       "\n",
       "  eta: Termination happens when ||b - Ax|| <= eta || b ||\n",
       "\n",
       "  ptv: preconditioner-vector product, which will also use pdata. The default\n",
       "  is nothing, which is no preconditioning at all. API for ptv is\n",
       "  px=ptv(x,pdat) just like kl_gmres\n",
       "\n",
       "  Keyword arguments\n",
       "\n",
       "  kl_store: You have the option of giving me some room for the vectors\n",
       "  bicgstab needs to do its work. These in which I will not overwrite and a\n",
       "  couple of vectors I use in the iteration. If you're only doing a linear\n",
       "  solve, it does no harm to let me allocate those vectores in kl_bicgstab. The\n",
       "  way to preallocate is \u001b[36mkl_store=kstore(n,\"bicgstab\")\u001b[39m where n is the number of\n",
       "  unknows. I call this myself in the initialization phase if you don't do it\n",
       "  ahead of me.\n",
       "\n",
       "  side: left or right preconditioning. The default is \"right\".\n",
       "\n",
       "  lmaxit: maximum number of linear iterations. The default is 10.\n",
       "\n",
       "  pdata: precomputed data. The default is nothing, but that ain't gonna work\n",
       "  well for nonlinear equations.\n",
       "\n",
       "  Output:\n",
       "\n",
       "  A named tuple (sol, reshist, lits, idid)\n",
       "\n",
       "  where\n",
       "\n",
       "  sol= final result reshist = residual norm history lits = number of\n",
       "  iterations idid = status of the iteration true -> converged false -> failed\n",
       "  to converge\n",
       "\n",
       "\u001b[1m  Examples from the docstrings for kl_bicgstab\u001b[22m\n",
       "\u001b[1m  ––––––––––––––––––––––––––––––––––––––––––––––\u001b[22m\n",
       "\n",
       "  In these examples you have the matrix and use\n",
       "\n",
       "\u001b[36m  function atv(x, A)\u001b[39m\n",
       "\u001b[36m      return A * x\u001b[39m\n",
       "\u001b[36m  end\u001b[39m\n",
       "\n",
       "  to compute the matvec.\n",
       "\n",
       "\u001b[1m  Three dimensional problem.\u001b[22m\n",
       "\u001b[1m  ----------------------------\u001b[22m\n",
       "\n",
       "  Will converge in the four iterations (worse than kl_gmres)\n",
       "\n",
       "\u001b[36m  julia> function atv(x, A)\u001b[39m\n",
       "\u001b[36m             return A * x\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  atv (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> A = [0.001 0 0; 0 0.0011 0; 0 0 1.e4];\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> V = zeros(3); b = [1.0; 1.0; 1.0]; x0 = zeros(3);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> gout.reshist\u001b[39m\n",
       "\u001b[36m  5-element Vector{Any}:\u001b[39m\n",
       "\u001b[36m   1.73205e+00\u001b[39m\n",
       "\u001b[36m   1.41421e+00\u001b[39m\n",
       "\u001b[36m   3.21642e-03\u001b[39m\n",
       "\u001b[36m   3.20321e-03\u001b[39m\n",
       "\u001b[36m   4.98049e-13\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> norm(b - A*gout.sol,Inf)\u001b[39m\n",
       "\u001b[36m  3.68594e-13\u001b[39m\n",
       "\n",
       "\u001b[1m  Integral equation. Notice that pdata has the kernel of the\u001b[22m\n",
       "\u001b[1m  ------------------------------------------------------------\u001b[22m\n",
       "\n",
       "  operator and we do the matvec directly. Just like the previous example. We\n",
       "  put the grid information and, for this artifical example, the solution in\n",
       "  the precomputed data.\n",
       "\n",
       "\u001b[36m  julia> function integop(u, pdata)\u001b[39m\n",
       "\u001b[36m                    K = pdata.K\u001b[39m\n",
       "\u001b[36m                    return u - K * u\u001b[39m\n",
       "\u001b[36m                end\u001b[39m\n",
       "\u001b[36m  integop (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function integopinit(n)\u001b[39m\n",
       "\u001b[36m                    h = 1 / n\u001b[39m\n",
       "\u001b[36m                    X = collect(0.5*h:h:1.0-0.5*h)\u001b[39m\n",
       "\u001b[36m                    K = [ker(x, y) for x in X, y in X]\u001b[39m\n",
       "\u001b[36m                    K .*= h\u001b[39m\n",
       "\u001b[36m                    sol = [usol(x) for x in X]\u001b[39m\n",
       "\u001b[36m                    f = sol - K * sol\u001b[39m\n",
       "\u001b[36m                    pdata = (K = K, xe = sol, f = f)\u001b[39m\n",
       "\u001b[36m                    return pdata\u001b[39m\n",
       "\u001b[36m                end\u001b[39m\n",
       "\u001b[36m  integopinit (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function usol(x)\u001b[39m\n",
       "\u001b[36m                    return exp.(x) .* log.(2.0 * x .+ 1.0)\u001b[39m\n",
       "\u001b[36m                end\u001b[39m\n",
       "\u001b[36m  usol (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function ker(x, y)\u001b[39m\n",
       "\u001b[36m                    ker = 0.1 * sin(x + exp(y))\u001b[39m\n",
       "\u001b[36m                end\u001b[39m\n",
       "\u001b[36m  ker (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> n=100; pdata = integopinit(n); ue = pdata.xe; f=pdata.f;\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> u0 = zeros(size(f)); V = zeros(size(f));\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> gout.reshist\u001b[39m\n",
       "\u001b[36m  4-element Vector{Any}:\u001b[39m\n",
       "\u001b[36m   1.48252e+01\u001b[39m\n",
       "\u001b[36m   2.90538e-02\u001b[39m\n",
       "\u001b[36m   2.07823e-07\u001b[39m\n",
       "\u001b[36m   2.17107e-17\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> norm(gout.sol-ue,Inf)\u001b[39m\n",
       "\u001b[36m  8.88178e-16\u001b[39m"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?kl_bicgstab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Docstrings for nsoli.jl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "search: \u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ml\u001b[22m\u001b[0m\u001b[1mi\u001b[22m \u001b[0m\u001b[1mn\u001b[22mda_n\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ml\u001b[22m\u001b[0m\u001b[1mi\u001b[22m \u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ml\u001b[22m \u001b[0m\u001b[1mn\u001b[22m\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ml\u001b[22msc s\u001b[0m\u001b[1mn\u001b[22m_\u001b[0m\u001b[1ms\u001b[22m\u001b[0m\u001b[1mo\u001b[22m\u001b[0m\u001b[1ml\u001b[22mve\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/latex": [
       "\\begin{verbatim}\n",
       "nsoli(F!, x0, FS, FPS, Jvec=dirder; rtol=1.e-6, atol=1.e-12,\n",
       "           maxit=20, lmaxit=-1, lsolver=\"gmres\", eta=.1,\n",
       "           fixedeta=true, Pvec=nothing, pside=\"right\",\n",
       "           armmax=10, dx = 1.e-7, armfix=false, pdata = nothing,\n",
       "           printerr = true, keepsolhist = false, \n",
       "           Krylov_Data = nothing, stagnationok=false)\n",
       "\\end{verbatim}\n",
       ")\n",
       "\n",
       "C. T. Kelley, 2022\n",
       "\n",
       "Julia versions of the nonlinear solvers from my SIAM books.  Herewith: nsoli\n",
       "\n",
       "You must allocate storage for the function and the Krylov basis in advance –> in the calling program <– ie. in FS and FPS\n",
       "\n",
       "Inputs:\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item F!: function evaluation, the ! indicates that F! overwrites FS, your   preallocated storage for the function.\n",
       "\n",
       "So FS=F!(FS,x) or FS=F!(FS,x,pdata) returns FS=F(x)\n",
       "\n",
       "Your function MUST have –> return FS <– at the end.   See the examples in the docstrings\n",
       "\n",
       "\\end{itemize}\n",
       "\\begin{itemize}\n",
       "\\item x0: initial iterate\n",
       "\n",
       "\\end{itemize}\n",
       "\\begin{itemize}\n",
       "\\item FS: Preallocated storage for function. It is a vector of size N\n",
       "\n",
       "You should store it as (N) and design F! to use vectors of size (N). If you use (N,1) consistently instead, the solvers may work, but I make no guarantees.\n",
       "\n",
       "\n",
       "\\item FPS: preallocated storage for the Krylov basis. It is an N x m matrix where      you plan to take at most m-1 GMRES iterations before a restart. \n",
       "\n",
       "\\end{itemize}\n",
       "\\begin{itemize}\n",
       "\\item Jvec: Jacobian vector product, If you leave this out the   default is a finite difference directional derivative.\n",
       "\n",
       "So, FP=Jvec(v,FS,x) or FP=Jvec(v,FS,x,pdata) returns FP=F'(x) v. \n",
       "\n",
       "(v, FS, x) or (v, FS, x, pdata) must be the argument list,    even if FP does not need FS.   One reason for this is that the finite-difference derivative   does and that is the default in the solver.\n",
       "\n",
       "\n",
       "\\item Precision: Lemme tell ya 'bout precision. I designed this code for    full precision functions and linear algebra in any precision you want.    You can declare FPS as Float64 or Float32 and nsoli    will do the right thing. Float16 support is there, but not working well.\n",
       "\n",
       "If the Jacobian is reasonably well conditioned, you can cut the cost   of orthogonalization and storage (for GMRES) in half with no loss.    There is no benefit if your linear solver is not GMRES or if    orthogonalization and storage of the Krylov vectors is only a   small part of the cost of the computation. So if your preconditioner   is good and you only need a few Krylovs/Newton, reduced precision won't   help you much.\n",
       "\n",
       "BiCGSTAB does not benefit from reduced precision. \n",
       "\n",
       "\\end{itemize}\n",
       "\\rule{\\textwidth}{1pt}\n",
       "Keyword Arguments (kwargs):\n",
       "\n",
       "rtol and atol: relative and absolute error tolerances\n",
       "\n",
       "maxit: limit on nonlinear iterations\n",
       "\n",
       "lmaxit: limit on linear iterations. If lmaxit > m-1, where FPS has m columns, and you need more than m-1 linear iterations, then GMRES  will restart. \n",
       "\n",
       "The default is -1 for GMRES. This means that you'll take m-1 iterations,  where size(V) = (n,m), and get no restarts. For BiCGSTAB the default is 10.\n",
       "\n",
       "lsolver: the linear solver, default = \"gmres\"\n",
       "\n",
       "Your choices will be \"gmres\" or \"bicgstab\". However, gmres is the only option for now.\n",
       "\n",
       "eta and fixed eta: eta > 0 or there's an error\n",
       "\n",
       "The linear solver terminates when ||F'(x)s + F(x) || <= etag || F(x) ||\n",
       "\n",
       "where \n",
       "\n",
       "etag = eta if fixedeta=true\n",
       "\n",
       "etag = Eisenstat-Walker as implemented in book if fixedeta=false\n",
       "\n",
       "The default, which may change, is eta=.1, fixedeta=true\n",
       "\n",
       "Pvec: Preconditioner-vector product. The rules are similar to Jvec     So, Pv=Pvec(v,x) or Pv=Pvec(v,x,pdata) returns P(x) v where     P(x) is the preconditioner. You must use x as an input even     if your preconditioner does not depend on x\n",
       "\n",
       "pside: apply preconditioner on pside, default = \"right\". I do not       recommend \"left\". See Chapter 3 for the story on this.\n",
       "\n",
       "armmax: upper bound on step size reductions in line search\n",
       "\n",
       "dx: default = 1.e-7\n",
       "\n",
       "difference increment in finite-difference derivatives       h=dx*norm(x,Inf)+1.e-8\n",
       "\n",
       "armfix: default = false\n",
       "\n",
       "The default is a parabolic line search (ie false). Set to true and the step size will be fixed at .5. Don't do this unless you are doing experiments for research.\n",
       "\n",
       "pdata:\n",
       "\n",
       "precomputed data for the function, Jacobian-vector, and Preconditioner-vector products.  Things will go better if you use this rather than hide the data  in global variables within the module for your function/Jacobian\n",
       "\n",
       "If you use pdata in any of F!, Jvec, or Pvec, you must use in in all of them.\n",
       "\n",
       "printerr: default = true\n",
       "\n",
       "I print a helpful message when the solver fails. To suppress that message set printerr to false.\n",
       "\n",
       "keepsolhist: default = false\n",
       "\n",
       "Set this to true to get the history of the iteration in the output tuple. This is on by default for scalar equations and off for systems. Only turn it on if you have use for the data, which can get REALLY LARGE.\n",
       "\n",
       "Krylov\\_Data: default = nothing\n",
       "\n",
       "This is a structure where I put the internal storage for the solvers. You can (but probably should not) preallocate this your self with the nkl\\_init function.\n",
       "\n",
       "Krylov\\_Data \n",
       "\n",
       "= nkl\\_init(n,lsolver)\n",
       "\n",
       "This is a dangerous thing to mess with and I only recommend it if  the allocations in nsoli become a problem in continuation or IVP integration. Krylov\\_Data is where I store the solution at the end of the iteration and if you reuse it without copying the solution to somewhere else, you'll lose it and it will be overwritten with the new solution. The continuation case study uses this and you  should look at that to see what I did.\n",
       "\n",
       "stagnationok: default = false\n",
       "\n",
       "Set this to true if you want to disable the line search and either observe divergence or stagnation. This is only useful for research or writing a book.\n",
       "\n",
       "Output:\n",
       "\n",
       "\\begin{itemize}\n",
       "\\item A named tuple (solution, functionval, history, stats, idid,              errcode, solhist)\n",
       "\n",
       "\\end{itemize}\n",
       "where\n",
       "\n",
       "– solution = converged result\n",
       "\n",
       "– functionval = F(solution)\n",
       "\n",
       "– history = the vector of residual norms (||F(x)||) for the iteration\n",
       "\n",
       "– stats = named tuple of the history of (ifun, ijac, iarm, ikfail), the  number of functions/Jacobian-vector prods/steplength reductions/linear solver failures at each iteration. Linear solver failures DO NOT mean that the nonlinear solver will fail. You should look at this stat if, for example, the line search fails. Increasing the size of FPS and/or lmaxit might solve the problem.\n",
       "\n",
       "I do not count the function values for a finite-difference derivative because they count toward a Jacobian-vector product.\n",
       "\n",
       "– idid=true if the iteration succeeded and false if not.\n",
       "\n",
       "– errcode = 0 if the iteration succeeded\n",
       "\n",
       "\\begin{verbatim}\n",
       "    = -1 if the initial iterate satisfies the termination criteria\n",
       "\n",
       "    = 10 if no convergence after maxit iterations\n",
       "\n",
       "    = 1  if the line search failed\n",
       "\\end{verbatim}\n",
       "– solhist:\n",
       "\n",
       "\\begin{verbatim}\n",
       "  This is the entire history of the iteration if you've set\n",
       "  keepsolhist=true\n",
       "\\end{verbatim}\n",
       "solhist is an N x K array where N is the length of x and K is the number of iteration + 1. So, for scalar equations, it's a row vector.\n",
       "\n",
       "\\rule{\\textwidth}{1pt}\n",
       "\\subsubsection{Example for nsoli}\n",
       "\\paragraph{Simple 2D problem.}\n",
       "You should get the same results as for nsol.jl because GMRES will solve the equation for the step exactly in two iterations. Finite difference Jacobians and analytic Jacobian-vector products for full precision and finite difference Jacobian-vector products for single precision.\n",
       "\n",
       "BiCGSTAB converges in 5 iterations and each nonlinear iteration costs two Jacobian-vector products. Note that the storage for the Krylov space in GMRES (jvs) is replace by a single vector (fpv) when BiCGSTAB is the linear solver.\n",
       "\n",
       "\\begin{verbatim}\n",
       "julia> function f!(fv,x)\n",
       "       fv[1]=x[1] + sin(x[2])\n",
       "       fv[2]=cos(x[1]+x[2])\n",
       "       return fv\n",
       "       end\n",
       "f! (generic function with 1 method)\n",
       "\n",
       "julia> function JVec(v, fv, x)\n",
       "       jvec=zeros(2);\n",
       "       p=-sin(x[1]+x[2])\n",
       "       jvec[1]=v[1]+cos(x[2])*v[2]\n",
       "       jvec[2]=p*(v[1]+v[2])\n",
       "       return jvec\n",
       "       end\n",
       "JVec (generic function with 1 method)\n",
       "\n",
       "julia> x0=ones(2); fv=zeros(2); jv=zeros(2,2); \n",
       "\n",
       "julia> jv32=zeros(Float32,2,2);\n",
       "\n",
       "julia> jvs=zeros(2,3); jvs32=zeros(Float32,2,3);\n",
       "\n",
       "julia> nout=nsol(f!,x0,fv,jv; sham=1);\n",
       "\n",
       "julia> kout=nsoli(f!,x0,fv,jvs,JVec; \n",
       "                  fixedeta=true, eta=.1, lmaxit=2);\n",
       "\n",
       "julia> kout32=nsoli(f!,x0,fv,jvs32; \n",
       "                    fixedeta=true, eta=.1, lmaxit=2);\n",
       "\n",
       "julia> [nout.history kout.history kout32.history]\n",
       "5×3 Array{Float64,2}:\n",
       " 1.88791e+00  1.88791e+00  1.88791e+00\n",
       " 2.43119e-01  2.43120e-01  2.43119e-01\n",
       " 1.19231e-02  1.19231e-02  1.19230e-02\n",
       " 1.03266e-05  1.03261e-05  1.03264e-05\n",
       " 1.46388e-11  1.40862e-11  1.39825e-11\n",
       "\n",
       "julia> fpv=zeros(2);\n",
       "\n",
       "julia> koutb=nsoli(f!,x0,fv,fpv,JVec; \n",
       "            fixedeta=true, eta=.1, lmaxit=2, lsolver=\"bicgstab\");\n",
       "\n",
       "julia> koutb.history\n",
       "6-element Vector{Float64}:\n",
       " 1.88791e+00\n",
       " 2.43120e-01\n",
       " 1.19231e-02\n",
       " 4.87500e-04\n",
       " 7.54236e-06\n",
       " 3.84646e-07\n",
       "\\end{verbatim}\n"
      ],
      "text/markdown": [
       "```\n",
       "nsoli(F!, x0, FS, FPS, Jvec=dirder; rtol=1.e-6, atol=1.e-12,\n",
       "           maxit=20, lmaxit=-1, lsolver=\"gmres\", eta=.1,\n",
       "           fixedeta=true, Pvec=nothing, pside=\"right\",\n",
       "           armmax=10, dx = 1.e-7, armfix=false, pdata = nothing,\n",
       "           printerr = true, keepsolhist = false, \n",
       "           Krylov_Data = nothing, stagnationok=false)\n",
       "```\n",
       "\n",
       ")\n",
       "\n",
       "C. T. Kelley, 2022\n",
       "\n",
       "Julia versions of the nonlinear solvers from my SIAM books.  Herewith: nsoli\n",
       "\n",
       "You must allocate storage for the function and the Krylov basis in advance –> in the calling program <– ie. in FS and FPS\n",
       "\n",
       "Inputs:\n",
       "\n",
       "  * F!: function evaluation, the ! indicates that F! overwrites FS, your   preallocated storage for the function.\n",
       "\n",
       "    So FS=F!(FS,x) or FS=F!(FS,x,pdata) returns FS=F(x)\n",
       "\n",
       "    Your function MUST have –> return FS <– at the end.   See the examples in the docstrings\n",
       "\n",
       "  * x0: initial iterate\n",
       "\n",
       "  * FS: Preallocated storage for function. It is a vector of size N\n",
       "\n",
       "    You should store it as (N) and design F! to use vectors of size (N). If you use (N,1) consistently instead, the solvers may work, but I make no guarantees.\n",
       "  * FPS: preallocated storage for the Krylov basis. It is an N x m matrix where      you plan to take at most m-1 GMRES iterations before a restart.\n",
       "\n",
       "  * Jvec: Jacobian vector product, If you leave this out the   default is a finite difference directional derivative.\n",
       "\n",
       "    So, FP=Jvec(v,FS,x) or FP=Jvec(v,FS,x,pdata) returns FP=F'(x) v. \n",
       "\n",
       "    (v, FS, x) or (v, FS, x, pdata) must be the argument list,    even if FP does not need FS.   One reason for this is that the finite-difference derivative   does and that is the default in the solver.\n",
       "  * Precision: Lemme tell ya 'bout precision. I designed this code for    full precision functions and linear algebra in any precision you want.    You can declare FPS as Float64 or Float32 and nsoli    will do the right thing. Float16 support is there, but not working well.\n",
       "\n",
       "    If the Jacobian is reasonably well conditioned, you can cut the cost   of orthogonalization and storage (for GMRES) in half with no loss.    There is no benefit if your linear solver is not GMRES or if    orthogonalization and storage of the Krylov vectors is only a   small part of the cost of the computation. So if your preconditioner   is good and you only need a few Krylovs/Newton, reduced precision won't   help you much.\n",
       "\n",
       "    BiCGSTAB does not benefit from reduced precision.\n",
       "\n",
       "---\n",
       "\n",
       "Keyword Arguments (kwargs):\n",
       "\n",
       "rtol and atol: relative and absolute error tolerances\n",
       "\n",
       "maxit: limit on nonlinear iterations\n",
       "\n",
       "lmaxit: limit on linear iterations. If lmaxit > m-1, where FPS has m columns, and you need more than m-1 linear iterations, then GMRES  will restart. \n",
       "\n",
       "The default is -1 for GMRES. This means that you'll take m-1 iterations,  where size(V) = (n,m), and get no restarts. For BiCGSTAB the default is 10.\n",
       "\n",
       "lsolver: the linear solver, default = \"gmres\"\n",
       "\n",
       "Your choices will be \"gmres\" or \"bicgstab\". However, gmres is the only option for now.\n",
       "\n",
       "eta and fixed eta: eta > 0 or there's an error\n",
       "\n",
       "The linear solver terminates when ||F'(x)s + F(x) || <= etag || F(x) ||\n",
       "\n",
       "where \n",
       "\n",
       "etag = eta if fixedeta=true\n",
       "\n",
       "etag = Eisenstat-Walker as implemented in book if fixedeta=false\n",
       "\n",
       "The default, which may change, is eta=.1, fixedeta=true\n",
       "\n",
       "Pvec: Preconditioner-vector product. The rules are similar to Jvec     So, Pv=Pvec(v,x) or Pv=Pvec(v,x,pdata) returns P(x) v where     P(x) is the preconditioner. You must use x as an input even     if your preconditioner does not depend on x\n",
       "\n",
       "pside: apply preconditioner on pside, default = \"right\". I do not       recommend \"left\". See Chapter 3 for the story on this.\n",
       "\n",
       "armmax: upper bound on step size reductions in line search\n",
       "\n",
       "dx: default = 1.e-7\n",
       "\n",
       "difference increment in finite-difference derivatives       h=dx*norm(x,Inf)+1.e-8\n",
       "\n",
       "armfix: default = false\n",
       "\n",
       "The default is a parabolic line search (ie false). Set to true and the step size will be fixed at .5. Don't do this unless you are doing experiments for research.\n",
       "\n",
       "pdata:\n",
       "\n",
       "precomputed data for the function, Jacobian-vector, and Preconditioner-vector products.  Things will go better if you use this rather than hide the data  in global variables within the module for your function/Jacobian\n",
       "\n",
       "If you use pdata in any of F!, Jvec, or Pvec, you must use in in all of them.\n",
       "\n",
       "printerr: default = true\n",
       "\n",
       "I print a helpful message when the solver fails. To suppress that message set printerr to false.\n",
       "\n",
       "keepsolhist: default = false\n",
       "\n",
       "Set this to true to get the history of the iteration in the output tuple. This is on by default for scalar equations and off for systems. Only turn it on if you have use for the data, which can get REALLY LARGE.\n",
       "\n",
       "Krylov_Data: default = nothing\n",
       "\n",
       "This is a structure where I put the internal storage for the solvers. You can (but probably should not) preallocate this your self with the nkl_init function.\n",
       "\n",
       "Krylov_Data \n",
       "\n",
       "= nkl_init(n,lsolver)\n",
       "\n",
       "This is a dangerous thing to mess with and I only recommend it if  the allocations in nsoli become a problem in continuation or IVP integration. Krylov_Data is where I store the solution at the end of the iteration and if you reuse it without copying the solution to somewhere else, you'll lose it and it will be overwritten with the new solution. The continuation case study uses this and you  should look at that to see what I did.\n",
       "\n",
       "stagnationok: default = false\n",
       "\n",
       "Set this to true if you want to disable the line search and either observe divergence or stagnation. This is only useful for research or writing a book.\n",
       "\n",
       "Output:\n",
       "\n",
       "  * A named tuple (solution, functionval, history, stats, idid,              errcode, solhist)\n",
       "\n",
       "where\n",
       "\n",
       "– solution = converged result\n",
       "\n",
       "– functionval = F(solution)\n",
       "\n",
       "– history = the vector of residual norms (||F(x)||) for the iteration\n",
       "\n",
       "– stats = named tuple of the history of (ifun, ijac, iarm, ikfail), the  number of functions/Jacobian-vector prods/steplength reductions/linear solver failures at each iteration. Linear solver failures DO NOT mean that the nonlinear solver will fail. You should look at this stat if, for example, the line search fails. Increasing the size of FPS and/or lmaxit might solve the problem.\n",
       "\n",
       "I do not count the function values for a finite-difference derivative because they count toward a Jacobian-vector product.\n",
       "\n",
       "– idid=true if the iteration succeeded and false if not.\n",
       "\n",
       "– errcode = 0 if the iteration succeeded\n",
       "\n",
       "```\n",
       "    = -1 if the initial iterate satisfies the termination criteria\n",
       "\n",
       "    = 10 if no convergence after maxit iterations\n",
       "\n",
       "    = 1  if the line search failed\n",
       "```\n",
       "\n",
       "– solhist:\n",
       "\n",
       "```\n",
       "  This is the entire history of the iteration if you've set\n",
       "  keepsolhist=true\n",
       "```\n",
       "\n",
       "solhist is an N x K array where N is the length of x and K is the number of iteration + 1. So, for scalar equations, it's a row vector.\n",
       "\n",
       "---\n",
       "\n",
       "### Example for nsoli\n",
       "\n",
       "#### Simple 2D problem.\n",
       "\n",
       "You should get the same results as for nsol.jl because GMRES will solve the equation for the step exactly in two iterations. Finite difference Jacobians and analytic Jacobian-vector products for full precision and finite difference Jacobian-vector products for single precision.\n",
       "\n",
       "BiCGSTAB converges in 5 iterations and each nonlinear iteration costs two Jacobian-vector products. Note that the storage for the Krylov space in GMRES (jvs) is replace by a single vector (fpv) when BiCGSTAB is the linear solver.\n",
       "\n",
       "```jldoctest\n",
       "julia> function f!(fv,x)\n",
       "       fv[1]=x[1] + sin(x[2])\n",
       "       fv[2]=cos(x[1]+x[2])\n",
       "       return fv\n",
       "       end\n",
       "f! (generic function with 1 method)\n",
       "\n",
       "julia> function JVec(v, fv, x)\n",
       "       jvec=zeros(2);\n",
       "       p=-sin(x[1]+x[2])\n",
       "       jvec[1]=v[1]+cos(x[2])*v[2]\n",
       "       jvec[2]=p*(v[1]+v[2])\n",
       "       return jvec\n",
       "       end\n",
       "JVec (generic function with 1 method)\n",
       "\n",
       "julia> x0=ones(2); fv=zeros(2); jv=zeros(2,2); \n",
       "\n",
       "julia> jv32=zeros(Float32,2,2);\n",
       "\n",
       "julia> jvs=zeros(2,3); jvs32=zeros(Float32,2,3);\n",
       "\n",
       "julia> nout=nsol(f!,x0,fv,jv; sham=1);\n",
       "\n",
       "julia> kout=nsoli(f!,x0,fv,jvs,JVec; \n",
       "                  fixedeta=true, eta=.1, lmaxit=2);\n",
       "\n",
       "julia> kout32=nsoli(f!,x0,fv,jvs32; \n",
       "                    fixedeta=true, eta=.1, lmaxit=2);\n",
       "\n",
       "julia> [nout.history kout.history kout32.history]\n",
       "5×3 Array{Float64,2}:\n",
       " 1.88791e+00  1.88791e+00  1.88791e+00\n",
       " 2.43119e-01  2.43120e-01  2.43119e-01\n",
       " 1.19231e-02  1.19231e-02  1.19230e-02\n",
       " 1.03266e-05  1.03261e-05  1.03264e-05\n",
       " 1.46388e-11  1.40862e-11  1.39825e-11\n",
       "\n",
       "julia> fpv=zeros(2);\n",
       "\n",
       "julia> koutb=nsoli(f!,x0,fv,fpv,JVec; \n",
       "            fixedeta=true, eta=.1, lmaxit=2, lsolver=\"bicgstab\");\n",
       "\n",
       "julia> koutb.history\n",
       "6-element Vector{Float64}:\n",
       " 1.88791e+00\n",
       " 2.43120e-01\n",
       " 1.19231e-02\n",
       " 4.87500e-04\n",
       " 7.54236e-06\n",
       " 3.84646e-07\n",
       "```\n"
      ],
      "text/plain": [
       "\u001b[36m  nsoli(F!, x0, FS, FPS, Jvec=dirder; rtol=1.e-6, atol=1.e-12,\u001b[39m\n",
       "\u001b[36m             maxit=20, lmaxit=-1, lsolver=\"gmres\", eta=.1,\u001b[39m\n",
       "\u001b[36m             fixedeta=true, Pvec=nothing, pside=\"right\",\u001b[39m\n",
       "\u001b[36m             armmax=10, dx = 1.e-7, armfix=false, pdata = nothing,\u001b[39m\n",
       "\u001b[36m             printerr = true, keepsolhist = false, \u001b[39m\n",
       "\u001b[36m             Krylov_Data = nothing, stagnationok=false)\u001b[39m\n",
       "\n",
       "  )\n",
       "\n",
       "  C. T. Kelley, 2022\n",
       "\n",
       "  Julia versions of the nonlinear solvers from my SIAM books. Herewith: nsoli\n",
       "\n",
       "  You must allocate storage for the function and the Krylov basis in advance\n",
       "  –> in the calling program <– ie. in FS and FPS\n",
       "\n",
       "  Inputs:\n",
       "\n",
       "    •  F!: function evaluation, the ! indicates that F! overwrites FS,\n",
       "       your preallocated storage for the function.\n",
       "       So FS=F!(FS,x) or FS=F!(FS,x,pdata) returns FS=F(x)\n",
       "       Your function MUST have –> return FS <– at the end. See the\n",
       "       examples in the docstrings\n",
       "\n",
       "    •  x0: initial iterate\n",
       "\n",
       "    •  FS: Preallocated storage for function. It is a vector of size N\n",
       "       You should store it as (N) and design F! to use vectors of size\n",
       "       (N). If you use (N,1) consistently instead, the solvers may work,\n",
       "       but I make no guarantees.\n",
       "\n",
       "    •  FPS: preallocated storage for the Krylov basis. It is an N x m\n",
       "       matrix where you plan to take at most m-1 GMRES iterations before\n",
       "       a restart.\n",
       "\n",
       "    •  Jvec: Jacobian vector product, If you leave this out the default\n",
       "       is a finite difference directional derivative.\n",
       "       So, FP=Jvec(v,FS,x) or FP=Jvec(v,FS,x,pdata) returns FP=F'(x) v.\n",
       "       (v, FS, x) or (v, FS, x, pdata) must be the argument list, even if\n",
       "       FP does not need FS. One reason for this is that the\n",
       "       finite-difference derivative does and that is the default in the\n",
       "       solver.\n",
       "\n",
       "    •  Precision: Lemme tell ya 'bout precision. I designed this code for\n",
       "       full precision functions and linear algebra in any precision you\n",
       "       want. You can declare FPS as Float64 or Float32 and nsoli will do\n",
       "       the right thing. Float16 support is there, but not working well.\n",
       "       If the Jacobian is reasonably well conditioned, you can cut the\n",
       "       cost of orthogonalization and storage (for GMRES) in half with no\n",
       "       loss. There is no benefit if your linear solver is not GMRES or if\n",
       "       orthogonalization and storage of the Krylov vectors is only a\n",
       "       small part of the cost of the computation. So if your\n",
       "       preconditioner is good and you only need a few Krylovs/Newton,\n",
       "       reduced precision won't help you much.\n",
       "       BiCGSTAB does not benefit from reduced precision.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "  Keyword Arguments (kwargs):\n",
       "\n",
       "  rtol and atol: relative and absolute error tolerances\n",
       "\n",
       "  maxit: limit on nonlinear iterations\n",
       "\n",
       "  lmaxit: limit on linear iterations. If lmaxit > m-1, where FPS has m\n",
       "  columns, and you need more than m-1 linear iterations, then GMRES will\n",
       "  restart.\n",
       "\n",
       "  The default is -1 for GMRES. This means that you'll take m-1 iterations,\n",
       "  where size(V) = (n,m), and get no restarts. For BiCGSTAB the default is 10.\n",
       "\n",
       "  lsolver: the linear solver, default = \"gmres\"\n",
       "\n",
       "  Your choices will be \"gmres\" or \"bicgstab\". However, gmres is the only\n",
       "  option for now.\n",
       "\n",
       "  eta and fixed eta: eta > 0 or there's an error\n",
       "\n",
       "  The linear solver terminates when ||F'(x)s + F(x) || <= etag || F(x) ||\n",
       "\n",
       "  where\n",
       "\n",
       "  etag = eta if fixedeta=true\n",
       "\n",
       "  etag = Eisenstat-Walker as implemented in book if fixedeta=false\n",
       "\n",
       "  The default, which may change, is eta=.1, fixedeta=true\n",
       "\n",
       "  Pvec: Preconditioner-vector product. The rules are similar to Jvec So,\n",
       "  Pv=Pvec(v,x) or Pv=Pvec(v,x,pdata) returns P(x) v where P(x) is the\n",
       "  preconditioner. You must use x as an input even if your preconditioner does\n",
       "  not depend on x\n",
       "\n",
       "  pside: apply preconditioner on pside, default = \"right\". I do not recommend\n",
       "  \"left\". See Chapter 3 for the story on this.\n",
       "\n",
       "  armmax: upper bound on step size reductions in line search\n",
       "\n",
       "  dx: default = 1.e-7\n",
       "\n",
       "  difference increment in finite-difference derivatives h=dx*norm(x,Inf)+1.e-8\n",
       "\n",
       "  armfix: default = false\n",
       "\n",
       "  The default is a parabolic line search (ie false). Set to true and the step\n",
       "  size will be fixed at .5. Don't do this unless you are doing experiments for\n",
       "  research.\n",
       "\n",
       "  pdata:\n",
       "\n",
       "  precomputed data for the function, Jacobian-vector, and\n",
       "  Preconditioner-vector products. Things will go better if you use this rather\n",
       "  than hide the data in global variables within the module for your\n",
       "  function/Jacobian\n",
       "\n",
       "  If you use pdata in any of F!, Jvec, or Pvec, you must use in in all of\n",
       "  them.\n",
       "\n",
       "  printerr: default = true\n",
       "\n",
       "  I print a helpful message when the solver fails. To suppress that message\n",
       "  set printerr to false.\n",
       "\n",
       "  keepsolhist: default = false\n",
       "\n",
       "  Set this to true to get the history of the iteration in the output tuple.\n",
       "  This is on by default for scalar equations and off for systems. Only turn it\n",
       "  on if you have use for the data, which can get REALLY LARGE.\n",
       "\n",
       "  Krylov_Data: default = nothing\n",
       "\n",
       "  This is a structure where I put the internal storage for the solvers. You\n",
       "  can (but probably should not) preallocate this your self with the nkl_init\n",
       "  function.\n",
       "\n",
       "  Krylov_Data\n",
       "\n",
       "  = nkl_init(n,lsolver)\n",
       "\n",
       "  This is a dangerous thing to mess with and I only recommend it if the\n",
       "  allocations in nsoli become a problem in continuation or IVP integration.\n",
       "  Krylov_Data is where I store the solution at the end of the iteration and if\n",
       "  you reuse it without copying the solution to somewhere else, you'll lose it\n",
       "  and it will be overwritten with the new solution. The continuation case\n",
       "  study uses this and you should look at that to see what I did.\n",
       "\n",
       "  stagnationok: default = false\n",
       "\n",
       "  Set this to true if you want to disable the line search and either observe\n",
       "  divergence or stagnation. This is only useful for research or writing a\n",
       "  book.\n",
       "\n",
       "  Output:\n",
       "\n",
       "    •  A named tuple (solution, functionval, history, stats, idid,\n",
       "       errcode, solhist)\n",
       "\n",
       "  where\n",
       "\n",
       "  – solution = converged result\n",
       "\n",
       "  – functionval = F(solution)\n",
       "\n",
       "  – history = the vector of residual norms (||F(x)||) for the iteration\n",
       "\n",
       "  – stats = named tuple of the history of (ifun, ijac, iarm, ikfail), the\n",
       "  number of functions/Jacobian-vector prods/steplength reductions/linear\n",
       "  solver failures at each iteration. Linear solver failures DO NOT mean that\n",
       "  the nonlinear solver will fail. You should look at this stat if, for\n",
       "  example, the line search fails. Increasing the size of FPS and/or lmaxit\n",
       "  might solve the problem.\n",
       "\n",
       "  I do not count the function values for a finite-difference derivative\n",
       "  because they count toward a Jacobian-vector product.\n",
       "\n",
       "  – idid=true if the iteration succeeded and false if not.\n",
       "\n",
       "  – errcode = 0 if the iteration succeeded\n",
       "\n",
       "\u001b[36m      = -1 if the initial iterate satisfies the termination criteria\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m      = 10 if no convergence after maxit iterations\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m      = 1  if the line search failed\u001b[39m\n",
       "\n",
       "  – solhist:\n",
       "\n",
       "\u001b[36m    This is the entire history of the iteration if you've set\u001b[39m\n",
       "\u001b[36m    keepsolhist=true\u001b[39m\n",
       "\n",
       "  solhist is an N x K array where N is the length of x and K is the number of\n",
       "  iteration + 1. So, for scalar equations, it's a row vector.\n",
       "\n",
       "  ────────────────────────────────────────────────────────────────────────────\n",
       "\n",
       "\u001b[1m  Example for nsoli\u001b[22m\n",
       "\u001b[1m  –––––––––––––––––––\u001b[22m\n",
       "\n",
       "\u001b[1m  Simple 2D problem.\u001b[22m\n",
       "\u001b[1m  --------------------\u001b[22m\n",
       "\n",
       "  You should get the same results as for nsol.jl because GMRES will solve the\n",
       "  equation for the step exactly in two iterations. Finite difference Jacobians\n",
       "  and analytic Jacobian-vector products for full precision and finite\n",
       "  difference Jacobian-vector products for single precision.\n",
       "\n",
       "  BiCGSTAB converges in 5 iterations and each nonlinear iteration costs two\n",
       "  Jacobian-vector products. Note that the storage for the Krylov space in\n",
       "  GMRES (jvs) is replace by a single vector (fpv) when BiCGSTAB is the linear\n",
       "  solver.\n",
       "\n",
       "\u001b[36m  julia> function f!(fv,x)\u001b[39m\n",
       "\u001b[36m         fv[1]=x[1] + sin(x[2])\u001b[39m\n",
       "\u001b[36m         fv[2]=cos(x[1]+x[2])\u001b[39m\n",
       "\u001b[36m         return fv\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  f! (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> function JVec(v, fv, x)\u001b[39m\n",
       "\u001b[36m         jvec=zeros(2);\u001b[39m\n",
       "\u001b[36m         p=-sin(x[1]+x[2])\u001b[39m\n",
       "\u001b[36m         jvec[1]=v[1]+cos(x[2])*v[2]\u001b[39m\n",
       "\u001b[36m         jvec[2]=p*(v[1]+v[2])\u001b[39m\n",
       "\u001b[36m         return jvec\u001b[39m\n",
       "\u001b[36m         end\u001b[39m\n",
       "\u001b[36m  JVec (generic function with 1 method)\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> x0=ones(2); fv=zeros(2); jv=zeros(2,2); \u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> jv32=zeros(Float32,2,2);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> jvs=zeros(2,3); jvs32=zeros(Float32,2,3);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> nout=nsol(f!,x0,fv,jv; sham=1);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> kout=nsoli(f!,x0,fv,jvs,JVec; \u001b[39m\n",
       "\u001b[36m                    fixedeta=true, eta=.1, lmaxit=2);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> kout32=nsoli(f!,x0,fv,jvs32; \u001b[39m\n",
       "\u001b[36m                      fixedeta=true, eta=.1, lmaxit=2);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> [nout.history kout.history kout32.history]\u001b[39m\n",
       "\u001b[36m  5×3 Array{Float64,2}:\u001b[39m\n",
       "\u001b[36m   1.88791e+00  1.88791e+00  1.88791e+00\u001b[39m\n",
       "\u001b[36m   2.43119e-01  2.43120e-01  2.43119e-01\u001b[39m\n",
       "\u001b[36m   1.19231e-02  1.19231e-02  1.19230e-02\u001b[39m\n",
       "\u001b[36m   1.03266e-05  1.03261e-05  1.03264e-05\u001b[39m\n",
       "\u001b[36m   1.46388e-11  1.40862e-11  1.39825e-11\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> fpv=zeros(2);\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> koutb=nsoli(f!,x0,fv,fpv,JVec; \u001b[39m\n",
       "\u001b[36m              fixedeta=true, eta=.1, lmaxit=2, lsolver=\"bicgstab\");\u001b[39m\n",
       "\u001b[36m  \u001b[39m\n",
       "\u001b[36m  julia> koutb.history\u001b[39m\n",
       "\u001b[36m  6-element Vector{Float64}:\u001b[39m\n",
       "\u001b[36m   1.88791e+00\u001b[39m\n",
       "\u001b[36m   2.43120e-01\u001b[39m\n",
       "\u001b[36m   1.19231e-02\u001b[39m\n",
       "\u001b[36m   4.87500e-04\u001b[39m\n",
       "\u001b[36m   7.54236e-06\u001b[39m\n",
       "\u001b[36m   3.84646e-07\u001b[39m"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "?nsoli"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.8.5",
   "language": "julia",
   "name": "julia-1.8"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}