code: def __lpc(
      y: np.ndarray,
      order: int,
      ar_coeffs: np.ndarray,
      ar_coeffs_prev: np.ndarray,
      reflect_coeff: np.ndarray,
      den: np.ndarray,
      epsilon: float,
  ) -> np.ndarray:
      # This implementation follows the description of Burg's algorithm given in
      # section III of Marple's paper referenced in the docstring.
      #
      # We use the Levinson-Durbin recursion to compute AR coefficients for each
      # increasing model order by using those from the last. We maintain two
      # arrays and then flip them each time we increase the model order so that
      # we may use all the coefficients from the previous order while we compute
      # those for the new one. These two arrays hold ar_coeffs for order M and
      # order M-1.  (Corresponding to a_{M,k} and a_{M-1,k} in eqn 5)
  
      # These two arrays hold the forward and backward prediction error. They
      # correspond to f_{M-1,k} and b_{M-1,k} in eqns 10, 11, 13 and 14 of
      # Marple. First they are used to compute the reflection coefficient at
      # order M from M-1 then are re-used as f_{M,k} and b_{M,k} for each
      # iteration of the below loop
      fwd_pred_error = y[1:]
      bwd_pred_error = y[:-1]
  
      # DEN_{M} from eqn 16 of Marple.
      den[0] = np.sum(fwd_pred_error**2 + bwd_pred_error**2, axis=0)
  
      for i in range(order):
          # can be removed if we keep the epsilon bias
          # if np.any(den <= 0):
          #    raise FloatingPointError("numerical error, input ill-conditioned?")
  
          # Eqn 15 of Marple, with fwd_pred_error and bwd_pred_error
          # corresponding to f_{M-1,k+1} and b{M-1,k} and the result as a_{M,M}
  
          reflect_coeff[0] = np.sum(
              bwd_pred_error * fwd_pred_error, axis=0
          )
          reflect_coeff[0] *= -2
          reflect_coeff[0] /= den[0] + epsilon
  
          # Now we use the reflection coefficient and the AR coefficients from
          # the last model order to compute all of the AR coefficients for the
          # current one.  This is the Levinson-Durbin recursion described in
          # eqn 5.
          # Note 1: We don't have to care about complex conjugates as our signals
          # are all real-valued
          # Note 2: j counts 1..order+1, i-j+1 counts order..0
          # Note 3: The first element of ar_coeffs* is always 1, which copies in
          # the reflection coefficient at the end of the new AR coefficient array
          # after the preceding coefficients
  
          ar_coeffs_prev, ar_coeffs = ar_coeffs, ar_coeffs_prev
          for j in range(1, i + 2):
              # reflection multiply should be broadcast
              ar_coeffs[j] = (
                  ar_coeffs_prev[j]
                  + reflect_coeff[0] * ar_coeffs_prev[i - j + 1]
              )
  
          # Update the forward and backward prediction errors corresponding to
          # eqns 13 and 14.  We start with f_{M-1,k+1} and b_{M-1,k} and use them
          # to compute f_{M,k} and b_{M,k}
          fwd_pred_error_tmp = fwd_pred_error
          fwd_pred_error = (
              fwd_pred_error + reflect_coeff * bwd_pred_error
          )
          bwd_pred_error = (
              bwd_pred_error + reflect_coeff * fwd_pred_error_tmp
          )
  
          # SNIP - we are now done with order M and advance. M-1 <- M
  
          # Compute DEN_{M} using the recursion from eqn 17.
          #
          # reflect_coeff = a_{M-1,M-1}      (we have advanced M)
          # den =  DEN_{M-1}                 (rhs)
          # bwd_pred_error = b_{M-1,N-M+1}   (we have advanced M)
          # fwd_pred_error = f_{M-1,k}       (we have advanced M)
          # den <- DEN_{M}                   (lhs)
          #
  
          q = 1.0 - reflect_coeff[0] ** 2
          den[0] = (
              q * den[0]
              - bwd_pred_error[-1] ** 2
              - fwd_pred_error[0] ** 2
          )
  
          # Shift up forward error.
          #
          # fwd_pred_error <- f_{M-1,k+1}
          # bwd_pred_error <- b_{M-1,k}
          #
          # N.B. We do this after computing the denominator using eqn 17 but
          # before using it in the numerator in eqn 15.
          fwd_pred_error = fwd_pred_error[1:]
          bwd_pred_error = bwd_pred_error[:-1]
  
      return ar_coeffs
  
imports: from __future__ import annotations
  import os
  import pathlib
  import warnings
  import soundfile
  import audioread
  import numpy
  import scipy.signal
  import soxr
  import lazy_loader
  from numba import jit, stencil, guvectorize
  from .fft import get_fftlib
  from .convert import frames_to_samples, time_to_samples
  from .._cache import cache
  from ..None import util
  from ..util.exceptions import ParameterError
  from ..util.decorators import deprecated
  from ..util.deprecation import Deprecated, rename_kw
  from .._typing import _FloatLike_co, _IntLike_co, _SequenceLike
  from typing import Any, BinaryIO, Callable, Generator, Optional, Tuple, Union, List
  from numpy.typing import DTypeLike, ArrayLike
label_desc: Use image node_id 11 for calling a global function with example usage: __lpc(y, order, ar_coeffs, ar_coeffs_prev, reflect_coeff, den, epsilon) and returns: ar_coeffs