docs: def partial_autocorrelation(x, param):
      """
      Calculates the value of the partial autocorrelation function at the given lag. The lag `k` partial autocorrelation
      of a time series :math:`\\lbrace x_t, t = 1 \\ldots T \\rbrace` equals the partial correlation of :math:`x_t` and
      :math:`x_{t-k}`, adjusted for the intermediate variables
      :math:`\\lbrace x_{t-1}, \\ldots, x_{t-k+1} \\rbrace` ([1]).
      Following [2], it can be defined as
  
      .. math::
  
          \\alpha_k = \\frac{ Cov(x_t, x_{t-k} | x_{t-1}, \\ldots, x_{t-k+1})}
          {\\sqrt{ Var(x_t | x_{t-1}, \\ldots, x_{t-k+1}) Var(x_{t-k} | x_{t-1}, \\ldots, x_{t-k+1} )}}
  
      with (a) :math:`x_t = f(x_{t-1}, \\ldots, x_{t-k+1})` and (b) :math:`x_{t-k} = f(x_{t-1}, \\ldots, x_{t-k+1})`
      being AR(k-1) models that can be fitted by OLS. Be aware that in (a), the regression is done on past values to
      predict :math:`x_t` whereas in (b), future values are used to calculate the past value :math:`x_{t-k}`.
      It is said in [1] that "for an AR(p), the partial autocorrelations [ :math:`\\alpha_k` ] will be nonzero for `k<=p`
      and zero for `k>p`."
      With this property, it is used to determine the lag of an AR-Process.
  
      .. rubric:: References
  
      |  [1] Box, G. E., Jenkins, G. M., Reinsel, G. C., & Ljung, G. M. (2015).
      |  Time series analysis: forecasting and control. John Wiley & Sons.
      |  [2] https://onlinecourses.science.psu.edu/stat510/node/62
  
      :param x: the time series to calculate the feature of
      :type x: numpy.ndarray
      :param param: contains dictionaries {"lag": val} with int val indicating the lag to be returned
      :type param: list
      :return: the value of this feature
      :return type: float
      """
      # Check the difference between demanded lags by param and possible lags to calculate (depends on len(x))
      max_demanded_lag = max([lag["lag"] for lag in param])
      n = len(x)
  
      # Check if list is too short to make calculations
      if n <= 1:
          pacf_coeffs = [np.nan] * (max_demanded_lag + 1)
      else:
          if (n <= max_demanded_lag):
              max_lag = n - 1
          else:
              max_lag = max_demanded_lag
          pacf_coeffs = list(pacf(x, method="ld", nlags=max_lag))
          pacf_coeffs = pacf_coeffs + [np.nan] * max(0, (max_demanded_lag - max_lag))
  
      return [("lag_{}".format(lag["lag"]), pacf_coeffs[lag["lag"]]) for lag in param]