Robust DCD-Based Recursive Adaptive Algorithms

TL;DR

This paper extends the dichotomous coordinate descent (DCD) algorithm to robust recursive least squares (RLS) adaptive filtering in impulsive noise environments, introducing efficient algorithms with tracking capabilities for abrupt system changes.

Contribution

It generalizes DCD-based RLS algorithms for impulsive noise and introduces a variable forgetting factor for tracking abrupt changes.

Findings

Effective in impulsive noise channel identification

Computationally efficient with robust noise handling

Capable of tracking abrupt system changes

Abstract

The dichotomous coordinate descent (DCD) algorithm has been successfully used for significant reduction in the complexity of recursive least squares (RLS) algorithms. In this work, we generalize the application of the DCD algorithm to RLS adaptive filtering in impulsive noise scenarios and derive a unified update formula. By employing different robust strategies against impulsive noise, we develop novel computationally efficient DCD-based robust recursive algorithms. Furthermore, to equip the proposed algorithms with the ability to track abrupt changes in unknown systems, a simple variable forgetting factor mechanism is also developed. Simulation results for channel identification scenarios in impulsive noise demonstrate the effectiveness of the proposed algorithms.

Tables

Table 1. TABLE I: DCD-Based Robust Recursive Update

Parameters:

Initialization: ${𝑹}_0={\delta }_0{𝑰}_M,{\widehat{𝒘}}_0=\mathrm{𝟎},{𝒓}_0=\mathrm{𝟎}$

for $n=1,\dots$

$e_n=d_n-{𝒙}_n^{\text{T}}{\widehat{𝒘}}_{n-1}$

${𝑹}_n=\lambda {𝑹}_{n-1}+f_n{𝒙}_n{𝒙}_n^T+\left({\delta }_n-\lambda {\delta }_{n-1}\right){𝑰}_M$

${𝒃}_n=\lambda {𝒓}_{n-1}+f_n{e}_n{𝒙}_n-\left({\delta }_n-\lambda {\delta }_{n-1}\right){\widehat{𝒘}}_{n-1}$

Using DCD iterations to solve ${𝑹}_n\Delta {𝒘}_n={𝒃}_n$, which yields $\Delta {\widehat{𝒘}}_n$ and ${𝒓}_n$

${\widehat{𝒘}}_n={\widehat{𝒘}}_{n-1}+\Delta {\widehat{𝒘}}_n$

end

Table 2. TABLE II: Leading DCD Algorithm

Parameters: $H,N_u,M_b$,

Initialization: $\Delta {\widehat{𝒘}}_n=\mathrm{𝟎},{𝒓}_n={𝒃}_n,y=1,\mu =H/2$

for $j=1,\dots ,N_u$

$l=\arg \underset{j=1,\dots ,M}{\max }\left\{\right|{\left[{𝒓}_n\right]}_j|\}$

while $\left|{\left[{𝒓}_n\right]}_l\right|\le (\mu /2)\left[{𝑹}_n\right]{}_{l,l}$ and $y\le M_b$

$y=y+1$, $\mu =\mu /2$

end

if $y>M_b$

break

else

${\left[\Delta {\widehat{𝒘}}_n\right]}_l\leftarrow {\left[\Delta {\widehat{𝒘}}_n\right]}_l+\mu \text{sign}\left({\left[{𝒓}_n\right]}_l\right)$

${𝒓}_n\leftarrow {𝒓}_n-\mu \text{sign}\left({\left[{𝒓}_n\right]}_l\right){\left[{𝑹}_n\right]}_{:,l}$

end

end

Table 3. TABLE III: Some Robust DCD-based Algorithms

Robust Algorithms	$\phi \left(e\right)$ in (2)	$f\left(e\right)={\phi }^{\prime }\left(e\right)/e$ in (9)
DCD-RMCC	$\frac{1}{\sqrt{2\pi }\beta }\left[1-\exp \left(-\frac{e^2}{2{\beta }^2}\right)\right]$	$\exp \left(-\frac{e^2}{2{\beta }^2}\right)$
DCD-RLM
DCD-RL$p$N	${\left|e\right|}^p$	${\left|e\right|}^p/\left({\left|e\right|}^2+\epsilon \right)$

