FluctuationAnalysisTools 1.11.0__tar.gz → 1.11.0.dev0__tar.gz

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/.github/workflows/reusable_test.yml

@@ -57,15 +57,13 @@ jobs:
         if: ${{ inputs.os != 'ubuntu-latest' }}
         shell: bash
         run: |
-          WHEEL=$(ls wheelhouse/*.whl)
-          pip install "${WHEEL}[experimental,test]"
+          pip install wheelhouse/*.whl
 
       - name: Install FluctuationAnalysisTools from sdist
         if: ${{ inputs.os == 'ubuntu-latest' }}
         shell: bash
         run: |
-          SDIST=$(ls wheelhouse/*.tar.gz)
-          pip install "${SDIST}[experimental,test]"
+          pip install wheelhouse/*.tar.gz
 
       - name: Run tests
         run: |

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/.github/workflows/test-and-release.yml

@@ -87,7 +87,6 @@ jobs:
           find ./artifacts -name "*.tar.gz" -exec cp {} ./dist \;
 
       - name: Create Github Release
-        if: contains(github.ref, 'release')
         uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ steps.get-release.outputs.tag }}

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/.gitignore

@@ -19,6 +19,3 @@ research/out/*
 memory-bank/*
 .theia/*
 .prompts/*
-research/kalman_filter/filter_matrices
-research/kalman_filter/reconstruction_of_long_term_complex_system_dynamics/data/model_signals
-research/kalman_filter/reconstruction_of_long_term_complex_system_dynamics/data/output

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/.pre-commit-config.yaml

@@ -2,7 +2,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v6.0.0
+    rev: v3.2.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/FluctuationAnalysisTools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FluctuationAnalysisTools
-Version: 1.11.0
+Version: 1.11.0.dev0
 Summary: Python library for DFA, Hurst exponent, and fluctuation analysis of time series.
 Author: Maya Gavrichenkova, Timofey Baburin, Olga Ivleva
 Author-email: Aleksandr Sinitca <amsinitca@etu.ru>, Alexandr Kuzmenko <alexander.k.spb@gmail.com>, Asya Lyanova <ailianova@etu.ru>
@@ -17,12 +17,9 @@ Requires-Dist: scipy>=1.13.1
 Requires-Dist: setuptools>=70.0.0
 Requires-Dist: tqdm~=4.62.3
 Requires-Dist: pandas>=1.3.5
+Requires-Dist: filterpy>=1.4.5
 Requires-Dist: sympy>=1.14.0
 Requires-Dist: pybind11>=2.11.1
-Provides-Extra: test
-Requires-Dist: pytest-timeout; extra == "test"
-Provides-Extra: experimental
-Requires-Dist: filterpy; extra == "experimental"
 Dynamic: license-file
 
 # FluctuationAnalysisTools

fluctuationanalysistools-1.11.0.dev0/FluctuationAnalysisTools.egg-info/SOURCES.txt

@@ -0,0 +1,104 @@
+.gitattributes
+.gitignore
+.pre-commit-config.yaml
+CHANGELOG.md
+CONTRIBUTING.md
+LICENSE.txt
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+.github/ISSUE_TEMPLATE/bug_report.md
+.github/ISSUE_TEMPLATE/feature_request.md
+.github/workflows/reusable_build-wheels.yml
+.github/workflows/reusable_pre-commit-validation.yml
+.github/workflows/reusable_test.yml
+.github/workflows/run-tests.yml
+.github/workflows/test-and-release.yml
+FluctuationAnalysisTools.egg-info/PKG-INFO
+FluctuationAnalysisTools.egg-info/SOURCES.txt
+FluctuationAnalysisTools.egg-info/dependency_links.txt
+FluctuationAnalysisTools.egg-info/requires.txt
+FluctuationAnalysisTools.egg-info/top_level.txt
+StatTools/Gamma.py
+StatTools/__init__.py
+StatTools/_version.py
+StatTools/auxiliary.py
+StatTools/analysis/__init__.py
+StatTools/analysis/bma.py
+StatTools/analysis/dfa.py
+StatTools/analysis/dpcca.py
+StatTools/analysis/dpcca_as_class.py
+StatTools/analysis/fa.py
+StatTools/analysis/movmean.py
+StatTools/analysis/nd_dfa.py
+StatTools/analysis/qss.py
+StatTools/analysis/support_ff.py
+StatTools/analysis/svd_dfa.py
+StatTools/analysis/utils.py
+StatTools/analysis/nonequidistant/__init__.py
+StatTools/analysis/nonequidistant/dfa.py
+StatTools/experimental/__init__.py
+StatTools/experimental/analysis/__init__.py
+StatTools/experimental/analysis/tools.py
+StatTools/experimental/augmentation/__init__.py
+StatTools/experimental/augmentation/perturbations.py
+StatTools/experimental/synthesis/__init__.py
+StatTools/experimental/synthesis/tools.py
+StatTools/filters/kalman_filter.py
+StatTools/filters/symbolic_kalman.py
+StatTools/generators/__init__.py
+StatTools/generators/base_filter.py
+StatTools/generators/cholesky_transform.py
+StatTools/generators/fbm.py
+StatTools/generators/field_generator.py
+StatTools/generators/kasdin_generator.py
+StatTools/generators/lbfbm_generator.py
+StatTools/generators/ndfnoise_generator.py
+StatTools/native/.gitkeep
+StatTools/utilities/deprecation.py
+StatTools/visualization/__init__.py
+StatTools/visualization/plot_ff.py
+research/Video-based_marker-free_tracking_and_multi-scale_analysis.ipynb
+research/__init__.py
+research/bma.ipynb
+research/ff_analysis.ipynb
+research/lbfbm_generator.ipynb
+research/ndfnoise_generator.ipynb
+research/readme.md
+research/kalman_filter/__init__.py
+research/kalman_filter/high-order_kalman.ipynb
+research/kalman_filter/kalman-kasdin.ipynb
+research/kalman_filter/kalman_experiments.py
+research/kalman_filter/kalman_filter.ipynb
+research/kalman_filter/kalman_filter[ru].ipynb
+research/kalman_filter/svd_dfa_demo.ipynb
+src/cpp/DFA.cpp
+src/cpp/StatTools_C_API.cpp
+src/cpp/StatTools_bindings.cpp
+src/cpp/StatTools_core.cpp
+src/cpp/StatTools_core.h
+tests/test_bma.py
+tests/test_dfa.py
+tests/test_dfa_func.py
+tests/test_dpcca.py
+tests/test_fa.py
+tests/test_filter.py
+tests/test_filtered_array.py
+tests/test_kalman_filter.py
+tests/test_kasdin_generator.py
+tests/test_lbfbm_generator.py
+tests/test_nddfa.py
+tests/test_ndfnoise_generator.py
+tests/test_ne_dfa.py
+tests/test_pybind11_bindings.py
+tests/test_svd_dfa.py
+tests/test_unified_generator.py
+tests/test_utils.py
+tests_manual/cholesky_with_R.py
+tests_manual/dfa_test.py
+tests_manual/dpcca_pipe.py
+tests_manual/dpcca_test.py
+tests_manual/ff_visualization_test.py
+tests_manual/ff_zero_crossover_visualisation_test.py
+tests_manual/test_buffer.py

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/FluctuationAnalysisTools.egg-info/requires.txt

@@ -4,11 +4,6 @@ scipy>=1.13.1
 setuptools>=70.0.0
 tqdm~=4.62.3
 pandas>=1.3.5
+filterpy>=1.4.5
 sympy>=1.14.0
 pybind11>=2.11.1
-
-[experimental]
-filterpy
-
-[test]
-pytest-timeout

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FluctuationAnalysisTools
-Version: 1.11.0
+Version: 1.11.0.dev0
 Summary: Python library for DFA, Hurst exponent, and fluctuation analysis of time series.
 Author: Maya Gavrichenkova, Timofey Baburin, Olga Ivleva
 Author-email: Aleksandr Sinitca <amsinitca@etu.ru>, Alexandr Kuzmenko <alexander.k.spb@gmail.com>, Asya Lyanova <ailianova@etu.ru>
@@ -17,12 +17,9 @@ Requires-Dist: scipy>=1.13.1
 Requires-Dist: setuptools>=70.0.0
 Requires-Dist: tqdm~=4.62.3
 Requires-Dist: pandas>=1.3.5
+Requires-Dist: filterpy>=1.4.5
 Requires-Dist: sympy>=1.14.0
 Requires-Dist: pybind11>=2.11.1
-Provides-Extra: test
-Requires-Dist: pytest-timeout; extra == "test"
-Provides-Extra: experimental
-Requires-Dist: filterpy; extra == "experimental"
 Dynamic: license-file
 
 # FluctuationAnalysisTools

fluctuationanalysistools-1.11.0.dev0/StatTools/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '1.11.0.dev0'
+__version_tuple__ = version_tuple = (1, 11, 0, 'dev0')
+
+__commit_id__ = commit_id = 'g90f7796de'

fluctuationanalysistools-1.11.0.dev0/StatTools/analysis/__init__.py

@@ -0,0 +1,19 @@
+from .bma import bma
+from .dpcca import dpcca
+from .fa import fa
+from .nd_dfa import nd_dfa
+from .support_ff import (
+    f_fcn,
+    f_fcn_without_overflaw,
+    ff_base_appriximation,
+    rev_f_fcn,
+    tf_minus_inf,
+    tf_plus_inf,
+)
+from .utils import (
+    analyse_cross_ff,
+    analyse_zero_cross_ff,
+    cross_fcn_sloped,
+    ff_params,
+    var_estimation,
+)

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/StatTools/analysis/bma.py

@@ -70,22 +70,22 @@ def _bma_worker(
 
     t_indices = np.asarray(t_indices)
 
-    # start and end for all indices
+    # start и end для всех индексов
     start = t_indices - n + 1
     end = t_indices
 
-    # Array for result
-    window_sums = np.zeros((cs.shape[0], len(t_indices)), dtype=cs.dtype)
+    # Массив для результата
+    window_sums = np.empty((cs.shape[0], len(t_indices)), dtype=cs.dtype)
 
-    # Masks
+    # Маски
     mask_start_le_zero = start <= 0
     mask_start_gt_zero = ~mask_start_le_zero
 
-    # Handle start <= 0
+    # Обработка start <= 0
     if mask_start_le_zero.any():
         window_sums[:, mask_start_le_zero] = cs[:, end[mask_start_le_zero]]
 
-    # Handle start > 0
+    # Обработка start > 0
     if mask_start_gt_zero.any():
         window_sums[:, mask_start_gt_zero] = (
             cs[:, end[mask_start_gt_zero]] - cs[:, start[mask_start_gt_zero] - 1]
@@ -216,13 +216,13 @@ def bma(
     if isinstance(s, Iterable) and not isinstance(s, (str, bytes)):
         s = list(s)
         init_s_len = len(s)
-        s = [x for x in s if x <= L / 4]
+        s = list(filter(lambda x: x <= L / 4, s))
         if len(s) < 1:
             raise ValueError(
                 "All input scale values are larger than series length / 4!"
             )
         if len(s) != init_s_len:
-            warnings.warn(f"BMA warning: only following scales are in use: {s}")
+            warnings.warn(f"\tBMA warning: only following scales are in use: {s}")
     elif isinstance(s, (float, int)):
         if s > L / 4:
             raise ValueError("Cannot use scale > length / 4")

{fluctuationanalysistools-1.11.0 → fluctuationanalysistools-1.11.0.dev0}/StatTools/analysis/dfa.py

@@ -1,6 +1,5 @@
 import time
 import warnings
-from collections.abc import Sequence
 from contextlib import closing
 from ctypes import c_double
 from functools import partial
@@ -134,8 +133,6 @@ def dfa(
     degree: int = 2,
     processes: int = 1,
     n_integral: int = 1,
-    s_values: Union[int, Sequence, None] = None,
-    s_min: int = 5,
 ) -> Tuple[np.ndarray, np.ndarray]:
     """
     Implementation of the Detrended Fluctuation Analysis (DFA) method.
@@ -148,8 +145,6 @@ def dfa(
         degree (int): Polynomial degree for detrending (default: 2).
         processes (int): Number of parallel workers (default: 1).
         n_integral (int): Number of cumulative sum operations to apply (default: 1).
-        s_values (Union[int, Sequence, None]): points where  fluctuation function F^2(s) is calculated (default: None).
-        s_min (int): Minimal scale in s_values (default: 5).
 
     Returns:
         tuple: (s, F2_s)
@@ -169,38 +164,8 @@ def dfa(
         raise ValueError("Only 1D or 2D arrays are allowed!")
 
     series_len = data.shape[1]
-    if s_values is None:
-        s_max = int(series_len / 4)
-        if s_max < s_min:
-            raise ValueError(
-                f"Cannot create scales with s_max({s_max}) < s_min({s_min})"
-            )
-        s_values = [
-            int(exp(step)) for step in np.arange(np.log(s_min), np.log(s_max), 0.5)
-        ]
-    elif isinstance(s_values, Sequence):
-        init_s_len = len(s_values)
-        if init_s_len < 1:
-            raise ValueError("Input s_values is empty.")
-        s_values = list(filter(lambda x: x <= series_len / 4, s_values))
-        if len(s_values) < 1:
-            raise ValueError(
-                "Invalid s_values: all entries are greater than L / 4. "
-                "No valid scales found for analysis."
-            )
-
-        if len(s_values) != init_s_len:
-            warnings.warn(
-                f"DFA warning: only following S values are in use: {s_values}"
-                f"\nOriginal input had {init_s_len} values.",
-                UserWarning,
-                stacklevel=2,
-            )
-
-    elif isinstance(s_values, (float, int)):
-        if s_values > series_len / 4:
-            raise ValueError("Cannot use S > L / 4")
-        s_values = (s_values,)
+    s_max = int(series_len / 4)
+    s_values = [int(exp(step)) for step in np.arange(1.6, np.log(s_max), 0.5)]
 
     n_series = data.shape[0]
     results = None

fluctuationanalysistools-1.11.0.dev0/StatTools/analysis/dpcca.py

@@ -0,0 +1,313 @@
+import gc
+from collections.abc import Iterable
+from contextlib import closing
+from ctypes import c_double
+from functools import partial
+from multiprocessing import Pool
+from typing import Union
+
+import numpy as np
+
+from StatTools.auxiliary import SharedBuffer
+
+
+def _covariation(signal: np.ndarray):
+    """
+    Implementation equation (4) from [1]
+
+    [1] Yuan, N., Fu, Z., Zhang, H. et al. Detrended Partial-Cross-Correlation Analysis: A New Method for Analyzing Correlations in Complex System. Sci Rep 5, 8143 (2015). https://doi.org/10.1038/srep08143
+    """
+    F = np.zeros((signal.shape[0], signal.shape[0]), dtype=float)
+    for n in range(signal.shape[0]):
+        for m in range(n + 1):
+            F[n][m] = np.mean(signal[n] * signal[m])
+            F[m][n] = F[n][m]
+    return F
+
+
+def _correlation(F: np.ndarray):
+    """
+    Implementation equation (6) from [1]
+    [1] Yuan, N., Fu, Z., Zhang, H. et al. Detrended Partial-Cross-Correlation Analysis: A New Method for Analyzing Correlations in Complex System. Sci Rep 5, 8143 (2015). https://doi.org/10.1038/srep08143
+    """
+    R = np.zeros((F.shape[0], F.shape[0]), dtype=float)
+    for n in range(F.shape[0]):
+        for m in range(n + 1):
+            R[n][m] = F[n][m] / np.sqrt(F[n][n] * F[m][m])
+            R[m][n] = R[n][m]
+    return R
+
+
+def _cross_correlation(R: np.ndarray):
+    """
+    Implementation equation (9) from [1]
+    [1] Yuan, N., Fu, Z., Zhang, H. et al. Detrended Partial-Cross-Correlation Analysis: A New Method for Analyzing Correlations in Complex System. Sci Rep 5, 8143 (2015). https://doi.org/10.1038/srep08143
+    """
+    P = np.zeros((R.shape[0], R.shape[0]), dtype=float)
+    Cinv = np.linalg.inv(R)
+    for n in range(R.shape[0]):
+        for m in range(n + 1):
+            if Cinv[n][n] * Cinv[m][m] < 0:
+                print(f" Error: Sqrt(-1)! No P array values for this S!")
+                break
+            P[n][m] = -Cinv[n][m] / np.sqrt(Cinv[n][n] * Cinv[m][m])
+            P[m][n] = P[n][m]
+        else:
+            continue
+        break
+    return P
+
+
+# @profile()
+def dpcca_worker(
+    s: Union[int, Iterable],
+    arr: Union[np.ndarray, None],
+    step: float,
+    pd: int,
+    buffer_in_use: bool,
+    gc_params: tuple = None,
+    short_vectors=False,
+    n_integral=1,
+) -> Union[tuple, None]:
+    """
+    Core of DPCAA algorithm. Takes bunch of S-values and returns 3 3d-matrices: first index
+    represents S value.
+    """
+    gc.set_threshold(10, 2, 2)
+    s_current = [s] if not isinstance(s, Iterable) else s
+
+    if buffer_in_use:
+        cumsum_arr = SharedBuffer.get("ARR")
+    else:
+        cumsum_arr = arr
+        for _ in range(n_integral):
+            cumsum_arr = np.cumsum(cumsum_arr, axis=1)
+
+    shape = cumsum_arr.shape if buffer_in_use else arr.shape
+
+    F = np.zeros((len(s_current), shape[0], shape[0]), dtype=float)
+    R = np.zeros((len(s_current), shape[0], shape[0]), dtype=float)
+    P = np.zeros((len(s_current), shape[0], shape[0]), dtype=float)
+
+    for s_i, s_val in enumerate(s_current):
+
+        V = np.arange(0, shape[1] - s_val, int(step * s_val))
+        Xw = np.arange(s_val, dtype=int)
+        Y = np.zeros((shape[0], len(V)), dtype=object)
+
+        for n in range(cumsum_arr.shape[0]):
+            for v_i, v in enumerate(V):
+                W = cumsum_arr[n][v : v + s_val]
+                if len(W) == 0:
+                    print(f"\tFor s = {s_val} W is an empty slice!")
+                    return P, R, F
+
+                p = np.polyfit(Xw, W, deg=pd)
+                Z = np.polyval(p, Xw)
+                Y[n][v_i] = Z - W
+
+                if gc_params is not None:
+                    if n % gc_params[0] == 0:
+                        gc.collect(gc_params[1])
+
+        Y = np.array([np.concatenate(Y[i]) for i in range(Y.shape[0])])
+
+        F[s_i] = _covariation(Y)
+        R[s_i] = _correlation(F[s_i])
+        P[s_i] = _cross_correlation(R[s_i])
+
+    return P, R, F
+
+
+def start_pool_with_buffer(
+    buffer: SharedBuffer,
+    processes: int,
+    s_by_workers: np.ndarray,
+    pd: int,
+    step: float,
+    gc_params: tuple = None,
+    n_integral=1,
+):
+
+    for _ in range(n_integral):
+        buffer.apply_in_place(np.cumsum, by_1st_dim=True)
+
+    with closing(
+        Pool(
+            processes=processes,
+            initializer=buffer.buffer_init,
+            initargs=({"ARR": buffer},),
+        )
+    ) as pool:
+        pool_result = pool.map(
+            partial(
+                dpcca_worker,
+                arr=None,
+                pd=pd,
+                step=step,
+                buffer_in_use=True,
+                gc_params=gc_params,
+            ),
+            s_by_workers,
+        )
+
+    return pool_result
+
+
+def concatenate_3d_matrices(p: np.ndarray, r: np.ndarray, f: np.ndarray):
+    P = np.concatenate(p, axis=1)[0]
+    R = np.concatenate(r, axis=1)[0]
+    F = np.concatenate(f, axis=1)[0]
+    return P, R, F
+
+
+def dpcca(
+    arr: np.ndarray,
+    pd: int,
+    step: float,
+    s: Union[int, Iterable],
+    processes: int = 1,
+    buffer: Union[bool, SharedBuffer] = False,
+    gc_params: tuple = None,
+    short_vectors: bool = False,
+    n_integral: int = 1,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """Implementation of the Detrended Partial-Cross-Correlation Analysis method proposed by Yuan, N. et al.[1]
+
+    Basic usage:
+        You can get whole F(s) function for first vector as:
+        ```python
+            s_vals = [i**2 for i in range(1, 5)]
+            P, R, F, S = dpcaa(input_array, 2, 0.5, s_vals, len(s_vals))
+            fluct_func = [F[s][0][0] for s in s_vals]
+        ```
+    [1] Yuan, N., Fu, Z., Zhang, H. et al. Detrended Partial-Cross-Correlation Analysis:
+        A New Method for Analyzing Correlations in Complex System. Sci Rep 5, 8143 (2015).
+        https://doi.org/10.1038/srep08143
+
+    Args:
+        arr (ndarray): dataset array
+        pd (int): polynomial degree
+        step (float): share of S - value. It's set usually as 0.5. The integer part of the number will be taken
+        s (Union[int, Iterable]): points where  fluctuation function F(s) is calculated. More on that in the article.
+        processes (int, optional): num of workers to spawn. Defaults to 1.
+        buffer (Union[bool, SharedBuffer], optional): allows to share input array between processes. Defaults to False.
+        gc_params (tuple, optional): _description_. Defaults to None.
+        short_vectors (bool, optional): _description_. Defaults to False.
+        n_integral (int, optional): Number of cumsum operation before computation. Defaults to 1.
+
+    Raises:
+        ValueError: All input S values are larger than vector shape / 4.
+        ValueError: Cannot use S > L / 4.
+        ValueError: Wrong type of input buffer, if buffer is not SharedBuffer
+
+    Returns:
+        tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]: [P, R, F^2, S], where
+            P is a partial cross-correlation levels on different time scales, coefficients can be used
+                to characterize the `intrinsic` relations between the two time series on time scales of S.
+            R is a coefficients matrix represents the level of cross-correlation on time scales of S.
+                However, it should be noted that it only shows the relations between two time series.
+                This may provide spurious correlation information if the two time series are both correlated with other signals.
+            F^2 is a covariance matrix (covariance between any two residuals on each scale),
+            S is used scales.
+    """
+    if short_vectors:
+        return dpcca_worker(
+            s,
+            arr,
+            step,
+            pd,
+            buffer_in_use=False,
+            gc_params=gc_params,
+            short_vectors=True,
+            n_integral=n_integral,
+        ) + (s,)
+
+    concatenate_all = False  # concatenate if 1d array , no need to use 3d P, R, F
+    if arr.ndim == 1:
+        arr = np.array([arr])
+        concatenate_all = True
+
+    if isinstance(s, Iterable):
+        init_s_len = len(s)
+
+        s = list(filter(lambda x: x <= arr.shape[1] / 4, s))
+        if len(s) < 1:
+            raise ValueError("All input S values are larger than vector shape / 4 !")
+
+        if len(s) != init_s_len:
+            print(f"\tDPCAA warning: only following S values are in use: {s}")
+
+    elif isinstance(s, (float, int)):
+        if s > arr.shape[1] / 4:
+            raise ValueError("Cannot use S > L / 4")
+        s = (s,)
+
+    if processes == 1 or len(s) == 1:
+        p, r, f = dpcca_worker(
+            s,
+            arr,
+            step,
+            pd,
+            buffer_in_use=False,
+            gc_params=gc_params,
+            n_integral=n_integral,
+        )
+        if concatenate_all:
+            return concatenate_3d_matrices(p, r, f) + (s,)
+
+        return p, r, f, s
+
+    processes = len(s) if processes > len(s) else processes
+
+    S = np.array(s, dtype=int) if not isinstance(s, np.ndarray) else s
+    S_by_workers = np.array_split(S, processes)
+
+    if isinstance(buffer, bool):
+        if buffer:
+            shared_input = SharedBuffer(arr.shape, c_double)
+            shared_input.write(arr)
+
+            pool_result = start_pool_with_buffer(
+                shared_input,
+                processes,
+                S_by_workers,
+                pd,
+                step,
+                gc_params,
+                n_integral=n_integral,
+            )
+
+        else:
+            with closing(Pool(processes=processes)) as pool:
+                pool_result = pool.map(
+                    partial(
+                        dpcca_worker,
+                        arr=arr,
+                        pd=pd,
+                        step=step,
+                        buffer_in_use=False,
+                        gc_params=gc_params,
+                        n_integral=n_integral,
+                    ),
+                    S_by_workers,
+                )
+
+    elif isinstance(buffer, SharedBuffer):
+        pool_result = start_pool_with_buffer(
+            buffer, processes, S_by_workers, pd, step, gc_params, n_integral=n_integral
+        )
+    else:
+        raise ValueError("Wrong type of input buffer!")
+
+    P, R, F = np.array([]), np.array([]), np.array([])
+
+    for res in pool_result:
+        P = res[0] if P.size < 1 else np.vstack((P, res[0]))
+        R = res[1] if R.size < 1 else np.vstack((R, res[1]))
+        F = res[2] if F.size < 1 else np.vstack((F, res[2]))
+
+    if concatenate_all:
+        return concatenate_3d_matrices(P, R, F) + (s,)
+
+    return P, R, F, s