class_docstr: Broyden-Fletcher-Goldfarb-Shanno (BFGS) Hessian update strategy.
  
  Parameters
  ----------
  exception_strategy : {'skip_update', 'damp_update'}, optional
      Define how to proceed when the curvature condition is violated.
      Set it to 'skip_update' to just skip the update. Or, alternatively,
      set it to 'damp_update' to interpolate between the actual BFGS
      result and the unmodified matrix. Both exceptions strategies
      are explained  in [1]_, p.536-537.
  min_curvature : float
      This number, scaled by a normalization factor, defines the
      minimum curvature ``dot(delta_grad, delta_x)`` allowed to go
      unaffected by the exception strategy. By default is equal to
      1e-8 when ``exception_strategy = 'skip_update'`` and equal
      to 0.2 when ``exception_strategy = 'damp_update'``.
  init_scale : {float, 'auto'}
      Matrix scale at first iteration. At the first
      iteration the Hessian matrix or its inverse will be initialized
      with ``init_scale*np.eye(n)``, where ``n`` is the problem dimension.
      Set it to 'auto' in order to use an automatic heuristic for choosing
      the initial scale. The heuristic is described in [1]_, p.143.
      By default uses 'auto'.
  
  Notes
  -----
  The update is based on the description in [1]_, p.140.
  
  References
  ----------
  .. [1] Nocedal, Jorge, and Stephen J. Wright. "Numerical optimization"
         Second Edition (2006).
code: def _update_implementation(self, delta_x, delta_grad):
      # Auxiliary variables w and z
      if self.approx_type == "hess":
          w = delta_x
          z = delta_grad
      else:
          w = delta_grad
          z = delta_x
      # Do some common operations
      wz = np.dot(w, z)
      Mw = self.dot(w)
      wMw = Mw.dot(w)
      # Guarantee that wMw > 0 by reinitializing matrix.
      # While this is always true in exact arithmetics,
      # indefinite matrix may appear due to roundoff errors.
      if wMw <= 0.0:
          scale = self._auto_scale(delta_x, delta_grad)
          # Reinitialize matrix
          if self.approx_type == "hess":
              self.B = scale * np.eye(self.n, dtype=float)
          else:
              self.H = scale * np.eye(self.n, dtype=float)
          # Do common operations for new matrix
          Mw = self.dot(w)
          wMw = Mw.dot(w)
      # Check if curvature condition is violated
      if wz <= self.min_curvature * wMw:
          # If the option 'skip_update' is set
          # we just skip the update when the condion
          # is violated.
          if self.exception_strategy == "skip_update":
              return
          # If the option 'damp_update' is set we
          # interpolate between the actual BFGS
          # result and the unmodified matrix.
          elif self.exception_strategy == "damp_update":
              update_factor = (1 - self.min_curvature) / (1 - wz / wMw)
              z = update_factor * z + (1 - update_factor) * Mw
              wz = np.dot(w, z)
      # Update matrix
      if self.approx_type == "hess":
          self._update_hessian(wz, Mw, wMw, z)
      else:
          self._update_inverse_hessian(wz, Mw, wMw, z)
  
imports: from __future__ import division, print_function, absolute_import
  import numpy
  from numpy.linalg import norm
  from scipy.linalg import get_blas_funcs
  from warnings import warn
label_desc: Use image node_id 4 for calling the BFGS obj's underlying member method code with example usage: obj._update_implementation(delta_x, delta_grad) without return types