Table 4. TABLE IV: Complexity of Algorithms per Input Sample

Algorithms	Additions	Multiplications	Divisions
LMS	$2M$	$2M+1$	0
(R) RLS	$3M^2+M$	$4M^2+4M+1$	1
(R) DCD RLS (general input)	$M^2+2M+P_a$	$\frac{3}{2}{M}^2+\frac{7}{2}M+1$	0
(R) DCD RLS (tap-delayed input)	$3M+P_a$	$5M+2$	0

Equations

$$\varphi (t)=\exp (-\gamma |t{|}^{\alpha }).$$

$${\mathbf{w}}_n=\arg \underset{\mathbf{w}}{\min }\left\{\sum _{i=0}^n{\lambda }^{n-i}\phi \left(d_i-{\mathbf{x}}_i^{\text{T}}\mathbf{w}\right)+{\delta }_n\Vert \mathbf{w}{\Vert }_2^2\right\},$$

$${\mathbf{R}}_n{\mathbf{w}}_n={\mathbf{z}}_n,$$

$$\begin{array}[]{rcl}\begin{aligned} \bm{R}_{n}&=\sum\limits_{i=0}^{n}\lambda^{n-i}f_{i}\bm{x}_{i}\bm{x}_{i}^{\text{T}}+\delta_{n}\bm{I}_{M}\\ &=\lambda\bm{R}_{n-1}+f_{n}\bm{x}_{n}\bm{x}_{n}^{\text{T}}+(\delta_{n}-\lambda\delta_{n-1})\bm{I}_{M}\end{aligned}\end{array}$$

$$\begin{array}[]{rcl}\begin{aligned} \bm{z}_{n}&=\sum\limits_{i=0}^{n}\lambda^{n-i}f_{i}d_{i}\bm{x}_{i}\\ &=\lambda\bm{z}_{n-1}+f_{n}d_{n}\bm{x}_{n}\end{aligned}\end{array}$$

$$\begin{array}[]{rcl}\begin{aligned} \bm{R}_{n}\Delta\bm{w}_{n}=\bm{z}_{n}-\bm{R}_{n}\hat{\bm{w}}_{n-1}\triangleq\bm{b}_{n}.\end{aligned}\end{array}$$

$${\mathbf{b}}_n=\lambda {\mathbf{r}}_{n-1}+f_n{e}_n{\mathbf{x}}_n-({\delta }_n-\lambda {\delta }_{n-1}){\hat{\mathbf{w}}}_{n-1},$$

$${\hat{\mathbf{w}}}_n={\hat{\mathbf{w}}}_{n-1}+\Delta {\hat{\mathbf{w}}}_n.$$

$$f_n\approx {\phi }^{\prime }(e_n)/e_n.$$

$${\hat{\sigma }}_{e,n}^2=\zeta {\hat{\sigma }}_{e,n-1}^2+c_{\sigma }(1-\zeta )\text{med}({\mathbf{a}}_n^e),$$

$$\begin{array}[]{rcl}[\bm{R}_{n}]_{:,1}\approx\lambda[\bm{R}_{n-1}]_{:,1}+f_{n}x_{n}\bm{x}_{n}.\end{array}$$

$$\begin{array}[]{rcl}\lambda_{n}=\lambda_{\text{min}}+(1-\lambda_{\text{min}})\exp(-\rho e_{n,f}^{2}),\end{array}$$

Full text

I Introduction

adaptive filtering has been a prominent technique in a variety of applications such as system identification, active noise control, and echo cancellation (EC) [1]. The least mean square (LMS) and recursive least squares (RLS) algorithms represent two typical families of adaptive algorithms [2],[3],[4],[5],[6],[7]. The complexity of LMS is $\mathcal{O}(M)$ arithmetic operations per sample (ops), where $M$ is the filter length, but its convergence is slow especially when the input signal is highly correlated. RLS improves the convergence at the cost of a high complexity of $\mathcal{O}(M^{2})$ ops. To reduce the complexity, some fast RLS algorithms were proposed as summarized in [1, Chapter 14]. However, these fast algorithms are numerically unstable in finite precision implementation since they are based on the matrix inversion.

