one_variable_equations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/marlonandres3m/computational_methods/blob/master/one_variable_equations.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "SXyvF2G-w7VE"
   },
   "source": [
    "# One Variable Equations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "cx_2LAjUw7VH"
   },
   "source": [
    "Throughout this section and the next ones we shall cover the topic of solutions to one variable equations. Many different problems in physics and astronomy require the use of complex expressions, even with implicit dependence of variables. When it is necessary to solve for one of those variable, an analytical approach is not usually the best solution, because of its complexity or even because it does not exist at all. Different approaches for dealing with this comprehend series expansions and numerical solutions. Among the most widely used numerical approaches are the Bisection or Binary-search method, fixed-point iteration, Newton's methods.\n",
    "\n",
    "For further details see for example Chap. 5 of Ref. ([1](../index.ipynb#Bibliography)) or Chap. 4 of Ref. ([3](../index.ipynb#Bibliography))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sExxbMPEw7VM"
   },
   "source": [
    "- - -\n",
    "- [Bisection Method](#Bisection-Method) \n",
    "    - [Steps](#Steps-BM)\n",
    "    - [Stop condition](#Stop-condition-BM)\n",
    "    - [Error analysis](#Error-analysis-BM)\n",
    "    - [Example 1](#Example-1)\n",
    "    - [Example 2](#Example-2)\n",
    "- [Fixed-point Iteration](./one-variable-equations-fixed-point.ipynb#Fixed-point-Iteration)\n",
    "    - [Steps](./one-variable-equations-fixed-point.ipynb#Steps-FP)\n",
    "    - [Example 3](./one-variable-equations-fixed-point.ipynb#Example-3)\n",
    "    - [Stop condition](./one-variable-equations-fixed-point.ipynb#Stop-condition-FP)\n",
    "    - [Example 4](./one-variable-equations-fixed-point.ipynb#Example-4)\n",
    "    - [Activity](./one-variable-equations-fixed-point.ipynb#ACTIVITY-FP)\n",
    "- [Newton-Raphson Method](./one-variable-equations-fixed-point.ipynb#Newton-Raphson-Method)\n",
    "    - [Derivation](./one-variable-equations-fixed-point.ipynb#Derivation-NM)\n",
    "    - [Steps](./one-variable-equations-fixed-point.ipynb#Steps-NM)\n",
    "    - [Example 5](./one-variable-equations-fixed-point.ipynb#Example-5)\n",
    "    - [Stop condition](./one-variable-equations-fixed-point.ipynb#Stop-condition-NM)\n",
    "    - [Convergence](./one-variable-equations-fixed-point.ipynb#Convergence-NM)\n",
    "- [Secant Method](./one-variable-equations-fixed-point.ipynb#Secant-Method)\n",
    "    - [Derivation](./one-variable-equations-fixed-point.ipynb#Derivation-SM)\n",
    "    - [Steps](./one-variable-equations-fixed-point.ipynb#Steps-SM)\n",
    "\n",
    "- - -"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GD4z2RTZw7VN",
    "outputId": "2780c361-b150-411f-b8ac-88567710c34f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FY0-QkUnw7VS"
   },
   "source": [
    "JSAnimation import available at https://github.com/jakevdp/JSAnimation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5rHmuj6mw7VT"
   },
   "outputs": [],
   "source": [
    "from JSAnimation import IPython_display\n",
    "from matplotlib import animation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zM--Q1_nw7VX"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "from scipy import integrate\n",
    "from scipy import optimize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_45Zy-RWw7Vb"
   },
   "source": [
    "- - - "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RNEo8n--w7Vc"
   },
   "source": [
    "# Bisection Method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2ZgAUxxyw7Vf"
   },
   "source": [
    "The Bisection method exploits the [intermediate value theorem](http://en.wikipedia.org/wiki/Intermediate_value_theorem), where a continuous and differentiable function $f$ must have a zero between an interval $[a,b]$ such that $f(a)f(b)<0$, or equivalently, there must be a value $p\\in[a,b]$ such that $f(p)=0$. Below the algorithmm is stated explicitly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "tCrKSgUrw7Vh"
   },
   "source": [
    "## Steps BM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "8uRIVSQOw7Vj"
   },
   "source": [
    "<div style=\"float: right;\" markdown=\"1\">\n",
    "    <img src=\"http://upload.wikimedia.org/wikipedia/commons/thumb/8/8c/Bisection_method.svg/300px-Bisection_method.svg.png\">\n",
    "</div>\n",
    "\n",
    "\n",
    "1. There must be selected two values $a$ and $b$ such that $f(a)f(b)<0$ and $p\\in[a,b]$ where $f(p)=0$. In other words, though we do not know the value of the root, we must know that there is at least one within the selected interval.\n",
    "\n",
    "2. To begin, it must be set $a_1=a$ and $b_1=b$.\n",
    "\n",
    "3. Calculate the mid-point $p_1$ as\n",
    "\n",
    "    $$p_1 = a_1 + \\frac{b_1-a_1}{2} = \\frac{a_1+b_1}{2}$$\n",
    "\n",
    "4. Evaluate the function in $p_1$, if the [stop condition](#Stop-Condition) is true, go to step 6.\n",
    "\n",
    "5. If the [stop condition](#Stop-Condition) is not satisfied, then:\n",
    "\n",
    "    1. If $f(p_1)f(a_1) > 0$, $p\\in(p_1,b_1)$. Then set $a_2=p_1$ and $b_2=b_1$\n",
    "\n",
    "    2. If $f(p_1)f(a_1) < 0$, $p\\in(a_1,p_1)$. Then set $a_2=a_1$ and $b_2=p_1$\n",
    "\n",
    "    3. Go to step 3 using $p_2$, $a_2$ and $b_2$ instead of $p_1$, $a_1$ and $b_1$. For next iterations the index increases until the [stop condition](#Stop-Condition) is reached.\n",
    "\n",
    "6. The End!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7uoUfZn9w7Vk"
   },
   "source": [
    "## Stop condition BM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qtHv5IGIw7Vl"
   },
   "source": [
    "There are several different stop conditions for this algorithm. The most used are stated below:\n",
    "\n",
    "* A fixed distance between the last two steps (absolute convergence):\n",
    "\n",
    "    $$|p_i - p_{i-1}|<\\epsilon$$\n",
    "\n",
    "* A fixed relative distance between the last two steps (relative convergence):\n",
    "\n",
    "    $$\\frac{|p_i - p_{i-1}|}{|p_i|}<\\epsilon\\ \\ \\ \\ \\ p_i \\neq 0$$\n",
    "\n",
    "* Function tolerance:\n",
    "\n",
    "    $$f(p_i)< \\epsilon$$\n",
    "\n",
    "All these conditions should lead to a desired convergence expressed by the $\\epsilon$ value. However, the first and the third conditions present some problems when the function has a derivative very large or close to $0$ as evaluated in the root value. When the function is very inclined, the first condition fails as a convergence in the $x$ axis does not guarantee a convergence in the $y$ axis, so the found root $p$ may be far from the real value. When the function is very flat ($dF/dx\\rightarrow 0$), the third condition fails due to an analogous reason.\n",
    "\n",
    "A final stop condition that does not have mathematical motivation yet computational is a maximum number of allowed iterations. This condition should be used not only for this algorithm but for all iteration-based numerical methods. This condition guarantees a finite computing time and prevents undesired infinite bucles.\n",
    "\n",
    "* If $N>N_{max}$, stop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nBQBHO23w7Vm"
   },
   "source": [
    "## Error analysis BM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2u-a2qPOw7Vn"
   },
   "source": [
    "If we suppose $f\\in C[a,b]$ and $f(a)f(b)<0$, the Bisection method generates a sequence of numbers $\\left\\{p_i\\right\\}_{i=1}^\\infty$ approximating a root $p$ of $f$ as:\n",
    "\n",
    "$$|p_i-p|\\leq \\frac{b-a}{2^n},\\ \\ \\ \\ \\ i\\geq 1$$\n",
    "\n",
    "From this, we can conclude the convergence rate of the method is\n",
    "\n",
    "$$p_i = p + \\mathcal{O}\\left( \\frac{1}{2^i} \\right)$$\n",
    "\n",
    "This expression allows us to estimate the maximum number of required iterations for achieving a desired precision. The next figure sketches the number of iterations required for some precision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "OsQu8x8Jw7Vo"
   },
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NRO_1bQGw7Vt",
    "outputId": "1816cac5-f362-471a-ef17-40cda939e068"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=np.arange( 1, 100)\n",
    "x[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Uf5JCpRuw7Vy"
   },
   "outputs": [],
   "source": [
    "# plt.plot( x,y  ) # points joined with straight lines "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XuHIZQEVw7V1"
   },
   "outputs": [],
   "source": [
    "y=np.exp2(-x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "j02SkcI1w7V4",
    "outputId": "6845b6c1-d366-4b39-c200-612315cd0cee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f1b34b6f0b8>]"
      ]
     },
     "execution_count": 43,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD8CAYAAACMwORRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nkirIcJekCvp/ET1g3C6ukfAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f1b47045eb8>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_Eye-yOJw7V7",
    "outputId": "f83011e3-ca2f-438b-c6e7-280f27334322"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAF8CAYAAAD7BQ27AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fec3eac6f10>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "s=time.time()\n",
    "#Array of iterations\n",
    "Niter = np.arange( 1, 100 )\n",
    "\n",
    "plt.figure( figsize=(6,6) )\n",
    "#plt.semilogy( Niter, 2.0**-Niter, color=\"green\", lw = 2 )\n",
    "plt.semilogy( Niter, np.exp2(-Niter), color=\"green\", lw = 2 )\n",
    "plt.grid(True)\n",
    "plt.xlabel(\"Number of Iterations\",size=15)\n",
    "plt.ylabel(\"Absolute Error $|p_n-p|$\",size=15)\n",
    "f=time.time()-s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "pd9PwTe1w7V-"
   },
   "source": [
    "## Example 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vlEpT9Sjw7V_"
   },
   "source": [
    "Find the root of the function $f$\n",
    "\n",
    "$f(x) = x^3 - 2$\n",
    "\n",
    "for $20$ iterations, show the result and the relative error in each iteration."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GpdA20yow7WB"
   },
   "outputs": [],
   "source": [
    "#Defining Bisection function\n",
    "def Bisection( f, a, b, Nmax, printer=False ):\n",
    "    \"\"\"\n",
    "    Find the root of function f between a and b\n",
    "    \n",
    "    f: function\n",
    "    a,b: the initial interval\n",
    "    Nmax: Nmax de interations\n",
    "    printer: bool, to print internal steps\n",
    "    \"\"\"\n",
    "    #verifying the STEP1, a and b with different signs\n",
    "    import sys\n",
    "    if f(a)*f(b)>0:\n",
    "        sys.exit(\"Error, f(a) and f(b) should have opposite signs\")\n",
    "        return False\n",
    "    #Assigning the current extreme values, STEP2\n",
    "    ai = a\n",
    "    bi = b\n",
    "    #Iterations\n",
    "    n = 1\n",
    "    while n<=Nmax:\n",
    "        #Bisection, STEP3\n",
    "        pi = (ai+bi)/2.0\n",
    "        #Evaluating function in pi, STEP4 and STEP5\n",
    "        if printer:\n",
    "            print( \"Value for {} iterations: {}\".format(n,pi) )\n",
    "        #Condition A\n",
    "        if f(pi)*f(ai)>0:\n",
    "            ai = pi\n",
    "        #Condition B\n",
    "        elif f(pi)*f(ai)<0:\n",
    "            bi = pi\n",
    "        #Condition C: repeat the cycle\n",
    "        n+=1\n",
    "    #Final result\n",
    "    return pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qEJf2IVuw7WG"
   },
   "outputs": [],
   "source": [
    "Bisection?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z1XWelBgw7WJ"
   },
   "source": [
    "Defining function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0Vd7ahTbw7WK"
   },
   "outputs": [],
   "source": [
    "def function(x):\n",
    "    return x**3.0 - 2.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Cy9OT7XDw7WN"
   },
   "source": [
    "Finding the root of the function. The real root is $\\sqrt[3]{2}$, so `a` and `b` should enclose this value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pvl1fZSKw7WO",
    "outputId": "e8accba7-9299-4533-c81c-5be42aeb1869"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value for 1 iterations: 1.0\n",
      "Value for 2 iterations: 1.5\n",
      "Value for 3 iterations: 1.25\n",
      "Value for 4 iterations: 1.375\n",
      "Value for 5 iterations: 1.3125\n",
      "Value for 6 iterations: 1.28125\n",
      "Value for 7 iterations: 1.265625\n",
      "Value for 8 iterations: 1.2578125\n",
      "Value for 9 iterations: 1.26171875\n",
      "Value for 10 iterations: 1.259765625\n",
      "Value for 11 iterations: 1.2607421875\n",
      "Value for 12 iterations: 1.26025390625\n",
      "Value for 13 iterations: 1.260009765625\n",
      "Value for 14 iterations: 1.2598876953125\n",
      "Value for 15 iterations: 1.25994873046875\n",
      "Value for 16 iterations: 1.259918212890625\n",
      "Value for 17 iterations: 1.2599334716796875\n",
      "Value for 18 iterations: 1.2599258422851562\n",
      "Value for 19 iterations: 1.2599220275878906\n",
      "Value for 20 iterations: 1.2599201202392578\n",
      "Real value: 1.2599210498948732\n",
      "Absolute error 9.296556153781665e-07\n"
     ]
    }
   ],
   "source": [
    "#Defining a and b\n",
    "a = 0.0\n",
    "b = 2.0\n",
    "Nmax = 20\n",
    "result = Bisection(function, a, b, Nmax, printer=True)\n",
    "print ( \"Real value:\", 2**(1/3.0))\n",
    "print ( \"Absolute error\", abs((2**(1/3.0)-result)) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "CmP1u-lPw7WQ"
   },
   "source": [
    "Using the error analysis, we can predict the produced error at $20$ iterations by computing:\n",
    "\n",
    "$$ \\left( \\frac{1}{2^{20}}\\right) \\approx 9.53674316\\times 10^{-7} $$\n",
    "\n",
    "This value is very close to the obtained relative error.\n",
    "\n",
    "If we were interested in a double precision, i.e. $\\epsilon \\sim 10^{-17}$, the number of required iterations would be:\n",
    "\n",
    "$$ 10^{-17} = \\left( \\frac{1}{2^{N}}\\right) \\longrightarrow N = \\frac{17}{\\log_{10}(2)} \\approx 56 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "p2lZUHGSw7WR"
   },
   "source": [
    "Now the same but using scipy implementation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "LKwXO9vfw7WS"
   },
   "outputs": [],
   "source": [
    "from scipy import optimize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "x92AU0K6w7WV"
   },
   "source": [
    "Instead of optimize?:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "collapsed": true,
    "id": "i8AmYwH0w7WW",
    "jupyter": {
     "outputs_hidden": true,
     "source_hidden": true
    },
    "outputId": "9fcfb5b9-a531-45a7-9989-6fc992158ff9"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on package scipy.optimize in scipy:\n",
      "\n",
      "NAME\n",
      "    scipy.optimize\n",
      "\n",
      "DESCRIPTION\n",
      "    =====================================================\n",
      "    Optimization and root finding (:mod:`scipy.optimize`)\n",
      "    =====================================================\n",
      "    \n",
      "    .. currentmodule:: scipy.optimize\n",
      "    \n",
      "    Optimization\n",
      "    ============\n",
      "    \n",
      "    Local Optimization\n",
      "    ------------------\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       minimize - Unified interface for minimizers of multivariate functions\n",
      "       minimize_scalar - Unified interface for minimizers of univariate functions\n",
      "       OptimizeResult - The optimization result returned by some optimizers\n",
      "       OptimizeWarning - The optimization encountered problems\n",
      "    \n",
      "    The `minimize` function supports the following methods:\n",
      "    \n",
      "    .. toctree::\n",
      "    \n",
      "       optimize.minimize-neldermead\n",
      "       optimize.minimize-powell\n",
      "       optimize.minimize-cg\n",
      "       optimize.minimize-bfgs\n",
      "       optimize.minimize-newtoncg\n",
      "       optimize.minimize-lbfgsb\n",
      "       optimize.minimize-tnc\n",
      "       optimize.minimize-cobyla\n",
      "       optimize.minimize-slsqp\n",
      "       optimize.minimize-dogleg\n",
      "       optimize.minimize-trustncg\n",
      "    \n",
      "    The `minimize_scalar` function supports the following methods:\n",
      "    \n",
      "    .. toctree::\n",
      "    \n",
      "       optimize.minimize_scalar-brent\n",
      "       optimize.minimize_scalar-bounded\n",
      "       optimize.minimize_scalar-golden\n",
      "    \n",
      "    The specific optimization method interfaces below in this subsection are\n",
      "    not recommended for use in new scripts; all of these methods are accessible\n",
      "    via a newer, more consistent interface provided by the functions above.\n",
      "    \n",
      "    General-purpose multivariate methods:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       fmin - Nelder-Mead Simplex algorithm\n",
      "       fmin_powell - Powell's (modified) level set method\n",
      "       fmin_cg - Non-linear (Polak-Ribiere) conjugate gradient algorithm\n",
      "       fmin_bfgs - Quasi-Newton method (Broydon-Fletcher-Goldfarb-Shanno)\n",
      "       fmin_ncg - Line-search Newton Conjugate Gradient\n",
      "    \n",
      "    Constrained multivariate methods:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       fmin_l_bfgs_b - Zhu, Byrd, and Nocedal's constrained optimizer\n",
      "       fmin_tnc - Truncated Newton code\n",
      "       fmin_cobyla - Constrained optimization by linear approximation\n",
      "       fmin_slsqp - Minimization using sequential least-squares programming\n",
      "       differential_evolution - stochastic minimization using differential evolution\n",
      "    \n",
      "    Univariate (scalar) minimization methods:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       fminbound - Bounded minimization of a scalar function\n",
      "       brent - 1-D function minimization using Brent method\n",
      "       golden - 1-D function minimization using Golden Section method\n",
      "    \n",
      "    Equation (Local) Minimizers\n",
      "    ---------------------------\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "       \n",
      "       leastsq - Minimize the sum of squares of M equations in N unknowns\n",
      "       least_squares - Feature-rich least-squares minimization.\n",
      "       nnls - Linear least-squares problem with non-negativity constraint\n",
      "       lsq_linear - Linear least-squares problem with bound constraints\n",
      "    \n",
      "    Global Optimization\n",
      "    -------------------\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       basinhopping - Basinhopping stochastic optimizer\n",
      "       brute - Brute force searching optimizer\n",
      "       differential_evolution - stochastic minimization using differential evolution\n",
      "    \n",
      "    Rosenbrock function\n",
      "    -------------------\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       rosen - The Rosenbrock function.\n",
      "       rosen_der - The derivative of the Rosenbrock function.\n",
      "       rosen_hess - The Hessian matrix of the Rosenbrock function.\n",
      "       rosen_hess_prod - Product of the Rosenbrock Hessian with a vector.\n",
      "    \n",
      "    Fitting\n",
      "    =======\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       curve_fit -- Fit curve to a set of points\n",
      "    \n",
      "    Root finding\n",
      "    ============\n",
      "    \n",
      "    Scalar functions\n",
      "    ----------------\n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       brentq - quadratic interpolation Brent method\n",
      "       brenth - Brent method, modified by Harris with hyperbolic extrapolation\n",
      "       ridder - Ridder's method\n",
      "       bisect - Bisection method\n",
      "       newton - Secant method or Newton's method\n",
      "    \n",
      "    Fixed point finding:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       fixed_point - Single-variable fixed-point solver\n",
      "    \n",
      "    Multidimensional\n",
      "    ----------------\n",
      "    \n",
      "    General nonlinear solvers:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       root - Unified interface for nonlinear solvers of multivariate functions\n",
      "       fsolve - Non-linear multi-variable equation solver\n",
      "       broyden1 - Broyden's first method\n",
      "       broyden2 - Broyden's second method\n",
      "    \n",
      "    The `root` function supports the following methods:\n",
      "    \n",
      "    .. toctree::\n",
      "    \n",
      "       optimize.root-hybr\n",
      "       optimize.root-lm\n",
      "       optimize.root-broyden1\n",
      "       optimize.root-broyden2\n",
      "       optimize.root-anderson\n",
      "       optimize.root-linearmixing\n",
      "       optimize.root-diagbroyden\n",
      "       optimize.root-excitingmixing\n",
      "       optimize.root-krylov\n",
      "       optimize.root-dfsane\n",
      "    \n",
      "    Large-scale nonlinear solvers:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       newton_krylov\n",
      "       anderson\n",
      "    \n",
      "    Simple iterations:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       excitingmixing\n",
      "       linearmixing\n",
      "       diagbroyden\n",
      "    \n",
      "    :mod:`Additional information on the nonlinear solvers <scipy.optimize.nonlin>`\n",
      "    \n",
      "    Linear Programming\n",
      "    ==================\n",
      "    \n",
      "    Simplex Algorithm:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       linprog -- Linear programming using the simplex algorithm\n",
      "       linprog_verbose_callback -- Sample callback function for linprog\n",
      "    \n",
      "    The `linprog` function supports the following methods:\n",
      "    \n",
      "    .. toctree::\n",
      "    \n",
      "       optimize.linprog-simplex\n",
      "    \n",
      "    Assignment problems:\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       linear_sum_assignment -- Solves the linear-sum assignment problem\n",
      "    \n",
      "    \n",
      "    Utilities\n",
      "    =========\n",
      "    \n",
      "    .. autosummary::\n",
      "       :toctree: generated/\n",
      "    \n",
      "       approx_fprime - Approximate the gradient of a scalar function\n",
      "       bracket - Bracket a minimum, given two starting points\n",
      "       check_grad - Check the supplied derivative using finite differences\n",
      "       line_search - Return a step that satisfies the strong Wolfe conditions\n",
      "    \n",
      "       show_options - Show specific options optimization solvers\n",
      "       LbfgsInvHessProduct - Linear operator for L-BFGS approximate inverse Hessian\n",
      "\n",
      "PACKAGE CONTENTS\n",
      "    _basinhopping\n",
      "    _cobyla\n",
      "    _differentialevolution\n",
      "    _group_columns\n",
      "    _hungarian\n",
      "    _lbfgsb\n",
      "    _linprog\n",
      "    _lsq (package)\n",
      "    _minimize\n",
      "    _minpack\n",
      "    _nnls\n",
      "    _numdiff\n",
      "    _root\n",
      "    _slsqp\n",
      "    _spectral\n",
      "    _trustregion\n",
      "    _trustregion_dogleg\n",
      "    _trustregion_ncg\n",
      "    _tstutils\n",
      "    _zeros\n",
      "    cobyla\n",
      "    lbfgsb\n",
      "    linesearch\n",
      "    minpack\n",
      "    minpack2\n",
      "    moduleTNC\n",
      "    nnls\n",
      "    nonlin\n",
      "    optimize\n",
      "    setup\n",
      "    slsqp\n",
      "    tnc\n",
      "    zeros\n",
      "\n",
      "CLASSES\n",
      "    builtins.UserWarning(builtins.Warning)\n",
      "        scipy.optimize.optimize.OptimizeWarning\n",
      "    builtins.dict(builtins.object)\n",
      "        scipy.optimize.optimize.OptimizeResult\n",
      "    scipy.sparse.linalg.interface.LinearOperator(builtins.object)\n",
      "        scipy.optimize.lbfgsb.LbfgsInvHessProduct\n",
      "    \n",
      "    class LbfgsInvHessProduct(scipy.sparse.linalg.interface.LinearOperator)\n",
      "     |  Linear operator for the L-BFGS approximate inverse Hessian.\n",
      "     |  \n",
      "     |  This operator computes the product of a vector with the approximate inverse\n",
      "     |  of the Hessian of the objective function, using the L-BFGS limited\n",
      "     |  memory approximation to the inverse Hessian, accumulated during the\n",
      "     |  optimization.\n",
      "     |  \n",
      "     |  Objects of this class implement the ``scipy.sparse.linalg.LinearOperator``\n",
      "     |  interface.\n",
      "     |  \n",
      "     |  Parameters\n",
      "     |  ----------\n",
      "     |  sk : array_like, shape=(n_corr, n)\n",
      "     |      Array of `n_corr` most recent updates to the solution vector.\n",
      "     |      (See [1]).\n",
      "     |  yk : array_like, shape=(n_corr, n)\n",
      "     |      Array of `n_corr` most recent updates to the gradient. (See [1]).\n",
      "     |  \n",
      "     |  References\n",
      "     |  ----------\n",
      "     |  .. [1] Nocedal, Jorge. \"Updating quasi-Newton matrices with limited\n",
      "     |     storage.\" Mathematics of computation 35.151 (1980): 773-782.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      LbfgsInvHessProduct\n",
      "     |      scipy.sparse.linalg.interface.LinearOperator\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, sk, yk)\n",
      "     |      Construct the operator.\n",
      "     |  \n",
      "     |  todense(self)\n",
      "     |      Return a dense array representation of this operator.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      arr : ndarray, shape=(n, n)\n",
      "     |          An array with the same shape and containing\n",
      "     |          the same data represented by this `LinearOperator`.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from scipy.sparse.linalg.interface.LinearOperator:\n",
      "     |  \n",
      "     |  __add__(self, x)\n",
      "     |  \n",
      "     |  __call__(self, x)\n",
      "     |  \n",
      "     |  __matmul__(self, other)\n",
      "     |  \n",
      "     |  __mul__(self, x)\n",
      "     |  \n",
      "     |  __neg__(self)\n",
      "     |  \n",
      "     |  __pow__(self, p)\n",
      "     |  \n",
      "     |  __repr__(self)\n",
      "     |  \n",
      "     |  __rmatmul__(self, other)\n",
      "     |  \n",
      "     |  __rmul__(self, x)\n",
      "     |  \n",
      "     |  __sub__(self, x)\n",
      "     |  \n",
      "     |  adjoint(self)\n",
      "     |      Hermitian adjoint.\n",
      "     |      \n",
      "     |      Returns the Hermitian adjoint of self, aka the Hermitian\n",
      "     |      conjugate or Hermitian transpose. For a complex matrix, the\n",
      "     |      Hermitian adjoint is equal to the conjugate transpose.\n",
      "     |      \n",
      "     |      Can be abbreviated self.H instead of self.adjoint().\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      A_H : LinearOperator\n",
      "     |          Hermitian adjoint of self.\n",
      "     |  \n",
      "     |  dot(self, x)\n",
      "     |      Matrix-matrix or matrix-vector multiplication.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : array_like\n",
      "     |          1-d or 2-d array, representing a vector or matrix.\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      Ax : array\n",
      "     |          1-d or 2-d array (depending on the shape of x) that represents\n",
      "     |          the result of applying this linear operator on x.\n",
      "     |  \n",
      "     |  matmat(self, X)\n",
      "     |      Matrix-matrix multiplication.\n",
      "     |      \n",
      "     |      Performs the operation y=A*X where A is an MxN linear\n",
      "     |      operator and X dense N*K matrix or ndarray.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      X : {matrix, ndarray}\n",
      "     |          An array with shape (N,K).\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      Y : {matrix, ndarray}\n",
      "     |          A matrix or ndarray with shape (M,K) depending on\n",
      "     |          the type of the X argument.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This matmat wraps any user-specified matmat routine or overridden\n",
      "     |      _matmat method to ensure that y has the correct type.\n",
      "     |  \n",
      "     |  matvec(self, x)\n",
      "     |      Matrix-vector multiplication.\n",
      "     |      \n",
      "     |      Performs the operation y=A*x where A is an MxN linear\n",
      "     |      operator and x is a column vector or 1-d array.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : {matrix, ndarray}\n",
      "     |          An array with shape (N,) or (N,1).\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      y : {matrix, ndarray}\n",
      "     |          A matrix or ndarray with shape (M,) or (M,1) depending\n",
      "     |          on the type and shape of the x argument.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This matvec wraps the user-specified matvec routine or overridden\n",
      "     |      _matvec method to ensure that y has the correct shape and type.\n",
      "     |  \n",
      "     |  rmatvec(self, x)\n",
      "     |      Adjoint matrix-vector multiplication.\n",
      "     |      \n",
      "     |      Performs the operation y = A^H * x where A is an MxN linear\n",
      "     |      operator and x is a column vector or 1-d array.\n",
      "     |      \n",
      "     |      Parameters\n",
      "     |      ----------\n",
      "     |      x : {matrix, ndarray}\n",
      "     |          An array with shape (M,) or (M,1).\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      y : {matrix, ndarray}\n",
      "     |          A matrix or ndarray with shape (N,) or (N,1) depending\n",
      "     |          on the type and shape of the x argument.\n",
      "     |      \n",
      "     |      Notes\n",
      "     |      -----\n",
      "     |      This rmatvec wraps the user-specified rmatvec routine or overridden\n",
      "     |      _rmatvec method to ensure that y has the correct shape and type.\n",
      "     |  \n",
      "     |  transpose(self)\n",
      "     |      Transpose this linear operator.\n",
      "     |      \n",
      "     |      Returns a LinearOperator that represents the transpose of this one.\n",
      "     |      Can be abbreviated self.T instead of self.transpose().\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from scipy.sparse.linalg.interface.LinearOperator:\n",
      "     |  \n",
      "     |  __new__(cls, *args, **kwargs)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from scipy.sparse.linalg.interface.LinearOperator:\n",
      "     |  \n",
      "     |  H\n",
      "     |      Hermitian adjoint.\n",
      "     |      \n",
      "     |      Returns the Hermitian adjoint of self, aka the Hermitian\n",
      "     |      conjugate or Hermitian transpose. For a complex matrix, the\n",
      "     |      Hermitian adjoint is equal to the conjugate transpose.\n",
      "     |      \n",
      "     |      Can be abbreviated self.H instead of self.adjoint().\n",
      "     |      \n",
      "     |      Returns\n",
      "     |      -------\n",
      "     |      A_H : LinearOperator\n",
      "     |          Hermitian adjoint of self.\n",
      "     |  \n",
      "     |  T\n",
      "     |      Transpose this linear operator.\n",
      "     |      \n",
      "     |      Returns a LinearOperator that represents the transpose of this one.\n",
      "     |      Can be abbreviated self.T instead of self.transpose().\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "    \n",
      "    class OptimizeResult(builtins.dict)\n",
      "     |  Represents the optimization result.\n",
      "     |  \n",
      "     |  Attributes\n",
      "     |  ----------\n",
      "     |  x : ndarray\n",
      "     |      The solution of the optimization.\n",
      "     |  success : bool\n",
      "     |      Whether or not the optimizer exited successfully.\n",
      "     |  status : int\n",
      "     |      Termination status of the optimizer. Its value depends on the\n",
      "     |      underlying solver. Refer to `message` for details.\n",
      "     |  message : str\n",
      "     |      Description of the cause of the termination.\n",
      "     |  fun, jac, hess: ndarray\n",
      "     |      Values of objective function, its Jacobian and its Hessian (if\n",
      "     |      available). The Hessians may be approximations, see the documentation\n",
      "     |      of the function in question.\n",
      "     |  hess_inv : object\n",
      "     |      Inverse of the objective function's Hessian; may be an approximation.\n",
      "     |      Not available for all solvers. The type of this attribute may be\n",
      "     |      either np.ndarray or scipy.sparse.linalg.LinearOperator.\n",
      "     |  nfev, njev, nhev : int\n",
      "     |      Number of evaluations of the objective functions and of its\n",
      "     |      Jacobian and Hessian.\n",
      "     |  nit : int\n",
      "     |      Number of iterations performed by the optimizer.\n",
      "     |  maxcv : float\n",
      "     |      The maximum constraint violation.\n",
      "     |  \n",
      "     |  Notes\n",
      "     |  -----\n",
      "     |  There may be additional attributes not listed above depending of the\n",
      "     |  specific solver. Since this class is essentially a subclass of dict\n",
      "     |  with attribute accessors, one can see which attributes are available\n",
      "     |  using the `keys()` method.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      OptimizeResult\n",
      "     |      builtins.dict\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __delattr__ = __delitem__(self, key, /)\n",
      "     |      Delete self[key].\n",
      "     |  \n",
      "     |  __dir__(self)\n",
      "     |  \n",
      "     |  __getattr__(self, name)\n",
      "     |  \n",
      "     |  __repr__(self)\n",
      "     |  \n",
      "     |  __setattr__ = __setitem__(self, key, value, /)\n",
      "     |      Set self[key] to value.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.dict:\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      True if D has a key k, else False.\n",
      "     |  \n",
      "     |  __delitem__(self, key, /)\n",
      "     |      Delete self[key].\n",
      "     |  \n",
      "     |  __eq__(self, value, /)\n",
      "     |      Return self==value.\n",
      "     |  \n",
      "     |  __ge__(self, value, /)\n",
      "     |      Return self>=value.\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __getitem__(...)\n",
      "     |      x.__getitem__(y) <==> x[y]\n",
      "     |  \n",
      "     |  __gt__(self, value, /)\n",
      "     |      Return self>value.\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __iter__(self, /)\n",
      "     |      Implement iter(self).\n",
      "     |  \n",
      "     |  __le__(self, value, /)\n",
      "     |      Return self<=value.\n",
      "     |  \n",
      "     |  __len__(self, /)\n",
      "     |      Return len(self).\n",
      "     |  \n",
      "     |  __lt__(self, value, /)\n",
      "     |      Return self<value.\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __setitem__(self, key, value, /)\n",
      "     |      Set self[key] to value.\n",
      "     |  \n",
      "     |  __sizeof__(...)\n",
      "     |      D.__sizeof__() -> size of D in memory, in bytes\n",
      "     |  \n",
      "     |  clear(...)\n",
      "     |      D.clear() -> None.  Remove all items from D.\n",
      "     |  \n",
      "     |  copy(...)\n",
      "     |      D.copy() -> a shallow copy of D\n",
      "     |  \n",
      "     |  fromkeys(iterable, value=None, /) from builtins.type\n",
      "     |      Returns a new dict with keys from iterable and values equal to value.\n",
      "     |  \n",
      "     |  get(...)\n",
      "     |      D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None.\n",
      "     |  \n",
      "     |  items(...)\n",
      "     |      D.items() -> a set-like object providing a view on D's items\n",
      "     |  \n",
      "     |  keys(...)\n",
      "     |      D.keys() -> a set-like object providing a view on D's keys\n",
      "     |  \n",
      "     |  pop(...)\n",
      "     |      D.pop(k[,d]) -> v, remove specified key and return the corresponding value.\n",
      "     |      If key is not found, d is returned if given, otherwise KeyError is raised\n",
      "     |  \n",
      "     |  popitem(...)\n",
      "     |      D.popitem() -> (k, v), remove and return some (key, value) pair as a\n",
      "     |      2-tuple; but raise KeyError if D is empty.\n",
      "     |  \n",
      "     |  setdefault(...)\n",
      "     |      D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D\n",
      "     |  \n",
      "     |  update(...)\n",
      "     |      D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.\n",
      "     |      If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]\n",
      "     |      If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v\n",
      "     |      In either case, this is followed by: for k in F:  D[k] = F[k]\n",
      "     |  \n",
      "     |  values(...)\n",
      "     |      D.values() -> an object providing a view on D's values\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from builtins.dict:\n",
      "     |  \n",
      "     |  __hash__ = None\n",
      "    \n",
      "    class OptimizeWarning(builtins.UserWarning)\n",
      "     |  Method resolution order:\n",
      "     |      OptimizeWarning\n",
      "     |      builtins.UserWarning\n",
      "     |      builtins.Warning\n",
      "     |      builtins.Exception\n",
      "     |      builtins.BaseException\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.UserWarning:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.BaseException:\n",
      "     |  \n",
      "     |  __delattr__(self, name, /)\n",
      "     |      Implement delattr(self, name).\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setattr__(self, name, value, /)\n",
      "     |      Implement setattr(self, name, value).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  with_traceback(...)\n",
      "     |      Exception.with_traceback(tb) --\n",
      "     |      set self.__traceback__ to tb and return self.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from builtins.BaseException:\n",
      "     |  \n",
      "     |  __cause__\n",
      "     |      exception cause\n",
      "     |  \n",
      "     |  __context__\n",
      "     |      exception context\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |  \n",
      "     |  __suppress_context__\n",
      "     |  \n",
      "     |  __traceback__\n",
      "     |  \n",
      "     |  args\n",
      "\n",
      "FUNCTIONS\n",
      "    anderson(F, xin, iter=None, alpha=None, w0=0.01, M=5, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using (extended) Anderson mixing.\n",
      "        \n",
      "        The Jacobian is formed by for a 'best' solution in the space\n",
      "        spanned by last `M` vectors. As a result, only a MxM matrix\n",
      "        inversions and MxN multiplications are required. [Ey]_\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        alpha : float, optional\n",
      "            Initial guess for the Jacobian is (-1/alpha).\n",
      "        M : float, optional\n",
      "            Number of previous vectors to retain. Defaults to 5.\n",
      "        w0 : float, optional\n",
      "            Regularization parameter for numerical stability.\n",
      "            Compared to unity, good values of the order of 0.01.\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [Ey] V. Eyert, J. Comp. Phys., 124, 271 (1996).\n",
      "    \n",
      "    approx_fprime(xk, f, epsilon, *args)\n",
      "        Finite-difference approximation of the gradient of a scalar function.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xk : array_like\n",
      "            The coordinate vector at which to determine the gradient of `f`.\n",
      "        f : callable\n",
      "            The function of which to determine the gradient (partial derivatives).\n",
      "            Should take `xk` as first argument, other arguments to `f` can be\n",
      "            supplied in ``*args``.  Should return a scalar, the value of the\n",
      "            function at `xk`.\n",
      "        epsilon : array_like\n",
      "            Increment to `xk` to use for determining the function gradient.\n",
      "            If a scalar, uses the same finite difference delta for all partial\n",
      "            derivatives.  If an array, should contain one value per element of\n",
      "            `xk`.\n",
      "        \\*args : args, optional\n",
      "            Any other arguments that are to be passed to `f`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        grad : ndarray\n",
      "            The partial derivatives of `f` to `xk`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        check_grad : Check correctness of gradient function against approx_fprime.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The function gradient is determined by the forward finite difference\n",
      "        formula::\n",
      "        \n",
      "                     f(xk[i] + epsilon[i]) - f(xk[i])\n",
      "            f'[i] = ---------------------------------\n",
      "                                epsilon[i]\n",
      "        \n",
      "        The main use of `approx_fprime` is in scalar function optimizers like\n",
      "        `fmin_bfgs`, to determine numerically the Jacobian of a function.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from scipy import optimize\n",
      "        >>> def func(x, c0, c1):\n",
      "        ...     \"Coordinate vector `x` should be an array of size two.\"\n",
      "        ...     return c0 * x[0]**2 + c1*x[1]**2\n",
      "        \n",
      "        >>> x = np.ones(2)\n",
      "        >>> c0, c1 = (1, 200)\n",
      "        >>> eps = np.sqrt(np.finfo(float).eps)\n",
      "        >>> optimize.approx_fprime(x, func, [eps, np.sqrt(200) * eps], c0, c1)\n",
      "        array([   2.        ,  400.00004198])\n",
      "    \n",
      "    basinhopping(func, x0, niter=100, T=1.0, stepsize=0.5, minimizer_kwargs=None, take_step=None, accept_test=None, callback=None, interval=50, disp=False, niter_success=None)\n",
      "        Find the global minimum of a function using the basin-hopping algorithm\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable ``f(x, *args)``\n",
      "            Function to be optimized.  ``args`` can be passed as an optional item\n",
      "            in the dict ``minimizer_kwargs``\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        niter : integer, optional\n",
      "            The number of basin hopping iterations\n",
      "        T : float, optional\n",
      "            The \"temperature\" parameter for the accept or reject criterion.  Higher\n",
      "            \"temperatures\" mean that larger jumps in function value will be\n",
      "            accepted.  For best results ``T`` should be comparable to the\n",
      "            separation\n",
      "            (in function value) between local minima.\n",
      "        stepsize : float, optional\n",
      "            initial step size for use in the random displacement.\n",
      "        minimizer_kwargs : dict, optional\n",
      "            Extra keyword arguments to be passed to the minimizer\n",
      "            ``scipy.optimize.minimize()`` Some important options could be:\n",
      "        \n",
      "                method : str\n",
      "                    The minimization method (e.g. ``\"L-BFGS-B\"``)\n",
      "                args : tuple\n",
      "                    Extra arguments passed to the objective function (``func``) and\n",
      "                    its derivatives (Jacobian, Hessian).\n",
      "        \n",
      "        take_step : callable ``take_step(x)``, optional\n",
      "            Replace the default step taking routine with this routine.  The default\n",
      "            step taking routine is a random displacement of the coordinates, but\n",
      "            other step taking algorithms may be better for some systems.\n",
      "            ``take_step`` can optionally have the attribute ``take_step.stepsize``.\n",
      "            If this attribute exists, then ``basinhopping`` will adjust\n",
      "            ``take_step.stepsize`` in order to try to optimize the global minimum\n",
      "            search.\n",
      "        accept_test : callable, ``accept_test(f_new=f_new, x_new=x_new, f_old=fold, x_old=x_old)``, optional\n",
      "            Define a test which will be used to judge whether or not to accept the\n",
      "            step.  This will be used in addition to the Metropolis test based on\n",
      "            \"temperature\" ``T``.  The acceptable return values are True,\n",
      "            False, or ``\"force accept\"``. If any of the tests return False\n",
      "            then the step is rejected. If the latter, then this will override any\n",
      "            other tests in order to accept the step. This can be used, for example,\n",
      "            to forcefully escape from a local minimum that ``basinhopping`` is\n",
      "            trapped in.\n",
      "        callback : callable, ``callback(x, f, accept)``, optional\n",
      "            A callback function which will be called for all minima found.  ``x``\n",
      "            and ``f`` are the coordinates and function value of the trial minimum,\n",
      "            and ``accept`` is whether or not that minimum was accepted.  This can be\n",
      "            used, for example, to save the lowest N minima found.  Also,\n",
      "            ``callback`` can be used to specify a user defined stop criterion by\n",
      "            optionally returning True to stop the ``basinhopping`` routine.\n",
      "        interval : integer, optional\n",
      "            interval for how often to update the ``stepsize``\n",
      "        disp : bool, optional\n",
      "            Set to True to print status messages\n",
      "        niter_success : integer, optional\n",
      "            Stop the run if the global minimum candidate remains the same for this\n",
      "            number of iterations.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        res : OptimizeResult\n",
      "            The optimization result represented as a ``OptimizeResult`` object.  Important\n",
      "            attributes are: ``x`` the solution array, ``fun`` the value of the\n",
      "            function at the solution, and ``message`` which describes the cause of\n",
      "            the termination. The ``OptimzeResult`` object returned by the selected\n",
      "            minimizer at the lowest minimum is also contained within this object\n",
      "            and can be accessed through the ``lowest_optimization_result`` attribute.\n",
      "            See `OptimizeResult` for a description of other attributes.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        minimize :\n",
      "            The local minimization function called once for each basinhopping step.\n",
      "            ``minimizer_kwargs`` is passed to this routine.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Basin-hopping is a stochastic algorithm which attempts to find the global\n",
      "        minimum of a smooth scalar function of one or more variables [1]_ [2]_ [3]_\n",
      "        [4]_.  The algorithm in its current form was described by David Wales and\n",
      "        Jonathan Doye [2]_ http://www-wales.ch.cam.ac.uk/.\n",
      "        \n",
      "        The algorithm is iterative with each cycle composed of the following\n",
      "        features\n",
      "        \n",
      "        1) random perturbation of the coordinates\n",
      "        \n",
      "        2) local minimization\n",
      "        \n",
      "        3) accept or reject the new coordinates based on the minimized function\n",
      "           value\n",
      "        \n",
      "        The acceptance test used here is the Metropolis criterion of standard Monte\n",
      "        Carlo algorithms, although there are many other possibilities [3]_.\n",
      "        \n",
      "        This global minimization method has been shown to be extremely efficient\n",
      "        for a wide variety of problems in physics and chemistry.  It is\n",
      "        particularly useful when the function has many minima separated by large\n",
      "        barriers. See the Cambridge Cluster Database\n",
      "        http://www-wales.ch.cam.ac.uk/CCD.html for databases of molecular systems\n",
      "        that have been optimized primarily using basin-hopping.  This database\n",
      "        includes minimization problems exceeding 300 degrees of freedom.\n",
      "        \n",
      "        See the free software program GMIN (http://www-wales.ch.cam.ac.uk/GMIN) for\n",
      "        a Fortran implementation of basin-hopping.  This implementation has many\n",
      "        different variations of the procedure described above, including more\n",
      "        advanced step taking algorithms and alternate acceptance criterion.\n",
      "        \n",
      "        For stochastic global optimization there is no way to determine if the true\n",
      "        global minimum has actually been found. Instead, as a consistency check,\n",
      "        the algorithm can be run from a number of different random starting points\n",
      "        to ensure the lowest minimum found in each example has converged to the\n",
      "        global minimum.  For this reason ``basinhopping`` will by default simply\n",
      "        run for the number of iterations ``niter`` and return the lowest minimum\n",
      "        found.  It is left to the user to ensure that this is in fact the global\n",
      "        minimum.\n",
      "        \n",
      "        Choosing ``stepsize``:  This is a crucial parameter in ``basinhopping`` and\n",
      "        depends on the problem being solved.  Ideally it should be comparable to\n",
      "        the typical separation between local minima of the function being\n",
      "        optimized.  ``basinhopping`` will, by default, adjust ``stepsize`` to find\n",
      "        an optimal value, but this may take many iterations.  You will get quicker\n",
      "        results if you set a sensible value for ``stepsize``.\n",
      "        \n",
      "        Choosing ``T``: The parameter ``T`` is the temperature used in the\n",
      "        metropolis criterion.  Basinhopping steps are accepted with probability\n",
      "        ``1`` if ``func(xnew) < func(xold)``, or otherwise with probability::\n",
      "        \n",
      "            exp( -(func(xnew) - func(xold)) / T )\n",
      "        \n",
      "        So, for best results, ``T`` should to be comparable to the typical\n",
      "        difference in function values between local minima.\n",
      "        \n",
      "        .. versionadded:: 0.12.0\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wales, David J. 2003, Energy Landscapes, Cambridge University Press,\n",
      "            Cambridge, UK.\n",
      "        .. [2] Wales, D J, and Doye J P K, Global Optimization by Basin-Hopping and\n",
      "            the Lowest Energy Structures of Lennard-Jones Clusters Containing up to\n",
      "            110 Atoms.  Journal of Physical Chemistry A, 1997, 101, 5111.\n",
      "        .. [3] Li, Z. and Scheraga, H. A., Monte Carlo-minimization approach to the\n",
      "            multiple-minima problem in protein folding, Proc. Natl. Acad. Sci. USA,\n",
      "            1987, 84, 6611.\n",
      "        .. [4] Wales, D. J. and Scheraga, H. A., Global optimization of clusters,\n",
      "            crystals, and biomolecules, Science, 1999, 285, 1368.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The following example is a one-dimensional minimization problem,  with many\n",
      "        local minima superimposed on a parabola.\n",
      "        \n",
      "        >>> from scipy.optimize import basinhopping\n",
      "        >>> func = lambda x: np.cos(14.5 * x - 0.3) + (x + 0.2) * x\n",
      "        >>> x0=[1.]\n",
      "        \n",
      "        Basinhopping, internally, uses a local minimization algorithm.  We will use\n",
      "        the parameter ``minimizer_kwargs`` to tell basinhopping which algorithm to\n",
      "        use and how to set up that minimizer.  This parameter will be passed to\n",
      "        ``scipy.optimize.minimize()``.\n",
      "        \n",
      "        >>> minimizer_kwargs = {\"method\": \"BFGS\"}\n",
      "        >>> ret = basinhopping(func, x0, minimizer_kwargs=minimizer_kwargs,\n",
      "        ...                    niter=200)\n",
      "        >>> print(\"global minimum: x = %.4f, f(x0) = %.4f\" % (ret.x, ret.fun))\n",
      "        global minimum: x = -0.1951, f(x0) = -1.0009\n",
      "        \n",
      "        Next consider a two-dimensional minimization problem. Also, this time we\n",
      "        will use gradient information to significantly speed up the search.\n",
      "        \n",
      "        >>> def func2d(x):\n",
      "        ...     f = np.cos(14.5 * x[0] - 0.3) + (x[1] + 0.2) * x[1] + (x[0] +\n",
      "        ...                                                            0.2) * x[0]\n",
      "        ...     df = np.zeros(2)\n",
      "        ...     df[0] = -14.5 * np.sin(14.5 * x[0] - 0.3) + 2. * x[0] + 0.2\n",
      "        ...     df[1] = 2. * x[1] + 0.2\n",
      "        ...     return f, df\n",
      "        \n",
      "        We'll also use a different local minimization algorithm.  Also we must tell\n",
      "        the minimizer that our function returns both energy and gradient (jacobian)\n",
      "        \n",
      "        >>> minimizer_kwargs = {\"method\":\"L-BFGS-B\", \"jac\":True}\n",
      "        >>> x0 = [1.0, 1.0]\n",
      "        >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n",
      "        ...                    niter=200)\n",
      "        >>> print(\"global minimum: x = [%.4f, %.4f], f(x0) = %.4f\" % (ret.x[0],\n",
      "        ...                                                           ret.x[1],\n",
      "        ...                                                           ret.fun))\n",
      "        global minimum: x = [-0.1951, -0.1000], f(x0) = -1.0109\n",
      "        \n",
      "        \n",
      "        Here is an example using a custom step taking routine.  Imagine you want\n",
      "        the first coordinate to take larger steps then the rest of the coordinates.\n",
      "        This can be implemented like so:\n",
      "        \n",
      "        >>> class MyTakeStep(object):\n",
      "        ...    def __init__(self, stepsize=0.5):\n",
      "        ...        self.stepsize = stepsize\n",
      "        ...    def __call__(self, x):\n",
      "        ...        s = self.stepsize\n",
      "        ...        x[0] += np.random.uniform(-2.*s, 2.*s)\n",
      "        ...        x[1:] += np.random.uniform(-s, s, x[1:].shape)\n",
      "        ...        return x\n",
      "        \n",
      "        Since ``MyTakeStep.stepsize`` exists basinhopping will adjust the magnitude\n",
      "        of ``stepsize`` to optimize the search.  We'll use the same 2-D function as\n",
      "        before\n",
      "        \n",
      "        >>> mytakestep = MyTakeStep()\n",
      "        >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n",
      "        ...                    niter=200, take_step=mytakestep)\n",
      "        >>> print(\"global minimum: x = [%.4f, %.4f], f(x0) = %.4f\" % (ret.x[0],\n",
      "        ...                                                           ret.x[1],\n",
      "        ...                                                           ret.fun))\n",
      "        global minimum: x = [-0.1951, -0.1000], f(x0) = -1.0109\n",
      "        \n",
      "        \n",
      "        Now let's do an example using a custom callback function which prints the\n",
      "        value of every minimum found\n",
      "        \n",
      "        >>> def print_fun(x, f, accepted):\n",
      "        ...         print(\"at minimum %.4f accepted %d\" % (f, int(accepted)))\n",
      "        \n",
      "        We'll run it for only 10 basinhopping steps this time.\n",
      "        \n",
      "        >>> np.random.seed(1)\n",
      "        >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n",
      "        ...                    niter=10, callback=print_fun)\n",
      "        at minimum 0.4159 accepted 1\n",
      "        at minimum -0.9073 accepted 1\n",
      "        at minimum -0.1021 accepted 1\n",
      "        at minimum -0.1021 accepted 1\n",
      "        at minimum 0.9102 accepted 1\n",
      "        at minimum 0.9102 accepted 1\n",
      "        at minimum 2.2945 accepted 0\n",
      "        at minimum -0.1021 accepted 1\n",
      "        at minimum -1.0109 accepted 1\n",
      "        at minimum -1.0109 accepted 1\n",
      "        \n",
      "        \n",
      "        The minimum at -1.0109 is actually the global minimum, found already on the\n",
      "        8th iteration.\n",
      "        \n",
      "        Now let's implement bounds on the problem using a custom ``accept_test``:\n",
      "        \n",
      "        >>> class MyBounds(object):\n",
      "        ...     def __init__(self, xmax=[1.1,1.1], xmin=[-1.1,-1.1] ):\n",
      "        ...         self.xmax = np.array(xmax)\n",
      "        ...         self.xmin = np.array(xmin)\n",
      "        ...     def __call__(self, **kwargs):\n",
      "        ...         x = kwargs[\"x_new\"]\n",
      "        ...         tmax = bool(np.all(x <= self.xmax))\n",
      "        ...         tmin = bool(np.all(x >= self.xmin))\n",
      "        ...         return tmax and tmin\n",
      "        \n",
      "        >>> mybounds = MyBounds()\n",
      "        >>> ret = basinhopping(func2d, x0, minimizer_kwargs=minimizer_kwargs,\n",
      "        ...                    niter=10, accept_test=mybounds)\n",
      "    \n",
      "    bisect(f, a, b, args=(), xtol=2e-12, rtol=8.8817841970012523e-16, maxiter=100, full_output=False, disp=True)\n",
      "        Find root of a function within an interval.\n",
      "        \n",
      "        Basic bisection routine to find a zero of the function `f` between the\n",
      "        arguments `a` and `b`. `f(a)` and `f(b)` cannot have the same signs.\n",
      "        Slow but sure.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : function\n",
      "            Python function returning a number.  `f` must be continuous, and\n",
      "            f(a) and f(b) must have opposite signs.\n",
      "        a : number\n",
      "            One end of the bracketing interval [a,b].\n",
      "        b : number\n",
      "            The other end of the bracketing interval [a,b].\n",
      "        xtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter must be nonnegative.\n",
      "        rtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter cannot be smaller than its default value of\n",
      "            ``4*np.finfo(float).eps``.\n",
      "        maxiter : number, optional\n",
      "            if convergence is not achieved in `maxiter` iterations, an error is\n",
      "            raised.  Must be >= 0.\n",
      "        args : tuple, optional\n",
      "            containing extra arguments for the function `f`.\n",
      "            `f` is called by ``apply(f, (x)+args)``.\n",
      "        full_output : bool, optional\n",
      "            If `full_output` is False, the root is returned.  If `full_output` is\n",
      "            True, the return value is ``(x, r)``, where x is the root, and r is\n",
      "            a `RootResults` object.\n",
      "        disp : bool, optional\n",
      "            If True, raise RuntimeError if the algorithm didn't converge.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x0 : float\n",
      "            Zero of `f` between `a` and `b`.\n",
      "        r : RootResults (present if ``full_output = True``)\n",
      "            Object containing information about the convergence.  In particular,\n",
      "            ``r.converged`` is True if the routine converged.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        brentq, brenth, bisect, newton\n",
      "        fixed_point : scalar fixed-point finder\n",
      "        fsolve : n-dimensional root-finding\n",
      "    \n",
      "    bracket(func, xa=0.0, xb=1.0, args=(), grow_limit=110.0, maxiter=1000)\n",
      "        Bracket the minimum of the function.\n",
      "        \n",
      "        Given a function and distinct initial points, search in the\n",
      "        downhill direction (as defined by the initital points) and return\n",
      "        new points xa, xb, xc that bracket the minimum of the function\n",
      "        f(xa) > f(xb) < f(xc). It doesn't always mean that obtained\n",
      "        solution will satisfy xa<=x<=xb\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable f(x,*args)\n",
      "            Objective function to minimize.\n",
      "        xa, xb : float, optional\n",
      "            Bracketing interval. Defaults `xa` to 0.0, and `xb` to 1.0.\n",
      "        args : tuple, optional\n",
      "            Additional arguments (if present), passed to `func`.\n",
      "        grow_limit : float, optional\n",
      "            Maximum grow limit.  Defaults to 110.0\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to perform. Defaults to 1000.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xa, xb, xc : float\n",
      "            Bracket.\n",
      "        fa, fb, fc : float\n",
      "            Objective function values in bracket.\n",
      "        funcalls : int\n",
      "            Number of function evaluations made.\n",
      "    \n",
      "    brent(func, args=(), brack=None, tol=1.48e-08, full_output=0, maxiter=500)\n",
      "        Given a function of one-variable and a possible bracketing interval,\n",
      "        return the minimum of the function isolated to a fractional precision of\n",
      "        tol.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable f(x,*args)\n",
      "            Objective function.\n",
      "        args : tuple, optional\n",
      "            Additional arguments (if present).\n",
      "        brack : tuple, optional\n",
      "            Either a triple (xa,xb,xc) where xa<xb<xc and func(xb) <\n",
      "            func(xa), func(xc) or a pair (xa,xb) which are used as a\n",
      "            starting interval for a downhill bracket search (see\n",
      "            `bracket`). Providing the pair (xa,xb) does not always mean\n",
      "            the obtained solution will satisfy xa<=x<=xb.\n",
      "        tol : float, optional\n",
      "            Stop if between iteration change is less than `tol`.\n",
      "        full_output : bool, optional\n",
      "            If True, return all output args (xmin, fval, iter,\n",
      "            funcalls).\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations in solution.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xmin : ndarray\n",
      "            Optimum point.\n",
      "        fval : float\n",
      "            Optimum value.\n",
      "        iter : int\n",
      "            Number of iterations.\n",
      "        funcalls : int\n",
      "            Number of objective function evaluations made.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize_scalar: Interface to minimization algorithms for scalar\n",
      "            univariate functions. See the 'Brent' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Uses inverse parabolic interpolation when possible to speed up\n",
      "        convergence of golden section method.\n",
      "    \n",
      "    brenth(f, a, b, args=(), xtol=2e-12, rtol=8.8817841970012523e-16, maxiter=100, full_output=False, disp=True)\n",
      "        Find root of f in [a,b].\n",
      "        \n",
      "        A variation on the classic Brent routine to find a zero of the function f\n",
      "        between the arguments a and b that uses hyperbolic extrapolation instead of\n",
      "        inverse quadratic extrapolation. There was a paper back in the 1980's ...\n",
      "        f(a) and f(b) cannot have the same signs. Generally on a par with the\n",
      "        brent routine, but not as heavily tested.  It is a safe version of the\n",
      "        secant method that uses hyperbolic extrapolation. The version here is by\n",
      "        Chuck Harris.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : function\n",
      "            Python function returning a number.  f must be continuous, and f(a) and\n",
      "            f(b) must have opposite signs.\n",
      "        a : number\n",
      "            One end of the bracketing interval [a,b].\n",
      "        b : number\n",
      "            The other end of the bracketing interval [a,b].\n",
      "        xtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter must be nonnegative. As with `brentq`, for nice\n",
      "            functions the method will often satisfy the above condition\n",
      "            will ``xtol/2`` and ``rtol/2``.\n",
      "        rtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter cannot be smaller than its default value of\n",
      "            ``4*np.finfo(float).eps``. As with `brentq`, for nice functions\n",
      "            the method will often satisfy the above condition will\n",
      "            ``xtol/2`` and ``rtol/2``.\n",
      "        maxiter : number, optional\n",
      "            if convergence is not achieved in maxiter iterations, an error is\n",
      "            raised.  Must be >= 0.\n",
      "        args : tuple, optional\n",
      "            containing extra arguments for the function `f`.\n",
      "            `f` is called by ``apply(f, (x)+args)``.\n",
      "        full_output : bool, optional\n",
      "            If `full_output` is False, the root is returned.  If `full_output` is\n",
      "            True, the return value is ``(x, r)``, where `x` is the root, and `r` is\n",
      "            a RootResults object.\n",
      "        disp : bool, optional\n",
      "            If True, raise RuntimeError if the algorithm didn't converge.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x0 : float\n",
      "            Zero of `f` between `a` and `b`.\n",
      "        r : RootResults (present if ``full_output = True``)\n",
      "            Object containing information about the convergence.  In particular,\n",
      "            ``r.converged`` is True if the routine converged.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        fmin, fmin_powell, fmin_cg,\n",
      "               fmin_bfgs, fmin_ncg : multivariate local optimizers\n",
      "        \n",
      "        leastsq : nonlinear least squares minimizer\n",
      "        \n",
      "        fmin_l_bfgs_b, fmin_tnc, fmin_cobyla : constrained multivariate optimizers\n",
      "        \n",
      "        basinhopping, differential_evolution, brute : global optimizers\n",
      "        \n",
      "        fminbound, brent, golden, bracket : local scalar minimizers\n",
      "        \n",
      "        fsolve : n-dimensional root-finding\n",
      "        \n",
      "        brentq, brenth, ridder, bisect, newton : one-dimensional root-finding\n",
      "        \n",
      "        fixed_point : scalar fixed-point finder\n",
      "    \n",
      "    brentq(f, a, b, args=(), xtol=2e-12, rtol=8.8817841970012523e-16, maxiter=100, full_output=False, disp=True)\n",
      "        Find a root of a function in a bracketing interval using Brent's method.\n",
      "        \n",
      "        Uses the classic Brent's method to find a zero of the function `f` on\n",
      "        the sign changing interval [a , b].  Generally considered the best of the\n",
      "        rootfinding routines here.  It is a safe version of the secant method that\n",
      "        uses inverse quadratic extrapolation.  Brent's method combines root\n",
      "        bracketing, interval bisection, and inverse quadratic interpolation.  It is\n",
      "        sometimes known as the van Wijngaarden-Dekker-Brent method.  Brent (1973)\n",
      "        claims convergence is guaranteed for functions computable within [a,b].\n",
      "        \n",
      "        [Brent1973]_ provides the classic description of the algorithm.  Another\n",
      "        description can be found in a recent edition of Numerical Recipes, including\n",
      "        [PressEtal1992]_.  Another description is at\n",
      "        http://mathworld.wolfram.com/BrentsMethod.html.  It should be easy to\n",
      "        understand the algorithm just by reading our code.  Our code diverges a bit\n",
      "        from standard presentations: we choose a different formula for the\n",
      "        extrapolation step.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : function\n",
      "            Python function returning a number.  The function :math:`f`\n",
      "            must be continuous, and :math:`f(a)` and :math:`f(b)` must\n",
      "            have opposite signs.\n",
      "        a : number\n",
      "            One end of the bracketing interval :math:`[a, b]`.\n",
      "        b : number\n",
      "            The other end of the bracketing interval :math:`[a, b]`.\n",
      "        xtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter must be nonnegative. For nice functions, Brent's\n",
      "            method will often satisfy the above condition will ``xtol/2``\n",
      "            and ``rtol/2``. [Brent1973]_\n",
      "        rtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter cannot be smaller than its default value of\n",
      "            ``4*np.finfo(float).eps``. For nice functions, Brent's\n",
      "            method will often satisfy the above condition will ``xtol/2``\n",
      "            and ``rtol/2``. [Brent1973]_\n",
      "        maxiter : number, optional\n",
      "            if convergence is not achieved in maxiter iterations, an error is\n",
      "            raised.  Must be >= 0.\n",
      "        args : tuple, optional\n",
      "            containing extra arguments for the function `f`.\n",
      "            `f` is called by ``apply(f, (x)+args)``.\n",
      "        full_output : bool, optional\n",
      "            If `full_output` is False, the root is returned.  If `full_output` is\n",
      "            True, the return value is ``(x, r)``, where `x` is the root, and `r` is\n",
      "            a RootResults object.\n",
      "        disp : bool, optional\n",
      "            If True, raise RuntimeError if the algorithm didn't converge.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x0 : float\n",
      "            Zero of `f` between `a` and `b`.\n",
      "        r : RootResults (present if ``full_output = True``)\n",
      "            Object containing information about the convergence.  In particular,\n",
      "            ``r.converged`` is True if the routine converged.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        multivariate local optimizers\n",
      "          `fmin`, `fmin_powell`, `fmin_cg`, `fmin_bfgs`, `fmin_ncg`\n",
      "        nonlinear least squares minimizer\n",
      "          `leastsq`\n",
      "        constrained multivariate optimizers\n",
      "          `fmin_l_bfgs_b`, `fmin_tnc`, `fmin_cobyla`\n",
      "        global optimizers\n",
      "          `basinhopping`, `brute`, `differential_evolution`\n",
      "        local scalar minimizers\n",
      "          `fminbound`, `brent`, `golden`, `bracket`\n",
      "        n-dimensional root-finding\n",
      "          `fsolve`\n",
      "        one-dimensional root-finding\n",
      "          `brentq`, `brenth`, `ridder`, `bisect`, `newton`\n",
      "        scalar fixed-point finder\n",
      "          `fixed_point`\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        `f` must be continuous.  f(a) and f(b) must have opposite signs.\n",
      "        \n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [Brent1973]\n",
      "           Brent, R. P.,\n",
      "           *Algorithms for Minimization Without Derivatives*.\n",
      "           Englewood Cliffs, NJ: Prentice-Hall, 1973. Ch. 3-4.\n",
      "        \n",
      "        .. [PressEtal1992]\n",
      "           Press, W. H.; Flannery, B. P.; Teukolsky, S. A.; and Vetterling, W. T.\n",
      "           *Numerical Recipes in FORTRAN: The Art of Scientific Computing*, 2nd ed.\n",
      "           Cambridge, England: Cambridge University Press, pp. 352-355, 1992.\n",
      "           Section 9.3:  \"Van Wijngaarden-Dekker-Brent Method.\"\n",
      "    \n",
      "    broyden1(F, xin, iter=None, alpha=None, reduction_method='restart', max_rank=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using Broyden's first Jacobian approximation.\n",
      "        \n",
      "        This method is also known as \\\"Broyden's good method\\\".\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        alpha : float, optional\n",
      "            Initial guess for the Jacobian is ``(-1/alpha)``.\n",
      "        reduction_method : str or tuple, optional\n",
      "            Method used in ensuring that the rank of the Broyden matrix\n",
      "            stays low. Can either be a string giving the name of the method,\n",
      "            or a tuple of the form ``(method, param1, param2, ...)``\n",
      "            that gives the name of the method and values for additional parameters.\n",
      "        \n",
      "            Methods available:\n",
      "        \n",
      "                - ``restart``: drop all matrix columns. Has no extra parameters.\n",
      "                - ``simple``: drop oldest matrix column. Has no extra parameters.\n",
      "                - ``svd``: keep only the most significant SVD components.\n",
      "                  Takes an extra parameter, ``to_retain``, which determines the\n",
      "                  number of SVD components to retain when rank reduction is done.\n",
      "                  Default is ``max_rank - 2``.\n",
      "        \n",
      "        max_rank : int, optional\n",
      "            Maximum rank for the Broyden matrix.\n",
      "            Default is infinity (ie., no rank reduction).\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This algorithm implements the inverse Jacobian Quasi-Newton update\n",
      "        \n",
      "        .. math:: H_+ = H + (dx - H df) dx^\\dagger H / ( dx^\\dagger H df)\n",
      "        \n",
      "        which corresponds to Broyden's first Jacobian update\n",
      "        \n",
      "        .. math:: J_+ = J + (df - J dx) dx^\\dagger / dx^\\dagger dx\n",
      "        \n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] B.A. van der Rotten, PhD thesis,\n",
      "           \\\"A limited memory Broyden method to solve high-dimensional\n",
      "           systems of nonlinear equations\\\". Mathematisch Instituut,\n",
      "           Universiteit Leiden, The Netherlands (2003).\n",
      "        \n",
      "           http://www.math.leidenuniv.nl/scripties/Rotten.pdf\n",
      "    \n",
      "    broyden2(F, xin, iter=None, alpha=None, reduction_method='restart', max_rank=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using Broyden's second Jacobian approximation.\n",
      "        \n",
      "        This method is also known as \"Broyden's bad method\".\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        alpha : float, optional\n",
      "            Initial guess for the Jacobian is ``(-1/alpha)``.\n",
      "        reduction_method : str or tuple, optional\n",
      "            Method used in ensuring that the rank of the Broyden matrix\n",
      "            stays low. Can either be a string giving the name of the method,\n",
      "            or a tuple of the form ``(method, param1, param2, ...)``\n",
      "            that gives the name of the method and values for additional parameters.\n",
      "        \n",
      "            Methods available:\n",
      "        \n",
      "                - ``restart``: drop all matrix columns. Has no extra parameters.\n",
      "                - ``simple``: drop oldest matrix column. Has no extra parameters.\n",
      "                - ``svd``: keep only the most significant SVD components.\n",
      "                  Takes an extra parameter, ``to_retain``, which determines the\n",
      "                  number of SVD components to retain when rank reduction is done.\n",
      "                  Default is ``max_rank - 2``.\n",
      "        \n",
      "        max_rank : int, optional\n",
      "            Maximum rank for the Broyden matrix.\n",
      "            Default is infinity (ie., no rank reduction).\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This algorithm implements the inverse Jacobian Quasi-Newton update\n",
      "        \n",
      "        .. math:: H_+ = H + (dx - H df) df^\\dagger / ( df^\\dagger df)\n",
      "        \n",
      "        corresponding to Broyden's second method.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] B.A. van der Rotten, PhD thesis,\n",
      "           \"A limited memory Broyden method to solve high-dimensional\n",
      "           systems of nonlinear equations\". Mathematisch Instituut,\n",
      "           Universiteit Leiden, The Netherlands (2003).\n",
      "        \n",
      "           http://www.math.leidenuniv.nl/scripties/Rotten.pdf\n",
      "    \n",
      "    brute(func, ranges, args=(), Ns=20, full_output=0, finish=<function fmin at 0x7f1b812f4158>, disp=False)\n",
      "        Minimize a function over a given range by brute force.\n",
      "        \n",
      "        Uses the \"brute force\" method, i.e. computes the function's value\n",
      "        at each point of a multidimensional grid of points, to find the global\n",
      "        minimum of the function.\n",
      "        \n",
      "        The function is evaluated everywhere in the range with the datatype of the\n",
      "        first call to the function, as enforced by the ``vectorize`` NumPy\n",
      "        function.  The value and type of the function evaluation returned when\n",
      "        ``full_output=True`` are affected in addition by the ``finish`` argument\n",
      "        (see Notes).\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable\n",
      "            The objective function to be minimized. Must be in the\n",
      "            form ``f(x, *args)``, where ``x`` is the argument in\n",
      "            the form of a 1-D array and ``args`` is a tuple of any\n",
      "            additional fixed parameters needed to completely specify\n",
      "            the function.\n",
      "        ranges : tuple\n",
      "            Each component of the `ranges` tuple must be either a\n",
      "            \"slice object\" or a range tuple of the form ``(low, high)``.\n",
      "            The program uses these to create the grid of points on which\n",
      "            the objective function will be computed. See `Note 2` for\n",
      "            more detail.\n",
      "        args : tuple, optional\n",
      "            Any additional fixed parameters needed to completely specify\n",
      "            the function.\n",
      "        Ns : int, optional\n",
      "            Number of grid points along the axes, if not otherwise\n",
      "            specified. See `Note2`.\n",
      "        full_output : bool, optional\n",
      "            If True, return the evaluation grid and the objective function's\n",
      "            values on it.\n",
      "        finish : callable, optional\n",
      "            An optimization function that is called with the result of brute force\n",
      "            minimization as initial guess.  `finish` should take `func` and\n",
      "            the initial guess as positional arguments, and take `args` as\n",
      "            keyword arguments.  It may additionally take `full_output`\n",
      "            and/or `disp` as keyword arguments.  Use None if no \"polishing\"\n",
      "            function is to be used. See Notes for more details.\n",
      "        disp : bool, optional\n",
      "            Set to True to print convergence messages.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x0 : ndarray\n",
      "            A 1-D array containing the coordinates of a point at which the\n",
      "            objective function had its minimum value. (See `Note 1` for\n",
      "            which point is returned.)\n",
      "        fval : float\n",
      "            Function value at the point `x0`. (Returned when `full_output` is\n",
      "            True.)\n",
      "        grid : tuple\n",
      "            Representation of the evaluation grid.  It has the same\n",
      "            length as `x0`. (Returned when `full_output` is True.)\n",
      "        Jout : ndarray\n",
      "            Function values at each point of the evaluation\n",
      "            grid, `i.e.`, ``Jout = func(*grid)``. (Returned\n",
      "            when `full_output` is True.)\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        basinhopping, differential_evolution\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        *Note 1*: The program finds the gridpoint at which the lowest value\n",
      "        of the objective function occurs.  If `finish` is None, that is the\n",
      "        point returned.  When the global minimum occurs within (or not very far\n",
      "        outside) the grid's boundaries, and the grid is fine enough, that\n",
      "        point will be in the neighborhood of the global minimum.\n",
      "        \n",
      "        However, users often employ some other optimization program to\n",
      "        \"polish\" the gridpoint values, `i.e.`, to seek a more precise\n",
      "        (local) minimum near `brute's` best gridpoint.\n",
      "        The `brute` function's `finish` option provides a convenient way to do\n",
      "        that.  Any polishing program used must take `brute's` output as its\n",
      "        initial guess as a positional argument, and take `brute's` input values\n",
      "        for `args` as keyword arguments, otherwise an error will be raised.\n",
      "        It may additionally take `full_output` and/or `disp` as keyword arguments.\n",
      "        \n",
      "        `brute` assumes that the `finish` function returns either an\n",
      "        `OptimizeResult` object or a tuple in the form:\n",
      "        ``(xmin, Jmin, ... , statuscode)``, where ``xmin`` is the minimizing\n",
      "        value of the argument, ``Jmin`` is the minimum value of the objective\n",
      "        function, \"...\" may be some other returned values (which are not used\n",
      "        by `brute`), and ``statuscode`` is the status code of the `finish` program.\n",
      "        \n",
      "        Note that when `finish` is not None, the values returned are those\n",
      "        of the `finish` program, *not* the gridpoint ones.  Consequently,\n",
      "        while `brute` confines its search to the input grid points,\n",
      "        the `finish` program's results usually will not coincide with any\n",
      "        gridpoint, and may fall outside the grid's boundary. Thus, if a\n",
      "        minimum only needs to be found over the provided grid points, make\n",
      "        sure to pass in `finish=None`.\n",
      "        \n",
      "        *Note 2*: The grid of points is a `numpy.mgrid` object.\n",
      "        For `brute` the `ranges` and `Ns` inputs have the following effect.\n",
      "        Each component of the `ranges` tuple can be either a slice object or a\n",
      "        two-tuple giving a range of values, such as (0, 5).  If the component is a\n",
      "        slice object, `brute` uses it directly.  If the component is a two-tuple\n",
      "        range, `brute` internally converts it to a slice object that interpolates\n",
      "        `Ns` points from its low-value to its high-value, inclusive.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        We illustrate the use of `brute` to seek the global minimum of a function\n",
      "        of two variables that is given as the sum of a positive-definite\n",
      "        quadratic and two deep \"Gaussian-shaped\" craters.  Specifically, define\n",
      "        the objective function `f` as the sum of three other functions,\n",
      "        ``f = f1 + f2 + f3``.  We suppose each of these has a signature\n",
      "        ``(z, *params)``, where ``z = (x, y)``,  and ``params`` and the functions\n",
      "        are as defined below.\n",
      "        \n",
      "        >>> params = (2, 3, 7, 8, 9, 10, 44, -1, 2, 26, 1, -2, 0.5)\n",
      "        >>> def f1(z, *params):\n",
      "        ...     x, y = z\n",
      "        ...     a, b, c, d, e, f, g, h, i, j, k, l, scale = params\n",
      "        ...     return (a * x**2 + b * x * y + c * y**2 + d*x + e*y + f)\n",
      "        \n",
      "        >>> def f2(z, *params):\n",
      "        ...     x, y = z\n",
      "        ...     a, b, c, d, e, f, g, h, i, j, k, l, scale = params\n",
      "        ...     return (-g*np.exp(-((x-h)**2 + (y-i)**2) / scale))\n",
      "        \n",
      "        >>> def f3(z, *params):\n",
      "        ...     x, y = z\n",
      "        ...     a, b, c, d, e, f, g, h, i, j, k, l, scale = params\n",
      "        ...     return (-j*np.exp(-((x-k)**2 + (y-l)**2) / scale))\n",
      "        \n",
      "        >>> def f(z, *params):\n",
      "        ...     return f1(z, *params) + f2(z, *params) + f3(z, *params)\n",
      "        \n",
      "        Thus, the objective function may have local minima near the minimum\n",
      "        of each of the three functions of which it is composed.  To\n",
      "        use `fmin` to polish its gridpoint result, we may then continue as\n",
      "        follows:\n",
      "        \n",
      "        >>> rranges = (slice(-4, 4, 0.25), slice(-4, 4, 0.25))\n",
      "        >>> from scipy import optimize\n",
      "        >>> resbrute = optimize.brute(f, rranges, args=params, full_output=True,\n",
      "        ...                           finish=optimize.fmin)\n",
      "        >>> resbrute[0]  # global minimum\n",
      "        array([-1.05665192,  1.80834843])\n",
      "        >>> resbrute[1]  # function value at global minimum\n",
      "        -3.4085818767\n",
      "        \n",
      "        Note that if `finish` had been set to None, we would have gotten the\n",
      "        gridpoint [-1.0 1.75] where the rounded function value is -2.892.\n",
      "    \n",
      "    check_grad(func, grad, x0, *args, **kwargs)\n",
      "        Check the correctness of a gradient function by comparing it against a\n",
      "        (forward) finite-difference approximation of the gradient.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable ``func(x0, *args)``\n",
      "            Function whose derivative is to be checked.\n",
      "        grad : callable ``grad(x0, *args)``\n",
      "            Gradient of `func`.\n",
      "        x0 : ndarray\n",
      "            Points to check `grad` against forward difference approximation of grad\n",
      "            using `func`.\n",
      "        args : \\*args, optional\n",
      "            Extra arguments passed to `func` and `grad`.\n",
      "        epsilon : float, optional\n",
      "            Step size used for the finite difference approximation. It defaults to\n",
      "            ``sqrt(numpy.finfo(float).eps)``, which is approximately 1.49e-08.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        err : float\n",
      "            The square root of the sum of squares (i.e. the 2-norm) of the\n",
      "            difference between ``grad(x0, *args)`` and the finite difference\n",
      "            approximation of `grad` using func at the points `x0`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        approx_fprime\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> def func(x):\n",
      "        ...     return x[0]**2 - 0.5 * x[1]**3\n",
      "        >>> def grad(x):\n",
      "        ...     return [2 * x[0], -1.5 * x[1]**2]\n",
      "        >>> from scipy.optimize import check_grad\n",
      "        >>> check_grad(func, grad, [1.5, -1.5])\n",
      "        2.9802322387695312e-08\n",
      "    \n",
      "    curve_fit(f, xdata, ydata, p0=None, sigma=None, absolute_sigma=False, check_finite=True, bounds=(-inf, inf), method=None, jac=None, **kwargs)\n",
      "        Use non-linear least squares to fit a function, f, to data.\n",
      "        \n",
      "        Assumes ``ydata = f(xdata, *params) + eps``\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : callable\n",
      "            The model function, f(x, ...).  It must take the independent\n",
      "            variable as the first argument and the parameters to fit as\n",
      "            separate remaining arguments.\n",
      "        xdata : An M-length sequence or an (k,M)-shaped array\n",
      "            for functions with k predictors.\n",
      "            The independent variable where the data is measured.\n",
      "        ydata : M-length sequence\n",
      "            The dependent data --- nominally f(xdata, ...)\n",
      "        p0 : None, scalar, or N-length sequence, optional\n",
      "            Initial guess for the parameters.  If None, then the initial\n",
      "            values will all be 1 (if the number of parameters for the function\n",
      "            can be determined using introspection, otherwise a ValueError\n",
      "            is raised).\n",
      "        sigma : None or M-length sequence, optional\n",
      "            If not None, the uncertainties in the ydata array. These are used as\n",
      "            weights in the least-squares problem\n",
      "            i.e. minimising ``np.sum( ((f(xdata, *popt) - ydata) / sigma)**2 )``\n",
      "            If None, the uncertainties are assumed to be 1.\n",
      "        absolute_sigma : bool, optional\n",
      "            If False, `sigma` denotes relative weights of the data points.\n",
      "            The returned covariance matrix `pcov` is based on *estimated*\n",
      "            errors in the data, and is not affected by the overall\n",
      "            magnitude of the values in `sigma`. Only the relative\n",
      "            magnitudes of the `sigma` values matter.\n",
      "        \n",
      "            If True, `sigma` describes one standard deviation errors of\n",
      "            the input data points. The estimated covariance in `pcov` is\n",
      "            based on these values.\n",
      "        check_finite : bool, optional\n",
      "            If True, check that the input arrays do not contain nans of infs,\n",
      "            and raise a ValueError if they do. Setting this parameter to\n",
      "            False may silently produce nonsensical results if the input arrays\n",
      "            do contain nans. Default is True.\n",
      "        bounds : 2-tuple of array_like, optional\n",
      "            Lower and upper bounds on independent variables. Defaults to no bounds.        \n",
      "            Each element of the tuple must be either an array with the length equal\n",
      "            to the number of parameters, or a scalar (in which case the bound is\n",
      "            taken to be the same for all parameters.) Use ``np.inf`` with an\n",
      "            appropriate sign to disable bounds on all or some parameters.\n",
      "        \n",
      "            .. versionadded:: 0.17\n",
      "        method : {'lm', 'trf', 'dogbox'}, optional\n",
      "            Method to use for optimization.  See `least_squares` for more details.\n",
      "            Default is 'lm' for unconstrained problems and 'trf' if `bounds` are\n",
      "            provided. The method 'lm' won't work when the number of observations\n",
      "            is less than the number of variables, use 'trf' or 'dogbox' in this\n",
      "            case.\n",
      "        \n",
      "            .. versionadded:: 0.17\n",
      "        jac : callable, string or None, optional\n",
      "            Function with signature ``jac(x, ...)`` which computes the Jacobian\n",
      "            matrix of the model function with respect to parameters as a dense\n",
      "            array_like structure. It will be scaled according to provided `sigma`.\n",
      "            If None (default), the Jacobian will be estimated numerically.\n",
      "            String keywords for 'trf' and 'dogbox' methods can be used to select\n",
      "            a finite difference scheme, see `least_squares`.\n",
      "        \n",
      "            .. versionadded:: 0.18\n",
      "        kwargs\n",
      "            Keyword arguments passed to `leastsq` for ``method='lm'`` or\n",
      "            `least_squares` otherwise.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        popt : array\n",
      "            Optimal values for the parameters so that the sum of the squared error\n",
      "            of ``f(xdata, *popt) - ydata`` is minimized\n",
      "        pcov : 2d array\n",
      "            The estimated covariance of popt. The diagonals provide the variance\n",
      "            of the parameter estimate. To compute one standard deviation errors\n",
      "            on the parameters use ``perr = np.sqrt(np.diag(pcov))``.\n",
      "        \n",
      "            How the `sigma` parameter affects the estimated covariance\n",
      "            depends on `absolute_sigma` argument, as described above.\n",
      "        \n",
      "            If the Jacobian matrix at the solution doesn't have a full rank, then\n",
      "            'lm' method returns a matrix filled with ``np.inf``, on the other hand\n",
      "            'trf'  and 'dogbox' methods use Moore-Penrose pseudoinverse to compute\n",
      "            the covariance matrix.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        ValueError\n",
      "            if either `ydata` or `xdata` contain NaNs, or if incompatible options\n",
      "            are used.\n",
      "        \n",
      "        RuntimeError\n",
      "            if the least-squares minimization fails.\n",
      "        \n",
      "        OptimizeWarning\n",
      "            if covariance of the parameters can not be estimated.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        least_squares : Minimize the sum of squares of nonlinear functions.\n",
      "        stats.linregress : Calculate a linear least squares regression for two sets\n",
      "                           of measurements.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        With ``method='lm'``, the algorithm uses the Levenberg-Marquardt algorithm\n",
      "        through `leastsq`. Note that this algorithm can only deal with\n",
      "        unconstrained problems.\n",
      "        \n",
      "        Box constraints can be handled by methods 'trf' and 'dogbox'. Refer to\n",
      "        the docstring of `least_squares` for more information.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> import numpy as np\n",
      "        >>> from scipy.optimize import curve_fit\n",
      "        >>> def func(x, a, b, c):\n",
      "        ...     return a * np.exp(-b * x) + c\n",
      "        \n",
      "        >>> xdata = np.linspace(0, 4, 50)\n",
      "        >>> y = func(xdata, 2.5, 1.3, 0.5)\n",
      "        >>> ydata = y + 0.2 * np.random.normal(size=len(xdata))\n",
      "        \n",
      "        >>> popt, pcov = curve_fit(func, xdata, ydata)\n",
      "        \n",
      "        Constrain the optimization to the region of ``0 < a < 3``, ``0 < b < 2``\n",
      "        and ``0 < c < 1``:\n",
      "        \n",
      "        >>> popt, pcov = curve_fit(func, xdata, ydata, bounds=(0, [3., 2., 1.]))\n",
      "    \n",
      "    diagbroyden(F, xin, iter=None, alpha=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using diagonal Broyden Jacobian approximation.\n",
      "        \n",
      "        The Jacobian approximation is derived from previous iterations, by\n",
      "        retaining only the diagonal of Broyden matrices.\n",
      "        \n",
      "        .. warning::\n",
      "        \n",
      "           This algorithm may be useful for specific problems, but whether\n",
      "           it will work may depend strongly on the problem.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        alpha : float, optional\n",
      "            Initial guess for the Jacobian is (-1/alpha).\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "    \n",
      "    differential_evolution(func, bounds, args=(), strategy='best1bin', maxiter=1000, popsize=15, tol=0.01, mutation=(0.5, 1), recombination=0.7, seed=None, callback=None, disp=False, polish=True, init='latinhypercube')\n",
      "        Finds the global minimum of a multivariate function.\n",
      "        Differential Evolution is stochastic in nature (does not use gradient\n",
      "        methods) to find the minimium, and can search large areas of candidate\n",
      "        space, but often requires larger numbers of function evaluations than\n",
      "        conventional gradient based techniques.\n",
      "        \n",
      "        The algorithm is due to Storn and Price [1]_.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable\n",
      "            The objective function to be minimized.  Must be in the form\n",
      "            ``f(x, *args)``, where ``x`` is the argument in the form of a 1-D array\n",
      "            and ``args`` is a  tuple of any additional fixed parameters needed to\n",
      "            completely specify the function.\n",
      "        bounds : sequence\n",
      "            Bounds for variables.  ``(min, max)`` pairs for each element in ``x``,\n",
      "            defining the lower and upper bounds for the optimizing argument of\n",
      "            `func`. It is required to have ``len(bounds) == len(x)``.\n",
      "            ``len(bounds)`` is used to determine the number of parameters in ``x``.\n",
      "        args : tuple, optional\n",
      "            Any additional fixed parameters needed to\n",
      "            completely specify the objective function.\n",
      "        strategy : str, optional\n",
      "            The differential evolution strategy to use. Should be one of:\n",
      "        \n",
      "                - 'best1bin'\n",
      "                - 'best1exp'\n",
      "                - 'rand1exp'\n",
      "                - 'randtobest1exp'\n",
      "                - 'best2exp'\n",
      "                - 'rand2exp'\n",
      "                - 'randtobest1bin'\n",
      "                - 'best2bin'\n",
      "                - 'rand2bin'\n",
      "                - 'rand1bin'\n",
      "        \n",
      "            The default is 'best1bin'.\n",
      "        maxiter : int, optional\n",
      "            The maximum number of generations over which the entire population is\n",
      "            evolved. The maximum number of function evaluations (with no polishing)\n",
      "            is: ``(maxiter + 1) * popsize * len(x)``\n",
      "        popsize : int, optional\n",
      "            A multiplier for setting the total population size.  The population has\n",
      "            ``popsize * len(x)`` individuals.\n",
      "        tol : float, optional\n",
      "            When the mean of the population energies, multiplied by tol,\n",
      "            divided by the standard deviation of the population energies\n",
      "            is greater than 1 the solving process terminates:\n",
      "            ``convergence = mean(pop) * tol / stdev(pop) > 1``\n",
      "        mutation : float or tuple(float, float), optional\n",
      "            The mutation constant. In the literature this is also known as\n",
      "            differential weight, being denoted by F.\n",
      "            If specified as a float it should be in the range [0, 2].\n",
      "            If specified as a tuple ``(min, max)`` dithering is employed. Dithering\n",
      "            randomly changes the mutation constant on a generation by generation\n",
      "            basis. The mutation constant for that generation is taken from\n",
      "            ``U[min, max)``. Dithering can help speed convergence significantly.\n",
      "            Increasing the mutation constant increases the search radius, but will\n",
      "            slow down convergence.\n",
      "        recombination : float, optional\n",
      "            The recombination constant, should be in the range [0, 1]. In the\n",
      "            literature this is also known as the crossover probability, being\n",
      "            denoted by CR. Increasing this value allows a larger number of mutants\n",
      "            to progress into the next generation, but at the risk of population\n",
      "            stability.\n",
      "        seed : int or `np.random.RandomState`, optional\n",
      "            If `seed` is not specified the `np.RandomState` singleton is used.\n",
      "            If `seed` is an int, a new `np.random.RandomState` instance is used,\n",
      "            seeded with seed.\n",
      "            If `seed` is already a `np.random.RandomState instance`, then that\n",
      "            `np.random.RandomState` instance is used.\n",
      "            Specify `seed` for repeatable minimizations.\n",
      "        disp : bool, optional\n",
      "            Display status messages\n",
      "        callback : callable, `callback(xk, convergence=val)`, optional\n",
      "            A function to follow the progress of the minimization. ``xk`` is\n",
      "            the current value of ``x0``. ``val`` represents the fractional\n",
      "            value of the population convergence.  When ``val`` is greater than one\n",
      "            the function halts. If callback returns `True`, then the minimization\n",
      "            is halted (any polishing is still carried out).\n",
      "        polish : bool, optional\n",
      "            If True (default), then `scipy.optimize.minimize` with the `L-BFGS-B`\n",
      "            method is used to polish the best population member at the end, which\n",
      "            can improve the minimization slightly.\n",
      "        init : string, optional\n",
      "            Specify how the population initialization is performed. Should be\n",
      "            one of:\n",
      "        \n",
      "                - 'latinhypercube'\n",
      "                - 'random'\n",
      "        \n",
      "            The default is 'latinhypercube'. Latin Hypercube sampling tries to\n",
      "            maximize coverage of the available parameter space. 'random' initializes\n",
      "            the population randomly - this has the drawback that clustering can\n",
      "            occur, preventing the whole of parameter space being covered.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        res : OptimizeResult\n",
      "            The optimization result represented as a `OptimizeResult` object.\n",
      "            Important attributes are: ``x`` the solution array, ``success`` a\n",
      "            Boolean flag indicating if the optimizer exited successfully and\n",
      "            ``message`` which describes the cause of the termination. See\n",
      "            `OptimizeResult` for a description of other attributes.  If `polish`\n",
      "            was employed, and a lower minimum was obtained by the polishing, then\n",
      "            OptimizeResult also contains the ``jac`` attribute.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Differential evolution is a stochastic population based method that is\n",
      "        useful for global optimization problems. At each pass through the population\n",
      "        the algorithm mutates each candidate solution by mixing with other candidate\n",
      "        solutions to create a trial candidate. There are several strategies [2]_ for\n",
      "        creating trial candidates, which suit some problems more than others. The\n",
      "        'best1bin' strategy is a good starting point for many systems. In this\n",
      "        strategy two members of the population are randomly chosen. Their difference\n",
      "        is used to mutate the best member (the `best` in `best1bin`), :math:`b_0`,\n",
      "        so far:\n",
      "        \n",
      "        .. math::\n",
      "        \n",
      "            b' = b_0 + mutation * (population[rand0] - population[rand1])\n",
      "        \n",
      "        A trial vector is then constructed. Starting with a randomly chosen 'i'th\n",
      "        parameter the trial is sequentially filled (in modulo) with parameters from\n",
      "        `b'` or the original candidate. The choice of whether to use `b'` or the\n",
      "        original candidate is made with a binomial distribution (the 'bin' in\n",
      "        'best1bin') - a random number in [0, 1) is generated.  If this number is\n",
      "        less than the `recombination` constant then the parameter is loaded from\n",
      "        `b'`, otherwise it is loaded from the original candidate.  The final\n",
      "        parameter is always loaded from `b'`.  Once the trial candidate is built\n",
      "        its fitness is assessed. If the trial is better than the original candidate\n",
      "        then it takes its place. If it is also better than the best overall\n",
      "        candidate it also replaces that.\n",
      "        To improve your chances of finding a global minimum use higher `popsize`\n",
      "        values, with higher `mutation` and (dithering), but lower `recombination`\n",
      "        values. This has the effect of widening the search radius, but slowing\n",
      "        convergence.\n",
      "        \n",
      "        .. versionadded:: 0.15.0\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Let us consider the problem of minimizing the Rosenbrock function. This\n",
      "        function is implemented in `rosen` in `scipy.optimize`.\n",
      "        \n",
      "        >>> from scipy.optimize import rosen, differential_evolution\n",
      "        >>> bounds = [(0,2), (0, 2), (0, 2), (0, 2), (0, 2)]\n",
      "        >>> result = differential_evolution(rosen, bounds)\n",
      "        >>> result.x, result.fun\n",
      "        (array([1., 1., 1., 1., 1.]), 1.9216496320061384e-19)\n",
      "        \n",
      "        Next find the minimum of the Ackley function\n",
      "        (http://en.wikipedia.org/wiki/Test_functions_for_optimization).\n",
      "        \n",
      "        >>> from scipy.optimize import differential_evolution\n",
      "        >>> import numpy as np\n",
      "        >>> def ackley(x):\n",
      "        ...     arg1 = -0.2 * np.sqrt(0.5 * (x[0] ** 2 + x[1] ** 2))\n",
      "        ...     arg2 = 0.5 * (np.cos(2. * np.pi * x[0]) + np.cos(2. * np.pi * x[1]))\n",
      "        ...     return -20. * np.exp(arg1) - np.exp(arg2) + 20. + np.e\n",
      "        >>> bounds = [(-5, 5), (-5, 5)]\n",
      "        >>> result = differential_evolution(ackley, bounds)\n",
      "        >>> result.x, result.fun\n",
      "        (array([ 0.,  0.]), 4.4408920985006262e-16)\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Storn, R and Price, K, Differential Evolution - a Simple and\n",
      "               Efficient Heuristic for Global Optimization over Continuous Spaces,\n",
      "               Journal of Global Optimization, 1997, 11, 341 - 359.\n",
      "        .. [2] http://www1.icsi.berkeley.edu/~storn/code.html\n",
      "        .. [3] http://en.wikipedia.org/wiki/Differential_evolution\n",
      "    \n",
      "    excitingmixing(F, xin, iter=None, alpha=None, alphamax=1.0, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using a tuned diagonal Jacobian approximation.\n",
      "        \n",
      "        The Jacobian matrix is diagonal and is tuned on each iteration.\n",
      "        \n",
      "        .. warning::\n",
      "        \n",
      "           This algorithm may be useful for specific problems, but whether\n",
      "           it will work may depend strongly on the problem.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        alpha : float, optional\n",
      "            Initial Jacobian approximation is (-1/alpha).\n",
      "        alphamax : float, optional\n",
      "            The entries of the diagonal Jacobian are kept in the range\n",
      "            ``[alpha, alphamax]``.\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "    \n",
      "    fixed_point(func, x0, args=(), xtol=1e-08, maxiter=500, method='del2')\n",
      "        Find a fixed point of the function.\n",
      "        \n",
      "        Given a function of one or more variables and a starting point, find a\n",
      "        fixed-point of the function: i.e. where ``func(x0) == x0``.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : function\n",
      "            Function to evaluate.\n",
      "        x0 : array_like\n",
      "            Fixed point of function.\n",
      "        args : tuple, optional\n",
      "            Extra arguments to `func`.\n",
      "        xtol : float, optional\n",
      "            Convergence tolerance, defaults to 1e-08.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations, defaults to 500.\n",
      "        method : {\"del2\", \"iteration\"}, optional\n",
      "            Method of finding the fixed-point, defaults to \"del2\"\n",
      "            which uses Steffensen's Method with Aitken's ``Del^2``\n",
      "            convergence acceleration [1]_. The \"iteration\" method simply iterates\n",
      "            the function until convergence is detected, without attempting to\n",
      "            accelerate the convergence.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Burden, Faires, \"Numerical Analysis\", 5th edition, pg. 80\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> from scipy import optimize\n",
      "        >>> def func(x, c1, c2):\n",
      "        ...    return np.sqrt(c1/(x+c2))\n",
      "        >>> c1 = np.array([10,12.])\n",
      "        >>> c2 = np.array([3, 5.])\n",
      "        >>> optimize.fixed_point(func, [1.2, 1.3], args=(c1,c2))\n",
      "        array([ 1.4920333 ,  1.37228132])\n",
      "    \n",
      "    fmin(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None, initial_simplex=None)\n",
      "        Minimize a function using the downhill simplex algorithm.\n",
      "        \n",
      "        This algorithm only uses function values, not derivatives or second\n",
      "        derivatives.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable func(x,*args)\n",
      "            The objective function to be minimized.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to func, i.e. ``f(x,*args)``.\n",
      "        xtol : float, optional\n",
      "            Absolute error in xopt between iterations that is acceptable for\n",
      "            convergence.\n",
      "        ftol : number, optional\n",
      "            Absolute error in func(xopt) between iterations that is acceptable for\n",
      "            convergence.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to perform.\n",
      "        maxfun : number, optional\n",
      "            Maximum number of function evaluations to make.\n",
      "        full_output : bool, optional\n",
      "            Set to True if fopt and warnflag outputs are desired.\n",
      "        disp : bool, optional\n",
      "            Set to True to print convergence messages.\n",
      "        retall : bool, optional\n",
      "            Set to True to return list of solutions at each iteration.\n",
      "        callback : callable, optional\n",
      "            Called after each iteration, as callback(xk), where xk is the\n",
      "            current parameter vector.\n",
      "        initial_simplex : array_like of shape (N + 1, N), optional\n",
      "            Initial simplex. If given, overrides `x0`.\n",
      "            ``initial_simplex[j,:]`` should contain the coordinates of\n",
      "            the j-th vertex of the ``N+1`` vertices in the simplex, where\n",
      "            ``N`` is the dimension.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xopt : ndarray\n",
      "            Parameter that minimizes function.\n",
      "        fopt : float\n",
      "            Value of function at minimum: ``fopt = func(xopt)``.\n",
      "        iter : int\n",
      "            Number of iterations performed.\n",
      "        funcalls : int\n",
      "            Number of function calls made.\n",
      "        warnflag : int\n",
      "            1 : Maximum number of function evaluations made.\n",
      "            2 : Maximum number of iterations reached.\n",
      "        allvecs : list\n",
      "            Solution at each iteration.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'Nelder-Mead' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Uses a Nelder-Mead simplex algorithm to find the minimum of function of\n",
      "        one or more variables.\n",
      "        \n",
      "        This algorithm has a long history of successful use in applications.\n",
      "        But it will usually be slower than an algorithm that uses first or\n",
      "        second derivative information. In practice it can have poor\n",
      "        performance in high-dimensional problems and is not robust to\n",
      "        minimizing complicated functions. Additionally, there currently is no\n",
      "        complete theory describing when the algorithm will successfully\n",
      "        converge to the minimum, or how fast it will if it does. Both the ftol and\n",
      "        xtol criteria must be met for convergence.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Nelder, J.A. and Mead, R. (1965), \"A simplex method for function\n",
      "               minimization\", The Computer Journal, 7, pp. 308-313\n",
      "        \n",
      "        .. [2] Wright, M.H. (1996), \"Direct Search Methods: Once Scorned, Now\n",
      "               Respectable\", in Numerical Analysis 1995, Proceedings of the\n",
      "               1995 Dundee Biennial Conference in Numerical Analysis, D.F.\n",
      "               Griffiths and G.A. Watson (Eds.), Addison Wesley Longman,\n",
      "               Harlow, UK, pp. 191-208.\n",
      "    \n",
      "    fmin_bfgs(f, x0, fprime=None, args=(), gtol=1e-05, norm=inf, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None)\n",
      "        Minimize a function using the BFGS algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : callable f(x,*args)\n",
      "            Objective function to be minimized.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        fprime : callable f'(x,*args), optional\n",
      "            Gradient of f.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to f and fprime.\n",
      "        gtol : float, optional\n",
      "            Gradient norm must be less than gtol before successful termination.\n",
      "        norm : float, optional\n",
      "            Order of norm (Inf is max, -Inf is min)\n",
      "        epsilon : int or ndarray, optional\n",
      "            If fprime is approximated, use this value for the step size.\n",
      "        callback : callable, optional\n",
      "            An optional user-supplied function to call after each\n",
      "            iteration.  Called as callback(xk), where xk is the\n",
      "            current parameter vector.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to perform.\n",
      "        full_output : bool, optional\n",
      "            If True,return fopt, func_calls, grad_calls, and warnflag\n",
      "            in addition to xopt.\n",
      "        disp : bool, optional\n",
      "            Print convergence message if True.\n",
      "        retall : bool, optional\n",
      "            Return a list of results at each iteration if True.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xopt : ndarray\n",
      "            Parameters which minimize f, i.e. f(xopt) == fopt.\n",
      "        fopt : float\n",
      "            Minimum value.\n",
      "        gopt : ndarray\n",
      "            Value of gradient at minimum, f'(xopt), which should be near 0.\n",
      "        Bopt : ndarray\n",
      "            Value of 1/f''(xopt), i.e. the inverse hessian matrix.\n",
      "        func_calls : int\n",
      "            Number of function_calls made.\n",
      "        grad_calls : int\n",
      "            Number of gradient calls made.\n",
      "        warnflag : integer\n",
      "            1 : Maximum number of iterations exceeded.\n",
      "            2 : Gradient and/or function calls not changing.\n",
      "        allvecs  :  list\n",
      "            `OptimizeResult` at each iteration.  Only returned if retall is True.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'BFGS' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Optimize the function, f, whose gradient is given by fprime\n",
      "        using the quasi-Newton method of Broyden, Fletcher, Goldfarb,\n",
      "        and Shanno (BFGS)\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Wright, and Nocedal 'Numerical Optimization', 1999, pg. 198.\n",
      "    \n",
      "    fmin_cg(f, x0, fprime=None, args=(), gtol=1e-05, norm=inf, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None)\n",
      "        Minimize a function using a nonlinear conjugate gradient algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : callable, ``f(x, *args)``\n",
      "            Objective function to be minimized.  Here `x` must be a 1-D array of\n",
      "            the variables that are to be changed in the search for a minimum, and\n",
      "            `args` are the other (fixed) parameters of `f`.\n",
      "        x0 : ndarray\n",
      "            A user-supplied initial estimate of `xopt`, the optimal value of `x`.\n",
      "            It must be a 1-D array of values.\n",
      "        fprime : callable, ``fprime(x, *args)``, optional\n",
      "            A function that returns the gradient of `f` at `x`. Here `x` and `args`\n",
      "            are as described above for `f`. The returned value must be a 1-D array.\n",
      "            Defaults to None, in which case the gradient is approximated\n",
      "            numerically (see `epsilon`, below).\n",
      "        args : tuple, optional\n",
      "            Parameter values passed to `f` and `fprime`. Must be supplied whenever\n",
      "            additional fixed parameters are needed to completely specify the\n",
      "            functions `f` and `fprime`.\n",
      "        gtol : float, optional\n",
      "            Stop when the norm of the gradient is less than `gtol`.\n",
      "        norm : float, optional\n",
      "            Order to use for the norm of the gradient\n",
      "            (``-np.Inf`` is min, ``np.Inf`` is max).\n",
      "        epsilon : float or ndarray, optional\n",
      "            Step size(s) to use when `fprime` is approximated numerically. Can be a\n",
      "            scalar or a 1-D array.  Defaults to ``sqrt(eps)``, with eps the\n",
      "            floating point machine precision.  Usually ``sqrt(eps)`` is about\n",
      "            1.5e-8.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to perform. Default is ``200 * len(x0)``.\n",
      "        full_output : bool, optional\n",
      "            If True, return `fopt`, `func_calls`, `grad_calls`, and `warnflag` in\n",
      "            addition to `xopt`.  See the Returns section below for additional\n",
      "            information on optional return values.\n",
      "        disp : bool, optional\n",
      "            If True, return a convergence message, followed by `xopt`.\n",
      "        retall : bool, optional\n",
      "            If True, add to the returned values the results of each iteration.\n",
      "        callback : callable, optional\n",
      "            An optional user-supplied function, called after each iteration.\n",
      "            Called as ``callback(xk)``, where ``xk`` is the current value of `x0`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xopt : ndarray\n",
      "            Parameters which minimize f, i.e. ``f(xopt) == fopt``.\n",
      "        fopt : float, optional\n",
      "            Minimum value found, f(xopt).  Only returned if `full_output` is True.\n",
      "        func_calls : int, optional\n",
      "            The number of function_calls made.  Only returned if `full_output`\n",
      "            is True.\n",
      "        grad_calls : int, optional\n",
      "            The number of gradient calls made. Only returned if `full_output` is\n",
      "            True.\n",
      "        warnflag : int, optional\n",
      "            Integer value with warning status, only returned if `full_output` is\n",
      "            True.\n",
      "        \n",
      "            0 : Success.\n",
      "        \n",
      "            1 : The maximum number of iterations was exceeded.\n",
      "        \n",
      "            2 : Gradient and/or function calls were not changing.  May indicate\n",
      "                that precision was lost, i.e., the routine did not converge.\n",
      "        \n",
      "        allvecs : list of ndarray, optional\n",
      "            List of arrays, containing the results at each iteration.\n",
      "            Only returned if `retall` is True.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        minimize : common interface to all `scipy.optimize` algorithms for\n",
      "                   unconstrained and constrained minimization of multivariate\n",
      "                   functions.  It provides an alternative way to call\n",
      "                   ``fmin_cg``, by specifying ``method='CG'``.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This conjugate gradient algorithm is based on that of Polak and Ribiere\n",
      "        [1]_.\n",
      "        \n",
      "        Conjugate gradient methods tend to work better when:\n",
      "        \n",
      "        1. `f` has a unique global minimizing point, and no local minima or\n",
      "           other stationary points,\n",
      "        2. `f` is, at least locally, reasonably well approximated by a\n",
      "           quadratic function of the variables,\n",
      "        3. `f` is continuous and has a continuous gradient,\n",
      "        4. `fprime` is not too large, e.g., has a norm less than 1000,\n",
      "        5. The initial guess, `x0`, is reasonably close to `f` 's global\n",
      "           minimizing point, `xopt`.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Wright & Nocedal, \"Numerical Optimization\", 1999, pp. 120-122.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Example 1: seek the minimum value of the expression\n",
      "        ``a*u**2 + b*u*v + c*v**2 + d*u + e*v + f`` for given values\n",
      "        of the parameters and an initial guess ``(u, v) = (0, 0)``.\n",
      "        \n",
      "        >>> args = (2, 3, 7, 8, 9, 10)  # parameter values\n",
      "        >>> def f(x, *args):\n",
      "        ...     u, v = x\n",
      "        ...     a, b, c, d, e, f = args\n",
      "        ...     return a*u**2 + b*u*v + c*v**2 + d*u + e*v + f\n",
      "        >>> def gradf(x, *args):\n",
      "        ...     u, v = x\n",
      "        ...     a, b, c, d, e, f = args\n",
      "        ...     gu = 2*a*u + b*v + d     # u-component of the gradient\n",
      "        ...     gv = b*u + 2*c*v + e     # v-component of the gradient\n",
      "        ...     return np.asarray((gu, gv))\n",
      "        >>> x0 = np.asarray((0, 0))  # Initial guess.\n",
      "        >>> from scipy import optimize\n",
      "        >>> res1 = optimize.fmin_cg(f, x0, fprime=gradf, args=args)\n",
      "        Optimization terminated successfully.\n",
      "                 Current function value: 1.617021\n",
      "                 Iterations: 4\n",
      "                 Function evaluations: 8\n",
      "                 Gradient evaluations: 8\n",
      "        >>> res1\n",
      "        array([-1.80851064, -0.25531915])\n",
      "        \n",
      "        Example 2: solve the same problem using the `minimize` function.\n",
      "        (This `myopts` dictionary shows all of the available options,\n",
      "        although in practice only non-default values would be needed.\n",
      "        The returned value will be a dictionary.)\n",
      "        \n",
      "        >>> opts = {'maxiter' : None,    # default value.\n",
      "        ...         'disp' : True,    # non-default value.\n",
      "        ...         'gtol' : 1e-5,    # default value.\n",
      "        ...         'norm' : np.inf,  # default value.\n",
      "        ...         'eps' : 1.4901161193847656e-08}  # default value.\n",
      "        >>> res2 = optimize.minimize(f, x0, jac=gradf, args=args,\n",
      "        ...                          method='CG', options=opts)\n",
      "        Optimization terminated successfully.\n",
      "                Current function value: 1.617021\n",
      "                Iterations: 4\n",
      "                Function evaluations: 8\n",
      "                Gradient evaluations: 8\n",
      "        >>> res2.x  # minimum found\n",
      "        array([-1.80851064, -0.25531915])\n",
      "    \n",
      "    fmin_cobyla(func, x0, cons, args=(), consargs=None, rhobeg=1.0, rhoend=0.0001, iprint=1, maxfun=1000, disp=None, catol=0.0002)\n",
      "        Minimize a function using the Constrained Optimization BY Linear\n",
      "        Approximation (COBYLA) method. This method wraps a FORTRAN\n",
      "        implementation of the algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable\n",
      "            Function to minimize. In the form func(x, \\*args).\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        cons : sequence\n",
      "            Constraint functions; must all be ``>=0`` (a single function\n",
      "            if only 1 constraint). Each function takes the parameters `x`\n",
      "            as its first argument, and it can return either a single number or\n",
      "            an array or list of numbers.\n",
      "        args : tuple, optional\n",
      "            Extra arguments to pass to function.\n",
      "        consargs : tuple, optional\n",
      "            Extra arguments to pass to constraint functions (default of None means\n",
      "            use same extra arguments as those passed to func).\n",
      "            Use ``()`` for no extra arguments.\n",
      "        rhobeg : float, optional\n",
      "            Reasonable initial changes to the variables.\n",
      "        rhoend : float, optional\n",
      "            Final accuracy in the optimization (not precisely guaranteed). This\n",
      "            is a lower bound on the size of the trust region.\n",
      "        iprint : {0, 1, 2, 3}, optional\n",
      "            Controls the frequency of output; 0 implies no output.  Deprecated.\n",
      "        disp : {0, 1, 2, 3}, optional\n",
      "            Over-rides the iprint interface.  Preferred.\n",
      "        maxfun : int, optional\n",
      "            Maximum number of function evaluations.\n",
      "        catol : float, optional\n",
      "            Absolute tolerance for constraint violations.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : ndarray\n",
      "            The argument that minimises `f`.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'COBYLA' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This algorithm is based on linear approximations to the objective\n",
      "        function and each constraint. We briefly describe the algorithm.\n",
      "        \n",
      "        Suppose the function is being minimized over k variables. At the\n",
      "        jth iteration the algorithm has k+1 points v_1, ..., v_(k+1),\n",
      "        an approximate solution x_j, and a radius RHO_j.\n",
      "        (i.e. linear plus a constant) approximations to the objective\n",
      "        function and constraint functions such that their function values\n",
      "        agree with the linear approximation on the k+1 points v_1,.., v_(k+1).\n",
      "        This gives a linear program to solve (where the linear approximations\n",
      "        of the constraint functions are constrained to be non-negative).\n",
      "        \n",
      "        However the linear approximations are likely only good\n",
      "        approximations near the current simplex, so the linear program is\n",
      "        given the further requirement that the solution, which\n",
      "        will become x_(j+1), must be within RHO_j from x_j. RHO_j only\n",
      "        decreases, never increases. The initial RHO_j is rhobeg and the\n",
      "        final RHO_j is rhoend. In this way COBYLA's iterations behave\n",
      "        like a trust region algorithm.\n",
      "        \n",
      "        Additionally, the linear program may be inconsistent, or the\n",
      "        approximation may give poor improvement. For details about\n",
      "        how these issues are resolved, as well as how the points v_i are\n",
      "        updated, refer to the source code or the references below.\n",
      "        \n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Powell M.J.D. (1994), \"A direct search optimization method that models\n",
      "        the objective and constraint functions by linear interpolation.\", in\n",
      "        Advances in Optimization and Numerical Analysis, eds. S. Gomez and\n",
      "        J-P Hennart, Kluwer Academic (Dordrecht), pp. 51-67\n",
      "        \n",
      "        Powell M.J.D. (1998), \"Direct search algorithms for optimization\n",
      "        calculations\", Acta Numerica 7, 287-336\n",
      "        \n",
      "        Powell M.J.D. (2007), \"A view of algorithms for optimization without\n",
      "        derivatives\", Cambridge University Technical Report DAMTP 2007/NA03\n",
      "        \n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Minimize the objective function f(x,y) = x*y subject\n",
      "        to the constraints x**2 + y**2 < 1 and y > 0::\n",
      "        \n",
      "            >>> def objective(x):\n",
      "            ...     return x[0]*x[1]\n",
      "            ...\n",
      "            >>> def constr1(x):\n",
      "            ...     return 1 - (x[0]**2 + x[1]**2)\n",
      "            ...\n",
      "            >>> def constr2(x):\n",
      "            ...     return x[1]\n",
      "            ...\n",
      "            >>> from scipy.optimize import fmin_cobyla\n",
      "            >>> fmin_cobyla(objective, [0.0, 0.1], [constr1, constr2], rhoend=1e-7)\n",
      "            array([-0.70710685,  0.70710671])\n",
      "        \n",
      "        The exact solution is (-sqrt(2)/2, sqrt(2)/2).\n",
      "    \n",
      "    fmin_l_bfgs_b(func, x0, fprime=None, args=(), approx_grad=0, bounds=None, m=10, factr=10000000.0, pgtol=1e-05, epsilon=1e-08, iprint=-1, maxfun=15000, maxiter=15000, disp=None, callback=None, maxls=20)\n",
      "        Minimize a function func using the L-BFGS-B algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable f(x,*args)\n",
      "            Function to minimise.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        fprime : callable fprime(x,*args), optional\n",
      "            The gradient of `func`.  If None, then `func` returns the function\n",
      "            value and the gradient (``f, g = func(x, *args)``), unless\n",
      "            `approx_grad` is True in which case `func` returns only ``f``.\n",
      "        args : sequence, optional\n",
      "            Arguments to pass to `func` and `fprime`.\n",
      "        approx_grad : bool, optional\n",
      "            Whether to approximate the gradient numerically (in which case\n",
      "            `func` returns only the function value).\n",
      "        bounds : list, optional\n",
      "            ``(min, max)`` pairs for each element in ``x``, defining\n",
      "            the bounds on that parameter. Use None or +-inf for one of ``min`` or\n",
      "            ``max`` when there is no bound in that direction.\n",
      "        m : int, optional\n",
      "            The maximum number of variable metric corrections\n",
      "            used to define the limited memory matrix. (The limited memory BFGS\n",
      "            method does not store the full hessian but uses this many terms in an\n",
      "            approximation to it.)\n",
      "        factr : float, optional\n",
      "            The iteration stops when\n",
      "            ``(f^k - f^{k+1})/max{|f^k|,|f^{k+1}|,1} <= factr * eps``,\n",
      "            where ``eps`` is the machine precision, which is automatically\n",
      "            generated by the code. Typical values for `factr` are: 1e12 for\n",
      "            low accuracy; 1e7 for moderate accuracy; 10.0 for extremely\n",
      "            high accuracy.\n",
      "        pgtol : float, optional\n",
      "            The iteration will stop when\n",
      "            ``max{|proj g_i | i = 1, ..., n} <= pgtol``\n",
      "            where ``pg_i`` is the i-th component of the projected gradient.\n",
      "        epsilon : float, optional\n",
      "            Step size used when `approx_grad` is True, for numerically\n",
      "            calculating the gradient\n",
      "        iprint : int, optional\n",
      "            Controls the frequency of output. ``iprint < 0`` means no output;\n",
      "            ``iprint = 0``    print only one line at the last iteration;\n",
      "            ``0 < iprint < 99`` print also f and ``|proj g|`` every iprint iterations;\n",
      "            ``iprint = 99``   print details of every iteration except n-vectors;\n",
      "            ``iprint = 100``  print also the changes of active set and final x;\n",
      "            ``iprint > 100``  print details of every iteration including x and g.\n",
      "        disp : int, optional\n",
      "            If zero, then no output.  If a positive number, then this over-rides\n",
      "            `iprint` (i.e., `iprint` gets the value of `disp`).\n",
      "        maxfun : int, optional\n",
      "            Maximum number of function evaluations.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations.\n",
      "        callback : callable, optional\n",
      "            Called after each iteration, as ``callback(xk)``, where ``xk`` is the\n",
      "            current parameter vector.\n",
      "        maxls : int, optional\n",
      "            Maximum number of line search steps (per iteration). Default is 20.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : array_like\n",
      "            Estimated position of the minimum.\n",
      "        f : float\n",
      "            Value of `func` at the minimum.\n",
      "        d : dict\n",
      "            Information dictionary.\n",
      "        \n",
      "            * d['warnflag'] is\n",
      "        \n",
      "              - 0 if converged,\n",
      "              - 1 if too many function evaluations or too many iterations,\n",
      "              - 2 if stopped for another reason, given in d['task']\n",
      "        \n",
      "            * d['grad'] is the gradient at the minimum (should be 0 ish)\n",
      "            * d['funcalls'] is the number of function calls made.\n",
      "            * d['nit'] is the number of iterations.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'L-BFGS-B' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        License of L-BFGS-B (FORTRAN code):\n",
      "        \n",
      "        The version included here (in fortran code) is 3.0\n",
      "        (released April 25, 2011).  It was written by Ciyou Zhu, Richard Byrd,\n",
      "        and Jorge Nocedal <nocedal@ece.nwu.edu>. It carries the following\n",
      "        condition for use:\n",
      "        \n",
      "        This software is freely available, but we expect that all publications\n",
      "        describing work using this software, or all commercial products using it,\n",
      "        quote at least one of the references given below. This software is released\n",
      "        under the BSD License.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        * R. H. Byrd, P. Lu and J. Nocedal. A Limited Memory Algorithm for Bound\n",
      "          Constrained Optimization, (1995), SIAM Journal on Scientific and\n",
      "          Statistical Computing, 16, 5, pp. 1190-1208.\n",
      "        * C. Zhu, R. H. Byrd and J. Nocedal. L-BFGS-B: Algorithm 778: L-BFGS-B,\n",
      "          FORTRAN routines for large scale bound constrained optimization (1997),\n",
      "          ACM Transactions on Mathematical Software, 23, 4, pp. 550 - 560.\n",
      "        * J.L. Morales and J. Nocedal. L-BFGS-B: Remark on Algorithm 778: L-BFGS-B,\n",
      "          FORTRAN routines for large scale bound constrained optimization (2011),\n",
      "          ACM Transactions on Mathematical Software, 38, 1.\n",
      "    \n",
      "    fmin_ncg(f, x0, fprime, fhess_p=None, fhess=None, args=(), avextol=1e-05, epsilon=1.4901161193847656e-08, maxiter=None, full_output=0, disp=1, retall=0, callback=None)\n",
      "        Unconstrained minimization of a function using the Newton-CG method.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : callable ``f(x, *args)``\n",
      "            Objective function to be minimized.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        fprime : callable ``f'(x, *args)``\n",
      "            Gradient of f.\n",
      "        fhess_p : callable ``fhess_p(x, p, *args)``, optional\n",
      "            Function which computes the Hessian of f times an\n",
      "            arbitrary vector, p.\n",
      "        fhess : callable ``fhess(x, *args)``, optional\n",
      "            Function to compute the Hessian matrix of f.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to f, fprime, fhess_p, and fhess\n",
      "            (the same set of extra arguments is supplied to all of\n",
      "            these functions).\n",
      "        epsilon : float or ndarray, optional\n",
      "            If fhess is approximated, use this value for the step size.\n",
      "        callback : callable, optional\n",
      "            An optional user-supplied function which is called after\n",
      "            each iteration.  Called as callback(xk), where xk is the\n",
      "            current parameter vector.\n",
      "        avextol : float, optional\n",
      "            Convergence is assumed when the average relative error in\n",
      "            the minimizer falls below this amount.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to perform.\n",
      "        full_output : bool, optional\n",
      "            If True, return the optional outputs.\n",
      "        disp : bool, optional\n",
      "            If True, print convergence message.\n",
      "        retall : bool, optional\n",
      "            If True, return a list of results at each iteration.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xopt : ndarray\n",
      "            Parameters which minimize f, i.e. ``f(xopt) == fopt``.\n",
      "        fopt : float\n",
      "            Value of the function at xopt, i.e. ``fopt = f(xopt)``.\n",
      "        fcalls : int\n",
      "            Number of function calls made.\n",
      "        gcalls : int\n",
      "            Number of gradient calls made.\n",
      "        hcalls : int\n",
      "            Number of hessian calls made.\n",
      "        warnflag : int\n",
      "            Warnings generated by the algorithm.\n",
      "            1 : Maximum number of iterations exceeded.\n",
      "        allvecs : list\n",
      "            The result at each iteration, if retall is True (see below).\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'Newton-CG' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Only one of `fhess_p` or `fhess` need to be given.  If `fhess`\n",
      "        is provided, then `fhess_p` will be ignored.  If neither `fhess`\n",
      "        nor `fhess_p` is provided, then the hessian product will be\n",
      "        approximated using finite differences on `fprime`. `fhess_p`\n",
      "        must compute the hessian times an arbitrary vector. If it is not\n",
      "        given, finite-differences on `fprime` are used to compute\n",
      "        it.\n",
      "        \n",
      "        Newton-CG methods are also called truncated Newton methods. This\n",
      "        function differs from scipy.optimize.fmin_tnc because\n",
      "        \n",
      "        1. scipy.optimize.fmin_ncg is written purely in python using numpy\n",
      "            and scipy while scipy.optimize.fmin_tnc calls a C function.\n",
      "        2. scipy.optimize.fmin_ncg is only for unconstrained minimization\n",
      "            while scipy.optimize.fmin_tnc is for unconstrained minimization\n",
      "            or box constrained minimization. (Box constraints give\n",
      "            lower and upper bounds for each variable separately.)\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Wright & Nocedal, 'Numerical Optimization', 1999, pg. 140.\n",
      "    \n",
      "    fmin_powell(func, x0, args=(), xtol=0.0001, ftol=0.0001, maxiter=None, maxfun=None, full_output=0, disp=1, retall=0, callback=None, direc=None)\n",
      "        Minimize a function using modified Powell's method. This method\n",
      "        only uses function values, not derivatives.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable f(x,*args)\n",
      "            Objective function to be minimized.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to func.\n",
      "        callback : callable, optional\n",
      "            An optional user-supplied function, called after each\n",
      "            iteration.  Called as ``callback(xk)``, where ``xk`` is the\n",
      "            current parameter vector.\n",
      "        direc : ndarray, optional\n",
      "            Initial direction set.\n",
      "        xtol : float, optional\n",
      "            Line-search error tolerance.\n",
      "        ftol : float, optional\n",
      "            Relative error in ``func(xopt)`` acceptable for convergence.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to perform.\n",
      "        maxfun : int, optional\n",
      "            Maximum number of function evaluations to make.\n",
      "        full_output : bool, optional\n",
      "            If True, fopt, xi, direc, iter, funcalls, and\n",
      "            warnflag are returned.\n",
      "        disp : bool, optional\n",
      "            If True, print convergence messages.\n",
      "        retall : bool, optional\n",
      "            If True, return a list of the solution at each iteration.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xopt : ndarray\n",
      "            Parameter which minimizes `func`.\n",
      "        fopt : number\n",
      "            Value of function at minimum: ``fopt = func(xopt)``.\n",
      "        direc : ndarray\n",
      "            Current direction set.\n",
      "        iter : int\n",
      "            Number of iterations.\n",
      "        funcalls : int\n",
      "            Number of function calls made.\n",
      "        warnflag : int\n",
      "            Integer warning flag:\n",
      "                1 : Maximum number of function evaluations.\n",
      "                2 : Maximum number of iterations.\n",
      "        allvecs : list\n",
      "            List of solutions at each iteration.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to unconstrained minimization algorithms for\n",
      "            multivariate functions. See the 'Powell' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Uses a modification of Powell's method to find the minimum of\n",
      "        a function of N variables. Powell's method is a conjugate\n",
      "        direction method.\n",
      "        \n",
      "        The algorithm has two loops. The outer loop\n",
      "        merely iterates over the inner loop. The inner loop minimizes\n",
      "        over each current direction in the direction set. At the end\n",
      "        of the inner loop, if certain conditions are met, the direction\n",
      "        that gave the largest decrease is dropped and replaced with\n",
      "        the difference between the current estimated x and the estimated\n",
      "        x from the beginning of the inner-loop.\n",
      "        \n",
      "        The technical conditions for replacing the direction of greatest\n",
      "        increase amount to checking that\n",
      "        \n",
      "        1. No further gain can be made along the direction of greatest increase\n",
      "           from that iteration.\n",
      "        2. The direction of greatest increase accounted for a large sufficient\n",
      "           fraction of the decrease in the function value from that iteration of\n",
      "           the inner loop.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Powell M.J.D. (1964) An efficient method for finding the minimum of a\n",
      "        function of several variables without calculating derivatives,\n",
      "        Computer Journal, 7 (2):155-162.\n",
      "        \n",
      "        Press W., Teukolsky S.A., Vetterling W.T., and Flannery B.P.:\n",
      "        Numerical Recipes (any edition), Cambridge University Press\n",
      "    \n",
      "    fmin_slsqp(func, x0, eqcons=(), f_eqcons=None, ieqcons=(), f_ieqcons=None, bounds=(), fprime=None, fprime_eqcons=None, fprime_ieqcons=None, args=(), iter=100, acc=1e-06, iprint=1, disp=None, full_output=0, epsilon=1.4901161193847656e-08, callback=None)\n",
      "        Minimize a function using Sequential Least SQuares Programming\n",
      "        \n",
      "        Python interface function for the SLSQP Optimization subroutine\n",
      "        originally implemented by Dieter Kraft.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable f(x,*args)\n",
      "            Objective function.\n",
      "        x0 : 1-D ndarray of float\n",
      "            Initial guess for the independent variable(s).\n",
      "        eqcons : list, optional\n",
      "            A list of functions of length n such that\n",
      "            eqcons[j](x,*args) == 0.0 in a successfully optimized\n",
      "            problem.\n",
      "        f_eqcons : callable f(x,*args), optional\n",
      "            Returns a 1-D array in which each element must equal 0.0 in a\n",
      "            successfully optimized problem.  If f_eqcons is specified,\n",
      "            eqcons is ignored.\n",
      "        ieqcons : list, optional\n",
      "            A list of functions of length n such that\n",
      "            ieqcons[j](x,*args) >= 0.0 in a successfully optimized\n",
      "            problem.\n",
      "        f_ieqcons : callable f(x,*args), optional\n",
      "            Returns a 1-D ndarray in which each element must be greater or\n",
      "            equal to 0.0 in a successfully optimized problem.  If\n",
      "            f_ieqcons is specified, ieqcons is ignored.\n",
      "        bounds : list, optional\n",
      "            A list of tuples specifying the lower and upper bound\n",
      "            for each independent variable [(xl0, xu0),(xl1, xu1),...]\n",
      "            Infinite values will be interpreted as large floating values.\n",
      "        fprime : callable `f(x,*args)`, optional\n",
      "            A function that evaluates the partial derivatives of func.\n",
      "        fprime_eqcons : callable `f(x,*args)`, optional\n",
      "            A function of the form `f(x, *args)` that returns the m by n\n",
      "            array of equality constraint normals.  If not provided,\n",
      "            the normals will be approximated. The array returned by\n",
      "            fprime_eqcons should be sized as ( len(eqcons), len(x0) ).\n",
      "        fprime_ieqcons : callable `f(x,*args)`, optional\n",
      "            A function of the form `f(x, *args)` that returns the m by n\n",
      "            array of inequality constraint normals.  If not provided,\n",
      "            the normals will be approximated. The array returned by\n",
      "            fprime_ieqcons should be sized as ( len(ieqcons), len(x0) ).\n",
      "        args : sequence, optional\n",
      "            Additional arguments passed to func and fprime.\n",
      "        iter : int, optional\n",
      "            The maximum number of iterations.\n",
      "        acc : float, optional\n",
      "            Requested accuracy.\n",
      "        iprint : int, optional\n",
      "            The verbosity of fmin_slsqp :\n",
      "        \n",
      "            * iprint <= 0 : Silent operation\n",
      "            * iprint == 1 : Print summary upon completion (default)\n",
      "            * iprint >= 2 : Print status of each iterate and summary\n",
      "        disp : int, optional\n",
      "            Over-rides the iprint interface (preferred).\n",
      "        full_output : bool, optional\n",
      "            If False, return only the minimizer of func (default).\n",
      "            Otherwise, output final objective function and summary\n",
      "            information.\n",
      "        epsilon : float, optional\n",
      "            The step size for finite-difference derivative estimates.\n",
      "        callback : callable, optional\n",
      "            Called after each iteration, as ``callback(x)``, where ``x`` is the\n",
      "            current parameter vector.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        out : ndarray of float\n",
      "            The final minimizer of func.\n",
      "        fx : ndarray of float, if full_output is true\n",
      "            The final value of the objective function.\n",
      "        its : int, if full_output is true\n",
      "            The number of iterations.\n",
      "        imode : int, if full_output is true\n",
      "            The exit mode from the optimizer (see below).\n",
      "        smode : string, if full_output is true\n",
      "            Message describing the exit mode from the optimizer.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'SLSQP' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Exit modes are defined as follows ::\n",
      "        \n",
      "            -1 : Gradient evaluation required (g & a)\n",
      "             0 : Optimization terminated successfully.\n",
      "             1 : Function evaluation required (f & c)\n",
      "             2 : More equality constraints than independent variables\n",
      "             3 : More than 3*n iterations in LSQ subproblem\n",
      "             4 : Inequality constraints incompatible\n",
      "             5 : Singular matrix E in LSQ subproblem\n",
      "             6 : Singular matrix C in LSQ subproblem\n",
      "             7 : Rank-deficient equality constraint subproblem HFTI\n",
      "             8 : Positive directional derivative for linesearch\n",
      "             9 : Iteration limit exceeded\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Examples are given :ref:`in the tutorial <tutorial-sqlsp>`.\n",
      "    \n",
      "    fmin_tnc(func, x0, fprime=None, args=(), approx_grad=0, bounds=None, epsilon=1e-08, scale=None, offset=None, messages=15, maxCGit=-1, maxfun=None, eta=-1, stepmx=0, accuracy=0, fmin=0, ftol=-1, xtol=-1, pgtol=-1, rescale=-1, disp=None, callback=None)\n",
      "        Minimize a function with variables subject to bounds, using\n",
      "        gradient information in a truncated Newton algorithm. This\n",
      "        method wraps a C implementation of the algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable ``func(x, *args)``\n",
      "            Function to minimize.  Must do one of:\n",
      "        \n",
      "            1. Return f and g, where f is the value of the function and g its\n",
      "               gradient (a list of floats).\n",
      "        \n",
      "            2. Return the function value but supply gradient function\n",
      "               separately as `fprime`.\n",
      "        \n",
      "            3. Return the function value and set ``approx_grad=True``.\n",
      "        \n",
      "            If the function returns None, the minimization\n",
      "            is aborted.\n",
      "        x0 : array_like\n",
      "            Initial estimate of minimum.\n",
      "        fprime : callable ``fprime(x, *args)``, optional\n",
      "            Gradient of `func`. If None, then either `func` must return the\n",
      "            function value and the gradient (``f,g = func(x, *args)``)\n",
      "            or `approx_grad` must be True.\n",
      "        args : tuple, optional\n",
      "            Arguments to pass to function.\n",
      "        approx_grad : bool, optional\n",
      "            If true, approximate the gradient numerically.\n",
      "        bounds : list, optional\n",
      "            (min, max) pairs for each element in x0, defining the\n",
      "            bounds on that parameter. Use None or +/-inf for one of\n",
      "            min or max when there is no bound in that direction.\n",
      "        epsilon : float, optional\n",
      "            Used if approx_grad is True. The stepsize in a finite\n",
      "            difference approximation for fprime.\n",
      "        scale : array_like, optional\n",
      "            Scaling factors to apply to each variable.  If None, the\n",
      "            factors are up-low for interval bounded variables and\n",
      "            1+|x| for the others.  Defaults to None.\n",
      "        offset : array_like, optional\n",
      "            Value to subtract from each variable.  If None, the\n",
      "            offsets are (up+low)/2 for interval bounded variables\n",
      "            and x for the others.\n",
      "        messages : int, optional\n",
      "            Bit mask used to select messages display during\n",
      "            minimization values defined in the MSGS dict.  Defaults to\n",
      "            MGS_ALL.\n",
      "        disp : int, optional\n",
      "            Integer interface to messages.  0 = no message, 5 = all messages\n",
      "        maxCGit : int, optional\n",
      "            Maximum number of hessian*vector evaluations per main\n",
      "            iteration.  If maxCGit == 0, the direction chosen is\n",
      "            -gradient if maxCGit < 0, maxCGit is set to\n",
      "            max(1,min(50,n/2)).  Defaults to -1.\n",
      "        maxfun : int, optional\n",
      "            Maximum number of function evaluation.  if None, maxfun is\n",
      "            set to max(100, 10*len(x0)).  Defaults to None.\n",
      "        eta : float, optional\n",
      "            Severity of the line search. if < 0 or > 1, set to 0.25.\n",
      "            Defaults to -1.\n",
      "        stepmx : float, optional\n",
      "            Maximum step for the line search.  May be increased during\n",
      "            call.  If too small, it will be set to 10.0.  Defaults to 0.\n",
      "        accuracy : float, optional\n",
      "            Relative precision for finite difference calculations.  If\n",
      "            <= machine_precision, set to sqrt(machine_precision).\n",
      "            Defaults to 0.\n",
      "        fmin : float, optional\n",
      "            Minimum function value estimate.  Defaults to 0.\n",
      "        ftol : float, optional\n",
      "            Precision goal for the value of f in the stoping criterion.\n",
      "            If ftol < 0.0, ftol is set to 0.0 defaults to -1.\n",
      "        xtol : float, optional\n",
      "            Precision goal for the value of x in the stopping\n",
      "            criterion (after applying x scaling factors).  If xtol <\n",
      "            0.0, xtol is set to sqrt(machine_precision).  Defaults to\n",
      "            -1.\n",
      "        pgtol : float, optional\n",
      "            Precision goal for the value of the projected gradient in\n",
      "            the stopping criterion (after applying x scaling factors).\n",
      "            If pgtol < 0.0, pgtol is set to 1e-2 * sqrt(accuracy).\n",
      "            Setting it to 0.0 is not recommended.  Defaults to -1.\n",
      "        rescale : float, optional\n",
      "            Scaling factor (in log10) used to trigger f value\n",
      "            rescaling.  If 0, rescale at each iteration.  If a large\n",
      "            value, never rescale.  If < 0, rescale is set to 1.3.\n",
      "        callback : callable, optional\n",
      "            Called after each iteration, as callback(xk), where xk is the\n",
      "            current parameter vector.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : ndarray\n",
      "            The solution.\n",
      "        nfeval : int\n",
      "            The number of function evaluations.\n",
      "        rc : int\n",
      "            Return code, see below\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize: Interface to minimization algorithms for multivariate\n",
      "            functions. See the 'TNC' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The underlying algorithm is truncated Newton, also called\n",
      "        Newton Conjugate-Gradient. This method differs from\n",
      "        scipy.optimize.fmin_ncg in that\n",
      "        \n",
      "        1. It wraps a C implementation of the algorithm\n",
      "        2. It allows each variable to be given an upper and lower bound.\n",
      "        \n",
      "        The algorithm incoporates the bound constraints by determining\n",
      "        the descent direction as in an unconstrained truncated Newton,\n",
      "        but never taking a step-size large enough to leave the space\n",
      "        of feasible x's. The algorithm keeps track of a set of\n",
      "        currently active constraints, and ignores them when computing\n",
      "        the minimum allowable step size. (The x's associated with the\n",
      "        active constraint are kept fixed.) If the maximum allowable\n",
      "        step size is zero then a new constraint is added. At the end\n",
      "        of each iteration one of the constraints may be deemed no\n",
      "        longer active and removed. A constraint is considered\n",
      "        no longer active is if it is currently active\n",
      "        but the gradient for that variable points inward from the\n",
      "        constraint. The specific constraint removed is the one\n",
      "        associated with the variable of largest index whose\n",
      "        constraint is no longer active.\n",
      "        \n",
      "        Return codes are defined as follows::\n",
      "        \n",
      "            -1 : Infeasible (lower bound > upper bound)\n",
      "             0 : Local minimum reached (|pg| ~= 0)\n",
      "             1 : Converged (|f_n-f_(n-1)| ~= 0)\n",
      "             2 : Converged (|x_n-x_(n-1)| ~= 0)\n",
      "             3 : Max. number of function evaluations reached\n",
      "             4 : Linear search failed\n",
      "             5 : All lower bounds are equal to the upper bounds\n",
      "             6 : Unable to progress\n",
      "             7 : User requested end of minimization\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Wright S., Nocedal J. (2006), 'Numerical Optimization'\n",
      "        \n",
      "        Nash S.G. (1984), \"Newton-Type Minimization Via the Lanczos Method\",\n",
      "        SIAM Journal of Numerical Analysis 21, pp. 770-778\n",
      "    \n",
      "    fminbound(func, x1, x2, args=(), xtol=1e-05, maxfun=500, full_output=0, disp=1)\n",
      "        Bounded minimization for scalar functions.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable f(x,*args)\n",
      "            Objective function to be minimized (must accept and return scalars).\n",
      "        x1, x2 : float or array scalar\n",
      "            The optimization bounds.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to function.\n",
      "        xtol : float, optional\n",
      "            The convergence tolerance.\n",
      "        maxfun : int, optional\n",
      "            Maximum number of function evaluations allowed.\n",
      "        full_output : bool, optional\n",
      "            If True, return optional outputs.\n",
      "        disp : int, optional\n",
      "            If non-zero, print messages.\n",
      "                0 : no message printing.\n",
      "                1 : non-convergence notification messages only.\n",
      "                2 : print a message on convergence too.\n",
      "                3 : print iteration results.\n",
      "        \n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        xopt : ndarray\n",
      "            Parameters (over given interval) which minimize the\n",
      "            objective function.\n",
      "        fval : number\n",
      "            The function value at the minimum point.\n",
      "        ierr : int\n",
      "            An error flag (0 if converged, 1 if maximum number of\n",
      "            function calls reached).\n",
      "        numfunc : int\n",
      "          The number of function calls made.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize_scalar: Interface to minimization algorithms for scalar\n",
      "            univariate functions. See the 'Bounded' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Finds a local minimizer of the scalar function `func` in the\n",
      "        interval x1 < xopt < x2 using Brent's method.  (See `brent`\n",
      "        for auto-bracketing).\n",
      "    \n",
      "    fsolve(func, x0, args=(), fprime=None, full_output=0, col_deriv=0, xtol=1.49012e-08, maxfev=0, band=None, epsfcn=None, factor=100, diag=None)\n",
      "        Find the roots of a function.\n",
      "        \n",
      "        Return the roots of the (non-linear) equations defined by\n",
      "        ``func(x) = 0`` given a starting estimate.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable ``f(x, *args)``\n",
      "            A function that takes at least one (possibly vector) argument.\n",
      "        x0 : ndarray\n",
      "            The starting estimate for the roots of ``func(x) = 0``.\n",
      "        args : tuple, optional\n",
      "            Any extra arguments to `func`.\n",
      "        fprime : callable(x), optional\n",
      "            A function to compute the Jacobian of `func` with derivatives\n",
      "            across the rows. By default, the Jacobian will be estimated.\n",
      "        full_output : bool, optional\n",
      "            If True, return optional outputs.\n",
      "        col_deriv : bool, optional\n",
      "            Specify whether the Jacobian function computes derivatives down\n",
      "            the columns (faster, because there is no transpose operation).\n",
      "        xtol : float, optional\n",
      "            The calculation will terminate if the relative error between two\n",
      "            consecutive iterates is at most `xtol`.\n",
      "        maxfev : int, optional\n",
      "            The maximum number of calls to the function. If zero, then\n",
      "            ``100*(N+1)`` is the maximum where N is the number of elements\n",
      "            in `x0`.\n",
      "        band : tuple, optional\n",
      "            If set to a two-sequence containing the number of sub- and\n",
      "            super-diagonals within the band of the Jacobi matrix, the\n",
      "            Jacobi matrix is considered banded (only for ``fprime=None``).\n",
      "        epsfcn : float, optional\n",
      "            A suitable step length for the forward-difference\n",
      "            approximation of the Jacobian (for ``fprime=None``). If\n",
      "            `epsfcn` is less than the machine precision, it is assumed\n",
      "            that the relative errors in the functions are of the order of\n",
      "            the machine precision.\n",
      "        factor : float, optional\n",
      "            A parameter determining the initial step bound\n",
      "            (``factor * || diag * x||``).  Should be in the interval\n",
      "            ``(0.1, 100)``.\n",
      "        diag : sequence, optional\n",
      "            N positive entries that serve as a scale factors for the\n",
      "            variables.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : ndarray\n",
      "            The solution (or the result of the last iteration for\n",
      "            an unsuccessful call).\n",
      "        infodict : dict\n",
      "            A dictionary of optional outputs with the keys:\n",
      "        \n",
      "            ``nfev``\n",
      "                number of function calls\n",
      "            ``njev``\n",
      "                number of Jacobian calls\n",
      "            ``fvec``\n",
      "                function evaluated at the output\n",
      "            ``fjac``\n",
      "                the orthogonal matrix, q, produced by the QR\n",
      "                factorization of the final approximate Jacobian\n",
      "                matrix, stored column wise\n",
      "            ``r``\n",
      "                upper triangular matrix produced by QR factorization\n",
      "                of the same matrix\n",
      "            ``qtf``\n",
      "                the vector ``(transpose(q) * fvec)``\n",
      "        \n",
      "        ier : int\n",
      "            An integer flag.  Set to 1 if a solution was found, otherwise refer\n",
      "            to `mesg` for more information.\n",
      "        mesg : str\n",
      "            If no solution is found, `mesg` details the cause of failure.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        root : Interface to root finding algorithms for multivariate\n",
      "        functions. See the 'hybr' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        ``fsolve`` is a wrapper around MINPACK's hybrd and hybrj algorithms.\n",
      "    \n",
      "    golden(func, args=(), brack=None, tol=1.4901161193847656e-08, full_output=0)\n",
      "        Return the minimum of a function of one variable.\n",
      "        \n",
      "        Given a function of one variable and a possible bracketing interval,\n",
      "        return the minimum of the function isolated to a fractional precision of\n",
      "        tol.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable func(x,*args)\n",
      "            Objective function to minimize.\n",
      "        args : tuple, optional\n",
      "            Additional arguments (if present), passed to func.\n",
      "        brack : tuple, optional\n",
      "            Triple (a,b,c), where (a<b<c) and func(b) <\n",
      "            func(a),func(c).  If bracket consists of two numbers (a,\n",
      "            c), then they are assumed to be a starting interval for a\n",
      "            downhill bracket search (see `bracket`); it doesn't always\n",
      "            mean that obtained solution will satisfy a<=x<=c.\n",
      "        tol : float, optional\n",
      "            x tolerance stop criterion\n",
      "        full_output : bool, optional\n",
      "            If True, return optional outputs.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize_scalar: Interface to minimization algorithms for scalar\n",
      "            univariate functions. See the 'Golden' `method` in particular.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Uses analog of bisection method to decrease the bracketed\n",
      "        interval.\n",
      "    \n",
      "    least_squares(fun, x0, jac='2-point', bounds=(-inf, inf), method='trf', ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0, loss='linear', f_scale=1.0, diff_step=None, tr_solver=None, tr_options={}, jac_sparsity=None, max_nfev=None, verbose=0, args=(), kwargs={})\n",
      "        Solve a nonlinear least-squares problem with bounds on the variables.\n",
      "        \n",
      "        Given the residuals f(x) (an m-dimensional function of n variables) and\n",
      "        the loss function rho(s) (a scalar function), `least_squares` finds a\n",
      "        local minimum of the cost function F(x)::\n",
      "        \n",
      "            minimize F(x) = 0.5 * sum(rho(f_i(x)**2), i = 0, ..., m - 1)\n",
      "            subject to lb <= x <= ub\n",
      "        \n",
      "        The purpose of the loss function rho(s) is to reduce the influence of\n",
      "        outliers on the solution.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fun : callable\n",
      "            Function which computes the vector of residuals, with the signature\n",
      "            ``fun(x, *args, **kwargs)``, i.e., the minimization proceeds with\n",
      "            respect to its first argument. The argument ``x`` passed to this\n",
      "            function is an ndarray of shape (n,) (never a scalar, even for n=1).\n",
      "            It must return a 1-d array_like of shape (m,) or a scalar.\n",
      "        x0 : array_like with shape (n,) or float\n",
      "            Initial guess on independent variables. If float, it will be treated\n",
      "            as a 1-d array with one element.\n",
      "        jac : {'2-point', '3-point', 'cs', callable}, optional\n",
      "            Method of computing the Jacobian matrix (an m-by-n matrix, where\n",
      "            element (i, j) is the partial derivative of f[i] with respect to\n",
      "            x[j]). The keywords select a finite difference scheme for numerical\n",
      "            estimation. The scheme '3-point' is more accurate, but requires\n",
      "            twice as much operations compared to '2-point' (default). The\n",
      "            scheme 'cs' uses complex steps, and while potentially the most\n",
      "            accurate, it is applicable only when `fun` correctly handles\n",
      "            complex inputs and can be analytically continued to the complex\n",
      "            plane. Method 'lm' always uses the '2-point' scheme. If callable,\n",
      "            it is used as ``jac(x, *args, **kwargs)`` and should return a\n",
      "            good approximation (or the exact value) for the Jacobian as an\n",
      "            array_like (np.atleast_2d is applied), a sparse matrix or a\n",
      "            `scipy.sparse.linalg.LinearOperator`.\n",
      "        bounds : 2-tuple of array_like, optional\n",
      "            Lower and upper bounds on independent variables. Defaults to no bounds.\n",
      "            Each array must match the size of `x0` or be a scalar, in the latter\n",
      "            case a bound will be the same for all variables. Use ``np.inf`` with\n",
      "            an appropriate sign to disable bounds on all or some variables.\n",
      "        method : {'trf', 'dogbox', 'lm'}, optional\n",
      "            Algorithm to perform minimization.\n",
      "        \n",
      "                * 'trf' : Trust Region Reflective algorithm, particularly suitable\n",
      "                  for large sparse problems with bounds. Generally robust method.\n",
      "                * 'dogbox' : dogleg algorithm with rectangular trust regions,\n",
      "                  typical use case is small problems with bounds. Not recommended\n",
      "                  for problems with rank-deficient Jacobian.\n",
      "                * 'lm' : Levenberg-Marquardt algorithm as implemented in MINPACK.\n",
      "                  Doesn't handle bounds and sparse Jacobians. Usually the most\n",
      "                  efficient method for small unconstrained problems.\n",
      "        \n",
      "            Default is 'trf'. See Notes for more information.\n",
      "        ftol : float, optional\n",
      "            Tolerance for termination by the change of the cost function. Default\n",
      "            is 1e-8. The optimization process is stopped when  ``dF < ftol * F``,\n",
      "            and there was an adequate agreement between a local quadratic model and\n",
      "            the true model in the last step.\n",
      "        xtol : float, optional\n",
      "            Tolerance for termination by the change of the independent variables.\n",
      "            Default is 1e-8. The exact condition depends on the `method` used:\n",
      "        \n",
      "                * For 'trf' and 'dogbox' : ``norm(dx) < xtol * (xtol + norm(x))``\n",
      "                * For 'lm' : ``Delta < xtol * norm(xs)``, where ``Delta`` is\n",
      "                  a trust-region radius and ``xs`` is the value of ``x``\n",
      "                  scaled according to `x_scale` parameter (see below).\n",
      "        \n",
      "        gtol : float, optional\n",
      "            Tolerance for termination by the norm of the gradient. Default is 1e-8.\n",
      "            The exact condition depends on a `method` used:\n",
      "        \n",
      "                * For 'trf' : ``norm(g_scaled, ord=np.inf) < gtol``, where\n",
      "                  ``g_scaled`` is the value of the gradient scaled to account for\n",
      "                  the presence of the bounds [STIR]_.\n",
      "                * For 'dogbox' : ``norm(g_free, ord=np.inf) < gtol``, where\n",
      "                  ``g_free`` is the gradient with respect to the variables which\n",
      "                  are not in the optimal state on the boundary.\n",
      "                * For 'lm' : the maximum absolute value of the cosine of angles\n",
      "                  between columns of the Jacobian and the residual vector is less\n",
      "                  than `gtol`, or the residual vector is zero.\n",
      "        \n",
      "        x_scale : array_like or 'jac', optional\n",
      "            Characteristic scale of each variable. Setting `x_scale` is equivalent\n",
      "            to reformulating the problem in scaled variables ``xs = x / x_scale``.\n",
      "            An alternative view is that the size of a trust region along j-th\n",
      "            dimension is proportional to ``x_scale[j]``. Improved convergence may\n",
      "            be achieved by setting `x_scale` such that a step of a given size\n",
      "            along any of the scaled variables has a similar effect on the cost\n",
      "            function. If set to 'jac', the scale is iteratively updated using the\n",
      "            inverse norms of the columns of the Jacobian matrix (as described in\n",
      "            [JJMore]_).\n",
      "        loss : str or callable, optional\n",
      "            Determines the loss function. The following keyword values are allowed:\n",
      "        \n",
      "                * 'linear' (default) : ``rho(z) = z``. Gives a standard\n",
      "                  least-squares problem.\n",
      "                * 'soft_l1' : ``rho(z) = 2 * ((1 + z)**0.5 - 1)``. The smooth\n",
      "                  approximation of l1 (absolute value) loss. Usually a good\n",
      "                  choice for robust least squares.\n",
      "                * 'huber' : ``rho(z) = z if z <= 1 else 2*z**0.5 - 1``. Works\n",
      "                  similarly to 'soft_l1'.\n",
      "                * 'cauchy' : ``rho(z) = ln(1 + z)``. Severely weakens outliers\n",
      "                  influence, but may cause difficulties in optimization process.\n",
      "                * 'arctan' : ``rho(z) = arctan(z)``. Limits a maximum loss on\n",
      "                  a single residual, has properties similar to 'cauchy'.\n",
      "        \n",
      "            If callable, it must take a 1-d ndarray ``z=f**2`` and return an\n",
      "            array_like with shape (3, m) where row 0 contains function values,\n",
      "            row 1 contains first derivatives and row 2 contains second\n",
      "            derivatives. Method 'lm' supports only 'linear' loss.\n",
      "        f_scale : float, optional\n",
      "            Value of soft margin between inlier and outlier residuals, default\n",
      "            is 1.0. The loss function is evaluated as follows\n",
      "            ``rho_(f**2) = C**2 * rho(f**2 / C**2)``, where ``C`` is `f_scale`,\n",
      "            and ``rho`` is determined by `loss` parameter. This parameter has\n",
      "            no effect with ``loss='linear'``, but for other `loss` values it is\n",
      "            of crucial importance.\n",
      "        max_nfev : None or int, optional\n",
      "            Maximum number of function evaluations before the termination.\n",
      "            If None (default), the value is chosen automatically:\n",
      "        \n",
      "                * For 'trf' and 'dogbox' : 100 * n.\n",
      "                * For 'lm' :  100 * n if `jac` is callable and 100 * n * (n + 1)\n",
      "                  otherwise (because 'lm' counts function calls in Jacobian\n",
      "                  estimation).\n",
      "        \n",
      "        diff_step : None or array_like, optional\n",
      "            Determines the relative step size for the finite difference\n",
      "            approximation of the Jacobian. The actual step is computed as\n",
      "            ``x * diff_step``. If None (default), then `diff_step` is taken to be\n",
      "            a conventional \"optimal\" power of machine epsilon for the finite\n",
      "            difference scheme used [NR]_.\n",
      "        tr_solver : {None, 'exact', 'lsmr'}, optional\n",
      "            Method for solving trust-region subproblems, relevant only for 'trf'\n",
      "            and 'dogbox' methods.\n",
      "        \n",
      "                * 'exact' is suitable for not very large problems with dense\n",
      "                  Jacobian matrices. The computational complexity per iteration is\n",
      "                  comparable to a singular value decomposition of the Jacobian\n",
      "                  matrix.\n",
      "                * 'lsmr' is suitable for problems with sparse and large Jacobian\n",
      "                  matrices. It uses the iterative procedure\n",
      "                  `scipy.sparse.linalg.lsmr` for finding a solution of a linear\n",
      "                  least-squares problem and only requires matrix-vector product\n",
      "                  evaluations.\n",
      "        \n",
      "            If None (default) the solver is chosen based on the type of Jacobian\n",
      "            returned on the first iteration.\n",
      "        tr_options : dict, optional\n",
      "            Keyword options passed to trust-region solver.\n",
      "        \n",
      "                * ``tr_solver='exact'``: `tr_options` are ignored.\n",
      "                * ``tr_solver='lsmr'``: options for `scipy.sparse.linalg.lsmr`.\n",
      "                  Additionally  ``method='trf'`` supports  'regularize' option\n",
      "                  (bool, default is True) which adds a regularization term to the\n",
      "                  normal equation, which improves convergence if the Jacobian is\n",
      "                  rank-deficient [Byrd]_ (eq. 3.4).\n",
      "        \n",
      "        jac_sparsity : {None, array_like, sparse matrix}, optional\n",
      "            Defines the sparsity structure of the Jacobian matrix for finite\n",
      "            difference estimation, its shape must be (m, n). If the Jacobian has\n",
      "            only few non-zero elements in *each* row, providing the sparsity\n",
      "            structure will greatly speed up the computations [Curtis]_. A zero\n",
      "            entry means that a corresponding element in the Jacobian is identically\n",
      "            zero. If provided, forces the use of 'lsmr' trust-region solver.\n",
      "            If None (default) then dense differencing will be used. Has no effect\n",
      "            for 'lm' method.\n",
      "        verbose : {0, 1, 2}, optional\n",
      "            Level of algorithm's verbosity:\n",
      "        \n",
      "                * 0 (default) : work silently.\n",
      "                * 1 : display a termination report.\n",
      "                * 2 : display progress during iterations (not supported by 'lm'\n",
      "                  method).\n",
      "        \n",
      "        args, kwargs : tuple and dict, optional\n",
      "            Additional arguments passed to `fun` and `jac`. Both empty by default.\n",
      "            The calling signature is ``fun(x, *args, **kwargs)`` and the same for\n",
      "            `jac`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        `OptimizeResult` with the following fields defined:\n",
      "        x : ndarray, shape (n,)\n",
      "            Solution found.\n",
      "        cost : float\n",
      "            Value of the cost function at the solution.\n",
      "        fun : ndarray, shape (m,)\n",
      "            Vector of residuals at the solution.\n",
      "        jac : ndarray, sparse matrix or LinearOperator, shape (m, n)\n",
      "            Modified Jacobian matrix at the solution, in the sense that J^T J\n",
      "            is a Gauss-Newton approximation of the Hessian of the cost function.\n",
      "            The type is the same as the one used by the algorithm.\n",
      "        grad : ndarray, shape (m,)\n",
      "            Gradient of the cost function at the solution.\n",
      "        optimality : float\n",
      "            First-order optimality measure. In unconstrained problems, it is always\n",
      "            the uniform norm of the gradient. In constrained problems, it is the\n",
      "            quantity which was compared with `gtol` during iterations.\n",
      "        active_mask : ndarray of int, shape (n,)\n",
      "            Each component shows whether a corresponding constraint is active\n",
      "            (that is, whether a variable is at the bound):\n",
      "        \n",
      "                *  0 : a constraint is not active.\n",
      "                * -1 : a lower bound is active.\n",
      "                *  1 : an upper bound is active.\n",
      "        \n",
      "            Might be somewhat arbitrary for 'trf' method as it generates a sequence\n",
      "            of strictly feasible iterates and `active_mask` is determined within a\n",
      "            tolerance threshold.\n",
      "        nfev : int\n",
      "            Number of function evaluations done. Methods 'trf' and 'dogbox' do not\n",
      "            count function calls for numerical Jacobian approximation, as opposed\n",
      "            to 'lm' method.\n",
      "        njev : int or None\n",
      "            Number of Jacobian evaluations done. If numerical Jacobian\n",
      "            approximation is used in 'lm' method, it is set to None.\n",
      "        status : int\n",
      "            The reason for algorithm termination:\n",
      "        \n",
      "                * -1 : improper input parameters status returned from MINPACK.\n",
      "                *  0 : the maximum number of function evaluations is exceeded.\n",
      "                *  1 : `gtol` termination condition is satisfied.\n",
      "                *  2 : `ftol` termination condition is satisfied.\n",
      "                *  3 : `xtol` termination condition is satisfied.\n",
      "                *  4 : Both `ftol` and `xtol` termination conditions are satisfied.\n",
      "        \n",
      "        message : str\n",
      "            Verbal description of the termination reason.\n",
      "        success : bool\n",
      "            True if one of the convergence criteria is satisfied (`status` > 0).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        leastsq : A legacy wrapper for the MINPACK implementation of the\n",
      "                  Levenberg-Marquadt algorithm.\n",
      "        curve_fit : Least-squares minimization applied to a curve fitting problem.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Method 'lm' (Levenberg-Marquardt) calls a wrapper over least-squares\n",
      "        algorithms implemented in MINPACK (lmder, lmdif). It runs the\n",
      "        Levenberg-Marquardt algorithm formulated as a trust-region type algorithm.\n",
      "        The implementation is based on paper [JJMore]_, it is very robust and\n",
      "        efficient with a lot of smart tricks. It should be your first choice\n",
      "        for unconstrained problems. Note that it doesn't support bounds. Also\n",
      "        it doesn't work when m < n.\n",
      "        \n",
      "        Method 'trf' (Trust Region Reflective) is motivated by the process of\n",
      "        solving a system of equations, which constitute the first-order optimality\n",
      "        condition for a bound-constrained minimization problem as formulated in\n",
      "        [STIR]_. The algorithm iteratively solves trust-region subproblems\n",
      "        augmented by a special diagonal quadratic term and with trust-region shape\n",
      "        determined by the distance from the bounds and the direction of the\n",
      "        gradient. This enhancements help to avoid making steps directly into bounds\n",
      "        and efficiently explore the whole space of variables. To further improve\n",
      "        convergence, the algorithm considers search directions reflected from the\n",
      "        bounds. To obey theoretical requirements, the algorithm keeps iterates\n",
      "        strictly feasible. With dense Jacobians trust-region subproblems are\n",
      "        solved by an exact method very similar to the one described in [JJMore]_\n",
      "        (and implemented in MINPACK). The difference from the MINPACK\n",
      "        implementation is that a singular value decomposition of a Jacobian\n",
      "        matrix is done once per iteration, instead of a QR decomposition and series\n",
      "        of Givens rotation eliminations. For large sparse Jacobians a 2-d subspace\n",
      "        approach of solving trust-region subproblems is used [STIR]_, [Byrd]_.\n",
      "        The subspace is spanned by a scaled gradient and an approximate\n",
      "        Gauss-Newton solution delivered by `scipy.sparse.linalg.lsmr`. When no\n",
      "        constraints are imposed the algorithm is very similar to MINPACK and has\n",
      "        generally comparable performance. The algorithm works quite robust in\n",
      "        unbounded and bounded problems, thus it is chosen as a default algorithm.\n",
      "        \n",
      "        Method 'dogbox' operates in a trust-region framework, but considers\n",
      "        rectangular trust regions as opposed to conventional ellipsoids [Voglis]_.\n",
      "        The intersection of a current trust region and initial bounds is again\n",
      "        rectangular, so on each iteration a quadratic minimization problem subject\n",
      "        to bound constraints is solved approximately by Powell's dogleg method\n",
      "        [NumOpt]_. The required Gauss-Newton step can be computed exactly for\n",
      "        dense Jacobians or approximately by `scipy.sparse.linalg.lsmr` for large\n",
      "        sparse Jacobians. The algorithm is likely to exhibit slow convergence when\n",
      "        the rank of Jacobian is less than the number of variables. The algorithm\n",
      "        often outperforms 'trf' in bounded problems with a small number of\n",
      "        variables.\n",
      "        \n",
      "        Robust loss functions are implemented as described in [BA]_. The idea\n",
      "        is to modify a residual vector and a Jacobian matrix on each iteration\n",
      "        such that computed gradient and Gauss-Newton Hessian approximation match\n",
      "        the true gradient and Hessian approximation of the cost function. Then\n",
      "        the algorithm proceeds in a normal way, i.e. robust loss functions are\n",
      "        implemented as a simple wrapper over standard least-squares algorithms.\n",
      "        \n",
      "        .. versionadded:: 0.17.0\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [STIR] M. A. Branch, T. F. Coleman, and Y. Li, \"A Subspace, Interior,\n",
      "                  and Conjugate Gradient Method for Large-Scale Bound-Constrained\n",
      "                  Minimization Problems,\" SIAM Journal on Scientific Computing,\n",
      "                  Vol. 21, Number 1, pp 1-23, 1999.\n",
      "        .. [NR] William H. Press et. al., \"Numerical Recipes. The Art of Scientific\n",
      "                Computing. 3rd edition\", Sec. 5.7.\n",
      "        .. [Byrd] R. H. Byrd, R. B. Schnabel and G. A. Shultz, \"Approximate\n",
      "                  solution of the trust region problem by minimization over\n",
      "                  two-dimensional subspaces\", Math. Programming, 40, pp. 247-263,\n",
      "                  1988.\n",
      "        .. [Curtis] A. Curtis, M. J. D. Powell, and J. Reid, \"On the estimation of\n",
      "                    sparse Jacobian matrices\", Journal of the Institute of\n",
      "                    Mathematics and its Applications, 13, pp. 117-120, 1974.\n",
      "        .. [JJMore] J. J. More, \"The Levenberg-Marquardt Algorithm: Implementation\n",
      "                    and Theory,\" Numerical Analysis, ed. G. A. Watson, Lecture\n",
      "                    Notes in Mathematics 630, Springer Verlag, pp. 105-116, 1977.\n",
      "        .. [Voglis] C. Voglis and I. E. Lagaris, \"A Rectangular Trust Region\n",
      "                    Dogleg Approach for Unconstrained and Bound Constrained\n",
      "                    Nonlinear Optimization\", WSEAS International Conference on\n",
      "                    Applied Mathematics, Corfu, Greece, 2004.\n",
      "        .. [NumOpt] J. Nocedal and S. J. Wright, \"Numerical optimization,\n",
      "                    2nd edition\", Chapter 4.\n",
      "        .. [BA] B. Triggs et. al., \"Bundle Adjustment - A Modern Synthesis\",\n",
      "                Proceedings of the International Workshop on Vision Algorithms:\n",
      "                Theory and Practice, pp. 298-372, 1999.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        In this example we find a minimum of the Rosenbrock function without bounds\n",
      "        on independed variables.\n",
      "        \n",
      "        >>> def fun_rosenbrock(x):\n",
      "        ...     return np.array([10 * (x[1] - x[0]**2), (1 - x[0])])\n",
      "        \n",
      "        Notice that we only provide the vector of the residuals. The algorithm\n",
      "        constructs the cost function as a sum of squares of the residuals, which\n",
      "        gives the Rosenbrock function. The exact minimum is at ``x = [1.0, 1.0]``.\n",
      "        \n",
      "        >>> from scipy.optimize import least_squares\n",
      "        >>> x0_rosenbrock = np.array([2, 2])\n",
      "        >>> res_1 = least_squares(fun_rosenbrock, x0_rosenbrock)\n",
      "        >>> res_1.x\n",
      "        array([ 1.,  1.])\n",
      "        >>> res_1.cost\n",
      "        9.8669242910846867e-30\n",
      "        >>> res_1.optimality\n",
      "        8.8928864934219529e-14\n",
      "        \n",
      "        We now constrain the variables, in such a way that the previous solution\n",
      "        becomes infeasible. Specifically, we require that ``x[1] >= 1.5``, and\n",
      "        ``x[0]`` left unconstrained. To this end, we specify the `bounds` parameter\n",
      "        to `least_squares` in the form ``bounds=([-np.inf, 1.5], np.inf)``.\n",
      "        \n",
      "        We also provide the analytic Jacobian:\n",
      "        \n",
      "        >>> def jac_rosenbrock(x):\n",
      "        ...     return np.array([\n",
      "        ...         [-20 * x[0], 10],\n",
      "        ...         [-1, 0]])\n",
      "        \n",
      "        Putting this all together, we see that the new solution lies on the bound:\n",
      "        \n",
      "        >>> res_2 = least_squares(fun_rosenbrock, x0_rosenbrock, jac_rosenbrock,\n",
      "        ...                       bounds=([-np.inf, 1.5], np.inf))\n",
      "        >>> res_2.x\n",
      "        array([ 1.22437075,  1.5       ])\n",
      "        >>> res_2.cost\n",
      "        0.025213093946805685\n",
      "        >>> res_2.optimality\n",
      "        1.5885401433157753e-07\n",
      "        \n",
      "        Now we solve a system of equations (i.e., the cost function should be zero\n",
      "        at a minimum) for a Broyden tridiagonal vector-valued function of 100000\n",
      "        variables:\n",
      "        \n",
      "        >>> def fun_broyden(x):\n",
      "        ...     f = (3 - x) * x + 1\n",
      "        ...     f[1:] -= x[:-1]\n",
      "        ...     f[:-1] -= 2 * x[1:]\n",
      "        ...     return f\n",
      "        \n",
      "        The corresponding Jacobian matrix is sparse. We tell the algorithm to\n",
      "        estimate it by finite differences and provide the sparsity structure of\n",
      "        Jacobian to significantly speed up this process.\n",
      "        \n",
      "        >>> from scipy.sparse import lil_matrix\n",
      "        >>> def sparsity_broyden(n):\n",
      "        ...     sparsity = lil_matrix((n, n), dtype=int)\n",
      "        ...     i = np.arange(n)\n",
      "        ...     sparsity[i, i] = 1\n",
      "        ...     i = np.arange(1, n)\n",
      "        ...     sparsity[i, i - 1] = 1\n",
      "        ...     i = np.arange(n - 1)\n",
      "        ...     sparsity[i, i + 1] = 1\n",
      "        ...     return sparsity\n",
      "        ...\n",
      "        >>> n = 100000\n",
      "        >>> x0_broyden = -np.ones(n)\n",
      "        ...\n",
      "        >>> res_3 = least_squares(fun_broyden, x0_broyden,\n",
      "        ...                       jac_sparsity=sparsity_broyden(n))\n",
      "        >>> res_3.cost\n",
      "        4.5687069299604613e-23\n",
      "        >>> res_3.optimality\n",
      "        1.1650454296851518e-11\n",
      "        \n",
      "        Let's also solve a curve fitting problem using robust loss function to\n",
      "        take care of outliers in the data. Define the model function as\n",
      "        ``y = a + b * exp(c * t)``, where t is a predictor variable, y is an\n",
      "        observation and a, b, c are parameters to estimate.\n",
      "        \n",
      "        First, define the function which generates the data with noise and\n",
      "        outliers, define the model parameters, and generate data:\n",
      "        \n",
      "        >>> def gen_data(t, a, b, c, noise=0, n_outliers=0, random_state=0):\n",
      "        ...     y = a + b * np.exp(t * c)\n",
      "        ...\n",
      "        ...     rnd = np.random.RandomState(random_state)\n",
      "        ...     error = noise * rnd.randn(t.size)\n",
      "        ...     outliers = rnd.randint(0, t.size, n_outliers)\n",
      "        ...     error[outliers] *= 10\n",
      "        ...\n",
      "        ...     return y + error\n",
      "        ...\n",
      "        >>> a = 0.5\n",
      "        >>> b = 2.0\n",
      "        >>> c = -1\n",
      "        >>> t_min = 0\n",
      "        >>> t_max = 10\n",
      "        >>> n_points = 15\n",
      "        ...\n",
      "        >>> t_train = np.linspace(t_min, t_max, n_points)\n",
      "        >>> y_train = gen_data(t_train, a, b, c, noise=0.1, n_outliers=3)\n",
      "        \n",
      "        Define function for computing residuals and initial estimate of\n",
      "        parameters.\n",
      "        \n",
      "        >>> def fun(x, t, y):\n",
      "        ...     return x[0] + x[1] * np.exp(x[2] * t) - y\n",
      "        ...\n",
      "        >>> x0 = np.array([1.0, 1.0, 0.0])\n",
      "        \n",
      "        Compute a standard least-squares solution:\n",
      "        \n",
      "        >>> res_lsq = least_squares(fun, x0, args=(t_train, y_train))\n",
      "        \n",
      "        Now compute two solutions with two different robust loss functions. The\n",
      "        parameter `f_scale` is set to 0.1, meaning that inlier residuals should\n",
      "        not significantly exceed 0.1 (the noise level used).\n",
      "        \n",
      "        >>> res_soft_l1 = least_squares(fun, x0, loss='soft_l1', f_scale=0.1,\n",
      "        ...                             args=(t_train, y_train))\n",
      "        >>> res_log = least_squares(fun, x0, loss='cauchy', f_scale=0.1,\n",
      "        ...                         args=(t_train, y_train))\n",
      "        \n",
      "        And finally plot all the curves. We see that by selecting an appropriate\n",
      "        `loss`  we can get estimates close to optimal even in the presence of\n",
      "        strong outliers. But keep in mind that generally it is recommended to try\n",
      "        'soft_l1' or 'huber' losses first (if at all necessary) as the other two\n",
      "        options may cause difficulties in optimization process.\n",
      "        \n",
      "        >>> t_test = np.linspace(t_min, t_max, n_points * 10)\n",
      "        >>> y_true = gen_data(t_test, a, b, c)\n",
      "        >>> y_lsq = gen_data(t_test, *res_lsq.x)\n",
      "        >>> y_soft_l1 = gen_data(t_test, *res_soft_l1.x)\n",
      "        >>> y_log = gen_data(t_test, *res_log.x)\n",
      "        ...\n",
      "        >>> import matplotlib.pyplot as plt\n",
      "        >>> plt.plot(t_train, y_train, 'o')\n",
      "        >>> plt.plot(t_test, y_true, 'k', linewidth=2, label='true')\n",
      "        >>> plt.plot(t_test, y_lsq, label='linear loss')\n",
      "        >>> plt.plot(t_test, y_soft_l1, label='soft_l1 loss')\n",
      "        >>> plt.plot(t_test, y_log, label='cauchy loss')\n",
      "        >>> plt.xlabel(\"t\")\n",
      "        >>> plt.ylabel(\"y\")\n",
      "        >>> plt.legend()\n",
      "        >>> plt.show()\n",
      "    \n",
      "    leastsq(func, x0, args=(), Dfun=None, full_output=0, col_deriv=0, ftol=1.49012e-08, xtol=1.49012e-08, gtol=0.0, maxfev=0, epsfcn=None, factor=100, diag=None)\n",
      "        Minimize the sum of squares of a set of equations.\n",
      "        \n",
      "        ::\n",
      "        \n",
      "            x = arg min(sum(func(y)**2,axis=0))\n",
      "                     y\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : callable\n",
      "            should take at least one (possibly length N vector) argument and\n",
      "            returns M floating point numbers. It must not return NaNs or\n",
      "            fitting might fail.\n",
      "        x0 : ndarray\n",
      "            The starting estimate for the minimization.\n",
      "        args : tuple, optional\n",
      "            Any extra arguments to func are placed in this tuple.\n",
      "        Dfun : callable, optional\n",
      "            A function or method to compute the Jacobian of func with derivatives\n",
      "            across the rows. If this is None, the Jacobian will be estimated.\n",
      "        full_output : bool, optional\n",
      "            non-zero to return all optional outputs.\n",
      "        col_deriv : bool, optional\n",
      "            non-zero to specify that the Jacobian function computes derivatives\n",
      "            down the columns (faster, because there is no transpose operation).\n",
      "        ftol : float, optional\n",
      "            Relative error desired in the sum of squares.\n",
      "        xtol : float, optional\n",
      "            Relative error desired in the approximate solution.\n",
      "        gtol : float, optional\n",
      "            Orthogonality desired between the function vector and the columns of\n",
      "            the Jacobian.\n",
      "        maxfev : int, optional\n",
      "            The maximum number of calls to the function. If `Dfun` is provided\n",
      "            then the default `maxfev` is 100*(N+1) where N is the number of elements\n",
      "            in x0, otherwise the default `maxfev` is 200*(N+1).\n",
      "        epsfcn : float, optional\n",
      "            A variable used in determining a suitable step length for the forward-\n",
      "            difference approximation of the Jacobian (for Dfun=None).\n",
      "            Normally the actual step length will be sqrt(epsfcn)*x\n",
      "            If epsfcn is less than the machine precision, it is assumed that the\n",
      "            relative errors are of the order of the machine precision.\n",
      "        factor : float, optional\n",
      "            A parameter determining the initial step bound\n",
      "            (``factor * || diag * x||``). Should be in interval ``(0.1, 100)``.\n",
      "        diag : sequence, optional\n",
      "            N positive entries that serve as a scale factors for the variables.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : ndarray\n",
      "            The solution (or the result of the last iteration for an unsuccessful\n",
      "            call).\n",
      "        cov_x : ndarray\n",
      "            Uses the fjac and ipvt optional outputs to construct an\n",
      "            estimate of the jacobian around the solution. None if a\n",
      "            singular matrix encountered (indicates very flat curvature in\n",
      "            some direction).  This matrix must be multiplied by the\n",
      "            residual variance to get the covariance of the\n",
      "            parameter estimates -- see curve_fit.\n",
      "        infodict : dict\n",
      "            a dictionary of optional outputs with the key s:\n",
      "        \n",
      "            ``nfev``\n",
      "                The number of function calls\n",
      "            ``fvec``\n",
      "                The function evaluated at the output\n",
      "            ``fjac``\n",
      "                A permutation of the R matrix of a QR\n",
      "                factorization of the final approximate\n",
      "                Jacobian matrix, stored column wise.\n",
      "                Together with ipvt, the covariance of the\n",
      "                estimate can be approximated.\n",
      "            ``ipvt``\n",
      "                An integer array of length N which defines\n",
      "                a permutation matrix, p, such that\n",
      "                fjac*p = q*r, where r is upper triangular\n",
      "                with diagonal elements of nonincreasing\n",
      "                magnitude. Column j of p is column ipvt(j)\n",
      "                of the identity matrix.\n",
      "            ``qtf``\n",
      "                The vector (transpose(q) * fvec).\n",
      "        \n",
      "        mesg : str\n",
      "            A string message giving information about the cause of failure.\n",
      "        ier : int\n",
      "            An integer flag.  If it is equal to 1, 2, 3 or 4, the solution was\n",
      "            found.  Otherwise, the solution was not found. In either case, the\n",
      "            optional output variable 'mesg' gives more information.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        \"leastsq\" is a wrapper around MINPACK's lmdif and lmder algorithms.\n",
      "        \n",
      "        cov_x is a Jacobian approximation to the Hessian of the least squares\n",
      "        objective function.\n",
      "        This approximation assumes that the objective function is based on the\n",
      "        difference between some observed target data (ydata) and a (non-linear)\n",
      "        function of the parameters `f(xdata, params)` ::\n",
      "        \n",
      "               func(params) = ydata - f(xdata, params)\n",
      "        \n",
      "        so that the objective function is ::\n",
      "        \n",
      "               min   sum((ydata - f(xdata, params))**2, axis=0)\n",
      "             params\n",
      "    \n",
      "    line_search = line_search_wolfe2(f, myfprime, xk, pk, gfk=None, old_fval=None, old_old_fval=None, args=(), c1=0.0001, c2=0.9, amax=50)\n",
      "        Find alpha that satisfies strong Wolfe conditions.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : callable f(x,*args)\n",
      "            Objective function.\n",
      "        myfprime : callable f'(x,*args)\n",
      "            Objective function gradient.\n",
      "        xk : ndarray\n",
      "            Starting point.\n",
      "        pk : ndarray\n",
      "            Search direction.\n",
      "        gfk : ndarray, optional\n",
      "            Gradient value for x=xk (xk being the current parameter\n",
      "            estimate). Will be recomputed if omitted.\n",
      "        old_fval : float, optional\n",
      "            Function value for x=xk. Will be recomputed if omitted.\n",
      "        old_old_fval : float, optional\n",
      "            Function value for the point preceding x=xk\n",
      "        args : tuple, optional\n",
      "            Additional arguments passed to objective function.\n",
      "        c1 : float, optional\n",
      "            Parameter for Armijo condition rule.\n",
      "        c2 : float, optional\n",
      "            Parameter for curvature condition rule.\n",
      "        amax : float, optional\n",
      "            Maximum step size\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        alpha : float or None\n",
      "            Alpha for which ``x_new = x0 + alpha * pk``,\n",
      "            or None if the line search algorithm did not converge.\n",
      "        fc : int\n",
      "            Number of function evaluations made.\n",
      "        gc : int\n",
      "            Number of gradient evaluations made.\n",
      "        new_fval : float or None\n",
      "            New function value ``f(x_new)=f(x0+alpha*pk)``,\n",
      "            or None if the line search algorithm did not converge.\n",
      "        old_fval : float\n",
      "            Old function value ``f(x0)``.\n",
      "        new_slope : float or None\n",
      "            The local slope along the search direction at the\n",
      "            new value ``<myfprime(x_new), pk>``,\n",
      "            or None if the line search algorithm did not converge.\n",
      "        \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Uses the line search algorithm to enforce strong Wolfe\n",
      "        conditions.  See Wright and Nocedal, 'Numerical Optimization',\n",
      "        1999, pg. 59-60.\n",
      "        \n",
      "        For the zoom phase it uses an algorithm by [...].\n",
      "    \n",
      "    linear_sum_assignment(cost_matrix)\n",
      "        Solve the linear sum assignment problem.\n",
      "        \n",
      "        The linear sum assignment problem is also known as minimum weight matching\n",
      "        in bipartite graphs. A problem instance is described by a matrix C, where\n",
      "        each C[i,j] is the cost of matching vertex i of the first partite set\n",
      "        (a \"worker\") and vertex j of the second set (a \"job\"). The goal is to find\n",
      "        a complete assignment of workers to jobs of minimal cost.\n",
      "        \n",
      "        Formally, let X be a boolean matrix where :math:`X[i,j] = 1` iff row i is\n",
      "        assigned to column j. Then the optimal assignment has cost\n",
      "        \n",
      "        .. math::\n",
      "            \\min \\sum_i \\sum_j C_{i,j} X_{i,j}\n",
      "        \n",
      "        s.t. each row is assignment to at most one column, and each column to at\n",
      "        most one row.\n",
      "        \n",
      "        This function can also solve a generalization of the classic assignment\n",
      "        problem where the cost matrix is rectangular. If it has more rows than\n",
      "        columns, then not every row needs to be assigned to a column, and vice\n",
      "        versa.\n",
      "        \n",
      "        The method used is the Hungarian algorithm, also known as the Munkres or\n",
      "        Kuhn-Munkres algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        cost_matrix : array\n",
      "            The cost matrix of the bipartite graph.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        row_ind, col_ind : array\n",
      "            An array of row indices and one of corresponding column indices giving\n",
      "            the optimal assignment. The cost of the assignment can be computed\n",
      "            as ``cost_matrix[row_ind, col_ind].sum()``. The row indices will be\n",
      "            sorted; in the case of a square cost matrix they will be equal to\n",
      "            ``numpy.arange(cost_matrix.shape[0])``.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        .. versionadded:: 0.17.0\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        >>> cost = np.array([[4, 1, 3], [2, 0, 5], [3, 2, 2]])\n",
      "        >>> from scipy.optimize import linear_sum_assignment\n",
      "        >>> row_ind, col_ind = linear_sum_assignment(cost)\n",
      "        >>> col_ind\n",
      "        array([1, 0, 2])\n",
      "        >>> cost[row_ind, col_ind].sum()\n",
      "        5\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        1. http://csclab.murraystate.edu/bob.pilgrim/445/munkres.html\n",
      "        \n",
      "        2. Harold W. Kuhn. The Hungarian Method for the assignment problem.\n",
      "           *Naval Research Logistics Quarterly*, 2:83-97, 1955.\n",
      "        \n",
      "        3. Harold W. Kuhn. Variants of the Hungarian method for assignment\n",
      "           problems. *Naval Research Logistics Quarterly*, 3: 253-258, 1956.\n",
      "        \n",
      "        4. Munkres, J. Algorithms for the Assignment and Transportation Problems.\n",
      "           *J. SIAM*, 5(1):32-38, March, 1957.\n",
      "        \n",
      "        5. https://en.wikipedia.org/wiki/Hungarian_algorithm\n",
      "    \n",
      "    linearmixing(F, xin, iter=None, alpha=None, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using a scalar Jacobian approximation.\n",
      "        \n",
      "        .. warning::\n",
      "        \n",
      "           This algorithm may be useful for specific problems, but whether\n",
      "           it will work may depend strongly on the problem.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        alpha : float, optional\n",
      "            The Jacobian approximation is (-1/alpha).\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "    \n",
      "    linprog(c, A_ub=None, b_ub=None, A_eq=None, b_eq=None, bounds=None, method='simplex', callback=None, options=None)\n",
      "        Minimize a linear objective function subject to linear\n",
      "        equality and inequality constraints.\n",
      "        \n",
      "        Linear Programming is intended to solve the following problem form:\n",
      "        \n",
      "        Minimize:     c^T * x\n",
      "        \n",
      "        Subject to:   A_ub * x <= b_ub\n",
      "                      A_eq * x == b_eq\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        c : array_like\n",
      "            Coefficients of the linear objective function to be minimized.\n",
      "        A_ub : array_like, optional\n",
      "            2-D array which, when matrix-multiplied by x, gives the values of the\n",
      "            upper-bound inequality constraints at x.\n",
      "        b_ub : array_like, optional\n",
      "            1-D array of values representing the upper-bound of each inequality\n",
      "            constraint (row) in A_ub.\n",
      "        A_eq : array_like, optional\n",
      "            2-D array which, when matrix-multiplied by x, gives the values of the\n",
      "            equality constraints at x.\n",
      "        b_eq : array_like, optional\n",
      "            1-D array of values representing the RHS of each equality constraint\n",
      "            (row) in A_eq.\n",
      "        bounds : sequence, optional\n",
      "            ``(min, max)`` pairs for each element in ``x``, defining\n",
      "            the bounds on that parameter. Use None for one of ``min`` or\n",
      "            ``max`` when there is no bound in that direction. By default\n",
      "            bounds are ``(0, None)`` (non-negative)\n",
      "            If a sequence containing a single tuple is provided, then ``min`` and\n",
      "            ``max`` will be applied to all variables in the problem.\n",
      "        method : str, optional\n",
      "            Type of solver.  At this time only 'simplex' is supported\n",
      "            :ref:`(see here) <optimize.linprog-simplex>`.\n",
      "        callback : callable, optional\n",
      "            If a callback function is provide, it will be called within each\n",
      "            iteration of the simplex algorithm. The callback must have the signature\n",
      "            `callback(xk, **kwargs)` where xk is the current solution vector\n",
      "            and kwargs is a dictionary containing the following::\n",
      "        \n",
      "                \"tableau\" : The current Simplex algorithm tableau\n",
      "                \"nit\" : The current iteration.\n",
      "                \"pivot\" : The pivot (row, column) used for the next iteration.\n",
      "                \"phase\" : Whether the algorithm is in Phase 1 or Phase 2.\n",
      "                \"basis\" : The indices of the columns of the basic variables.\n",
      "        \n",
      "        options : dict, optional\n",
      "            A dictionary of solver options. All methods accept the following\n",
      "            generic options:\n",
      "        \n",
      "                maxiter : int\n",
      "                    Maximum number of iterations to perform.\n",
      "                disp : bool\n",
      "                    Set to True to print convergence messages.\n",
      "        \n",
      "            For method-specific options, see `show_options('linprog')`.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        A `scipy.optimize.OptimizeResult` consisting of the following fields:\n",
      "        \n",
      "            x : ndarray\n",
      "                The independent variable vector which optimizes the linear\n",
      "                programming problem.\n",
      "            fun : float\n",
      "                Value of the objective function.\n",
      "            slack : ndarray\n",
      "                The values of the slack variables.  Each slack variable corresponds\n",
      "                to an inequality constraint.  If the slack is zero, then the\n",
      "                corresponding constraint is active.\n",
      "            success : bool\n",
      "                Returns True if the algorithm succeeded in finding an optimal\n",
      "                solution.\n",
      "            status : int\n",
      "                An integer representing the exit status of the optimization::\n",
      "        \n",
      "                     0 : Optimization terminated successfully\n",
      "                     1 : Iteration limit reached\n",
      "                     2 : Problem appears to be infeasible\n",
      "                     3 : Problem appears to be unbounded\n",
      "        \n",
      "            nit : int\n",
      "                The number of iterations performed.\n",
      "            message : str\n",
      "                A string descriptor of the exit status of the optimization.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        show_options : Additional options accepted by the solvers\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This section describes the available solvers that can be selected by the\n",
      "        'method' parameter. The default method is :ref:`Simplex <optimize.linprog-simplex>`.\n",
      "        \n",
      "        Method *Simplex* uses the Simplex algorithm (as it relates to Linear\n",
      "        Programming, NOT the Nelder-Mead Simplex) [1]_, [2]_. This algorithm\n",
      "        should be reasonably reliable and fast.\n",
      "        \n",
      "        .. versionadded:: 0.15.0\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Dantzig, George B., Linear programming and extensions. Rand\n",
      "               Corporation Research Study Princeton Univ. Press, Princeton, NJ, 1963\n",
      "        .. [2] Hillier, S.H. and Lieberman, G.J. (1995), \"Introduction to\n",
      "               Mathematical Programming\", McGraw-Hill, Chapter 4.\n",
      "        .. [3] Bland, Robert G. New finite pivoting rules for the simplex method.\n",
      "               Mathematics of Operations Research (2), 1977: pp. 103-107.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Consider the following problem:\n",
      "        \n",
      "        Minimize: f = -1*x[0] + 4*x[1]\n",
      "        \n",
      "        Subject to: -3*x[0] + 1*x[1] <= 6\n",
      "                     1*x[0] + 2*x[1] <= 4\n",
      "                                x[1] >= -3\n",
      "        \n",
      "        where:  -inf <= x[0] <= inf\n",
      "        \n",
      "        This problem deviates from the standard linear programming problem.\n",
      "        In standard form, linear programming problems assume the variables x are\n",
      "        non-negative.  Since the variables don't have standard bounds where\n",
      "        0 <= x <= inf, the bounds of the variables must be explicitly set.\n",
      "        \n",
      "        There are two upper-bound constraints, which can be expressed as\n",
      "        \n",
      "        dot(A_ub, x) <= b_ub\n",
      "        \n",
      "        The input for this problem is as follows:\n",
      "        \n",
      "        >>> c = [-1, 4]\n",
      "        >>> A = [[-3, 1], [1, 2]]\n",
      "        >>> b = [6, 4]\n",
      "        >>> x0_bounds = (None, None)\n",
      "        >>> x1_bounds = (-3, None)\n",
      "        >>> from scipy.optimize import linprog\n",
      "        >>> res = linprog(c, A_ub=A, b_ub=b, bounds=(x0_bounds, x1_bounds),\n",
      "        ...               options={\"disp\": True})\n",
      "        Optimization terminated successfully.\n",
      "             Current function value: -22.000000\n",
      "             Iterations: 1\n",
      "        >>> print(res)\n",
      "             fun: -22.0\n",
      "         message: 'Optimization terminated successfully.'\n",
      "             nit: 1\n",
      "           slack: array([ 39.,   0.])\n",
      "          status: 0\n",
      "         success: True\n",
      "               x: array([ 10.,  -3.])\n",
      "        \n",
      "        Note the actual objective value is 11.428571.  In this case we minimized\n",
      "        the negative of the objective function.\n",
      "    \n",
      "    linprog_verbose_callback(xk, **kwargs)\n",
      "        A sample callback function demonstrating the linprog callback interface.\n",
      "        This callback produces detailed output to sys.stdout before each iteration\n",
      "        and after the final iteration of the simplex algorithm.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        xk : array_like\n",
      "            The current solution vector.\n",
      "        **kwargs : dict\n",
      "            A dictionary containing the following parameters:\n",
      "        \n",
      "            tableau : array_like\n",
      "                The current tableau of the simplex algorithm.\n",
      "                Its structure is defined in _solve_simplex.\n",
      "            phase : int\n",
      "                The current Phase of the simplex algorithm (1 or 2)\n",
      "            nit : int\n",
      "                The current iteration number.\n",
      "            pivot : tuple(int, int)\n",
      "                The index of the tableau selected as the next pivot,\n",
      "                or nan if no pivot exists\n",
      "            basis : array(int)\n",
      "                A list of the current basic variables.\n",
      "                Each element contains the name of a basic variable and its value.\n",
      "            complete : bool\n",
      "                True if the simplex algorithm has completed\n",
      "                (and this is the final call to callback), otherwise False.\n",
      "    \n",
      "    lsq_linear(A, b, bounds=(-inf, inf), method='trf', tol=1e-10, lsq_solver=None, lsmr_tol=None, max_iter=None, verbose=0)\n",
      "        Solve a linear least-squares problem with bounds on the variables.\n",
      "        \n",
      "        Given a m-by-n design matrix A and a target vector b with m elements,\n",
      "        `lsq_linear` solves the following optimization problem::\n",
      "        \n",
      "            minimize 0.5 * ||A x - b||**2\n",
      "            subject to lb <= x <= ub\n",
      "        \n",
      "        This optimization problem is convex, hence a found minimum (if iterations\n",
      "        have converged) is guaranteed to be global.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        A : array_like, sparse matrix of LinearOperator, shape (m, n)\n",
      "            Design matrix. Can be `scipy.sparse.linalg.LinearOperator`.\n",
      "        b : array_like, shape (m,)\n",
      "            Target vector.\n",
      "        bounds : 2-tuple of array_like, optional\n",
      "            Lower and upper bounds on independent variables. Defaults to no bounds.\n",
      "            Each array must have shape (n,) or be a scalar, in the latter\n",
      "            case a bound will be the same for all variables. Use ``np.inf`` with\n",
      "            an appropriate sign to disable bounds on all or some variables.\n",
      "        method : 'trf' or 'bvls', optional\n",
      "            Method to perform minimization.\n",
      "        \n",
      "                * 'trf' : Trust Region Reflective algorithm adapted for a linear\n",
      "                  least-squares problem. This is an interior-point-like method\n",
      "                  and the required number of iterations is weakly correlated with\n",
      "                  the number of variables.\n",
      "                * 'bvls' : Bounded-Variable Least-Squares algorithm. This is\n",
      "                  an active set method, which requires the number of iterations\n",
      "                  comparable to the number of variables. Can't be used when `A` is\n",
      "                  sparse or LinearOperator.\n",
      "        \n",
      "            Default is 'trf'.\n",
      "        tol : float, optional\n",
      "            Tolerance parameter. The algorithm terminates if a relative change\n",
      "            of the cost function is less than `tol` on the last iteration.\n",
      "            Additionally the first-order optimality measure is considered:\n",
      "        \n",
      "                * ``method='trf'`` terminates if the uniform norm of the gradient,\n",
      "                  scaled to account for the presence of the bounds, is less than\n",
      "                  `tol`.\n",
      "                * ``method='bvls'`` terminates if Karush-Kuhn-Tucker conditions\n",
      "                  are satisfied within `tol` tolerance.\n",
      "        \n",
      "        lsq_solver : {None, 'exact', 'lsmr'}, optional\n",
      "            Method of solving unbounded least-squares problems throughout\n",
      "            iterations:\n",
      "        \n",
      "                * 'exact' : Use dense QR or SVD decomposition approach. Can't be\n",
      "                  used when `A` is sparse or LinearOperator.\n",
      "                * 'lsmr' : Use `scipy.sparse.linalg.lsmr` iterative procedure\n",
      "                  which requires only matrix-vector product evaluations. Can't\n",
      "                  be used with ``method='bvls'``.\n",
      "        \n",
      "            If None (default) the solver is chosen based on type of `A`.\n",
      "        lsmr_tol : None, float or 'auto', optional\n",
      "            Tolerance parameters 'atol' and 'btol' for `scipy.sparse.linalg.lsmr`\n",
      "            If None (default), it is set to ``1e-2 * tol``. If 'auto', the\n",
      "            tolerance will be adjusted based on the optimality of the current\n",
      "            iterate, which can speed up the optimization process, but is not always\n",
      "            reliable.\n",
      "        max_iter : None or int, optional\n",
      "            Maximum number of iterations before termination. If None (default), it\n",
      "            is set to 100 for ``method='trf'`` or to the number of variables for\n",
      "            ``method='bvls'`` (not counting iterations for 'bvls' initialization).\n",
      "        verbose : {0, 1, 2}, optional\n",
      "            Level of algorithm's verbosity:\n",
      "        \n",
      "                * 0 : work silently (default).\n",
      "                * 1 : display a termination report.\n",
      "                * 2 : display progress during iterations.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        OptimizeResult with the following fields defined:\n",
      "        x : ndarray, shape (n,)\n",
      "            Solution found.\n",
      "        cost : float\n",
      "            Value of the cost function at the solution.\n",
      "        fun : ndarray, shape (m,)\n",
      "            Vector of residuals at the solution.\n",
      "        optimality : float\n",
      "            First-order optimality measure. The exact meaning depends on `method`,\n",
      "            refer to the description of `tol` parameter.\n",
      "        active_mask : ndarray of int, shape (n,)\n",
      "            Each component shows whether a corresponding constraint is active\n",
      "            (that is, whether a variable is at the bound):\n",
      "        \n",
      "                *  0 : a constraint is not active.\n",
      "                * -1 : a lower bound is active.\n",
      "                *  1 : an upper bound is active.\n",
      "        \n",
      "            Might be somewhat arbitrary for the `trf` method as it generates a\n",
      "            sequence of strictly feasible iterates and active_mask is determined\n",
      "            within a tolerance threshold.\n",
      "        nit : int\n",
      "            Number of iterations. Zero if the unconstrained solution is optimal.\n",
      "        status : int\n",
      "            Reason for algorithm termination:\n",
      "        \n",
      "                * -1 : the algorithm was not able to make progress on the last\n",
      "                  iteration.\n",
      "                *  0 : the maximum number of iterations is exceeded.\n",
      "                *  1 : the first-order optimality measure is less than `tol`.\n",
      "                *  2 : the relative change of the cost function is less than `tol`.\n",
      "                *  3 : the unconstrained solution is optimal.\n",
      "        \n",
      "        message : str\n",
      "            Verbal description of the termination reason.\n",
      "        success : bool\n",
      "            True if one of the convergence criteria is satisfied (`status` > 0).\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        nnls : Linear least squares with non-negativity constraint.\n",
      "        least_squares : Nonlinear least squares with bounds on the variables.                    \n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The algorithm first computes the unconstrained least-squares solution by\n",
      "        `numpy.linalg.lstsq` or `scipy.sparse.linalg.lsmr` depending on\n",
      "        `lsq_solver`. This solution is returned as optimal if it lies within the\n",
      "        bounds.\n",
      "        \n",
      "        Method 'trf' runs the adaptation of the algorithm described in [STIR]_ for\n",
      "        a linear least-squares problem. The iterations are essentially the same as\n",
      "        in the nonlinear least-squares algorithm, but as the quadratic function\n",
      "        model is always accurate, we don't need to track or modify the radius of\n",
      "        a trust region. The line search (backtracking) is used as a safety net\n",
      "        when a selected step does not decrease the cost function. Read more\n",
      "        detailed description of the algorithm in `scipy.optimize.least_squares`.\n",
      "        \n",
      "        Method 'bvls' runs a Python implementation of the algorithm described in\n",
      "        [BVLS]_. The algorithm maintains active and free sets of variables, on\n",
      "        each iteration chooses a new variable to move from the active set to the\n",
      "        free set and then solves the unconstrained least-squares problem on free\n",
      "        variables. This algorithm is guaranteed to give an accurate solution\n",
      "        eventually, but may require up to n iterations for a problem with n\n",
      "        variables. Additionally, an ad-hoc initialization procedure is\n",
      "        implemented, that determines which variables to set free or active\n",
      "        initially. It takes some number of iterations before actual BVLS starts,\n",
      "        but can significantly reduce the number of further iterations.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [STIR] M. A. Branch, T. F. Coleman, and Y. Li, \"A Subspace, Interior,\n",
      "                  and Conjugate Gradient Method for Large-Scale Bound-Constrained\n",
      "                  Minimization Problems,\" SIAM Journal on Scientific Computing,\n",
      "                  Vol. 21, Number 1, pp 1-23, 1999.\n",
      "        .. [BVLS] P. B. Start and R. L. Parker, \"Bounded-Variable Least-Squares:\n",
      "                  an Algorithm and Applications\", Computational Statistics, 10,\n",
      "                  129-141, 1995.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        In this example a problem with a large sparse matrix and bounds on the\n",
      "        variables is solved.\n",
      "        \n",
      "        >>> from scipy.sparse import rand\n",
      "        >>> from scipy.optimize import lsq_linear\n",
      "        ...\n",
      "        >>> np.random.seed(0)\n",
      "        ...\n",
      "        >>> m = 20000\n",
      "        >>> n = 10000\n",
      "        ...\n",
      "        >>> A = rand(m, n, density=1e-4)\n",
      "        >>> b = np.random.randn(m)\n",
      "        ...\n",
      "        >>> lb = np.random.randn(n)\n",
      "        >>> ub = lb + 1\n",
      "        ...\n",
      "        >>> res = lsq_linear(A, b, bounds=(lb, ub), lsmr_tol='auto', verbose=1)\n",
      "        # may vary\n",
      "        The relative change of the cost function is less than `tol`.\n",
      "        Number of iterations 16, initial cost 1.5039e+04, final cost 1.1112e+04,\n",
      "        first-order optimality 4.66e-08.\n",
      "    \n",
      "    minimize(fun, x0, args=(), method=None, jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None)\n",
      "        Minimization of scalar function of one or more variables.\n",
      "        \n",
      "        In general, the optimization problems are of the form::\n",
      "        \n",
      "            minimize f(x) subject to\n",
      "        \n",
      "            g_i(x) >= 0,  i = 1,...,m\n",
      "            h_j(x)  = 0,  j = 1,...,p\n",
      "        \n",
      "        where x is a vector of one or more variables.\n",
      "        ``g_i(x)`` are the inequality constraints.\n",
      "        ``h_j(x)`` are the equality constrains.\n",
      "        \n",
      "        Optionally, the lower and upper bounds for each element in x can also be\n",
      "        specified using the `bounds` argument.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fun : callable\n",
      "            Objective function.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to the objective function and its\n",
      "            derivatives (Jacobian, Hessian).\n",
      "        method : str or callable, optional\n",
      "            Type of solver.  Should be one of\n",
      "        \n",
      "                - 'Nelder-Mead' :ref:`(see here) <optimize.minimize-neldermead>`\n",
      "                - 'Powell'      :ref:`(see here) <optimize.minimize-powell>`\n",
      "                - 'CG'          :ref:`(see here) <optimize.minimize-cg>`\n",
      "                - 'BFGS'        :ref:`(see here) <optimize.minimize-bfgs>`\n",
      "                - 'Newton-CG'   :ref:`(see here) <optimize.minimize-newtoncg>`\n",
      "                - 'L-BFGS-B'    :ref:`(see here) <optimize.minimize-lbfgsb>`\n",
      "                - 'TNC'         :ref:`(see here) <optimize.minimize-tnc>`\n",
      "                - 'COBYLA'      :ref:`(see here) <optimize.minimize-cobyla>`\n",
      "                - 'SLSQP'       :ref:`(see here) <optimize.minimize-slsqp>`\n",
      "                - 'dogleg'      :ref:`(see here) <optimize.minimize-dogleg>`\n",
      "                - 'trust-ncg'   :ref:`(see here) <optimize.minimize-trustncg>`\n",
      "                - custom - a callable object (added in version 0.14.0),\n",
      "                  see below for description.\n",
      "        \n",
      "            If not given, chosen to be one of ``BFGS``, ``L-BFGS-B``, ``SLSQP``,\n",
      "            depending if the problem has constraints or bounds.\n",
      "        jac : bool or callable, optional\n",
      "            Jacobian (gradient) of objective function. Only for CG, BFGS,\n",
      "            Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg.\n",
      "            If `jac` is a Boolean and is True, `fun` is assumed to return the\n",
      "            gradient along with the objective function. If False, the\n",
      "            gradient will be estimated numerically.\n",
      "            `jac` can also be a callable returning the gradient of the\n",
      "            objective. In this case, it must accept the same arguments as `fun`.\n",
      "        hess, hessp : callable, optional\n",
      "            Hessian (matrix of second-order derivatives) of objective function or\n",
      "            Hessian of objective function times an arbitrary vector p.  Only for\n",
      "            Newton-CG, dogleg, trust-ncg.\n",
      "            Only one of `hessp` or `hess` needs to be given.  If `hess` is\n",
      "            provided, then `hessp` will be ignored.  If neither `hess` nor\n",
      "            `hessp` is provided, then the Hessian product will be approximated\n",
      "            using finite differences on `jac`. `hessp` must compute the Hessian\n",
      "            times an arbitrary vector.\n",
      "        bounds : sequence, optional\n",
      "            Bounds for variables (only for L-BFGS-B, TNC and SLSQP).\n",
      "            ``(min, max)`` pairs for each element in ``x``, defining\n",
      "            the bounds on that parameter. Use None for one of ``min`` or\n",
      "            ``max`` when there is no bound in that direction.\n",
      "        constraints : dict or sequence of dict, optional\n",
      "            Constraints definition (only for COBYLA and SLSQP).\n",
      "            Each constraint is defined in a dictionary with fields:\n",
      "        \n",
      "                type : str\n",
      "                    Constraint type: 'eq' for equality, 'ineq' for inequality.\n",
      "                fun : callable\n",
      "                    The function defining the constraint.\n",
      "                jac : callable, optional\n",
      "                    The Jacobian of `fun` (only for SLSQP).\n",
      "                args : sequence, optional\n",
      "                    Extra arguments to be passed to the function and Jacobian.\n",
      "        \n",
      "            Equality constraint means that the constraint function result is to\n",
      "            be zero whereas inequality means that it is to be non-negative.\n",
      "            Note that COBYLA only supports inequality constraints.\n",
      "        tol : float, optional\n",
      "            Tolerance for termination. For detailed control, use solver-specific\n",
      "            options.\n",
      "        options : dict, optional\n",
      "            A dictionary of solver options. All methods accept the following\n",
      "            generic options:\n",
      "        \n",
      "                maxiter : int\n",
      "                    Maximum number of iterations to perform.\n",
      "                disp : bool\n",
      "                    Set to True to print convergence messages.\n",
      "        \n",
      "            For method-specific options, see :func:`show_options()`.\n",
      "        callback : callable, optional\n",
      "            Called after each iteration, as ``callback(xk)``, where ``xk`` is the\n",
      "            current parameter vector.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        res : OptimizeResult\n",
      "            The optimization result represented as a ``OptimizeResult`` object.\n",
      "            Important attributes are: ``x`` the solution array, ``success`` a\n",
      "            Boolean flag indicating if the optimizer exited successfully and\n",
      "            ``message`` which describes the cause of the termination. See\n",
      "            `OptimizeResult` for a description of other attributes.\n",
      "        \n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize_scalar : Interface to minimization algorithms for scalar\n",
      "            univariate functions\n",
      "        show_options : Additional options accepted by the solvers\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This section describes the available solvers that can be selected by the\n",
      "        'method' parameter. The default method is *BFGS*.\n",
      "        \n",
      "        **Unconstrained minimization**\n",
      "        \n",
      "        Method :ref:`Nelder-Mead <optimize.minimize-neldermead>` uses the\n",
      "        Simplex algorithm [1]_, [2]_. This algorithm is robust in many\n",
      "        applications. However, if numerical computation of derivative can be\n",
      "        trusted, other algorithms using the first and/or second derivatives\n",
      "        information might be preferred for their better performance in\n",
      "        general.\n",
      "        \n",
      "        Method :ref:`Powell <optimize.minimize-powell>` is a modification\n",
      "        of Powell's method [3]_, [4]_ which is a conjugate direction\n",
      "        method. It performs sequential one-dimensional minimizations along\n",
      "        each vector of the directions set (`direc` field in `options` and\n",
      "        `info`), which is updated at each iteration of the main\n",
      "        minimization loop. The function need not be differentiable, and no\n",
      "        derivatives are taken.\n",
      "        \n",
      "        Method :ref:`CG <optimize.minimize-cg>` uses a nonlinear conjugate\n",
      "        gradient algorithm by Polak and Ribiere, a variant of the\n",
      "        Fletcher-Reeves method described in [5]_ pp.  120-122. Only the\n",
      "        first derivatives are used.\n",
      "        \n",
      "        Method :ref:`BFGS <optimize.minimize-bfgs>` uses the quasi-Newton\n",
      "        method of Broyden, Fletcher, Goldfarb, and Shanno (BFGS) [5]_\n",
      "        pp. 136. It uses the first derivatives only. BFGS has proven good\n",
      "        performance even for non-smooth optimizations. This method also\n",
      "        returns an approximation of the Hessian inverse, stored as\n",
      "        `hess_inv` in the OptimizeResult object.\n",
      "        \n",
      "        Method :ref:`Newton-CG <optimize.minimize-newtoncg>` uses a\n",
      "        Newton-CG algorithm [5]_ pp. 168 (also known as the truncated\n",
      "        Newton method). It uses a CG method to the compute the search\n",
      "        direction. See also *TNC* method for a box-constrained\n",
      "        minimization with a similar algorithm.\n",
      "        \n",
      "        Method :ref:`dogleg <optimize.minimize-dogleg>` uses the dog-leg\n",
      "        trust-region algorithm [5]_ for unconstrained minimization. This\n",
      "        algorithm requires the gradient and Hessian; furthermore the\n",
      "        Hessian is required to be positive definite.\n",
      "        \n",
      "        Method :ref:`trust-ncg <optimize.minimize-trustncg>` uses the\n",
      "        Newton conjugate gradient trust-region algorithm [5]_ for\n",
      "        unconstrained minimization. This algorithm requires the gradient\n",
      "        and either the Hessian or a function that computes the product of\n",
      "        the Hessian with a given vector.\n",
      "        \n",
      "        **Constrained minimization**\n",
      "        \n",
      "        Method :ref:`L-BFGS-B <optimize.minimize-lbfgsb>` uses the L-BFGS-B\n",
      "        algorithm [6]_, [7]_ for bound constrained minimization.\n",
      "        \n",
      "        Method :ref:`TNC <optimize.minimize-tnc>` uses a truncated Newton\n",
      "        algorithm [5]_, [8]_ to minimize a function with variables subject\n",
      "        to bounds. This algorithm uses gradient information; it is also\n",
      "        called Newton Conjugate-Gradient. It differs from the *Newton-CG*\n",
      "        method described above as it wraps a C implementation and allows\n",
      "        each variable to be given upper and lower bounds.\n",
      "        \n",
      "        Method :ref:`COBYLA <optimize.minimize-cobyla>` uses the\n",
      "        Constrained Optimization BY Linear Approximation (COBYLA) method\n",
      "        [9]_, [10]_, [11]_. The algorithm is based on linear\n",
      "        approximations to the objective function and each constraint. The\n",
      "        method wraps a FORTRAN implementation of the algorithm. The\n",
      "        constraints functions 'fun' may return either a single number\n",
      "        or an array or list of numbers.\n",
      "        \n",
      "        Method :ref:`SLSQP <optimize.minimize-slsqp>` uses Sequential\n",
      "        Least SQuares Programming to minimize a function of several\n",
      "        variables with any combination of bounds, equality and inequality\n",
      "        constraints. The method wraps the SLSQP Optimization subroutine\n",
      "        originally implemented by Dieter Kraft [12]_. Note that the\n",
      "        wrapper handles infinite values in bounds by converting them into\n",
      "        large floating values.\n",
      "        \n",
      "        **Custom minimizers**\n",
      "        \n",
      "        It may be useful to pass a custom minimization method, for example\n",
      "        when using a frontend to this method such as `scipy.optimize.basinhopping`\n",
      "        or a different library.  You can simply pass a callable as the ``method``\n",
      "        parameter.\n",
      "        \n",
      "        The callable is called as ``method(fun, x0, args, **kwargs, **options)``\n",
      "        where ``kwargs`` corresponds to any other parameters passed to `minimize`\n",
      "        (such as `callback`, `hess`, etc.), except the `options` dict, which has\n",
      "        its contents also passed as `method` parameters pair by pair.  Also, if\n",
      "        `jac` has been passed as a bool type, `jac` and `fun` are mangled so that\n",
      "        `fun` returns just the function values and `jac` is converted to a function\n",
      "        returning the Jacobian.  The method shall return an ``OptimizeResult``\n",
      "        object.\n",
      "        \n",
      "        The provided `method` callable must be able to accept (and possibly ignore)\n",
      "        arbitrary parameters; the set of parameters accepted by `minimize` may\n",
      "        expand in future versions and then these parameters will be passed to\n",
      "        the method.  You can find an example in the scipy.optimize tutorial.\n",
      "        \n",
      "        .. versionadded:: 0.11.0\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] Nelder, J A, and R Mead. 1965. A Simplex Method for Function\n",
      "            Minimization. The Computer Journal 7: 308-13.\n",
      "        .. [2] Wright M H. 1996. Direct search methods: Once scorned, now\n",
      "            respectable, in Numerical Analysis 1995: Proceedings of the 1995\n",
      "            Dundee Biennial Conference in Numerical Analysis (Eds. D F\n",
      "            Griffiths and G A Watson). Addison Wesley Longman, Harlow, UK.\n",
      "            191-208.\n",
      "        .. [3] Powell, M J D. 1964. An efficient method for finding the minimum of\n",
      "           a function of several variables without calculating derivatives. The\n",
      "           Computer Journal 7: 155-162.\n",
      "        .. [4] Press W, S A Teukolsky, W T Vetterling and B P Flannery.\n",
      "           Numerical Recipes (any edition), Cambridge University Press.\n",
      "        .. [5] Nocedal, J, and S J Wright. 2006. Numerical Optimization.\n",
      "           Springer New York.\n",
      "        .. [6] Byrd, R H and P Lu and J. Nocedal. 1995. A Limited Memory\n",
      "           Algorithm for Bound Constrained Optimization. SIAM Journal on\n",
      "           Scientific and Statistical Computing 16 (5): 1190-1208.\n",
      "        .. [7] Zhu, C and R H Byrd and J Nocedal. 1997. L-BFGS-B: Algorithm\n",
      "           778: L-BFGS-B, FORTRAN routines for large scale bound constrained\n",
      "           optimization. ACM Transactions on Mathematical Software 23 (4):\n",
      "           550-560.\n",
      "        .. [8] Nash, S G. Newton-Type Minimization Via the Lanczos Method.\n",
      "           1984. SIAM Journal of Numerical Analysis 21: 770-778.\n",
      "        .. [9] Powell, M J D. A direct search optimization method that models\n",
      "           the objective and constraint functions by linear interpolation.\n",
      "           1994. Advances in Optimization and Numerical Analysis, eds. S. Gomez\n",
      "           and J-P Hennart, Kluwer Academic (Dordrecht), 51-67.\n",
      "        .. [10] Powell M J D. Direct search algorithms for optimization\n",
      "           calculations. 1998. Acta Numerica 7: 287-336.\n",
      "        .. [11] Powell M J D. A view of algorithms for optimization without\n",
      "           derivatives. 2007.Cambridge University Technical Report DAMTP\n",
      "           2007/NA03\n",
      "        .. [12] Kraft, D. A software package for sequential quadratic\n",
      "           programming. 1988. Tech. Rep. DFVLR-FB 88-28, DLR German Aerospace\n",
      "           Center -- Institute for Flight Mechanics, Koln, Germany.\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Let us consider the problem of minimizing the Rosenbrock function. This\n",
      "        function (and its respective derivatives) is implemented in `rosen`\n",
      "        (resp. `rosen_der`, `rosen_hess`) in the `scipy.optimize`.\n",
      "        \n",
      "        >>> from scipy.optimize import minimize, rosen, rosen_der\n",
      "        \n",
      "        A simple application of the *Nelder-Mead* method is:\n",
      "        \n",
      "        >>> x0 = [1.3, 0.7, 0.8, 1.9, 1.2]\n",
      "        >>> res = minimize(rosen, x0, method='Nelder-Mead', tol=1e-6)\n",
      "        >>> res.x\n",
      "        array([ 1.,  1.,  1.,  1.,  1.])\n",
      "        \n",
      "        Now using the *BFGS* algorithm, using the first derivative and a few\n",
      "        options:\n",
      "        \n",
      "        >>> res = minimize(rosen, x0, method='BFGS', jac=rosen_der,\n",
      "        ...                options={'gtol': 1e-6, 'disp': True})\n",
      "        Optimization terminated successfully.\n",
      "                 Current function value: 0.000000\n",
      "                 Iterations: 26\n",
      "                 Function evaluations: 31\n",
      "                 Gradient evaluations: 31\n",
      "        >>> res.x\n",
      "        array([ 1.,  1.,  1.,  1.,  1.])\n",
      "        >>> print(res.message)\n",
      "        Optimization terminated successfully.\n",
      "        >>> res.hess_inv\n",
      "        array([[ 0.00749589,  0.01255155,  0.02396251,  0.04750988,  0.09495377],  # may vary\n",
      "               [ 0.01255155,  0.02510441,  0.04794055,  0.09502834,  0.18996269],\n",
      "               [ 0.02396251,  0.04794055,  0.09631614,  0.19092151,  0.38165151],\n",
      "               [ 0.04750988,  0.09502834,  0.19092151,  0.38341252,  0.7664427 ],\n",
      "               [ 0.09495377,  0.18996269,  0.38165151,  0.7664427,   1.53713523]])\n",
      "        \n",
      "        \n",
      "        Next, consider a minimization problem with several constraints (namely\n",
      "        Example 16.4 from [5]_). The objective function is:\n",
      "        \n",
      "        >>> fun = lambda x: (x[0] - 1)**2 + (x[1] - 2.5)**2\n",
      "        \n",
      "        There are three constraints defined as:\n",
      "        \n",
      "        >>> cons = ({'type': 'ineq', 'fun': lambda x:  x[0] - 2 * x[1] + 2},\n",
      "        ...         {'type': 'ineq', 'fun': lambda x: -x[0] - 2 * x[1] + 6},\n",
      "        ...         {'type': 'ineq', 'fun': lambda x: -x[0] + 2 * x[1] + 2})\n",
      "        \n",
      "        And variables must be positive, hence the following bounds:\n",
      "        \n",
      "        >>> bnds = ((0, None), (0, None))\n",
      "        \n",
      "        The optimization problem is solved using the SLSQP method as:\n",
      "        \n",
      "        >>> res = minimize(fun, (2, 0), method='SLSQP', bounds=bnds,\n",
      "        ...                constraints=cons)\n",
      "        \n",
      "        It should converge to the theoretical solution (1.4 ,1.7).\n",
      "    \n",
      "    minimize_scalar(fun, bracket=None, bounds=None, args=(), method='brent', tol=None, options=None)\n",
      "        Minimization of scalar function of one variable.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fun : callable\n",
      "            Objective function.\n",
      "            Scalar function, must return a scalar.\n",
      "        bracket : sequence, optional\n",
      "            For methods 'brent' and 'golden', `bracket` defines the bracketing\n",
      "            interval and can either have three items `(a, b, c)` so that `a < b\n",
      "            < c` and `fun(b) < fun(a), fun(c)` or two items `a` and `c` which\n",
      "            are assumed to be a starting interval for a downhill bracket search\n",
      "            (see `bracket`); it doesn't always mean that the obtained solution\n",
      "            will satisfy `a <= x <= c`.\n",
      "        bounds : sequence, optional\n",
      "            For method 'bounded', `bounds` is mandatory and must have two items\n",
      "            corresponding to the optimization bounds.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to the objective function.\n",
      "        method : str or callable, optional\n",
      "            Type of solver.  Should be one of\n",
      "        \n",
      "                - 'Brent'     :ref:`(see here) <optimize.minimize_scalar-brent>`\n",
      "                - 'Bounded'   :ref:`(see here) <optimize.minimize_scalar-bounded>`\n",
      "                - 'Golden'    :ref:`(see here) <optimize.minimize_scalar-golden>`\n",
      "                - custom - a callable object (added in version 0.14.0),\n",
      "                  see below\n",
      "        tol : float, optional\n",
      "            Tolerance for termination. For detailed control, use solver-specific\n",
      "            options.\n",
      "        options : dict, optional\n",
      "            A dictionary of solver options.\n",
      "                maxiter : int\n",
      "                    Maximum number of iterations to perform.\n",
      "                disp : bool\n",
      "                    Set to True to print convergence messages.\n",
      "        \n",
      "            See :func:`show_options()` for solver-specific options.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        res : OptimizeResult\n",
      "            The optimization result represented as a ``OptimizeResult`` object.\n",
      "            Important attributes are: ``x`` the solution array, ``success`` a\n",
      "            Boolean flag indicating if the optimizer exited successfully and\n",
      "            ``message`` which describes the cause of the termination. See\n",
      "            `OptimizeResult` for a description of other attributes.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        minimize : Interface to minimization algorithms for scalar multivariate\n",
      "            functions\n",
      "        show_options : Additional options accepted by the solvers\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This section describes the available solvers that can be selected by the\n",
      "        'method' parameter. The default method is *Brent*.\n",
      "        \n",
      "        Method :ref:`Brent <optimize.minimize_scalar-brent>` uses Brent's\n",
      "        algorithm to find a local minimum.  The algorithm uses inverse\n",
      "        parabolic interpolation when possible to speed up convergence of\n",
      "        the golden section method.\n",
      "        \n",
      "        Method :ref:`Golden <optimize.minimize_scalar-golden>` uses the\n",
      "        golden section search technique. It uses analog of the bisection\n",
      "        method to decrease the bracketed interval. It is usually\n",
      "        preferable to use the *Brent* method.\n",
      "        \n",
      "        Method :ref:`Bounded <optimize.minimize_scalar-bounded>` can\n",
      "        perform bounded minimization. It uses the Brent method to find a\n",
      "        local minimum in the interval x1 < xopt < x2.\n",
      "        \n",
      "        **Custom minimizers**\n",
      "        \n",
      "        It may be useful to pass a custom minimization method, for example\n",
      "        when using some library frontend to minimize_scalar.  You can simply\n",
      "        pass a callable as the ``method`` parameter.\n",
      "        \n",
      "        The callable is called as ``method(fun, args, **kwargs, **options)``\n",
      "        where ``kwargs`` corresponds to any other parameters passed to `minimize`\n",
      "        (such as `bracket`, `tol`, etc.), except the `options` dict, which has\n",
      "        its contents also passed as `method` parameters pair by pair.  The method\n",
      "        shall return an ``OptimizeResult`` object.\n",
      "        \n",
      "        The provided `method` callable must be able to accept (and possibly ignore)\n",
      "        arbitrary parameters; the set of parameters accepted by `minimize` may\n",
      "        expand in future versions and then these parameters will be passed to\n",
      "        the method.  You can find an example in the scipy.optimize tutorial.\n",
      "        \n",
      "        .. versionadded:: 0.11.0\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        Consider the problem of minimizing the following function.\n",
      "        \n",
      "        >>> def f(x):\n",
      "        ...     return (x - 2) * x * (x + 2)**2\n",
      "        \n",
      "        Using the *Brent* method, we find the local minimum as:\n",
      "        \n",
      "        >>> from scipy.optimize import minimize_scalar\n",
      "        >>> res = minimize_scalar(f)\n",
      "        >>> res.x\n",
      "        1.28077640403\n",
      "        \n",
      "        Using the *Bounded* method, we find a local minimum with specified\n",
      "        bounds as:\n",
      "        \n",
      "        >>> res = minimize_scalar(f, bounds=(-3, -1), method='bounded')\n",
      "        >>> res.x\n",
      "        -2.0000002026\n",
      "    \n",
      "    newton(func, x0, fprime=None, args=(), tol=1.48e-08, maxiter=50, fprime2=None)\n",
      "        Find a zero using the Newton-Raphson or secant method.\n",
      "        \n",
      "        Find a zero of the function `func` given a nearby starting point `x0`.\n",
      "        The Newton-Raphson method is used if the derivative `fprime` of `func`\n",
      "        is provided, otherwise the secant method is used.  If the second order\n",
      "        derivate `fprime2` of `func` is provided, parabolic Halley's method\n",
      "        is used.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        func : function\n",
      "            The function whose zero is wanted. It must be a function of a\n",
      "            single variable of the form f(x,a,b,c...), where a,b,c... are extra\n",
      "            arguments that can be passed in the `args` parameter.\n",
      "        x0 : float\n",
      "            An initial estimate of the zero that should be somewhere near the\n",
      "            actual zero.\n",
      "        fprime : function, optional\n",
      "            The derivative of the function when available and convenient. If it\n",
      "            is None (default), then the secant method is used.\n",
      "        args : tuple, optional\n",
      "            Extra arguments to be used in the function call.\n",
      "        tol : float, optional\n",
      "            The allowable error of the zero value.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations.\n",
      "        fprime2 : function, optional\n",
      "            The second order derivative of the function when available and\n",
      "            convenient. If it is None (default), then the normal Newton-Raphson\n",
      "            or the secant method is used. If it is given, parabolic Halley's\n",
      "            method is used.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        zero : float\n",
      "            Estimated location where function is zero.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        brentq, brenth, ridder, bisect\n",
      "        fsolve : find zeroes in n dimensions.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The convergence rate of the Newton-Raphson method is quadratic,\n",
      "        the Halley method is cubic, and the secant method is\n",
      "        sub-quadratic.  This means that if the function is well behaved\n",
      "        the actual error in the estimated zero is approximately the square\n",
      "        (cube for Halley) of the requested tolerance up to roundoff\n",
      "        error. However, the stopping criterion used here is the step size\n",
      "        and there is no guarantee that a zero has been found. Consequently\n",
      "        the result should be verified. Safer algorithms are brentq,\n",
      "        brenth, ridder, and bisect, but they all require that the root\n",
      "        first be bracketed in an interval where the function changes\n",
      "        sign. The brentq algorithm is recommended for general use in one\n",
      "        dimensional problems when such an interval has been found.\n",
      "    \n",
      "    newton_krylov(F, xin, iter=None, rdiff=None, method='lgmres', inner_maxiter=20, inner_M=None, outer_k=10, verbose=False, maxiter=None, f_tol=None, f_rtol=None, x_tol=None, x_rtol=None, tol_norm=None, line_search='armijo', callback=None, **kw)\n",
      "        Find a root of a function, using Krylov approximation for inverse Jacobian.\n",
      "        \n",
      "        This method is suitable for solving large-scale problems.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        F : function(x) -> f\n",
      "            Function whose root to find; should take and return an array-like\n",
      "            object.\n",
      "        x0 : array_like\n",
      "            Initial guess for the solution\n",
      "        rdiff : float, optional\n",
      "            Relative step size to use in numerical differentiation.\n",
      "        method : {'lgmres', 'gmres', 'bicgstab', 'cgs', 'minres'} or function\n",
      "            Krylov method to use to approximate the Jacobian.\n",
      "            Can be a string, or a function implementing the same interface as\n",
      "            the iterative solvers in `scipy.sparse.linalg`.\n",
      "        \n",
      "            The default is `scipy.sparse.linalg.lgmres`.\n",
      "        inner_M : LinearOperator or InverseJacobian\n",
      "            Preconditioner for the inner Krylov iteration.\n",
      "            Note that you can use also inverse Jacobians as (adaptive)\n",
      "            preconditioners. For example,\n",
      "        \n",
      "            >>> from scipy.optimize.nonlin import BroydenFirst, KrylovJacobian\n",
      "            >>> from scipy.optimize.nonlin import InverseJacobian\n",
      "            >>> jac = BroydenFirst()\n",
      "            >>> kjac = KrylovJacobian(inner_M=InverseJacobian(jac))\n",
      "        \n",
      "            If the preconditioner has a method named 'update', it will be called\n",
      "            as ``update(x, f)`` after each nonlinear step, with ``x`` giving\n",
      "            the current point, and ``f`` the current function value.\n",
      "        inner_tol, inner_maxiter, ...\n",
      "            Parameters to pass on to the \\\"inner\\\" Krylov solver.\n",
      "            See `scipy.sparse.linalg.gmres` for details.\n",
      "        outer_k : int, optional\n",
      "            Size of the subspace kept across LGMRES nonlinear iterations.\n",
      "            See `scipy.sparse.linalg.lgmres` for details.\n",
      "        iter : int, optional\n",
      "            Number of iterations to make. If omitted (default), make as many\n",
      "            as required to meet tolerances.\n",
      "        verbose : bool, optional\n",
      "            Print status to stdout on every iteration.\n",
      "        maxiter : int, optional\n",
      "            Maximum number of iterations to make. If more are needed to\n",
      "            meet convergence, `NoConvergence` is raised.\n",
      "        f_tol : float, optional\n",
      "            Absolute tolerance (in max-norm) for the residual.\n",
      "            If omitted, default is 6e-6.\n",
      "        f_rtol : float, optional\n",
      "            Relative tolerance for the residual. If omitted, not used.\n",
      "        x_tol : float, optional\n",
      "            Absolute minimum step size, as determined from the Jacobian\n",
      "            approximation. If the step size is smaller than this, optimization\n",
      "            is terminated as successful. If omitted, not used.\n",
      "        x_rtol : float, optional\n",
      "            Relative minimum step size. If omitted, not used.\n",
      "        tol_norm : function(vector) -> scalar, optional\n",
      "            Norm to use in convergence check. Default is the maximum norm.\n",
      "        line_search : {None, 'armijo' (default), 'wolfe'}, optional\n",
      "            Which type of a line search to use to determine the step size in the\n",
      "            direction given by the Jacobian approximation. Defaults to 'armijo'.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : ndarray\n",
      "            An array (of similar array type as `x0`) containing the final solution.\n",
      "        \n",
      "        Raises\n",
      "        ------\n",
      "        NoConvergence\n",
      "            When a solution was not found.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        scipy.sparse.linalg.gmres\n",
      "        scipy.sparse.linalg.lgmres\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This function implements a Newton-Krylov solver. The basic idea is\n",
      "        to compute the inverse of the Jacobian with an iterative Krylov\n",
      "        method. These methods require only evaluating the Jacobian-vector\n",
      "        products, which are conveniently approximated by a finite difference:\n",
      "        \n",
      "        .. math:: J v \\approx (f(x + \\omega*v/|v|) - f(x)) / \\omega\n",
      "        \n",
      "        Due to the use of iterative matrix inverses, these methods can\n",
      "        deal with large nonlinear problems.\n",
      "        \n",
      "        Scipy's `scipy.sparse.linalg` module offers a selection of Krylov\n",
      "        solvers to choose from. The default here is `lgmres`, which is a\n",
      "        variant of restarted GMRES iteration that reuses some of the\n",
      "        information obtained in the previous Newton steps to invert\n",
      "        Jacobians in subsequent steps.\n",
      "        \n",
      "        For a review on Newton-Krylov methods, see for example [1]_,\n",
      "        and for the LGMRES sparse inverse method, see [2]_.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] D.A. Knoll and D.E. Keyes, J. Comp. Phys. 193, 357 (2004).\n",
      "               doi:10.1016/j.jcp.2003.08.010\n",
      "        .. [2] A.H. Baker and E.R. Jessup and T. Manteuffel,\n",
      "               SIAM J. Matrix Anal. Appl. 26, 962 (2005).\n",
      "               doi:10.1137/S0895479803422014\n",
      "    \n",
      "    nnls(A, b)\n",
      "        Solve ``argmin_x || Ax - b ||_2`` for ``x>=0``. This is a wrapper\n",
      "        for a FORTAN non-negative least squares solver.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        A : ndarray\n",
      "            Matrix ``A`` as shown above.\n",
      "        b : ndarray\n",
      "            Right-hand side vector.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x : ndarray\n",
      "            Solution vector.\n",
      "        rnorm : float\n",
      "            The residual, ``|| Ax-b ||_2``.\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The FORTRAN code was published in the book below. The algorithm\n",
      "        is an active set method. It solves the KKT (Karush-Kuhn-Tucker)\n",
      "        conditions for the non-negative least squares problem.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        Lawson C., Hanson R.J., (1987) Solving Least Squares Problems, SIAM\n",
      "    \n",
      "    ridder(f, a, b, args=(), xtol=2e-12, rtol=8.8817841970012523e-16, maxiter=100, full_output=False, disp=True)\n",
      "        Find a root of a function in an interval.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        f : function\n",
      "            Python function returning a number.  f must be continuous, and f(a) and\n",
      "            f(b) must have opposite signs.\n",
      "        a : number\n",
      "            One end of the bracketing interval [a,b].\n",
      "        b : number\n",
      "            The other end of the bracketing interval [a,b].\n",
      "        xtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter must be nonnegative.\n",
      "        rtol : number, optional\n",
      "            The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "            atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "            parameter cannot be smaller than its default value of\n",
      "            ``4*np.finfo(float).eps``.\n",
      "        maxiter : number, optional\n",
      "            if convergence is not achieved in maxiter iterations, an error is\n",
      "            raised.  Must be >= 0.\n",
      "        args : tuple, optional\n",
      "            containing extra arguments for the function `f`.\n",
      "            `f` is called by ``apply(f, (x)+args)``.\n",
      "        full_output : bool, optional\n",
      "            If `full_output` is False, the root is returned.  If `full_output` is\n",
      "            True, the return value is ``(x, r)``, where `x` is the root, and `r` is\n",
      "            a RootResults object.\n",
      "        disp : bool, optional\n",
      "            If True, raise RuntimeError if the algorithm didn't converge.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        x0 : float\n",
      "            Zero of `f` between `a` and `b`.\n",
      "        r : RootResults (present if ``full_output = True``)\n",
      "            Object containing information about the convergence.\n",
      "            In particular, ``r.converged`` is True if the routine converged.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        brentq, brenth, bisect, newton : one-dimensional root-finding\n",
      "        fixed_point : scalar fixed-point finder\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        Uses [Ridders1979]_ method to find a zero of the function `f` between the\n",
      "        arguments `a` and `b`. Ridders' method is faster than bisection, but not\n",
      "        generally as fast as the Brent rountines. [Ridders1979]_ provides the\n",
      "        classic description and source of the algorithm. A description can also be\n",
      "        found in any recent edition of Numerical Recipes.\n",
      "        \n",
      "        The routine used here diverges slightly from standard presentations in\n",
      "        order to be a bit more careful of tolerance.\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [Ridders1979]\n",
      "           Ridders, C. F. J. \"A New Algorithm for Computing a\n",
      "           Single Root of a Real Continuous Function.\"\n",
      "           IEEE Trans. Circuits Systems 26, 979-980, 1979.\n",
      "    \n",
      "    root(fun, x0, args=(), method='hybr', jac=None, tol=None, callback=None, options=None)\n",
      "        Find a root of a vector function.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        fun : callable\n",
      "            A vector function to find a root of.\n",
      "        x0 : ndarray\n",
      "            Initial guess.\n",
      "        args : tuple, optional\n",
      "            Extra arguments passed to the objective function and its Jacobian.\n",
      "        method : str, optional\n",
      "            Type of solver.  Should be one of\n",
      "        \n",
      "                - 'hybr'             :ref:`(see here) <optimize.root-hybr>`\n",
      "                - 'lm'               :ref:`(see here) <optimize.root-lm>`\n",
      "                - 'broyden1'         :ref:`(see here) <optimize.root-broyden1>`\n",
      "                - 'broyden2'         :ref:`(see here) <optimize.root-broyden2>`\n",
      "                - 'anderson'         :ref:`(see here) <optimize.root-anderson>`\n",
      "                - 'linearmixing'     :ref:`(see here) <optimize.root-linearmixing>`\n",
      "                - 'diagbroyden'      :ref:`(see here) <optimize.root-diagbroyden>`\n",
      "                - 'excitingmixing'   :ref:`(see here) <optimize.root-excitingmixing>`\n",
      "                - 'krylov'           :ref:`(see here) <optimize.root-krylov>`\n",
      "                - 'df-sane'          :ref:`(see here) <optimize.root-dfsane>`\n",
      "        \n",
      "        jac : bool or callable, optional\n",
      "            If `jac` is a Boolean and is True, `fun` is assumed to return the\n",
      "            value of Jacobian along with the objective function. If False, the\n",
      "            Jacobian will be estimated numerically.\n",
      "            `jac` can also be a callable returning the Jacobian of `fun`. In\n",
      "            this case, it must accept the same arguments as `fun`.\n",
      "        tol : float, optional\n",
      "            Tolerance for termination. For detailed control, use solver-specific\n",
      "            options.\n",
      "        callback : function, optional\n",
      "            Optional callback function. It is called on every iteration as\n",
      "            ``callback(x, f)`` where `x` is the current solution and `f`\n",
      "            the corresponding residual. For all methods but 'hybr' and 'lm'.\n",
      "        options : dict, optional\n",
      "            A dictionary of solver options. E.g. `xtol` or `maxiter`, see\n",
      "            :obj:`show_options()` for details.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        sol : OptimizeResult\n",
      "            The solution represented as a ``OptimizeResult`` object.\n",
      "            Important attributes are: ``x`` the solution array, ``success`` a\n",
      "            Boolean flag indicating if the algorithm exited successfully and\n",
      "            ``message`` which describes the cause of the termination. See\n",
      "            `OptimizeResult` for a description of other attributes.\n",
      "        \n",
      "        See also\n",
      "        --------\n",
      "        show_options : Additional options accepted by the solvers\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        This section describes the available solvers that can be selected by the\n",
      "        'method' parameter. The default method is *hybr*.\n",
      "        \n",
      "        Method *hybr* uses a modification of the Powell hybrid method as\n",
      "        implemented in MINPACK [1]_.\n",
      "        \n",
      "        Method *lm* solves the system of nonlinear equations in a least squares\n",
      "        sense using a modification of the Levenberg-Marquardt algorithm as\n",
      "        implemented in MINPACK [1]_.\n",
      "        \n",
      "        Method *df-sane* is a derivative-free spectral method. [3]_\n",
      "        \n",
      "        Methods *broyden1*, *broyden2*, *anderson*, *linearmixing*,\n",
      "        *diagbroyden*, *excitingmixing*, *krylov* are inexact Newton methods,\n",
      "        with backtracking or full line searches [2]_. Each method corresponds\n",
      "        to a particular Jacobian approximations. See `nonlin` for details.\n",
      "        \n",
      "        - Method *broyden1* uses Broyden's first Jacobian approximation, it is\n",
      "          known as Broyden's good method.\n",
      "        - Method *broyden2* uses Broyden's second Jacobian approximation, it\n",
      "          is known as Broyden's bad method.\n",
      "        - Method *anderson* uses (extended) Anderson mixing.\n",
      "        - Method *Krylov* uses Krylov approximation for inverse Jacobian. It\n",
      "          is suitable for large-scale problem.\n",
      "        - Method *diagbroyden* uses diagonal Broyden Jacobian approximation.\n",
      "        - Method *linearmixing* uses a scalar Jacobian approximation.\n",
      "        - Method *excitingmixing* uses a tuned diagonal Jacobian\n",
      "          approximation.\n",
      "        \n",
      "        .. warning::\n",
      "        \n",
      "            The algorithms implemented for methods *diagbroyden*,\n",
      "            *linearmixing* and *excitingmixing* may be useful for specific\n",
      "            problems, but whether they will work may depend strongly on the\n",
      "            problem.\n",
      "        \n",
      "        .. versionadded:: 0.11.0\n",
      "        \n",
      "        References\n",
      "        ----------\n",
      "        .. [1] More, Jorge J., Burton S. Garbow, and Kenneth E. Hillstrom.\n",
      "           1980. User Guide for MINPACK-1.\n",
      "        .. [2] C. T. Kelley. 1995. Iterative Methods for Linear and Nonlinear\n",
      "            Equations. Society for Industrial and Applied Mathematics.\n",
      "            <http://www.siam.org/books/kelley/>\n",
      "        .. [3] W. La Cruz, J.M. Martinez, M. Raydan. Math. Comp. 75, 1429 (2006).\n",
      "        \n",
      "        Examples\n",
      "        --------\n",
      "        The following functions define a system of nonlinear equations and its\n",
      "        jacobian.\n",
      "        \n",
      "        >>> def fun(x):\n",
      "        ...     return [x[0]  + 0.5 * (x[0] - x[1])**3 - 1.0,\n",
      "        ...             0.5 * (x[1] - x[0])**3 + x[1]]\n",
      "        \n",
      "        >>> def jac(x):\n",
      "        ...     return np.array([[1 + 1.5 * (x[0] - x[1])**2,\n",
      "        ...                       -1.5 * (x[0] - x[1])**2],\n",
      "        ...                      [-1.5 * (x[1] - x[0])**2,\n",
      "        ...                       1 + 1.5 * (x[1] - x[0])**2]])\n",
      "        \n",
      "        A solution can be obtained as follows.\n",
      "        \n",
      "        >>> from scipy import optimize\n",
      "        >>> sol = optimize.root(fun, [0, 0], jac=jac, method='hybr')\n",
      "        >>> sol.x\n",
      "        array([ 0.8411639,  0.1588361])\n",
      "    \n",
      "    rosen(x)\n",
      "        The Rosenbrock function.\n",
      "        \n",
      "        The function computed is::\n",
      "        \n",
      "            sum(100.0*(x[1:] - x[:-1]**2.0)**2.0 + (1 - x[:-1])**2.0)\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            1-D array of points at which the Rosenbrock function is to be computed.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        f : float\n",
      "            The value of the Rosenbrock function.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rosen_der, rosen_hess, rosen_hess_prod\n",
      "    \n",
      "    rosen_der(x)\n",
      "        The derivative (i.e. gradient) of the Rosenbrock function.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            1-D array of points at which the derivative is to be computed.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        rosen_der : (N,) ndarray\n",
      "            The gradient of the Rosenbrock function at `x`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rosen, rosen_hess, rosen_hess_prod\n",
      "    \n",
      "    rosen_hess(x)\n",
      "        The Hessian matrix of the Rosenbrock function.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            1-D array of points at which the Hessian matrix is to be computed.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        rosen_hess : ndarray\n",
      "            The Hessian matrix of the Rosenbrock function at `x`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rosen, rosen_der, rosen_hess_prod\n",
      "    \n",
      "    rosen_hess_prod(x, p)\n",
      "        Product of the Hessian matrix of the Rosenbrock function with a vector.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        x : array_like\n",
      "            1-D array of points at which the Hessian matrix is to be computed.\n",
      "        p : array_like\n",
      "            1-D array, the vector to be multiplied by the Hessian matrix.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        rosen_hess_prod : ndarray\n",
      "            The Hessian matrix of the Rosenbrock function at `x` multiplied\n",
      "            by the vector `p`.\n",
      "        \n",
      "        See Also\n",
      "        --------\n",
      "        rosen, rosen_der, rosen_hess\n",
      "    \n",
      "    show_options(solver=None, method=None, disp=True)\n",
      "        Show documentation for additional options of optimization solvers.\n",
      "        \n",
      "        These are method-specific options that can be supplied through the\n",
      "        ``options`` dict.\n",
      "        \n",
      "        Parameters\n",
      "        ----------\n",
      "        solver : str\n",
      "            Type of optimization solver. One of 'minimize', 'minimize_scalar',\n",
      "            'root', or 'linprog'.\n",
      "        method : str, optional\n",
      "            If not given, shows all methods of the specified solver. Otherwise,\n",
      "            show only the options for the specified method. Valid values\n",
      "            corresponds to methods' names of respective solver (e.g. 'BFGS' for\n",
      "            'minimize').\n",
      "        disp : bool, optional\n",
      "            Whether to print the result rather than returning it.\n",
      "        \n",
      "        Returns\n",
      "        -------\n",
      "        text\n",
      "            Either None (for disp=False) or the text string (disp=True)\n",
      "        \n",
      "        Notes\n",
      "        -----\n",
      "        The solver-specific methods are:\n",
      "        \n",
      "        `scipy.optimize.minimize`\n",
      "        \n",
      "        - :ref:`Nelder-Mead <optimize.minimize-neldermead>`\n",
      "        - :ref:`Powell      <optimize.minimize-powell>`\n",
      "        - :ref:`CG          <optimize.minimize-cg>`\n",
      "        - :ref:`BFGS        <optimize.minimize-bfgs>`\n",
      "        - :ref:`Newton-CG   <optimize.minimize-newtoncg>`\n",
      "        - :ref:`L-BFGS-B    <optimize.minimize-lbfgsb>`\n",
      "        - :ref:`TNC         <optimize.minimize-tnc>`\n",
      "        - :ref:`COBYLA      <optimize.minimize-cobyla>`\n",
      "        - :ref:`SLSQP       <optimize.minimize-slsqp>`\n",
      "        - :ref:`dogleg      <optimize.minimize-dogleg>`\n",
      "        - :ref:`trust-ncg   <optimize.minimize-trustncg>`\n",
      "        \n",
      "        `scipy.optimize.root`\n",
      "        \n",
      "        - :ref:`hybr              <optimize.root-hybr>`\n",
      "        - :ref:`lm                <optimize.root-lm>`\n",
      "        - :ref:`broyden1          <optimize.root-broyden1>`\n",
      "        - :ref:`broyden2          <optimize.root-broyden2>`\n",
      "        - :ref:`anderson          <optimize.root-anderson>`\n",
      "        - :ref:`linearmixing      <optimize.root-linearmixing>`\n",
      "        - :ref:`diagbroyden       <optimize.root-diagbroyden>`\n",
      "        - :ref:`excitingmixing    <optimize.root-excitingmixing>`\n",
      "        - :ref:`krylov            <optimize.root-krylov>`\n",
      "        - :ref:`df-sane           <optimize.root-dfsane>`\n",
      "        \n",
      "        `scipy.optimize.minimize_scalar`\n",
      "        \n",
      "        - :ref:`brent       <optimize.minimize_scalar-brent>`\n",
      "        - :ref:`golden      <optimize.minimize_scalar-golden>`\n",
      "        - :ref:`bounded     <optimize.minimize_scalar-bounded>`\n",
      "        \n",
      "        `scipy.optimize.linprog`\n",
      "        \n",
      "        - :ref:`simplex     <optimize.linprog-simplex>`\n",
      "\n",
      "DATA\n",
      "    __all__ = ['LbfgsInvHessProduct', 'OptimizeResult', 'OptimizeWarning',...\n",
      "    absolute_import = _Feature((2, 5, 0, 'alpha', 1), (3, 0, 0, 'alpha', 0...\n",
      "    division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192...\n",
      "    print_function = _Feature((2, 6, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0)...\n",
      "\n",
      "FILE\n",
      "    /usr/local/lib/python3.4/dist-packages/scipy/optimize/__init__.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(optimize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "VqmyDCFIw7Wa"
   },
   "source": [
    "Check the help:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1q3FdDj2ynV6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m\n",
       "\u001b[0moptimize\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbisect\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mf\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mb\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0margs\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mxtol\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2e-12\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mrtol\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m8.881784197001252e-16\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mmaxiter\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mfull_output\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m    \u001b[0mdisp\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n",
       "\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "Find root of a function within an interval using bisection.\n",
       "\n",
       "Basic bisection routine to find a zero of the function `f` between the\n",
       "arguments `a` and `b`. `f(a)` and `f(b)` cannot have the same signs.\n",
       "Slow but sure.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "f : function\n",
       "    Python function returning a number.  `f` must be continuous, and\n",
       "    f(a) and f(b) must have opposite signs.\n",
       "a : scalar\n",
       "    One end of the bracketing interval [a,b].\n",
       "b : scalar\n",
       "    The other end of the bracketing interval [a,b].\n",
       "xtol : number, optional\n",
       "    The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
       "    atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
       "    parameter must be nonnegative.\n",
       "rtol : number, optional\n",
       "    The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
       "    atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
       "    parameter cannot be smaller than its default value of\n",
       "    ``4*np.finfo(float).eps``.\n",
       "maxiter : int, optional\n",
       "    if convergence is not achieved in `maxiter` iterations, an error is\n",
       "    raised.  Must be >= 0.\n",
       "args : tuple, optional\n",
       "    containing extra arguments for the function `f`.\n",
       "    `f` is called by ``apply(f, (x)+args)``.\n",
       "full_output : bool, optional\n",
       "    If `full_output` is False, the root is returned.  If `full_output` is\n",
       "    True, the return value is ``(x, r)``, where x is the root, and r is\n",
       "    a `RootResults` object.\n",
       "disp : bool, optional\n",
       "    If True, raise RuntimeError if the algorithm didn't converge.\n",
       "    Otherwise the convergence status is recorded in a `RootResults`\n",
       "    return object.\n",
       "\n",
       "Returns\n",
       "-------\n",
       "x0 : float\n",
       "    Zero of `f` between `a` and `b`.\n",
       "r : `RootResults` (present if ``full_output = True``)\n",
       "    Object containing information about the convergence.  In particular,\n",
       "    ``r.converged`` is True if the routine converged.\n",
       "\n",
       "Examples\n",
       "--------\n",
       "\n",
       ">>> def f(x):\n",
       "...     return (x**2 - 1)\n",
       "\n",
       ">>> from scipy import optimize\n",
       "\n",
       ">>> root = optimize.bisect(f, 0, 2)\n",
       ">>> root\n",
       "1.0\n",
       "\n",
       ">>> root = optimize.bisect(f, -2, 0)\n",
       ">>> root\n",
       "-1.0\n",
       "\n",
       "See Also\n",
       "--------\n",
       "brentq, brenth, bisect, newton\n",
       "fixed_point : scalar fixed-point finder\n",
       "fsolve : n-dimensional root-finding\n",
       "\u001b[1;31mFile:\u001b[0m      c:\\program files\\python\\lib\\site-packages\\scipy\\optimize\\zeros.py\n",
       "\u001b[1;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "optimize.bisect?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "colab_type": "code",
    "id": "s7ZzL1BEw7Wa",
    "outputId": "7b4af95b-ae70-4a02-e3ea-eb5ad062a87f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function bisect in module scipy.optimize.zeros:\n",
      "\n",
      "bisect(f, a, b, args=(), xtol=2e-12, rtol=8.881784197001252e-16, maxiter=100, full_output=False, disp=True)\n",
      "    Find root of a function within an interval using bisection.\n",
      "    \n",
      "    Basic bisection routine to find a zero of the function `f` between the\n",
      "    arguments `a` and `b`. `f(a)` and `f(b)` cannot have the same signs.\n",
      "    Slow but sure.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    f : function\n",
      "        Python function returning a number.  `f` must be continuous, and\n",
      "        f(a) and f(b) must have opposite signs.\n",
      "    a : scalar\n",
      "        One end of the bracketing interval [a,b].\n",
      "    b : scalar\n",
      "        The other end of the bracketing interval [a,b].\n",
      "    xtol : number, optional\n",
      "        The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "        atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "        parameter must be nonnegative.\n",
      "    rtol : number, optional\n",
      "        The computed root ``x0`` will satisfy ``np.allclose(x, x0,\n",
      "        atol=xtol, rtol=rtol)``, where ``x`` is the exact root. The\n",
      "        parameter cannot be smaller than its default value of\n",
      "        ``4*np.finfo(float).eps``.\n",
      "    maxiter : int, optional\n",
      "        if convergence is not achieved in `maxiter` iterations, an error is\n",
      "        raised.  Must be >= 0.\n",
      "    args : tuple, optional\n",
      "        containing extra arguments for the function `f`.\n",
      "        `f` is called by ``apply(f, (x)+args)``.\n",
      "    full_output : bool, optional\n",
      "        If `full_output` is False, the root is returned.  If `full_output` is\n",
      "        True, the return value is ``(x, r)``, where x is the root, and r is\n",
      "        a `RootResults` object.\n",
      "    disp : bool, optional\n",
      "        If True, raise RuntimeError if the algorithm didn't converge.\n",
      "        Otherwise the convergence status is recorded in a `RootResults`\n",
      "        return object.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    x0 : float\n",
      "        Zero of `f` between `a` and `b`.\n",
      "    r : `RootResults` (present if ``full_output = True``)\n",
      "        Object containing information about the convergence.  In particular,\n",
      "        ``r.converged`` is True if the routine converged.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    \n",
      "    >>> def f(x):\n",
      "    ...     return (x**2 - 1)\n",
      "    \n",
      "    >>> from scipy import optimize\n",
      "    \n",
      "    >>> root = optimize.bisect(f, 0, 2)\n",
      "    >>> root\n",
      "    1.0\n",
      "    \n",
      "    >>> root = optimize.bisect(f, -2, 0)\n",
      "    >>> root\n",
      "    -1.0\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    brentq, brenth, bisect, newton\n",
      "    fixed_point : scalar fixed-point finder\n",
      "    fsolve : n-dimensional root-finding\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(optimize.bisect)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yC9nyRCwGJaw"
   },
   "source": [
    "## General arguments and options of a SciPy function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "B-D9tsnEGTHD"
   },
   "source": [
    "* `f`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3Jxl8Cyx4J32"
   },
   "outputs": [],
   "source": [
    "def f(x,m=3,b=-2):\n",
    "    return m*x+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "WrYXrulI44Ij",
    "outputId": "b5bb125b-60da-4edc-fc0b-0249f80b66ca"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 59,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(0.66666666666666666,-3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "R6ihC-WN4ZUR",
    "outputId": "9d5a4737-95fe-4940-e9bc-f4dee796793c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666671972"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimize.bisect(lambda x: -3*x+2,-10,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "iZHq9BrU4xFh",
    "outputId": "1a105e92-22a5-47e6-873b-6f17d8f6a412"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666671972"
      ]
     },
     "execution_count": 10,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimize.bisect(lambda x: f(x,-3,2),-10,10,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "ojivSEZh5YLx",
    "outputId": "ed0c6690-c165-43d1-8e8e-4251fe0ea33b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666671972"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimize.bisect(f,-10,10,args=(-3,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7wLEoVWK8FqU"
   },
   "source": [
    "* `xtol`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "1UyHY0m76fIk",
    "outputId": "2b172be2-43dd-4940-ba04-75659bda3d83"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666671"
      ]
     },
     "execution_count": 14,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimize.bisect(f,-10,10,args=(-3,2),xtol=1E-17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "yjQIGQ5fGpIU"
   },
   "source": [
    "* `maxiter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "xyyTsH7L7R-E",
    "outputId": "bc87c14b-b6a1-4c22-b68f-bef351841a12"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6666666666666671"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimize.bisect(f,-10,10,args=(-3,2),xtol=1E-17,maxiter=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FiXdFcKEGuIU"
   },
   "source": [
    "* `full_output`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tQnA1hbu7vYE"
   },
   "outputs": [],
   "source": [
    "x0,r=optimize.bisect(f,-10,10,args=(-3,2),xtol=1E-17,full_output=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "YIE2XkN68Bfg",
    "outputId": "4f964c0f-7ebb-488a-fe1a-084f6629647f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "scipy.optimize.zeros.RootResults"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QmSG5wGKw7We"
   },
   "source": [
    "Check the code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "jBi0uZeE8NGk",
    "outputId": "aacf42d1-5bb2-4028-bbdc-e4ae465ff554"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "57"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.function_calls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "csnji5Tsw7Wf"
   },
   "outputs": [],
   "source": [
    "optimize.bisect??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6_7lOL6Ww7Wj"
   },
   "source": [
    "Check the internal referenced code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qh9fqUvgw7Wk"
   },
   "outputs": [],
   "source": [
    "optimize._zeros??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "IJIfqraOG_fz"
   },
   "source": [
    "### Example\n",
    "Find the roots of\n",
    "$$x^3=2$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "O1E6o0IRw7Wo"
   },
   "outputs": [],
   "source": [
    "def function(x):\n",
    "    return x**3.0 - 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kABWCrNcw7Wq"
   },
   "outputs": [],
   "source": [
    "a = 0.0\n",
    "b = 2.0\n",
    "\n",
    "result,r=optimize.bisect(function,a,b,full_output=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "nlxlkNYyw7Wt",
    "outputId": "1ca5ef81-e255-4df2-fe73-ebff00268deb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2599210498938191"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "L3HyS2OGw7Wv",
    "outputId": "d0094839-53ce-43cc-ab3b-c276f0275ff3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2599210498948732"
      ]
     },
     "execution_count": 43,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**(1/3.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TKlBRLXUw7Wy"
   },
   "source": [
    "Check `r` object by using the `<TAB>` key next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "TkfTsXumw7Wz",
    "outputId": "d618fc43-05eb-4e22-de7e-4db81ad77435"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "40"
      ]
     },
     "execution_count": 44,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "HpBNHlWDw7W3",
    "outputId": "25eb56bd-9ec6-4c4f-9a08-b3035ac7260c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.094947017729282e-13"
      ]
     },
     "execution_count": 45,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**(-r.iterations)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "tvkJ0Jy5w7W6",
    "outputId": "c9d1ebf4-0f00-4992-c901-562c1ae6dfde"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0540457395791236e-12"
      ]
     },
     "execution_count": 46,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs((2**(1/3.0)-result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "4m6VCcpiw7W8",
    "outputId": "8229c9e2-8cb1-4a0c-a2e1-51f77ae36dc4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.converged"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7bp9qun4w7W_"
   },
   "outputs": [],
   "source": [
    "result,r=optimize.bisect(function,a,b,xtol=1E-17,full_output=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "kmUCIBwlw7XB",
    "outputId": "70a1d062-9ec4-4082-afbc-4056962e0d46"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 49,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "zQTyAChgw7XE",
    "outputId": "c1a5a72d-53f8-4f53-ef5c-26ef8fcd2305"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.220446049250313e-16"
      ]
     },
     "execution_count": 50,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs((2**(1/3.0)-result))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "eXvvDw-4EZr-",
    "outputId": "bb036e6a-67cb-4b17-b1db-8f1fe1e38021"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.440892098500626e-16"
      ]
     },
     "execution_count": 51,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**(-r.iterations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mf8r3RfJw7XG"
   },
   "source": [
    "### <font color='red'> ACTIVITY </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gDKsdwSZw7XH"
   },
   "source": [
    "<font color='red'>\n",
    "In an IPython notebook, use the scipy implementation and find the first solution to the equation\n",
    "    \n",
    "$ 7 = \\sqrt{x^2+1}+e^x\\sin x $\n",
    "    \n",
    "CLUE: Check graphically (with matplotlib) that the solution is within the interval $[0,2]$.\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "VSpNg5PIillI",
    "outputId": "92d6441f-0c50-4ec6-faee-eb0f3c8403c2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.628718494926943"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "from scipy import optimize\n",
    "\n",
    "a = 0\n",
    "b = 2\n",
    "\n",
    "def f(x):\n",
    "  return np.sqrt(x**2 + 1) + np.exp(x)*np.sin(x) - 7\n",
    "  \n",
    "x0 = optimize.bisect(f, a, b)\n",
    "\n",
    "x0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3Sr162oVw7XI"
   },
   "source": [
    "[solution](./solutions/sltn_bisect.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "e5at_XXzHSlk"
   },
   "outputs": [],
   "source": [
    "a,b,c=(2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "geD3ecfDHXFE",
    "outputId": "e823e103-fbd6-461d-c9ed-82c11a9c5d28"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 63,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zrY4Rc19E_zC"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "SZhTQgvLFDmg",
    "outputId": "51f03fe3-2248-4cd6-832e-0f4ecebc3059"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 53,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solo usar para constante\n",
    "np.e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 35
    },
    "colab_type": "code",
    "id": "ela6ZuPcFGPQ",
    "outputId": "9237d95b-cf27-43b2-aab8-242954b8ec85"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 54,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hBSyBUNrw7XJ"
   },
   "source": [
    "## Example 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qpIK0RxFw7XK"
   },
   "source": [
    "In orbital mechanics, when solving the central-force problem it becomes necessary to solve the Kepler's equation. This is a transcendental equation that relates the orbital parameters of the trajectory.\n",
    "\n",
    "*Kepler equation:* $M = E - \\epsilon \\sin E$\n",
    "\n",
    "where $M$ is the mean anomaly, $E$ the eccentric anomaly and $\\epsilon$ the eccentricity. The mean anomaly can be computed with the expression\n",
    "\n",
    "$$M = n\\ t = \\sqrt{ \\frac{GM}{a^3} } t$$\n",
    "\n",
    "where $n$ is the mean motion, $G$ the gravitational constant, $M$ the mass of the central body and $a$ the semi-major axis. $t$ is the time where the position in the trajectory will be computed.\n",
    "\n",
    "The coordinates $x$ and $y$ as time functions can be recovered by means of the next expressions\n",
    "\n",
    "$$x(t) = a(\\cos E - \\epsilon)$$\n",
    "\n",
    "$$y(t) = b\\sin E$$\n",
    "\n",
    "where $b = a \\sqrt{1-\\epsilon^2}$ is the semi-minor axis of the orbit and the implicit time-dependence of the eccentric anomaly $E$ is computed through the Kepler's equation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "FlKupbitw7XL"
   },
   "source": [
    "**Problem:**\n",
    "\n",
    "For a stallite orbiting the earth in a equatorial trajectory with eccentricity $\\epsilon = 0.5$ at a geostationary distance for the semi-major axis, tabulate the positions $x$ and $y$ within the orbital plane in intervals of $15$ min during $5$ hours.\n",
    "\n",
    "**Parameters:**\n",
    "\n",
    "- $\\epsilon = 0.5$\n",
    "\n",
    "- $a = 35900$ km\n",
    "\n",
    "- $G = 6.67384 \\times 10^{-11}$ m$^3$ kg$^{-1}$ s$^{-2}$\n",
    "\n",
    "- $M_{\\oplus} = 5.972\\times 10^{24}$ kg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "URwGARM5w7XL"
   },
   "outputs": [],
   "source": [
    "#====================================================================\n",
    "#Parameters\n",
    "#====================================================================\n",
    "#Eccentricity\n",
    "eps = 0.5\n",
    "#Semi-major axis    [m]\n",
    "a = 35900e3\n",
    "#Gravitational constant    [m3kg-1s-2]\n",
    "GC = 6.67384e-11\n",
    "#Earth mass    [kg]\n",
    "Me = 5.972e24\n",
    "\n",
    "#Semi-minor axis    [m]\n",
    "b = a*(1-eps**2.0)**0.5\n",
    "#Mean motion\n",
    "n = ( GC*Me/a**3.0 )**0.5\n",
    "\n",
    "#Hour to Second\n",
    "HR2SC = 3600.\n",
    "#Initial time    [hr]\n",
    "t0 = 0*HR2SC\n",
    "#Final time    [hr]\n",
    "tf = 5*HR2SC\n",
    "#Time step    [hr]\n",
    "tstep = 0.25*HR2SC\n",
    "#Number of maxim iterations\n",
    "Niter = 56\n",
    "#Root interval\n",
    "a0 = -10\n",
    "b0 = 10\n",
    "\n",
    "#====================================================================\n",
    "#Kepler Function\n",
    "#====================================================================\n",
    "def kepler( E ):\n",
    "    func = E - eps*np.sin(E) - n*t\n",
    "    return func\n",
    "\n",
    "#====================================================================\n",
    "#Position function\n",
    "#====================================================================\n",
    "def r(E):\n",
    "    x = a*(np.cos(E)-eps)\n",
    "    y = b*np.sin(E)\n",
    "    return [x/1.e3, y/1.e3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "z4PZbsmIw7XQ",
    "outputId": "bb53b14d-8d19-459f-ecf6-4e9d8988266d"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In 0.000000 hours, the satellite is located at (17950.000000,0.000000) km\n",
      "In 0.250000 hours, the satellite is located at (17454.741542,5146.426647) km\n",
      "In 0.500000 hours, the satellite is located at (16033.097675,10023.437750) km\n",
      "In 0.750000 hours, the satellite is located at (13848.847528,14430.262364) km\n",
      "In 1.000000 hours, the satellite is located at (11104.379909,18261.701894) km\n",
      "In 1.250000 hours, the satellite is located at (7989.437466,21493.410338) km\n",
      "In 1.500000 hours, the satellite is located at (4657.168469,24151.489610) km\n",
      "In 1.750000 hours, the satellite is located at (1221.066166,26286.121177) km\n",
      "In 2.000000 hours, the satellite is located at (-2238.747501,27954.872718) km\n",
      "In 2.250000 hours, the satellite is located at (-5667.264143,29214.008624) km\n",
      "In 2.500000 hours, the satellite is located at (-9027.373695,30114.739827) km\n",
      "In 2.750000 hours, the satellite is located at (-12294.392344,30702.085866) km\n",
      "In 3.000000 hours, the satellite is located at (-15452.164136,31014.965936) km\n",
      "In 3.250000 hours, the satellite is located at (-18490.361033,31086.789919) km\n",
      "In 3.500000 hours, the satellite is located at (-21402.633716,30946.195086) km\n",
      "In 3.750000 hours, the satellite is located at (-24185.347784,30617.769816) km\n",
      "In 4.000000 hours, the satellite is located at (-26836.717825,30122.702148) km\n",
      "In 4.250000 hours, the satellite is located at (-29356.211228,29479.336137) km\n",
      "In 4.500000 hours, the satellite is located at (-31744.135350,28703.638662) km\n",
      "In 4.750000 hours, the satellite is located at (-34001.350021,27809.586870) km\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7fbd6e9f7d90>"
      ]
     },
     "execution_count": 56,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaIAAAEOCAYAAADL1RP6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEvX/AQpskLAs2fuQAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7fbd6ea685d0>"
      ]
     },
     "metadata": {
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#====================================================================\n",
    "#Solving for different times\n",
    "#====================================================================\n",
    "#Time array\n",
    "times = np.arange( t0, tf, tstep )\n",
    "\n",
    "rpos = []\n",
    "for t in times:\n",
    "    #Finding the new eccentric anomaly\n",
    "    E = optimize.bisect( kepler, a0, b0 )\n",
    "    #Computing coordinates at this time\n",
    "    ri = r(E)\n",
    "    print \"In %f hours, the satellite is located at (%f,%f) km\"%(t/HR2SC, ri[0], ri[1])\n",
    "    rpos.append( ri )\n",
    "rpos = np.array(rpos)    \n",
    "\n",
    "#Plotting\n",
    "plt.plot( rpos[:,0], rpos[:,1], \"o-\", color=\"red\", lw = 2 )\n",
    "plt.grid(True)\n",
    "plt.xlabel(\"$x$ coordinate [km]\")\n",
    "plt.ylabel(\"$y$ coordinate [km]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RJlKLGjww7XU"
   },
   "source": [
    "- - - "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "one-variable-equations.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.2"
  },
  "toc": {
   "colors": {
    "hover_highlight": "#DAA520",
    "running_highlight": "#FF0000",
    "selected_highlight": "#FFD700"
   },
   "moveMenuLeft": true,
   "nav_menu": {
    "height": "426px",
    "width": "252px"
   },
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 4,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}