A. Median filter

A median filter is implemented by windowing the acquired data, ranking the samples in the window, and outputting the median of the sorted samples. Considering a RR interval (RR _n ) sequence x _n , as shown in Figure 1(a), the output y _n of this nonlinear filter is given by,

$y_n=\text{median}\{x_{n-w},\cdots ,x_n,\cdots ,x_{n+w}\}$

(1)

where the window is of a fixed width 2w+1. From the perspective of signal processing, the time delay of the median filter is w. A window size of 17 is used herein, with a delay of 8 samples. The introduction of a median filter brings about two advantages: (i) the suppression of unwanted outliers, which are mostly caused by erroneously detected (or missed) R-wave peaks; (ii) to preserve sharp edges (i.e., onsets and terminations of AF episodes) without extensively blurring the context.

B. Integer filter for low scale reference

where, the gain is G a i n 1=16=2⁴, and the intrinsic delay of H _l (z) is 7.5 samples. This low-pass filter is applied to smooth y _n resulting from the previous median filtering. Another benefit of the low-pass filter is the removal of fluctuations possibly caused by Respiratory Sinus Arrhythmia (RSA) phenomena around the current sample from acquisition. Let xl _n be the output of this filter, as illustrated in Figure 1(b).

C. Integer filter for high scale reference

where, the gain is G a i n 2=2048=2¹¹, and the relevant delay of H _h (z) is 47 samples. This low-pass filter is introduced to generate a reference RR sequence of a larger scale, which needs to be exploited in the definition of symbolic series as explained in the following subsection. The resulting output denoted by xh _n is shown in Figure 1(c).

As we have seen, the time delays of x _n and xl _n are −62.5 and −47 samples with respect to xh _n , respectively. To ensure synchronization of the filtered data, let $x_n^{\prime }$ and ${\mathit{\text{xl}}}_n^{\prime }$ denote the corresponding time-delay corrected sequences of x _n and xl _n , respectively. Then, $\Delta {\mathit{\text{RR}}}_n=x_n^{\prime }-{\mathit{\text{xl}}}_n^{\prime }$ can be defined as the difference in time delay, seen in Figure 1(d).

A. Pseudo-recursive median filtering

The median filter in Eq. (1) can be implemented with a so-called pseudo-recursive method: for input x _i , we define S={s _r ↑:1≤r≤2w+1} as a sorted array of successive elements from x _i−2w−1 to x _i−1, where the output y _i is obtained by following steps ➊-➎ below,

➊ A Binary search technique is used to seek out the position m of the sample x _i−2w−1 which will depart from the window (i.e., s _m =x _i−2w−1. Simultaneously, x _i will get into the window);

➋ The Binary search technique is applied again to search for the position t at which the input x _i needs to be set (i.e., s _t <x _i ≤s _t+1);

➌ From positions m to t, the current s _r is replaced with the adjacent s _{r ± 1} (the ’ _±’ indicates where the element is taken from the right or left, with the ’ ₊’ and ’ ₋’ symbols representing the element to the right and left, respectively);

➍ Replace the element s _t with x _i ;

➎ Median s _w+1 of the updated S becomes output y _i .

For the following input x _i+1, we repeat steps ➊ to ➎ and obtain the new output s _w+1 (i.e., y _i+1), as shown in Figure 3, where the sorting utilizes the Binary search technique twice. Comparing our technique with the traditional median filter, the computational complexity can be decreased from approximately O(n²) to O(n).

B. Recursive implementation of integer filters

The above equation, Eq. (9) includes 1 integer addition, 3 integer subtractions as well as 1 integer right-shift operation, when xl _n >>4 (as G a i n 1=2⁴) to offset the gain of H _l (z).

where, xh _n−1×2 is implemented with xh _n−1<<1. The above equation, Eq. (10) consists of 2 integer additions, 8 integer subtractions, 1 integer left-shift operation and 1 integer right-shift operation, when xh _n >>11 (as G a i n 2=2¹¹) to offset the gain of H _h (z).

C. Mapping the definition of $-\frac{1}{\underset{2}{log}N}{p}_i\underset{2}{log}{p}_i$

where, C o n s=1000000 is a constant such that decimal floating points can be converted into integers and N=127, and $\stackrel{\lfloor ·\rfloor }{=}$ indicates to take the integer part of each $-\frac{\mathit{\text{Cons}}}{\underset{2}{log}N}{p}_i\underset{2}{log}{p}_i$.

Notably, for each cardiac cycle screened, this predefined PiMap permits the sole operation by picking the straightforward integer (i.e., P i M a p[i]) from the set PiMap in accordance with the index i rather than calculating $-\frac{1}{\underset{2}{log}N}{p}_i\underset{2}{log}{p}_i$ using arithmetic and logarithmic operations. The use of this predefined calculation significantly decreases calculation times.

D. Recursive implementation of ${\mathcal{\mathscr{H}}}^{\mathrm{\prime \prime }}(\mathbf{A})$

We define a buffer array ${\mathit{\text{nu}}}_{w{v}_i}$ (wv _i ≤2457) to store the number of the i th characteristic element wv _i in space A. For the input wv _n , it will get into A (i.e., wv _n will be the rightmost element), and simultaneously the leftmost element wv _n−127 will depart from A, see Figure 2 for clarity. It is obvious that a variation of SE ${\mathcal{\mathscr{H}}}^{\prime }(\mathbf{A})$ is purely determined by ${\mathit{\text{nu}}}_{w{v}_n}$ and ${\mathit{\text{nu}}}_{w{v}_{n-127}}$ in dynamic A. Therefore, ${\mathcal{\mathscr{H}}}^{\mathrm{\prime \prime }}(\mathbf{A})$ is calculated recursively by the algorithm below,

where $s{h}_n^{\prime }$ and $s{h}_n^{\mathrm{\prime \prime }}$ represent ${\mathcal{\mathscr{H}}}^{\prime }(\mathbf{A})$ and ${\mathcal{\mathscr{H}}}^{\mathrm{\prime \prime }}(\mathbf{A})$, respectively; ^(∗ indicates that P i M a p[i]=0 is fixed for the case i≡0; and 127000000=N∗C o n s=127×1000000. For the next input wv _n+1, steps ➀-âž‚ are again executed to obtain $s{h}_{n+1}^{\mathrm{\prime \prime }}$. From an online processing perspective, the time delays of $s{h}_n^{\mathrm{\prime \prime }}$ are 64 and 126.5 samples with respect to xh _n and x _n , respectively.

An architecture of the overall logic of the recursive realization can be seen in Figure 4. By using recursive algorithms, this AF detector consists of several basic operations, such as integer addition/subtraction, integer comparison and integer shifting. In effect, the calculation of $s{h}_n^{\mathrm{\prime \prime }}$ and distinguishing the current beat x _n , only needs to include 1 multiplication and 1 division lying within $\frac{k}{127000000}·$, together with 1 floating-point comparison between $s{h}_n^{\mathrm{\prime \prime }}$ and a threshold. Consequently, a useful computational efficiency can be achieved.