code: def fmin_tnc(
      func,
      x0,
      fprime=None,
      args=(),
      approx_grad=0,
      bounds=None,
      epsilon=1e-8,
      scale=None,
      offset=None,
      messages=MSG_ALL,
      maxCGit=-1,
      maxfun=None,
      eta=-1,
      stepmx=0,
      accuracy=0,
      fmin=0,
      ftol=-1,
      xtol=-1,
      pgtol=-1,
      rescale=-1,
      disp=None,
      callback=None,
  ):
      """
      Minimize a function with variables subject to bounds, using
      gradient information in a truncated Newton algorithm. This
      method wraps a C implementation of the algorithm.
  
      Parameters
      ----------
      func : callable ``func(x, *args)``
          Function to minimize.  Must do one of:
  
          1. Return f and g, where f is the value of the function and g its
             gradient (a list of floats).
  
          2. Return the function value but supply gradient function
             separately as `fprime`.
  
          3. Return the function value and set ``approx_grad=True``.
  
          If the function returns None, the minimization
          is aborted.
      x0 : array_like
          Initial estimate of minimum.
      fprime : callable ``fprime(x, *args)``, optional
          Gradient of `func`. If None, then either `func` must return the
          function value and the gradient (``f,g = func(x, *args)``)
          or `approx_grad` must be True.
      args : tuple, optional
          Arguments to pass to function.
      approx_grad : bool, optional
          If true, approximate the gradient numerically.
      bounds : list, optional
          (min, max) pairs for each element in x0, defining the
          bounds on that parameter. Use None or +/-inf for one of
          min or max when there is no bound in that direction.
      epsilon : float, optional
          Used if approx_grad is True. The stepsize in a finite
          difference approximation for fprime.
      scale : array_like, optional
          Scaling factors to apply to each variable. If None, the
          factors are up-low for interval bounded variables and
          1+|x| for the others. Defaults to None.
      offset : array_like, optional
          Value to subtract from each variable. If None, the
          offsets are (up+low)/2 for interval bounded variables
          and x for the others.
      messages : int, optional
          Bit mask used to select messages display during
          minimization values defined in the MSGS dict. Defaults to
          MGS_ALL.
      disp : int, optional
          Integer interface to messages. 0 = no message, 5 = all messages
      maxCGit : int, optional
          Maximum number of hessian*vector evaluations per main
          iteration. If maxCGit == 0, the direction chosen is
          -gradient if maxCGit < 0, maxCGit is set to
          max(1,min(50,n/2)). Defaults to -1.
      maxfun : int, optional
          Maximum number of function evaluation. If None, maxfun is
          set to max(100, 10*len(x0)). Defaults to None. Note that this function
          may violate the limit because of evaluating gradients by numerical
          differentiation.
      eta : float, optional
          Severity of the line search. If < 0 or > 1, set to 0.25.
          Defaults to -1.
      stepmx : float, optional
          Maximum step for the line search. May be increased during
          call. If too small, it will be set to 10.0. Defaults to 0.
      accuracy : float, optional
          Relative precision for finite difference calculations. If
          <= machine_precision, set to sqrt(machine_precision).
          Defaults to 0.
      fmin : float, optional
          Minimum function value estimate. Defaults to 0.
      ftol : float, optional
          Precision goal for the value of f in the stopping criterion.
          If ftol < 0.0, ftol is set to 0.0 defaults to -1.
      xtol : float, optional
          Precision goal for the value of x in the stopping
          criterion (after applying x scaling factors). If xtol <
          0.0, xtol is set to sqrt(machine_precision). Defaults to
          -1.
      pgtol : float, optional
          Precision goal for the value of the projected gradient in
          the stopping criterion (after applying x scaling factors).
          If pgtol < 0.0, pgtol is set to 1e-2 * sqrt(accuracy).
          Setting it to 0.0 is not recommended. Defaults to -1.
      rescale : float, optional
          Scaling factor (in log10) used to trigger f value
          rescaling. If 0, rescale at each iteration. If a large
          value, never rescale. If < 0, rescale is set to 1.3.
      callback : callable, optional
          Called after each iteration, as callback(xk), where xk is the
          current parameter vector.
  
      Returns
      -------
      x : ndarray
          The solution.
      nfeval : int
          The number of function evaluations.
      rc : int
          Return code, see below
  
      See also
      --------
      minimize: Interface to minimization algorithms for multivariate
          functions. See the 'TNC' `method` in particular.
  
      Notes
      -----
      The underlying algorithm is truncated Newton, also called
      Newton Conjugate-Gradient. This method differs from
      scipy.optimize.fmin_ncg in that
  
      1. it wraps a C implementation of the algorithm
      2. it allows each variable to be given an upper and lower bound.
  
      The algorithm incorporates the bound constraints by determining
      the descent direction as in an unconstrained truncated Newton,
      but never taking a step-size large enough to leave the space
      of feasible x's. The algorithm keeps track of a set of
      currently active constraints, and ignores them when computing
      the minimum allowable step size. (The x's associated with the
      active constraint are kept fixed.) If the maximum allowable
      step size is zero then a new constraint is added. At the end
      of each iteration one of the constraints may be deemed no
      longer active and removed. A constraint is considered
      no longer active is if it is currently active
      but the gradient for that variable points inward from the
      constraint. The specific constraint removed is the one
      associated with the variable of largest index whose
      constraint is no longer active.
  
      Return codes are defined as follows::
  
          -1 : Infeasible (lower bound > upper bound)
           0 : Local minimum reached (|pg| ~= 0)
           1 : Converged (|f_n-f_(n-1)| ~= 0)
           2 : Converged (|x_n-x_(n-1)| ~= 0)
           3 : Max. number of function evaluations reached
           4 : Linear search failed
           5 : All lower bounds are equal to the upper bounds
           6 : Unable to progress
           7 : User requested end of minimization
  
      References
      ----------
      Wright S., Nocedal J. (2006), 'Numerical Optimization'
  
      Nash S.G. (1984), "Newton-Type Minimization Via the Lanczos Method",
      SIAM Journal of Numerical Analysis 21, pp. 770-778
  
      """
      # handle fprime/approx_grad
      if approx_grad:
          fun = func
          jac = None
      elif fprime is None:
          fun = MemoizeJac(func)
          jac = fun.derivative
      else:
          fun = func
          jac = fprime
  
      if disp is not None:  # disp takes precedence over messages
          mesg_num = disp
      else:
          mesg_num = {
              0: MSG_NONE,
              1: MSG_ITER,
              2: MSG_INFO,
              3: MSG_VERS,
              4: MSG_EXIT,
              5: MSG_ALL,
          }.get(messages, MSG_ALL)
      # build options
      opts = {
          "eps": epsilon,
          "scale": scale,
          "offset": offset,
          "mesg_num": mesg_num,
          "maxCGit": maxCGit,
          "maxfun": maxfun,
          "eta": eta,
          "stepmx": stepmx,
          "accuracy": accuracy,
          "minfev": fmin,
          "ftol": ftol,
          "xtol": xtol,
          "gtol": pgtol,
          "rescale": rescale,
          "disp": False,
      }
  
      res = _minimize_tnc(
          fun, x0, args, jac, bounds, callback=callback, **opts
      )
  
      return res["x"], res["nfev"], res["status"]
  
imports: from scipy.optimize import _moduleTNC
  from ._optimize import MemoizeJac, OptimizeResult, _check_unknown_options, _prepare_scalar_function
  from ._constraints import old_bound_to_new
  from scipy._lib._array_api import atleast_nd, array_namespace
  from numpy import inf, array, zeros
label_desc: Use image node_id 1 for calling a global function with example usage: fmin_tnc(func, x0, fprime, args, approx_grad, bounds, epsilon, scale, offset, messages, maxCGit, maxfun, eta, stepmx, accuracy, fmin, ftol, xtol, pgtol, rescale, disp, callback) and returns: res,  res,  res