docs: def permutation_entropy(time_series, order=3, delay=1, normalize=False):
      """Permutation Entropy.
  
      Parameters
      ----------
      time_series : list or np.array
          Time series
      order : int
          Order of permutation entropy
      delay : int
          Time delay
      normalize : bool
          If True, divide by log2(factorial(m)) to normalize the entropy
          between 0 and 1. Otherwise, return the permutation entropy in bit.
  
      Returns
      -------
      pe : float
          Permutation Entropy
  
      References
      ----------
      .. [1] Massimiliano Zanin et al. Permutation Entropy and Its Main
          Biomedical and Econophysics Applications: A Review.
          http://www.mdpi.com/1099-4300/14/8/1553/pdf
  
      .. [2] Christoph Bandt and Bernd Pompe. Permutation entropy — a natural
          complexity measure for time series.
          http://stubber.math-inf.uni-greifswald.de/pub/full/prep/2001/11.pdf
  
      Notes
      -----
      Last updated (Oct 2018) by Raphael Vallat (raphaelvallat9@gmail.com):
      - Major speed improvements
      - Use of base 2 instead of base e
      - Added normalization
  
      Examples
      --------
      1. Permutation entropy with order 2
  
          >>> x = [4, 7, 9, 10, 6, 11, 3]
          >>> # Return a value between 0 and log2(factorial(order))
          >>> print(permutation_entropy(x, order=2))
              0.918
  
      2. Normalized permutation entropy with order 3
  
          >>> x = [4, 7, 9, 10, 6, 11, 3]
          >>> # Return a value comprised between 0 and 1.
          >>> print(permutation_entropy(x, order=3, normalize=True))
              0.589
      """
      x = np.array(time_series)
      hashmult = np.power(order, np.arange(order))
      # Embed x and sort the order of permutations
      sorted_idx = _embed(x, order=order, delay=delay).argsort(kind='quicksort')
      # Associate unique integer to each permutations
      hashval = (np.multiply(sorted_idx, hashmult)).sum(1)
      # Return the counts
      _, c = np.unique(hashval, return_counts=True)
      # Use np.true_divide for Python 2 compatibility
      p = np.true_divide(c, c.sum())
      pe = -np.multiply(p, np.log2(p)).sum()
      if normalize:
          pe /= np.log2(factorial(order))
      return pe