class_docstr: Explicit Runge-Kutta method of order 8.
  
  This is a Python implementation of "DOP853" algorithm originally written
  in Fortran [1]_, [2]_. Note that this is not a literal translation, but
  the algorithmic core and coefficients are the same.
  
  Can be applied in the complex domain.
  
  Parameters
  ----------
  fun : callable
      Right-hand side of the system. The calling signature is ``fun(t, y)``.
      Here, ``t`` is a scalar, and there are two options for the ndarray ``y``:
      It can either have shape (n,); then ``fun`` must return array_like with
      shape (n,). Alternatively it can have shape (n, k); then ``fun``
      must return an array_like with shape (n, k), i.e. each column
      corresponds to a single column in ``y``. The choice between the two
      options is determined by `vectorized` argument (see below).
  t0 : float
      Initial time.
  y0 : array_like, shape (n,)
      Initial state.
  t_bound : float
      Boundary time - the integration won't continue beyond it. It also
      determines the direction of the integration.
  first_step : float or None, optional
      Initial step size. Default is ``None`` which means that the algorithm
      should choose.
  max_step : float, optional
      Maximum allowed step size. Default is np.inf, i.e. the step size is not
      bounded and determined solely by the solver.
  rtol, atol : float and array_like, optional
      Relative and absolute tolerances. The solver keeps the local error
      estimates less than ``atol + rtol * abs(y)``. Here `rtol` controls a
      relative accuracy (number of correct digits), while `atol` controls
      absolute accuracy (number of correct decimal places). To achieve the
      desired `rtol`, set `atol` to be smaller than the smallest value that
      can be expected from ``rtol * abs(y)`` so that `rtol` dominates the
      allowable error. If `atol` is larger than ``rtol * abs(y)`` the
      number of correct digits is not guaranteed. Conversely, to achieve the
      desired `atol` set `rtol` such that ``rtol * abs(y)`` is always smaller
      than `atol`. If components of y have different scales, it might be
      beneficial to set different `atol` values for different components by
      passing array_like with shape (n,) for `atol`. Default values are
      1e-3 for `rtol` and 1e-6 for `atol`.
  vectorized : bool, optional
      Whether `fun` is implemented in a vectorized fashion. Default is False.
  
  Attributes
  ----------
  n : int
      Number of equations.
  status : string
      Current status of the solver: 'running', 'finished' or 'failed'.
  t_bound : float
      Boundary time.
  direction : float
      Integration direction: +1 or -1.
  t : float
      Current time.
  y : ndarray
      Current state.
  t_old : float
      Previous time. None if no steps were made yet.
  step_size : float
      Size of the last successful step. None if no steps were made yet.
  nfev : int
      Number evaluations of the system's right-hand side.
  njev : int
      Number of evaluations of the Jacobian. Is always 0 for this solver
      as it does not use the Jacobian.
  nlu : int
      Number of LU decompositions. Is always 0 for this solver.
  
  References
  ----------
  .. [1] E. Hairer, S. P. Norsett G. Wanner, "Solving Ordinary Differential
         Equations I: Nonstiff Problems", Sec. II.
  .. [2] `Page with original Fortran code of DOP853
          <http://www.unige.ch/~hairer/software.html>`_.
code: def _estimate_error_norm(self, K, h, scale):
      err5 = np.dot(K.T, self.E5) / scale
      err3 = np.dot(K.T, self.E3) / scale
      err5_norm_2 = np.linalg.norm(err5) ** 2
      err3_norm_2 = np.linalg.norm(err3) ** 2
      if err5_norm_2 == 0 and err3_norm_2 == 0:
          return 0.0
      denom = err5_norm_2 + 0.01 * err3_norm_2
      return np.abs(h) * err5_norm_2 / np.sqrt(denom * len(scale))
  
imports: import numpy
  from .base import OdeSolver, DenseOutput
  from .common import validate_max_step, validate_tol, select_initial_step, norm, warn_extraneous, validate_first_step
  from .None import dop853_coefficients
label_desc: Use image node_id 3 for calling the DOP853 obj's underlying member method code with example usage: obj._estimate_error_norm(K, h, scale) and returns: unknown, int