docs: def nelder_mead(fun, x0, bounds=np.array([[], []]).T, args=(), tol_f=1e-10,
                  tol_x=1e-10, max_iter=1000):
      """
      .. highlight:: none
  
      Maximize a scalar-valued function with one or more variables using the
      Nelder-Mead method.
  
      This function is JIT-compiled in `nopython` mode using Numba.
  
      Parameters
      ----------
      fun : callable
          The objective function to be maximized: `fun(x, *args) -> float`
          where x is an 1-D array with shape (n,) and args is a tuple of the
          fixed parameters needed to completely specify the function. This
          function must be JIT-compiled in `nopython` mode using Numba.
  
      x0 : ndarray(float, ndim=1)
          Initial guess. Array of real elements of size (n,), where ‘n’ is the
          number of independent variables.
  
      bounds: ndarray(float, ndim=2), optional
          Bounds for each variable for proposed solution, encoded as a sequence
          of (min, max) pairs for each element in x. The default option is used
          to specify no bounds on x.
  
      args : tuple, optional
          Extra arguments passed to the objective function.
  
      tol_f : scalar(float), optional(default=1e-10)
          Tolerance to be used for the function value convergence test.
  
      tol_x : scalar(float), optional(default=1e-10)
          Tolerance to be used for the function domain convergence test.
  
      max_iter : scalar(float), optional(default=1000)
          The maximum number of allowed iterations.
  
      Returns
      ----------
      results : namedtuple
          A namedtuple containing the following items:
          ::
  
              "x" : Approximate local maximizer
              "fun" : Approximate local maximum value
              "success" : 1 if the algorithm successfully terminated, 0 otherwise
              "nit" : Number of iterations
              "final_simplex" : Vertices of the final simplex
  
      Examples
      --------
      >>> @njit
      ... def rosenbrock(x):
      ...     return -(100 * (x[1] - x[0] ** 2) ** 2 + (1 - x[0])**2)
      ...
      >>> x0 = np.array([-2, 1])
      >>> qe.optimize.nelder_mead(rosenbrock, x0)
      results(x=array([0.99999814, 0.99999756]), fun=-1.6936258239463265e-10,
              success=True, nit=110,
              final_simplex=array([[0.99998652, 0.9999727],
                                   [1.00000218, 1.00000301],
                                   [0.99999814, 0.99999756]]))
  
      Notes
      --------
      This algorithm has a long history of successful use in applications, but it
      will usually be slower than an algorithm that uses first or second
      derivative information. In practice, it can have poor performance in
      high-dimensional problems and is not robust to minimizing complicated
      functions. Additionally, there currently is no complete theory describing
      when the algorithm will successfully converge to the minimum, or how fast
      it will if it does.
  
      References
      ----------
  
      .. [1] J. C. Lagarias, J. A. Reeds, M. H. Wright and P. E. Wright,
             Convergence Properties of the Nelder–Mead Simplex Method in Low
             Dimensions, SIAM. J. Optim. 9, 112–147 (1998).
  
      .. [2] S. Singer and S. Singer, Efficient implementation of the Nelder–Mead
             search algorithm, Appl. Numer. Anal. Comput. Math., vol. 1, no. 2,
             pp. 524–534, 2004.
  
      .. [3] J. A. Nelder and R. Mead, A simplex method for function
             minimization, Comput. J. 7, 308–313 (1965).
  
      .. [4] Gao, F. and Han, L., Implementing the Nelder-Mead simplex algorithm
             with adaptive parameters, Comput Optim Appl (2012) 51: 259.
  
      .. [5] http://www.scholarpedia.org/article/Nelder-Mead_algorithm
  
      .. [6] http://www.brnt.eu/phd/node10.html#SECTION00622200000000000000
  
      .. [7] Chase Coleman's tutorial on Nelder Mead
  
      .. [8] SciPy's Nelder-Mead implementation
  
      """
      vertices = _initialize_simplex(x0, bounds)
  
      results = _nelder_mead_algorithm(fun, vertices, bounds, args=args,
                                       tol_f=tol_f, tol_x=tol_x,
                                       max_iter=max_iter)
  
      return results