docstr: This function is used to calculate the local minima using the specified
  sampling point as a starting value.
  
  Parameters
  ----------
  x_min : vector of floats
      Current starting point to minimize.
  
  Returns
  -------
  lres : OptimizeResult
      The local optimization result represented as a `OptimizeResult`
      object.
code: def minimize(self, x_min, ind=None):
      """
      This function is used to calculate the local minima using the specified
      sampling point as a starting value.
  
      Parameters
      ----------
      x_min : vector of floats
          Current starting point to minimize.
  
      Returns
      -------
      lres : OptimizeResult
          The local optimization result represented as a `OptimizeResult`
          object.
      """
      # Use minima maps if vertex was already run
      if self.disp:
          logging.info(f"Vertex minimiser maps = {self.LMC.v_maps}")
  
      if self.LMC[x_min].lres is not None:
          logging.info(
              f"Found self.LMC[x_min].lres = " f"{self.LMC[x_min].lres}"
          )
          return self.LMC[x_min].lres
  
      if self.callback is not None:
          logging.info(f"Callback for minimizer starting at {x_min}:")
  
      if self.disp:
          logging.info(f"Starting minimization at {x_min}...")
  
      if self.sampling_method == "simplicial":
          x_min_t = tuple(x_min)
          # Find the normalized tuple in the Vertex cache:
          x_min_t_norm = self.X_min_cache[tuple(x_min_t)]
          x_min_t_norm = tuple(x_min_t_norm)
          g_bounds = self.construct_lcb_simplicial(
              self.HC.V[x_min_t_norm]
          )
          if "bounds" in self.min_solver_args:
              self.minimizer_kwargs["bounds"] = g_bounds
              logging.info(self.minimizer_kwargs["bounds"])
  
      else:
          g_bounds = self.construct_lcb_delaunay(x_min, ind=ind)
          if "bounds" in self.min_solver_args:
              self.minimizer_kwargs["bounds"] = g_bounds
              logging.info(self.minimizer_kwargs["bounds"])
  
      if self.disp and "bounds" in self.minimizer_kwargs:
          logging.info("bounds in kwarg:")
          logging.info(self.minimizer_kwargs["bounds"])
  
      # Local minimization using scipy.optimize.minimize:
      lres = minimize(self.func, x_min, **self.minimizer_kwargs)
  
      if self.disp:
          logging.info(f"lres = {lres}")
  
      # Local function evals for all minimizers
      self.res.nlfev += lres.nfev
      if "njev" in lres:
          self.res.nljev += lres.njev
      if "nhev" in lres:
          self.res.nlhev += lres.nhev
  
      try:  # Needed because of the brain dead 1x1 NumPy arrays
          lres.fun = lres.fun[0]
      except (IndexError, TypeError):
          lres.fun
  
      # Append minima maps
      self.LMC[x_min]
      self.LMC.add_res(x_min, lres, bounds=g_bounds)
  
      return lres
  
imports: from collections import namedtuple
  import time
  import logging
  import warnings
  import sys
  import numpy
  from scipy import spatial
  from scipy.optimize import OptimizeResult, minimize, Bounds
  from scipy.optimize._optimize import MemoizeJac
  from scipy.optimize._constraints import new_bounds_to_old
  from scipy.optimize._minimize import standardize_constraints
  from scipy._lib._util import _FunctionWrapper
  from scipy.optimize._shgo_lib._complex import Complex
label_desc: Use image node_id 25 for calling the SHGO obj's underlying member method code with example usage: obj.minimize(x_min, ind) and returns: lres, self