Alternatively, the dichotomous coordinate descent (DCD) iterations for solving the normal equations in the RLS algorithms were proposed [8]. They result in not only numerically stable adaptive algorithms but also in performance comparable to that of the original RLS algorithm. An important property of the DCD algorithm is that it only requires addition and shift operations, which are simpler for implementation than multiplication and division, and thus it is well suited to real-time implementation. Moreover, the DCD-RLS algorithm reduces the complexity to $\mathcal{O}(M)$ ops for input signals with the tapped-delay structure. The DCD algorithm was also applied for the complexity reduction in the affine projection algorithm [9], sparse signal recovery [10], and distributed estimation [11].

Regrettably, the LMS and RLS algorithms undergo performance deterioration in impulsive noise [12], owing to the squared-error based minimization criteria. Realizations of impulsive noise process are sparse and random with amplitude far higher than the Gaussian noise, and therefore, best modeled by heavy-tailed distributions, e.g., the $\alpha$-stable distribution. Such noise scenarios are common in such as echo cancellation, underwater acoustics, audio processing, array processing, distributed processing and communications [13],[14],[15],[16],[17],[18],[19],[20]. For adapting impulsive noise scenarios, existing literature have reported various robust approaches [21],[22, 23]. For instance, the recursive least M-estimate (RLM) algorithm [24] exploits the Hampel’s M-estimate function to suppress impulsive interferences. Based on the $l_{p}$-norm of errors, the recursive least $p$-norm (RL$p$N) algorithm was developed [25]. By gathering all the $p$-norms from $p=1$ to 2 of the error, the continuous mixed $p$-norms (CMPN) algorithm was derived [26]; however, it has slow convergence for correlated inputs due to the gradient descent (GD) principle. Taking advantage of the Geman-McClure (GMC) estimator, a recursive algorithm [27] for Volterra system identification was derived, which shows a better performance than RL$p$N and RLM algorithms in impulsive noise modeled by the $\alpha$-stable distribution [13]. When impulsive noise appears, by incorporating the step-size scaler into the update term, a robust subband algorithm was developed [28]. The correntropy measures the similarity between two variables, which is helpful for suppressing large outliers; thus, the maximum correntropy criterion (MCC) has been used for improving the anti-jamming capability of adaptive filters to impulsive noise, yielding the GD-based MCC [29, 30, 31] and recursive MCC (RMCC) algorithms [32, 33]. However, these robust recursive algorithms have also high complexity of $\mathcal{O}(M^{2})$ ops. In particular, the complexity of the fixed-point variant of MCC algorithm in [32] is $\mathcal{O}(M^{3})$ due to the direct inverse of an $M\times M$ matrix.

This work focuses on a class of low-complexity robust algorithms against impulsive noise by resorting to the DCD approach. Concretely, a generalized DCD-based robust recursion is derived. By applying different robust strategies to this recursion, we develop DCD-based robust algorithms, such as the DCD-RMCC, DCD-RLM, and DCD-RL$p$N algorithms. We also design a variable forgetting factor (VFF) scheme for improving the tracking capability of the algorithms.

II DCD-Based Robust Algorithms

II-A Unified Formulation

Suppose that at time instant $n$, the desired signal $d_{n}$ and an $M\times 1$ input signal vector $\bm{x}_{n}$ are available and obey the relation $d_{n}=\bm{x}_{n}^{\text{T}}\bm{w}^{o}+v_{n}$, where the $M\times 1$ vector $\bm{w}^{o}$ needs to be estimated, and $(\cdot)^{\text{T}}$ denotes the transpose. The additive noise with impulsive behavior, $v_{n}$, here is described by the $\alpha$-stable process111Other models describing the noise with impulses include the contaminated-Gaussian (CG) model [11] and the Gaussian mixture model (GMM) [34]., also called the $\alpha$-stable noise. A (symmetric) $\alpha$-stable random variable is usually characterized by the characteristic function [13]

