10872007559

Committed 15 Sep 2024 02:59PM UTC coverage: 91.795% (+3.8%) from 88.039%

Build # 10872007559

Build Type

push

github

Committed by

Koaha

Commit Message

add hrv and fix some bugs

Run Details

1087 of 1311 branches covered (82.91%)

Branch coverage included in aggregate %.

196 of 227 new or added lines in 11 files covered. (86.34%)

2 existing lines in 2 files now uncovered.

4395 of 4661 relevant lines covered (94.29%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.38

/src/vitalDSP/physiological_features/nonlinear.py

import numpy as np


class NonlinearFeatures:
    """
    A class for computing nonlinear (geometric) features from physiological signals (ECG, PPG, EEG).

    Attributes
    ----------
    signal : np.array
        The physiological signal (e.g., ECG, PPG, EEG).
    fs : int
        The sampling frequency of the signal in Hz. Default is 1000 Hz.

    Methods
    -------
    compute_sample_entropy(m=2, r=0.2)
        Computes the sample entropy of the signal, measuring its complexity.
    compute_approximate_entropy(m=2, r=0.2)
        Computes the approximate entropy of the signal, quantifying its unpredictability.
    compute_fractal_dimension(kmax=10)
        Computes the fractal dimension of the signal using Higuchi's method.
    compute_lyapunov_exponent()
        Computes the largest Lyapunov exponent, indicating the presence of chaos in the signal.
    compute_dfa(order=1)
        Computes the detrended fluctuation analysis (DFA) for assessing fractal scaling.
    compute_poincare_features()
        Computes Poincaré plot features (SD1 and SD2) to assess short- and long-term HRV variability.
    compute_recurrence_features(threshold=0.2)
        Computes features from the recurrence plot, including recurrence rate, determinism, and laminarity.
    """

    def __init__(self, signal, fs=1000):
        """
        Initializes the NonlinearFeatures object.

        Args:
            signal (np.array): The physiological signal.
            fs (int): The sampling frequency of the signal in Hz. Default is 1000 Hz.
        """
        self.signal = np.array(signal)
        self.fs = fs  # Sampling frequency

    def compute_sample_entropy(self, m=2, r=0.2):
        """
        Computes the sample entropy of the signal. Sample entropy is a measure of signal complexity,
        specifically used for detecting the regularity and unpredictability of fluctuations in a signal.

        Args:
            m (int): Embedding dimension (default is 2).
            r (float): Tolerance (default is 0.2).

        Returns:
            float: The computed sample entropy of the signal.

        Example:
            >>> ecg_signal = [...]  # Sample ECG signal
            >>> nf = NonlinearFeatures(ecg_signal)
            >>> sample_entropy = nf.compute_sample_entropy()
            >>> print(f"Sample Entropy: {sample_entropy}")
        """
        if np.all(self.signal == 0) or np.std(self.signal) == 0:
            return 0  # Return 0 for constant or zero signals
        if len(self.signal) <= m:
            return 0  # Return 0 for signals too short for meaningful entropy

        def _phi(m):
            """
            Computes the _phi function for sample entropy calculation.
            Args:
                m (int): Embedding dimension.
            Returns:
                float: The computed _phi value.
            """
            N = len(self.signal)
            x = np.array([self.signal[i : i + m] for i in range(N - m + 1)])
            C = np.sum(
                np.sum(np.abs(x[i] - x[j]) < r)
                for i in range(len(x))
                for j in range(i + 1, len(x))
            )
            return C / (len(x) ** 2 - len(x))

        phi_m = _phi(m)
        phi_m1 = _phi(m + 1)

        if phi_m == 0 or phi_m1 == 0:
            return 0  # Avoid log of zero
        return -np.log(phi_m1 / phi_m)

    def compute_approximate_entropy(self, m=2, r=0.2):
        """
        Computes the approximate entropy of the signal. Approximate entropy quantifies the
        unpredictability and regularity of signal patterns.

        Args:
            m (int): Embedding dimension (default is 2).
            r (float): Tolerance (default is 0.2).

        Returns:
            float: The computed approximate entropy of the signal.

        Example:
            >>> ppg_signal = [...]  # Sample PPG signal
            >>> nf = NonlinearFeatures(ppg_signal)
            >>> approx_entropy = nf.compute_approximate_entropy()
            >>> print(f"Approximate Entropy: {approx_entropy}")
        """
        if np.all(self.signal == 0) or np.std(self.signal) == 0:
            return 0  # Return 0 for constant or zero signals
        if len(self.signal) <= m:
            return 0  # Return 0 for signals too short for meaningful entropy

        def _phi(m):
            x = np.array(
                [self.signal[i : i + m] for i in range(len(self.signal) - m + 1)]
            )
            C = np.sum(
                [
                    np.max(np.abs(x[i] - x[j])) < r
                    for i in range(len(x))
                    for j in range(len(x))
                    if i != j
                ]
            )
            return C / (len(self.signal) - m + 1)

        return _phi(m) - _phi(m + 1)

    def compute_fractal_dimension(self, kmax=10):
        """
        Computes the fractal dimension of the signal using Higuchi's method. Fractal dimension
        is a measure of complexity, reflecting how the signal fills space as its scale changes.

        Returns:
            float: The fractal dimension of the signal.

        Example:
            >>> eeg_signal = [...]  # Sample EEG signal
            >>> nf = NonlinearFeatures(eeg_signal)
            >>> fractal_dimension = nf.compute_fractal_dimension()
            >>> print(f"Fractal Dimension: {fractal_dimension}")
        """

        if len(self.signal) < kmax:
            return 0  # Return 0 for signals too short for the given kmax

        def _higuchi_fd(signal, kmax):
            Lmk = np.zeros((kmax, kmax))
            N = len(signal)
            for k in range(1, kmax + 1):
                for m in range(0, k):
                    Lm = 0
                    for i in range(1, int((N - m) / k)):
                        Lm += abs(signal[m + i * k] - signal[m + (i - 1) * k])
                    if int((N - m) / k) == 0:
                        return 0
                    Lmk[m, k - 1] = Lm * (N - 1) / ((int((N - m) / k) * k * k))

            Lk = np.sum(Lmk, axis=0) / kmax
            log_range = np.log(np.arange(1, kmax + 1))
            if np.any(Lk == 0):
                return 0  # Return 0 to avoid division by zero in polyfit
            return -np.polyfit(log_range, np.log(Lk), 1)[0]

        return _higuchi_fd(self.signal, kmax)

    def compute_lyapunov_exponent(self):
        """
        Computes the largest Lyapunov exponent (LLE) of the signal. LLE measures the rate at
        which nearby trajectories in phase space diverge, indicating chaotic behavior in the signal.

        Returns:
            float: The largest Lyapunov exponent of the signal.

        Example:
            >>> ecg_signal = [...]  # Sample ECG signal
            >>> nf = NonlinearFeatures(ecg_signal)
            >>> lyapunov_exponent = nf.compute_lyapunov_exponent()
            >>> print(f"Largest Lyapunov Exponent: {lyapunov_exponent}")
        """
        N = len(self.signal)
        if N < 3:
            return 0  # Not enough data for meaningful computation

        epsilon = np.std(self.signal) * 0.1
        max_t = min(
            int(N / 10), N - 3
        )  # Ensure max_t is not larger than the length of the phase space

        def _distance(x, y):
            return np.sqrt(np.sum((x - y) ** 2))

        def _lyapunov(time_delay, dim, max_t):
            if max_t <= 1:
                return 0  # Prevent division errors with too short signals
            phase_space = np.array([self.signal[i::time_delay] for i in range(dim)]).T

            divergences = []
            for i in range(len(phase_space) - max_t - 1):
                d0 = _distance(phase_space[i], phase_space[i + 1])
                d1 = _distance(phase_space[i + max_t], phase_space[i + max_t + 1])
                if d0 > epsilon and d1 > epsilon:
                    divergences.append(np.log(d1 / d0))

            if len(divergences) == 0:
                return 0  # Return 0 if no valid divergences were found
            return np.mean(divergences)

        return _lyapunov(time_delay=5, dim=2, max_t=max_t)

    def compute_dfa(self, order=1):
        """
        Computes the Detrended Fluctuation Analysis (DFA) of the signal. DFA is used to assess
        the fractal scaling properties of time-series data, especially in physiological signals.

        Args:
            order (int): The order of the polynomial fit for detrending. Default is 1 (linear detrending).

        Returns:
            float: The DFA scaling exponent (α).

        Example:
            >>> ecg_signal = [...]  # Sample ECG signal
            >>> nf = NonlinearFeatures(ecg_signal)
            >>> dfa = nf.compute_dfa(order=1)
            >>> print(f"DFA Scaling Exponent: {dfa}")
        """
        N = len(self.signal)
        if N < 4:
            return 0  # Not enough data for DFA computation

        def _integrated_signal(signal):
            return np.cumsum(signal - np.mean(signal))

        def _detrended_fluctuation(integrated_signal, n, order):
            segment_length = len(integrated_signal) // n
            fluctuations = np.zeros(n)
            for i in range(n):
                segment = integrated_signal[
                    i * segment_length : (i + 1) * segment_length
                ]
                x = np.arange(segment_length)
                poly = np.polyfit(x, segment, order)
                trend = np.polyval(poly, x)
                fluctuations[i] = np.sqrt(np.mean((segment - trend) ** 2))
            return fluctuations

        integrated_signal = _integrated_signal(self.signal)
        fluctuation_sizes = []
        scales = np.logspace(1, np.log10(N // 2), 50).astype(int)
        for scale in scales:
            fluctuation_sizes.append(
                np.mean(_detrended_fluctuation(integrated_signal, scale, order))
            )

        log_fluctuation_sizes = np.log(fluctuation_sizes)
        log_scales = np.log(scales)
        dfa_alpha = np.polyfit(log_scales, log_fluctuation_sizes, 1)[0]
        return dfa_alpha

    def compute_poincare_features(self, nn_intervals):
        """
        Computes the SD1 and SD2 features from the Poincaré plot of the NN intervals. SD1 reflects
        short-term HRV, while SD2 reflects long-term HRV.

        Returns:
            tuple: SD1 (short-term HRV), SD2 (long-term HRV).

        Example:
            >>> nf = NonlinearFeatures(signal)
            >>> nn_intervals = [800, 810, 790, 805, 795]
            >>> sd1, sd2 = nf.compute_poincare_features(nn_intervals=nn_intervals)
            >>> print(f"SD1: {sd1}, SD2: {sd2}")
        """
        diff_nn_intervals = np.diff(nn_intervals)
        sd1 = np.sqrt(np.var(diff_nn_intervals) / 2)
        sd2 = np.sqrt(2 * np.var(nn_intervals) - sd1**2)
        return sd1, sd2

    def compute_recurrence_features(self, threshold=0.2):
        """
        Computes features from the recurrence plot, including recurrence rate, determinism,
        and laminarity. These features provide insights into the recurrence of signal dynamics.

        Args:
            threshold (float): The threshold to define recurrences. Default is 0.2.

        Returns:
            dict: A dictionary containing recurrence rate, determinism, and laminarity.

        Example:
            >>> ecg_signal = [...]  # Sample ECG signal
            >>> nf = NonlinearFeatures(ecg_signal)
            >>> rqa_features = nf.compute_recurrence_features(threshold=0.2)
            >>> print(rqa_features)
        """
        N = len(self.signal)
        phase_space = np.array([self.signal[i::2] for i in range(2)]).T
        rec_matrix = (
            np.sqrt(
                np.sum(
                    (phase_space[:, np.newaxis] - phase_space[np.newaxis, :]) ** 2,
                    axis=2,
                )
            )
            < threshold
        )

        recurrence_rate = np.sum(rec_matrix) / (N**2)
        diag_lens = [np.sum(np.diag(rec_matrix, k)) for k in range(1, N)]
        det = np.sum(np.array(diag_lens) > 1) / np.sum(diag_lens)
        laminarity = np.sum(diag_lens) / N

        return {
            "recurrence_rate": recurrence_rate,
            "determinism": det,
            "laminarity": laminarity,
        }

1	import numpy as np	1✔
2
3
4	class NonlinearFeatures:	1✔
5	"""
6	A class for computing nonlinear (geometric) features from physiological signals (ECG, PPG, EEG).
7
8	Attributes
9	----------
10	signal : np.array
11	The physiological signal (e.g., ECG, PPG, EEG).
12	fs : int
13	The sampling frequency of the signal in Hz. Default is 1000 Hz.
14
15	Methods
16	-------
17	compute_sample_entropy(m=2, r=0.2)
18	Computes the sample entropy of the signal, measuring its complexity.
19	compute_approximate_entropy(m=2, r=0.2)
20	Computes the approximate entropy of the signal, quantifying its unpredictability.
21	compute_fractal_dimension(kmax=10)
22	Computes the fractal dimension of the signal using Higuchi's method.
23	compute_lyapunov_exponent()
24	Computes the largest Lyapunov exponent, indicating the presence of chaos in the signal.
25	compute_dfa(order=1)
26	Computes the detrended fluctuation analysis (DFA) for assessing fractal scaling.
27	compute_poincare_features()
28	Computes Poincaré plot features (SD1 and SD2) to assess short- and long-term HRV variability.
29	compute_recurrence_features(threshold=0.2)
30	Computes features from the recurrence plot, including recurrence rate, determinism, and laminarity.
31	"""
32
33	def __init__(self, signal, fs=1000):	1✔
34	"""
35	Initializes the NonlinearFeatures object.
36
37	Args:
38	signal (np.array): The physiological signal.
39	fs (int): The sampling frequency of the signal in Hz. Default is 1000 Hz.
40	"""
41	self.signal = np.array(signal)	1✔
42	self.fs = fs # Sampling frequency	1✔
43
44	def compute_sample_entropy(self, m=2, r=0.2):	1✔
45	"""
46	Computes the sample entropy of the signal. Sample entropy is a measure of signal complexity,
47	specifically used for detecting the regularity and unpredictability of fluctuations in a signal.
48
49	Args:
50	m (int): Embedding dimension (default is 2).
51	r (float): Tolerance (default is 0.2).
52
53	Returns:
54	float: The computed sample entropy of the signal.
55
56	Example:
57	>>> ecg_signal = [...] # Sample ECG signal
58	>>> nf = NonlinearFeatures(ecg_signal)
59	>>> sample_entropy = nf.compute_sample_entropy()
60	>>> print(f"Sample Entropy: {sample_entropy}")
61	"""
62	if np.all(self.signal == 0) or np.std(self.signal) == 0:	1✔
63	return 0 # Return 0 for constant or zero signals	1✔
64	if len(self.signal) <= m:	1!
UNCOV 65	return 0 # Return 0 for signals too short for meaningful entropy	×
66
67	def _phi(m):	1✔
68	"""
69	Computes the _phi function for sample entropy calculation.
70	Args:
71	m (int): Embedding dimension.
72	Returns:
73	float: The computed _phi value.
74	"""
75	N = len(self.signal)	1✔
76	x = np.array([self.signal[i : i + m] for i in range(N - m + 1)])	1✔
77	C = np.sum(	1✔
78	np.sum(np.abs(x[i] - x[j]) < r)
79	for i in range(len(x))
80	for j in range(i + 1, len(x))
81	)
82	return C / (len(x) ** 2 - len(x))	1✔
83
84	phi_m = _phi(m)	1✔
85	phi_m1 = _phi(m + 1)	1✔
86
87	if phi_m == 0 or phi_m1 == 0:	1!
NEW 88	return 0 # Avoid log of zero	×
89	return -np.log(phi_m1 / phi_m)	1✔
90
91	def compute_approximate_entropy(self, m=2, r=0.2):	1✔
92	"""
93	Computes the approximate entropy of the signal. Approximate entropy quantifies the
94	unpredictability and regularity of signal patterns.
95
96	Args:
97	m (int): Embedding dimension (default is 2).
98	r (float): Tolerance (default is 0.2).
99
100	Returns:
101	float: The computed approximate entropy of the signal.
102
103	Example:
104	>>> ppg_signal = [...] # Sample PPG signal
105	>>> nf = NonlinearFeatures(ppg_signal)
106	>>> approx_entropy = nf.compute_approximate_entropy()
107	>>> print(f"Approximate Entropy: {approx_entropy}")
108	"""
109	if np.all(self.signal == 0) or np.std(self.signal) == 0:	1✔
110	return 0 # Return 0 for constant or zero signals	1✔
111	if len(self.signal) <= m:	1!
112	return 0 # Return 0 for signals too short for meaningful entropy	×
113
114	def _phi(m):	1✔
115	x = np.array(	1✔
116	[self.signal[i : i + m] for i in range(len(self.signal) - m + 1)]
117	)
118	C = np.sum(	1✔
119	[
120	np.max(np.abs(x[i] - x[j])) < r
121	for i in range(len(x))
122	for j in range(len(x))
123	if i != j
124	]
125	)
126	return C / (len(self.signal) - m + 1)	1✔
127
128	return _phi(m) - _phi(m + 1)	1✔
129
130	def compute_fractal_dimension(self, kmax=10):	1✔
131	"""
132	Computes the fractal dimension of the signal using Higuchi's method. Fractal dimension
133	is a measure of complexity, reflecting how the signal fills space as its scale changes.
134
135	Returns:
136	float: The fractal dimension of the signal.
137
138	Example:
139	>>> eeg_signal = [...] # Sample EEG signal
140	>>> nf = NonlinearFeatures(eeg_signal)
141	>>> fractal_dimension = nf.compute_fractal_dimension()
142	>>> print(f"Fractal Dimension: {fractal_dimension}")
143	"""
144
145	if len(self.signal) < kmax:	1✔
146	return 0 # Return 0 for signals too short for the given kmax	1✔
147
148	def _higuchi_fd(signal, kmax):	1✔
149	Lmk = np.zeros((kmax, kmax))	1✔
150	N = len(signal)	1✔
151	for k in range(1, kmax + 1):	1✔
152	for m in range(0, k):	1✔
153	Lm = 0	1✔
154	for i in range(1, int((N - m) / k)):	1✔
155	Lm += abs(signal[m + i * k] - signal[m + (i - 1) * k])	1✔
156	if int((N - m) / k) == 0:	1!
157	return 0	×
158	Lmk[m, k - 1] = Lm * (N - 1) / ((int((N - m) / k) * k * k))	1✔
159
160	Lk = np.sum(Lmk, axis=0) / kmax	1✔
161	log_range = np.log(np.arange(1, kmax + 1))	1✔
162	if np.any(Lk == 0):	1✔
163	return 0 # Return 0 to avoid division by zero in polyfit	1✔
164	return -np.polyfit(log_range, np.log(Lk), 1)[0]	1✔
165
166	return _higuchi_fd(self.signal, kmax)	1✔
167
168	def compute_lyapunov_exponent(self):	1✔
169	"""
170	Computes the largest Lyapunov exponent (LLE) of the signal. LLE measures the rate at
171	which nearby trajectories in phase space diverge, indicating chaotic behavior in the signal.
172
173	Returns:
174	float: The largest Lyapunov exponent of the signal.
175
176	Example:
177	>>> ecg_signal = [...] # Sample ECG signal
178	>>> nf = NonlinearFeatures(ecg_signal)
179	>>> lyapunov_exponent = nf.compute_lyapunov_exponent()
180	>>> print(f"Largest Lyapunov Exponent: {lyapunov_exponent}")
181	"""
182	N = len(self.signal)	1✔
183	if N < 3:	1✔
184	return 0 # Not enough data for meaningful computation	1✔
185
186	epsilon = np.std(self.signal) * 0.1	1✔
187	max_t = min(	1✔
188	int(N / 10), N - 3
189	) # Ensure max_t is not larger than the length of the phase space
190
191	def _distance(x, y):	1✔
192	return np.sqrt(np.sum((x - y) ** 2))	1✔
193
194	def _lyapunov(time_delay, dim, max_t):	1✔
195	if max_t <= 1:	1✔
196	return 0 # Prevent division errors with too short signals	1✔
197	phase_space = np.array([self.signal[i::time_delay] for i in range(dim)]).T	1✔
198
199	divergences = []	1✔
200	for i in range(len(phase_space) - max_t - 1):	1✔
201	d0 = _distance(phase_space[i], phase_space[i + 1])	1✔
202	d1 = _distance(phase_space[i + max_t], phase_space[i + max_t + 1])	1✔
203	if d0 > epsilon and d1 > epsilon:	1✔
204	divergences.append(np.log(d1 / d0))	1✔
205
206	if len(divergences) == 0:	1✔
207	return 0 # Return 0 if no valid divergences were found	1✔
208	return np.mean(divergences)	1✔
209
210	return _lyapunov(time_delay=5, dim=2, max_t=max_t)	1✔
211
212	def compute_dfa(self, order=1):	1✔
213	"""
214	Computes the Detrended Fluctuation Analysis (DFA) of the signal. DFA is used to assess
215	the fractal scaling properties of time-series data, especially in physiological signals.
216
217	Args:
218	order (int): The order of the polynomial fit for detrending. Default is 1 (linear detrending).
219
220	Returns:
221	float: The DFA scaling exponent (α).
222
223	Example:
224	>>> ecg_signal = [...] # Sample ECG signal
225	>>> nf = NonlinearFeatures(ecg_signal)
226	>>> dfa = nf.compute_dfa(order=1)
227	>>> print(f"DFA Scaling Exponent: {dfa}")
228	"""
229	N = len(self.signal)	1✔
230	if N < 4:	1!
NEW 231	return 0 # Not enough data for DFA computation	×
232
233	def _integrated_signal(signal):	1✔
234	return np.cumsum(signal - np.mean(signal))	1✔
235
236	def _detrended_fluctuation(integrated_signal, n, order):	1✔
237	segment_length = len(integrated_signal) // n	1✔
238	fluctuations = np.zeros(n)	1✔
239	for i in range(n):	1✔
240	segment = integrated_signal[	1✔
241	i * segment_length : (i + 1) * segment_length
242	]
243	x = np.arange(segment_length)	1✔
244	poly = np.polyfit(x, segment, order)	1✔
245	trend = np.polyval(poly, x)	1✔
246	fluctuations[i] = np.sqrt(np.mean((segment - trend) ** 2))	1✔
247	return fluctuations	1✔
248
249	integrated_signal = _integrated_signal(self.signal)	1✔
250	fluctuation_sizes = []	1✔
251	scales = np.logspace(1, np.log10(N // 2), 50).astype(int)	1✔
252	for scale in scales:	1✔
253	fluctuation_sizes.append(	1✔
254	np.mean(_detrended_fluctuation(integrated_signal, scale, order))
255	)
256
257	log_fluctuation_sizes = np.log(fluctuation_sizes)	1✔
258	log_scales = np.log(scales)	1✔
259	dfa_alpha = np.polyfit(log_scales, log_fluctuation_sizes, 1)[0]	1✔
260	return dfa_alpha	1✔
261
262	def compute_poincare_features(self, nn_intervals):	1✔
263	"""
264	Computes the SD1 and SD2 features from the Poincaré plot of the NN intervals. SD1 reflects
265	short-term HRV, while SD2 reflects long-term HRV.
266
267	Returns:
268	tuple: SD1 (short-term HRV), SD2 (long-term HRV).
269
270	Example:
271	>>> nf = NonlinearFeatures(signal)
272	>>> nn_intervals = [800, 810, 790, 805, 795]
273	>>> sd1, sd2 = nf.compute_poincare_features(nn_intervals=nn_intervals)
274	>>> print(f"SD1: {sd1}, SD2: {sd2}")
275	"""
276	diff_nn_intervals = np.diff(nn_intervals)	1✔
277	sd1 = np.sqrt(np.var(diff_nn_intervals) / 2)	1✔
278	sd2 = np.sqrt(2 * np.var(nn_intervals) - sd1**2)	1✔
279	return sd1, sd2	1✔
280
281	def compute_recurrence_features(self, threshold=0.2):	1✔
282	"""
283	Computes features from the recurrence plot, including recurrence rate, determinism,
284	and laminarity. These features provide insights into the recurrence of signal dynamics.
285
286	Args:
287	threshold (float): The threshold to define recurrences. Default is 0.2.
288
289	Returns:
290	dict: A dictionary containing recurrence rate, determinism, and laminarity.
291
292	Example:
293	>>> ecg_signal = [...] # Sample ECG signal
294	>>> nf = NonlinearFeatures(ecg_signal)
295	>>> rqa_features = nf.compute_recurrence_features(threshold=0.2)
296	>>> print(rqa_features)
297	"""
298	N = len(self.signal)	1✔
299	phase_space = np.array([self.signal[i::2] for i in range(2)]).T	1✔
300	rec_matrix = (	1✔
301	np.sqrt(
302	np.sum(
303	(phase_space[:, np.newaxis] - phase_space[np.newaxis, :]) ** 2,
304	axis=2,
305	)
306	)
307	< threshold
308	)
309
310	recurrence_rate = np.sum(rec_matrix) / (N**2)	1✔
311	diag_lens = [np.sum(np.diag(rec_matrix, k)) for k in range(1, N)]	1✔
312	det = np.sum(np.array(diag_lens) > 1) / np.sum(diag_lens)	1✔
313	laminarity = np.sum(diag_lens) / N	1✔
314
315	return {	1✔
316	"recurrence_rate": recurrence_rate,
317	"determinism": det,
318	"laminarity": laminarity,
319	}

Oucru-Innovations / vital-DSP / 10872007559

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous