code: def _minimize_cg(
      fun,
      x0,
      args=(),
      jac=None,
      callback=None,
      gtol=1e-5,
      norm=Inf,
      eps=_epsilon,
      maxiter=None,
      disp=False,
      return_all=False,
      finite_diff_rel_step=None,
      **unknown_options,
  ):
      """
      Minimization of scalar function of one or more variables using the
      conjugate gradient algorithm.
  
      Options
      -------
      disp : bool
          Set to True to print convergence messages.
      maxiter : int
          Maximum number of iterations to perform.
      gtol : float
          Gradient norm must be less than `gtol` before successful
          termination.
      norm : float
          Order of norm (Inf is max, -Inf is min).
      eps : float or ndarray
          If `jac is None` the absolute step size used for numerical
          approximation of the jacobian via forward differences.
      return_all : bool, optional
          Set to True to return a list of the best solution at each of the
          iterations.
      finite_diff_rel_step : None or array_like, optional
          If `jac in ['2-point', '3-point', 'cs']` the relative step size to
          use for numerical approximation of the jacobian. The absolute step
          size is computed as ``h = rel_step * sign(x0) * max(1, abs(x0))``,
          possibly adjusted to fit into the bounds. For ``method='3-point'``
          the sign of `h` is ignored. If None (default) then step is selected
          automatically.
      """
      _check_unknown_options(unknown_options)
  
      retall = return_all
  
      x0 = asarray(x0).flatten()
      if maxiter is None:
          maxiter = len(x0) * 200
  
      sf = _prepare_scalar_function(
          fun,
          x0,
          jac=jac,
          args=args,
          epsilon=eps,
          finite_diff_rel_step=finite_diff_rel_step,
      )
  
      f = sf.fun
      myfprime = sf.grad
  
      old_fval = f(x0)
      gfk = myfprime(x0)
  
      if not np.isscalar(old_fval):
          try:
              old_fval = old_fval.item()
          except (ValueError, AttributeError) as e:
              raise ValueError(
                  "The user-provided "
                  "objective function must "
                  "return a scalar value."
              ) from e
  
      k = 0
      xk = x0
      # Sets the initial step guess to dx ~ 1
      old_old_fval = old_fval + np.linalg.norm(gfk) / 2
  
      if retall:
          allvecs = [xk]
      warnflag = 0
      pk = -gfk
      gnorm = vecnorm(gfk, ord=norm)
  
      sigma_3 = 0.01
  
      while (gnorm > gtol) and (k < maxiter):
          deltak = np.dot(gfk, gfk)
  
          cached_step = [None]
  
          def polak_ribiere_powell_step(alpha, gfkp1=None):
              xkp1 = xk + alpha * pk
              if gfkp1 is None:
                  gfkp1 = myfprime(xkp1)
              yk = gfkp1 - gfk
              beta_k = max(0, np.dot(yk, gfkp1) / deltak)
              pkp1 = -gfkp1 + beta_k * pk
              gnorm = vecnorm(gfkp1, ord=norm)
              return (alpha, xkp1, pkp1, gfkp1, gnorm)
  
          def descent_condition(alpha, xkp1, fp1, gfkp1):
              # Polak-Ribiere+ needs an explicit check of a sufficient
              # descent condition, which is not guaranteed by strong Wolfe.
              #
              # See Gilbert & Nocedal, "Global convergence properties of
              # conjugate gradient methods for optimization",
              # SIAM J. Optimization 2, 21 (1992).
              cached_step[:] = polak_ribiere_powell_step(alpha, gfkp1)
              alpha, xk, pk, gfk, gnorm = cached_step
  
              # Accept step if it leads to convergence.
              if gnorm <= gtol:
                  return True
  
              # Accept step if sufficient descent condition applies.
              return np.dot(pk, gfk) <= -sigma_3 * np.dot(gfk, gfk)
  
          try:
              (
                  alpha_k,
                  fc,
                  gc,
                  old_fval,
                  old_old_fval,
                  gfkp1,
              ) = _line_search_wolfe12(
                  f,
                  myfprime,
                  xk,
                  pk,
                  gfk,
                  old_fval,
                  old_old_fval,
                  c2=0.4,
                  amin=1e-100,
                  amax=1e100,
                  extra_condition=descent_condition,
              )
          except _LineSearchError:
              # Line search failed to find a better solution.
              warnflag = 2
              break
  
          # Reuse already computed results if possible
          if alpha_k == cached_step[0]:
              alpha_k, xk, pk, gfk, gnorm = cached_step
          else:
              alpha_k, xk, pk, gfk, gnorm = polak_ribiere_powell_step(
                  alpha_k, gfkp1
              )
  
          if retall:
              allvecs.append(xk)
          if callback is not None:
              callback(xk)
          k += 1
  
      fval = old_fval
      if warnflag == 2:
          msg = _status_message["pr_loss"]
      elif k >= maxiter:
          warnflag = 1
          msg = _status_message["maxiter"]
      elif np.isnan(gnorm) or np.isnan(fval) or np.isnan(xk).any():
          warnflag = 3
          msg = _status_message["nan"]
      else:
          msg = _status_message["success"]
  
      if disp:
          print("%s%s" % ("Warning: " if warnflag != 0 else "", msg))
          print("         Current function value: %f" % fval)
          print("         Iterations: %d" % k)
          print("         Function evaluations: %d" % sf.nfev)
          print("         Gradient evaluations: %d" % sf.ngev)
  
      result = OptimizeResult(
          fun=fval,
          jac=gfk,
          nfev=sf.nfev,
          njev=sf.ngev,
          status=warnflag,
          success=(warnflag == 0),
          message=msg,
          x=xk,
          nit=k,
      )
      if retall:
          result["allvecs"] = allvecs
      return result
  
imports: import warnings
  import sys
  from numpy import atleast_1d, eye, argmin, zeros, shape, squeeze, asarray, sqrt, Inf, asfarray, isinf
  import numpy
  from .linesearch import line_search_wolfe1, line_search_wolfe2, line_search_wolfe2, LineSearchWarning
  from ._numdiff import approx_derivative
  from scipy._lib._util import getfullargspec_no_self
  from scipy._lib._util import MapWrapper
  from scipy.optimize._differentiable_functions import ScalarFunction, FD_METHODS
label_desc: Use image node_id 21 for calling a global function with example usage: _minimize_cg(fun, x0, args, jac, callback, gtol, norm, eps, maxiter, disp, return_all, finite_diff_rel_step) and returns: result, alpha,  xkp1,  pkp1,  gfkp1,  gnorm, unknown, True