[TABLE]

The characteristic exponent $\alpha\in(0,2]$ describes the impulsiveness of the noise (smaller $\alpha$ leads to more outliers) and $\gamma>0$ represents the dispersion degree of the noise. Note that when $\alpha$ = 1 and 2, it reduces to the Cauchy and Gaussian distributions, respectively.

To effectively estimate $\bm{w}^{o}$ in such noise scenarios, we define a unified robust exponentially weighted least squares problem:

[TABLE]

where $0\ll\lambda<1$ is the forgetting factor, $\delta_{n}>0$ is a regularization parameter, and $\varphi(\cdot)$ is a function that specifies the robustness against impulsive noise.

By setting the derivative of (2) with respect to $\bm{w}$ to zero, we arrive at the normal equations:

[TABLE]

where

[TABLE]

is the time-averaged autocorrelation matrix of $\bm{x}_{n}$,

[TABLE]

is the time-averaged crosscorrelation vector of $d_{n}$ and $\bm{x}_{n}$, and $\bm{I}_{M}$ is an $M\times M$ identity matrix. Also, $f_{n}=\varphi^{\prime}(\epsilon_{n})/\epsilon_{n}$, where $\epsilon_{n}=d_{n}-\bm{x}_{n}^{\text{T}}\bm{w}_{n}$ is the a posteriori error and $\varphi^{\prime}(\epsilon_{n})$ is the derivative of $\varphi(\epsilon_{n})$.

At time instant $n-1$, let $\hat{\bm{w}}_{n-1}$ denote the approximate solution of (3) for estimating $\bm{w}^{o}$, and the corresponding residual vector is $\bm{r}_{n-1}=\bm{z}_{n-1}-\bm{R}_{n-1}\hat{\bm{w}}_{n-1}$. By defining $\Delta\bm{w}_{n}=\bm{w}_{n}-\hat{\bm{w}}_{n-1}$, from (3) we obtain an auxiliary system of equations:

[TABLE]

Applying the recursive expressions (4) and (5), $\bm{b}_{n}$ can be rewritten as

[TABLE]

where $e_{n}=d_{n}-\bm{x}_{n}^{\text{T}}\hat{\bm{w}}_{n-1}$ denotes the a priori error.

By using the DCD algorithm to solve the problem in (6), we arrive at an approximate solution of the original normal equations (3):

[TABLE]

Although (7) shows that $\bm{b}_{n}$ requires the residual error vector of the original system (3), after some algebra we notice that it is equivalent to the residual error vector for the auxiliary system (6), i.e., $\bm{r}_{n}=\bm{z}_{n}-\bm{R}_{n}\hat{\bm{w}}_{n}=\bm{b}_{n}-\bm{R}_{n}\Delta\hat{\bm{w}}_{n}$. At time index $n$, $f_{n}$ in (7) is not yet available, but by resorting to the a priori error, we may approximate $f_{n}$ as

[TABLE]

This completes the derivation of DCD-based robust recursion, summarized in Table I.

Table II presents the leading DCD algorithm for solving the system of equations $\bm{R}_{n}\Delta\bm{w}_{n}=\bm{b}_{n}$ (readers can refer to [9, 8] for details), where $[\bm{r}_{n}]_{l}$ is the $l$-th entry of $\bm{r}_{n}$, and $[\bm{R}_{n}]_{l,l}$ and $[\bm{R}_{n}]_{:,l}$ are the $(l,l)$-th entry and the $l$-th column of $\bm{R}_{n}$, respectively. Herein, $[-H,H]$ denotes the amplitude range for elements of the solution vector $\Delta\hat{\bm{w}}_{n}$. It is often chosen as a power-of-two number so that all multiplications by $\mu$ can be implemented by bit-shifts. $M_{b}$ is the number of bits for a fixed-point representation of $\hat{\bm{w}}_{n}$ within the range $[-H,H]$. $N_{u}$ stands for a maximum number of elements in $\Delta\hat{\bm{w}}_{n}$ that are updated. The solution $\Delta\hat{\bm{w}}_{n}$ approaches the optimal one (i.e., $\Delta\hat{\bm{w}}_{n}=\bm{R}_{n}^{-1}\bm{b}_{n}$ ) as $N_{u}$ increases. As seen in Table II, the implementation of DCD only requires shift and addition operations, excluding multiplication and division operations.

