# Source code for neurokit2.complexity.fractal_petrosian

```
import numpy as np
import pandas as pd
from .utils_complexity_symbolize import complexity_symbolize
[docs]
def fractal_petrosian(signal, symbolize="C", show=False):
"""**Petrosian fractal dimension (PFD)**
Petrosian (1995) proposed a fast method to estimate the fractal dimension by converting the
signal into a binary sequence from which the fractal dimension is estimated. Several variations
of the algorithm exist (e.g., ``"A"``, ``"B"``, ``"C"`` or ``"D"``), primarily differing in the
way the discrete (symbolic) sequence is created (see func:`complexity_symbolize` for details).
The most common method (``"C"``, by default) binarizes the signal by the sign of consecutive
differences.
.. math::
\\frac{log(N)}{log(N) + log(\\frac{N}{N+0.4N_{\\delta}})}
Most of these methods assume that the signal is periodic (without a linear trend). Linear
detrending might be useful to eliminate linear trends (see :func:`.signal_detrend`).
See Also
--------
information_mutual, entropy_svd
Parameters
----------
signal : Union[list, np.array, pd.Series]
The signal (i.e., a time series) in the form of a vector of values.
symbolize : str
Method to convert a continuous signal input into a symbolic (discrete) signal. By default,
assigns 0 and 1 to values below and above the mean. Can be ``None`` to skip the process (in
case the input is already discrete). See :func:`complexity_symbolize` for details.
show : bool
If ``True``, will show the discrete the signal.
Returns
-------
pfd : float
The petrosian fractal dimension (PFD).
info : dict
A dictionary containing additional information regarding the parameters used
to compute PFD.
Examples
----------
.. ipython:: python
import neurokit2 as nk
signal = nk.signal_simulate(duration=2, frequency=[5, 12])
@savefig p_fractal_petrosian1.png scale=100%
pfd, info = nk.fractal_petrosian(signal, symbolize = "C", show=True)
@suppress
plt.close()
.. ipython:: python
pfd
info
References
----------
* Esteller, R., Vachtsevanos, G., Echauz, J., & Litt, B. (2001). A comparison of waveform
fractal dimension algorithms. IEEE Transactions on Circuits and Systems I: Fundamental Theory
and Applications, 48(2), 177-183.
* Petrosian, A. (1995, June). Kolmogorov complexity of finite sequences and recognition of
different preictal EEG patterns. In Proceedings eighth IEEE symposium on computer-based
medical systems (pp. 212-217). IEEE.
* Kumar, D. K., Arjunan, S. P., & Aliahmad, B. (2017). Fractals: applications in biological
Signalling and image processing. CRC Press.
* Goh, C., Hamadicharef, B., Henderson, G., & Ifeachor, E. (2005, June). Comparison of fractal
dimension algorithms for the computation of EEG biomarkers for dementia. In 2nd International
Conference on Computational Intelligence in Medicine and Healthcare (CIMED2005).
"""
# Sanity checks
if isinstance(signal, (np.ndarray, pd.DataFrame)) and signal.ndim > 1:
raise ValueError(
"Multidimensional inputs (e.g., matrices or multichannel data) are not supported yet."
)
# Binarize the sequence
symbolic = complexity_symbolize(signal, method=symbolize, show=show)
# if isinstance(method, str) and method.lower() in ["d", "r"]:
# # These methods are already based on the consecutive differences
# n_inversions = symbolic.sum()
# else:
# # Note: np.diff(symbolic).sum() wouldn't work in case there's a seq like [0, -1, 1]
# n_inversions = (symbolic[1:] != symbolic[:-1]).sum()
n_inversions = (symbolic[1:] != symbolic[:-1]).sum()
n = len(symbolic)
pfd = np.log10(n) / (np.log10(n) + np.log10(n / (n + 0.4 * n_inversions)))
return pfd, {"Symbolization": symbolize}
```