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(
              "Vertex minimiser maps = {}".format(self.LMC.v_maps)
          )
  
      if self.LMC[x_min].lres is not None:
          return self.LMC[x_min].lres
  
      # TODO: Check discarded bound rules
  
      if self.callback is not None:
          print(
              "Callback for " "minimizer starting at {}:".format(x_min)
          )
  
      if self.disp:
          print("Starting " "minimization at {}...".format(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
  
      else:
          g_bounds = self.construct_lcb_delaunay(x_min, ind=ind)
          if "bounds" in self.min_solver_args:
              self.minimizer_kwargs["bounds"] = g_bounds
  
      if self.disp and "bounds" in self.minimizer_kwargs:
          print("bounds in kwarg:")
          print(self.minimizer_kwargs["bounds"])
  
      # Local minimization using scipy.optimize.minimize:
      lres = minimize(self.func, x_min, **self.minimizer_kwargs)
  
      if self.disp:
          print("lres = {}".format(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: import numpy
  import time
  import logging
  import warnings
  from scipy import spatial
  from scipy.optimize import OptimizeResult, minimize
  from scipy.optimize._shgo_lib.triangulation import Complex
label_desc: Use image node_id 23 for calling the SHGO obj's underlying member method code with example usage: obj.minimize(x_min, ind) and returns: lres, self