II-B Robust Strategies

Applying a particular robust strategy to define $\varphi(e)$ in (2), we can compute $f_{n}$ by (9) to arrive at a DCD-based robust algorithm. Table III gives examples of $\varphi(e)$ for the DCD-RMCC, DCD-RLM, and DCD-RL$p$N algorithms derived from the widely studied MCC, M-estimate, and $l_{p}$-norm strategies, respectively. We note the following about the proposed algorithms:

1) For the DCD-RMCC algorithm, $\beta>0$ denotes the kernel width. When $\beta\rightarrow\infty$, $f_{n}$ approaches 1 so that the DCD-RMCC algorithm reduces to the DCD-RLS algorithm. When $\beta\rightarrow 0$, $f_{n}$ becomes 0, and the DCD-RMCC update is frozen. Thus, $\beta$ balances the robustness and dynamic performance of the algorithm in impulsive noise.

2) The DCD-RLM algorithm uses the modified Huber M-estimate function [35] for $\varphi(e)$222Other M-estimate functions may also be used, e.g., the Huber [36] and Hampel [24] functions.. When $|e_{n}|<\xi$, thus $f_{n}$ equals 1 so that the DCD-RLM algorithm becomes the DCD-RLS algorithm. Otherwise, $f_{n}$ becomes 0 to stop the update (ideally, this only happens when the impulsive noise appears). To effectively suppress the impulsive noise, the threshold $\xi$ is adaptively adjusted by $\xi=\tau\hat{\sigma}_{e,n}$,

[TABLE]

where $\left.0<\zeta<1\right.$ is a weighting factor (except $\zeta=0$ at the algorithm start), $\text{med}(\cdot)$ is the median operator which helps to remove outliers in the data window $\bm{a}_{n}^{e}=[e_{n}^{2},e_{n-1}^{2},...,e_{n-N_{w}+1}^{2}]$, and $c_{\sigma}=1.483(1+5/(N_{w}-1))$ is the correction factor [24]. It is worth noting that, the window length $N_{w}$ should be properly chosen. Larger $N_{w}$ makes a more robust estimate $\hat{\sigma}_{e,n}^{2}$ from (10) but requires a higher complexity. A typical value of $\tau$ is 2.576. If $e_{n}$ is assumed to be Gaussian (which is reasonable except when being polluted by impulsive noise), this value means the 99% confidence to prevent $e_{n}$ from contributing to the update for $|e_{n}|\geq\xi$ [24].

3) The convergence of the RL$p$N algorithm in the $\alpha$-stable noise requires $0<p<\alpha$. If $p=2$, the DCD-RL$p$N algorithm will also become the DCD-RLS algorithm. When $p=1$, this corresponds to the recursion sign algorithm [37] with good robustness against impulsive noise.

Remark 1: In a nutshell, when impulsive noise happens, its negative influence on the updates of $\bm{R}_{n}$ and $\bm{b}_{n}$ will be lowered significantly due to by multiplying a tiny scaler $f_{n}$ into the updates. Then, we can generalize the DCD recursion to find $\Delta\bm{\hat{}}{w}_{n}$ from the system of equations $\bm{R}_{n}\Delta\bm{w}_{n}=\bm{b}_{n}$ with impulse-free. Hence, according to (8), the proposed DCD-based algorithms can work well in impulsive noise.

II-C Computational Complexity

