# A Low-Complexity Volterra Filtered-Error LMS Algorithm with a Kronecker Product Decomposition
## 4 Computational Complexity  
The proposed algorithm's computational complexity is analyzed and compared with state-of-the-art nonlinear filters in NANC, including the Volterra filter [11], GFLNN [19], and second-order EMFNL (20 EMFNL) [39]. The computational complexity based on the filtered-reference and the filtered-error structure is considered. The computational load per iteration can be calculated according to \(L\), \(M\), and \(P\). Note that only the multiplications required for all algorithms are considered in this section. The number of multiplications of the proposed DVMFXLMS algorithm is first calculated in the following. The number of multiplications for generating the \(p\)th-order output \(y_{p}(n)\) is \(Lp+1\). The number of multiplications for the \(p\)th-order filtered-reference signal vector is \(Lp(M+1)+3(p-2)\), and for the updating weights, the number of multiplications is \(Lp\). In all, the total number of multiplications of the proposed DVMFXLMS algorithm is  
\[T_{\text{DVMFXLMS}} =\sum_{p=1}^{p}{(Lp(M+3)+3p-5)}, \tag{26}\] \[=\frac{(P+1)P(LM+3L+3)}{2}-5P,\]  
The computational complexity required for VFXLMS, FXGFLNN, 20 FXEMFNL, and the proposed DVMFXLMS algorithm for NANC with NSP is summarized in Table 1. It can be seen that the VFXLMS algorithm has the highest computational complexity. The 20 FXEMFNL algorithm and the FXGFLNN algorithm can achieve comparable performance with less computational complexity in higher-order nonlinearity. The proposed DVMFXLMS algorithm has the lowest computational complexity due to the Kronecker product decomposition and a similar property against the VFXLMS algorithm; however, due to the decomposition error of (10), its performance may have some degradations in some real applications, which will be analyzed in next section. From Table 1, it should be noted that the number of multiplications of the DVMFXLMS algorithm for generating the filtered signal are computationally consuming. The computational complexity required for the DVMFELMS algorithm is then calculated. From (25), the difference between the filtered-reference and filtered-error structure is the generation of the filtered signal. In the DVMFELMS algorithm, only the error vector needed to be filtered by the adjoint virtual secondary path filter; thus, only \(M\) multiplications are needed for all the sub-filter updates. While the generation of all p-th order auxiliary vector \(\overline{\boldsymbol{\mu}}_{p,q}(n)\) needs \(Lp+3(p-2)\) multiplications, the total complexity of the DVMFELMS algorithm is calculated as  
\[T_{\text{DVMFELMS}} =\sum_{p=1}^{p}{(3 Lp+3p-1)}+M, \tag{27}\] \[=\frac{(P+1)P(3L+3)}{2}-P+M,\]  
The computational complexity required for the VFELMS algorithm, the FEGFLNN algorithm, the 20 FEEMFNL algorithm, and the proposed DVMFELMS algorithm for NANC with an NSP case is summarized in Table 2. In order to make the computational complexity required for all algorithms visible, the number of multiplications required for all algorithms versus memory length is shown in Figure 3, while the length of the secondary path \(M\) is 10 for all the cases. It is worth noting that only the NANC with the NSP case is considered in this section because the NANC with the LSP can be seen as a special case for NANC with NSP. In addition, for structures that have a time-shifting property, such as the Volterra filter, GFLNN, and EMFNL, the computational complexity required for all algorithms in NANC with the LSP case based on the filtered-reference structure is almost the same as in NANC with the NSP case based on the filtered-error structure, while for the proposed algorithm, the computational complexity required for all algorithms in NANC with the LSP case based on the filtered-reference structure is the same as in NANCwith the NSP case regardless of the computational complexity of the generation of the virtual secondary path filter. Figure 3 shows that the filtered-error structure can reduce the computational complexity in the NANC with the NSP case for all algorithms.