The direct solution of (3) is $\bm{w}_{n}=\bm{R}_{n}^{-1}\bm{z}_{n}$. The regularization $\delta_{n}$ is to maintain the numerical stability of this solution [1]. However, this leads to the complexity of $\mathcal{O}(M^{3})$ due to the matrix inversion $\bm{R}_{n}^{-1}$. Generally, $\delta_{n}$ is chosen as $\delta_{n}=\lambda^{n+1}\delta_{0}$ (e.g., in this paper), it makes (4) become $\bm{R}_{n}=\lambda\bm{R}_{n-1}+f_{n}\bm{x}_{n}\bm{x}_{n}^{\text{T}}$. Then, using the matrix inversion lemma, $\bm{R}_{n}^{-1}$ can be calculated in a recursive way so that the complexity of the resulting algorithm is $\mathcal{O}(M^{2})$, while it is still high for large $M$.

Table IV mainly compares the complexity of robust (R) RLS-type with that of proposed (R) DCD variant in terms of ops, where we drop the calculation of $f_{n}$ dependent on a specific robust strategy. As in [8], the DCD recursion requires $P_{a}=2N_{u}M+M_{b}$ additions at most for finding $\Delta\hat{\bm{w}}_{n}$. Thus, it is clear to see from Table IV, for general input vector form, the DCD version reduces the complexity by at least a factor of 0.5 in contrast with the original algorithm, in terms of multiplications and additions. On the other hand, if the input vector $\bm{x}_{n}$ has a tapped-delay structure, i.e., $\bm{x}_{n}=[x_{n},x_{n-1},...,x_{n-M+1}]^{\text{T}}$, where $x_{n}$ is a data sample at time $n$, the calculation of $\bm{R}_{n}$ will be simplified. Specifically, assuming $f_{n}\approx f_{n-1}$, we can obtain the lower-right $(M-1)\times(M-1)$ block of $\bm{R}_{n}$ by copying the upper-left $(M-1)\times(M-1)$ block of $\bm{R}_{n-1}$. Then, considering the symmetry of $\bm{R}_{n}$, we only need the calculation of its first column:

[TABLE]

Equation (11) is exact when $f_{n}=1$ [8]. As claimed in Section II. B, $f_{n}$ is normally close to 1, and becomes very small to suppress the update only when the impulsive noise happens. As such, using (11) is also suitable for computing $\bm{R}_{n}$ in the proposed DCD recursion. In this scenario, the complexity is reduced to the same order of magnitude as that of LMS. This reduction is considerable especially for a long $\bm{w}^{o}$ such as in EC applications.

II-D Improving Tracking Performance

For the proposed algorithms, there is also a trade-off between steady-state error and tracking capability for abrupt changes of $\bm{w}^{o}$, because of using the fixed forgetting factor $\lambda$. To address this problem, one may utilize the adaptive combination (AC) of two independently running DCD-based filters. Like the AC-RL$p$N algorithm in [25], it combines RL$p$N filters with the large forgetting factor for low steady-state error and with the small one for good tracking capability. However, it requires at least double complexity of the original algorithm. Alternatively, the VFF has been also an effective mechanism for improving the original RLS algorithm [38, 39, 40]. Consequently, to equip the proposed DCD-based algorithms, we also propose a simple VFF scheme:

[TABLE]

where $\rho>0$ is a design parameter, $e_{n,f}^{2}$ is the impulse-free squared error which can be estimated by (10). As $n\rightarrow\infty$, $e_{n,f}^{2}$ converges to a small value, and according to (12), $\lambda_{n}$ approaches 1, thus reducing the steady-state error. When $\bm{w}^{o}$ has a sudden change, $e_{n,f}^{2}$ becomes large due the mismatch estimation at that time, and $\lambda_{n}$ will approach a small forgetting factor $\lambda_{\text{min}}$, thus speeding up the convergence.

III Simulation results

In this section, simulations are conducted for identifying the network echo channel response $\bm{w}^{o}$ of length $M$ using an adaptive filter. The echo channels in Fig. 1 are from the ITU-T G.168 standard, with $M=128$ taps [41]. For the tapped-delay input vector $\bm{x}_{n}$, its element $x_{n}$ is given by the first-order autoregressive model $x_{n}=\varrho x_{n-1}+\vartheta_{n}$, where $\vartheta_{n}$ is a zero-mean white Gaussian random process with unit variance. Both $\varrho=0$ (which is used only in Fig. 2(b)) and $\varrho=0.9$ correspond to the white and correlated inputs, respectively, with the eigenvalue spreads of 1 and 346. The $\alpha$-stable noise is set to $\alpha=1.4$ and $\gamma=1/20$. We use the normalized mean square deviation, $\text{NMSD}(n)=10\log_{10}(||\bm{w}_{n}-\bm{w}^{o}||_{2}^{2}/||\bm{w}^{o}||_{2}^{2})$, as a performance measure. All simulated curves are the average over 100 independent runs.

Fig. 2 shows the NMSD performance of the DCD-RLS, GD-based MCC333The update equation is $\bm{w}_{n}=\bm{w}_{n-1}+\mu f_{n}e_{n}\bm{x}_{n}$ [31]., RMCC, and proposed DCD-RMCC algorithms. As expected for impulsive noise scenarios, the performance of the original DCD-RLS algorithm is poor, while the MCC-based algorithms are performing very well. The DCD-RMCC performance approaches that of the original RMCC algorithm as $N_{u}$ increases. In particular, $N_{u}=8\ll M$ (at most eight entries of $\bm{w}_{n}$ are updated per time $n$) has been enough for the DCD-RMCC performance to approach closely the RMCC performance regardless of whether $\bm{w}^{o}$ is sparse or not. However, as seen from Table IV, the DCD-RMCC with $N_{u}=8$ reduces significantly the complexity of the RMCC. Although the DCD-RMCC requires 2.5 times multiplications of the GD-based MCC, the former (even if with $N_{u}=1$) has much faster convergence than the latter. Likewise, the convergence of the proposed low-cost DCD-RLM and DCD-RL$p$N versions also approximate well that of the RLM and RL$p$N algorithms, respectively; these results are omitted for brevity.

Fig. 3 shows the NMSD of the proposed DCD-RMCC, DCD-RLM and DCD-RL$p$N algorithms, with $N_{u}=8$. The proposed algorithms show robustness in $\alpha$-stable noise and can arrive at similar performance by properly setting their parameters. This reason is they generally behave like the DCD-RLS and use a tiny $f_{n}$ to suppress the algorithms’ adaptation once the impulsive noise appears. In addition, we also show the DCD-CMPN algorithm by applying the CMPN criteria in [26], i.e., $\varphi(e)=\int_{1}^{2}|e|^{p}dp$ and $f(e)=\left((2|e|-1)\ln(|e|)-|e|+1\right)/\left(|e|\ln^{2}(|e|)\right)$. For the $l_{p}$-norm based algorithms, $p$ should be slightly less than $\alpha$ in $\alpha$-stable noise; thus, the DCD-RL$p$N may outperform the DCD-CMPN, since the latter inherits the behavior of $p>\alpha$.

Fig. 4 demonstrates the tracking capability of the proposed algorithms, in a scenario where the echo channel changes at time $n=8001$ by shifting its impulse response by 12 samples. As one can see, using the proposed VFF instead of the fixed one, the DCD-based algorithms can reduce the steady-state error and improve the tracking capability.

IV Conclusion

We have proposed a general low-complexity recursion for developing RLS-type adaptive filtering algorithms operating in impulsive noise scenarios. This is based on using DCD iterations. As examples of the MCC, M-estimator, and $p$-norm strategies applied to this recursion, we have developed the DCD-RMCC, DCD-RLM, and DCD-RL$p$N algorithms, respectively. These algorithms show a performance similar to that of their high-complexity counterparts, RMCC, RLM, and RLpN algorithms, respectively. To improve the tracking capability of the algorithms, a simple time-varying forgetting factor mechanism has also been developed. Simulation results demonstrate the performance of the proposed algorithms.