betaFeedback

WorksEngineering

Greedy Vector Approximation Based on Rotation for Multiplierless Complex Products

Abstract

This paper proposes a greedy approximation algorithm for performing complex-valued inner products in multiplierless hardware. The matching pursuits for accurate rotation approximation (MPARA) algorithm approximates the tangent of the phase of complex elements as a sum of signed powers of two (SOPOT) representation, enabling multiplierless hardware for complex-valued multiplication. The proposed algorithm outperforms other state-of-the-art approximation methods for approximating the twiddle factors of a fast Fourier transform (FFT).

Introduction

Complex-number multiplication is a key operation in many digital signal processing applications for communications. It is the basis for the discrete Fourier transform (DFT), the core of orthogonal frequency division multiplexing (OFDM). The DFT also appears in other countless communication applications, such as multiple-input multiple-output (MIMO) systems, direction of arrival (DoA) estimation, precoding and postcoding in transceivers, and antenna selection [1, 2].

Performing bit shifts instead of conventional multiplications is a well-known way to reduce the computational cost of inner products. The shift-and-add structure for multiplication falls under multiplierless hardware and is a known design for efficient finite impulse response (FIR) filter hardware designs [3, 4, 5].

In [4], the authors explore efficient sums of signed powers of two (SOPOT) representations that rely on signed powers of two (SPTs) to represent real numbers. As the computational complexity is proportional to the number of SPTs, they propose an algorithm called matching pursuits with generalized bit planes (MPGBP) that achieves vector approximation based on SOPOT representations with a minimal number of SPTs for FIR filters. However, their solution is based on real-valued multiplications.

For complex values, multiplication is interpreted as a phase rotation and an amplitude gain. A multiplierless solution for rotation is the coordinate rotation digit computer (CORDIC), which iterates over quantized micro-rotations (MR) performed by bit shifts to approximate a given rotation [6, 7]. Although efficient, CORDIC cannot select the steps it should take in the approximation, so it takes unnecessary steps and leaves room for improvement [7, 8, 9, 10, 11, 12].

In this paper, we propose a middle-ground algorithm that approximates complex-valued vectors for multiplierless hardware using the fewest bit shifts. The matching pursuits for accurate rotation approximation (MPARA) combines MPGBP and CORDIC. It approximates the vector by considering each element’s phase. The solution allocates MRs to the vector elements that most reduce the cost function and enables mixed-precision quantization based on the rotation.

As a use case, we approximate the twiddle factors of a fast Fourier transform (FFT) and show that our method mitigates the non-orthogonality between the transform and its inverse.

Multiplierless Rotation

Let x,w∈Cx, w \in\mathbb{C} be two complex values such that ∣w∣=1\lvert w\rvert= 1, where ∣⋅∣\lvert\cdot\rvert is the absolute value operator. The product of these values is written as

y=xw=xrwr−xiwi+j(xrwi+xiwr)=yr+jyi,(1)\begin{aligned} y = xw = x_{\mathrm{r}}w_{\mathrm{r}} - x_{\mathrm{i}}w_{\mathrm{i}} + \mathrm{j}(x_{\mathrm{r}}w_{\mathrm{i}} + x_{\mathrm{i}}w_{\mathrm{r}}) \\ &= y_{\mathrm{r}} + \mathrm{j}y_{\mathrm{i}}, \tag*{(1)} \end{aligned}

where y∈Cy \in\mathbb{C} is the resulting complex number, j=−1\mathrm{j} = \sqrt{-1}, and (⋅)r(\cdot)_{\mathrm{r}} and (⋅)i(\cdot)_{\mathrm{i}} indicate the real and imaginary components of the complex number.

Complex-Number Multiplication as a Rotation

Complex numbers have amplitude and phase. When we multiply two complex numbers, the resulting amplitude is the Algorithm 1 CORDIC phase rotation

Input: x∈Cx \in\mathbb{C}, w∈Cw \in\mathbb{C}, kmax⁡∈Nk_{\max} \in\mathbb{N}

Output: y^∈C\hat{y} \in\mathbb{C}

  1. k←0k \gets0, θ0←arctan⁡(wiwr)\theta_0 \gets\arctan\left(\frac{w_i}{w_r}\right), y(0)←xy^{(0)} \gets x ▹\triangleright Initialization

  2. while k<kmax⁡k < k_{\max} do

  3. yr(k+1)←yr(k)−sign⁡(θk)yi(k)2−ky_r^{(k+1)} \gets y_r^{(k)}-\operatorname{sign}(\theta_k)y_i^{(k)}2^{-k} ▹\triangleright (2)

  4. yi(k+1)←yi(k)+sign⁡(θk)yr(k)2−ky_i^{(k+1)} \gets y_i^{(k)}+\operatorname{sign}(\theta_k)y_r^{(k)}2^{-k} ▹\triangleright (3)

  5. θk+1←θk−sign⁡(θk)arctan⁡(2−k)\theta_{k+1} \gets\theta_k-\operatorname{sign}(\theta_k)\arctan(2^{-k}) ▹\triangleright (4)

  6. k←k+1k \gets k+1

  7. end while

  8. y^←y(kmax⁡)\hat{y} \gets y^{(k_{\max})}

product of the amplitudes, and the resulting phase is the sum of the phases. Let θ\theta be the phase of ww, we have

yr=wr(xr−xiwiwr)=cos⁡(θ)(xr−xitan⁡(θ))(2)y_r = w_r\left(x_r-x_i\frac{w_i}{w_r}\right)=\cos(\theta)(x_r-x_i\tan(\theta)) \tag*{(2)}
yi=wr(xi+xrwiwr)=cos⁡(θ)(xi+xrtan⁡(θ)).(3)y_i = w_r\left(x_i+x_r\frac{w_i}{w_r}\right)=\cos(\theta)(x_i+x_r\tan(\theta)). \tag*{(3)}

The phase rotation θ=arctan⁡(wiwr)\theta=\arctan\left(\frac{w_i}{w_r}\right) transforms, by rotation, xx into yy, and by operating (2) and (3) instead of Eq. (1), explains the phase rotation in the cartesian form. Figure 1 shows the phase rotation, using four multipliers and two adders.

Figure 1. Diagram of complex-number multiplication, y=xwy=xw, as a phase rotation.

Coordinate Rotation Digit Computer (CORDIC)

CORDIC exploits equations (2) and (3) by approximating tan⁡(θ)\tan(\theta) as a SOPOT, enabling shift-and-add computation. In each CORDIC iteration, we take an angular step of size θk=arctan⁡(2−k)\theta_k=\arctan(2^{-k}) in the direction of the desired rotation, where kk is the algorithm’s iteration index. Algorithm 1.

At each iteration, the residual rotation is calculated as

θk+1=θk−sign⁡(θk)arctan⁡(2−k),(4)\theta_{k+1}=\theta_k-\operatorname{sign}(\theta_k)\arctan(2^{-k}), \tag*{(4)}

and θk+1\theta_{k+1} is the residual rotation and defines the direction of the next iteration’s step.

Algorithm 1 disregards the amplitude correction of y^\hat{y}, which is due to cos⁡(θk)\cos(\theta_k) in equations (2) and (3). In CORDIC, the correction is performed as follows

c=∏k=0kmax⁡cos⁡(arctan⁡(2−k))=∏k=0kmax⁡11+2−2k,(5)c=\prod_{k=0}^{k_{\max}}\cos(\arctan(2^{-k}))=\prod_{k=0}^{k_{\max}}\frac{1}{\sqrt{1+2^{-2k}}}, \tag*{(5)}

where c∈Rc \in\mathbb{R} is the amplitude correction. As with shift-and-add multiplierless structures, CORDIC hardware design can be optimized to minimize FPGA area, latency, or other criteria [3, 5, 6].

CORDIC and the Signed Bit Plane

When representing vectors as SOPOT, the vector is mapped into kmax⁡+1k_{\max}+1 signed bit planes. We allocate symbols from the set M={−1,0,1}\mathcal{M}=\{-1,0,1\} in the signed bit plane. A bit plane is defined by its maximum value, or the shallowest bit, and by its minimum value, or deepest bit.

Algorithm 1 allocates symbols from the nonzero set Mnz={−1,1}\mathcal{M}_{\mathrm{nz}}=\{-1,1\}, where Mnz⊂M\mathcal{M}_{\mathrm{nz}}\subset\mathcal{M} in a bit plane. The bit plane starts at k=0k=0 and increases in depth in each iteration, up to the maximum bit plane depth, kmax⁡k_{\max}. Each allocated symbol represents two shift-and-add operations.

By using the set M\mathcal{M}, we promote sparsity in the bit plane, enabling approximations with few nonzero elements [4]. This reduces the number of shift-and-add operations. We propose a greedy algorithm to achieve this approximation.

Greedy Phase Approximation

Let w∈CN\mathbf{w}\in\mathbb{C}^{N} be a complex-valued vector, composed as

w=[w(0)w(1)⋯w(N−1)]T,(6)\mathbf{w}=\left[w(0)\quad w(1)\quad\cdots\quad w(N-1)\right]^{T}, \tag*{(6)}

where [⋅]T[\cdot]^{T} is the transpose operator, and w(n)∈Cw(n)\in\mathbb{C}. We assume that ∣w(n)∣=1\lvert w(n)\rvert=1 and that ∣θn∣<π4\lvert\theta_n\rvert<\frac{\pi}{4}, where θn\theta_n is the phase of w(n)w(n), which can be achieved in a preprocessing step justified further in this section. Let r∈RN\mathbf{r}\in\mathbb{R}^{N} be a vector which elements are r(n)=θnr(n)=\theta_n, i.e., r=arctan⁡(ℑ{w}⊘ℜ{w})\mathbf{r}=\arctan(\Im\{\mathbf{w}\}\oslash\Re\{\mathbf{w}\}), where ⊘\oslash is the Hadamard division operator, ℜ{⋅}\Re\{\cdot\} returns the real components of a complex, and ℑ{⋅}\Im\{\cdot\} its imaginary.

Let D={ϕp}p∈Γ\mathcal{D}=\{\boldsymbol{\phi}_p\}_{p\in\Gamma} be a dictionary composed of PP NN-length complex-valued vectors, referred as codewords, and r~=tan⁡(r)\tilde{\mathbf{r}}=\tan(\mathbf{r}) a vector containing the tangent of each element of w\mathbf{w}. The inner product between r~\tilde{\mathbf{r}} and ϕp\boldsymbol{\phi}_p is defined as

⟨r~,ϕp⟩=ϕpTr~=∑n=0N−1r~(n)ϕp(n),(7)\langle\tilde{\mathbf{r}},\boldsymbol{\phi}_p\rangle=\boldsymbol{\phi}_p^{T}\tilde{\mathbf{r}}=\sum_{n=0}^{N-1}\tilde{r}(n)\phi_p(n), \tag*{(7)}

and the projection of r~\tilde{\mathbf{r}} in ϕp\boldsymbol{\phi}_p is

⟨r~,ϕp⟩∥ϕp∥22ϕp=apϕp,(8)\frac{\langle\tilde{\mathbf{r}},\boldsymbol{\phi}_p\rangle}{\lVert\boldsymbol{\phi}_p\rVert_2^2}\boldsymbol{\phi}_p=a_p\boldsymbol{\phi}_p, \tag*{(8)}

where ap∈Ra_p\in\mathbb{R} is the projection coefficient, and ∥⋅∥2\lVert\cdot\rVert_2 is the Euclidean norm. We use the following MM-term approximation

r≈r^M=∑m=0M−1arctan⁡(Q(aρm))ϕρm,(9)\mathbf{r}\approx\hat{\mathbf{r}}_M=\sum_{m=0}^{M-1}\arctan\left(Q(a_{\rho_m})\right)\boldsymbol{\phi}_{\rho_m}, \tag*{(9)}

where r^M∈RN\hat{\mathbf{r}}_{M} \in\mathbb{R}^{N} is the approximated vector, Q(⋅)Q(\cdot) is a quantization function to round apma_{p_m} to the nearest power of two, pmp_m is the mm-th codeword index, and kmk_m is the mm-th bit plane depth.

We base the approximation on a matching pursuits (MP) algorithm, namely the matching pursuits with generalized bit planes (MPGBP) [4]. Starting at r0=r\mathbf{r}_0=\mathbf{r} and r^0=0\hat{\mathbf{r}}_0=\mathbf{0}, the algorithm iteratively performs the approximation by computing

rm+1=rm−arctan⁡(2−km)ϕpm(10)\mathbf{r}_{m+1}=\mathbf{r}_m-\arctan\left(2^{-k_m}\right)\boldsymbol{\phi}_{p_m} \tag*{(10)}
r^m+1=r^m+arctan⁡(2−km)ϕpm,(11)\hat{\mathbf{r}}_{m+1}=\hat{\mathbf{r}}_m+\arctan\left(2^{-k_m}\right)\boldsymbol{\phi}_{p_m}, \tag*{(11)}

where mm indexes the algorithm iterations. Next, we discuss codeword and bit plane depth selection.

Codeword Selection

The dictionary D\mathcal{D} is composed of codewords of length NN with elements from the set M\mathcal{M}, i.e., ϕp∈MN\boldsymbol{\phi}_p \in\mathcal{M}^{N}. We limit the number of nonzero elements in the codeword to L∈NL \in\mathbb{N}, with L<NL<N. At the mm-th iteration, we select the codeword that maximizes the projection coefficient,

pm=arg⁡max⁡p∈Γ ⟨r~m,ϕp⟩L,(12)p_m=\underset{p\in\Gamma}{\arg\max}\ \frac{\langle\tilde{\mathbf{r}}_m,\boldsymbol{\phi}_p\rangle}{L}, \tag*{(12)}

with L=∥ϕp∥22L=\lVert\boldsymbol{\phi}_p\rVert_2^2. The dictionary size, ∣D∣=2L(NL)|\mathcal{D}|=2^L\binom{N}{L}, becomes rapidly impractical for an exhaustive codeword search as NN and LL increases. However, we can generate the codeword that solves (12). Let N\mathcal{N} be the set of indices of the vector rm\mathbf{r}_m. Since the codeword is composed of elements from M\mathcal{M}, the optimal codeword must select and sum the LL greatest absolute values of r~m\tilde{\mathbf{r}}_m, i.e., the set

L∗=arg⁡max⁡L⊆N,∣L∣=L∑n∈L∣r~m(n)∣,(13)\mathcal{L}^{*}=\underset{\mathcal{L}\subseteq\mathcal{N},|\mathcal{L}|=L}{\arg\max}\sum_{n\in\mathcal{L}}|\tilde{r}_m(n)|, \tag*{(13)}

where L\mathcal{L} is any subset of N\mathcal{N} with size LL. Therefore, the codeword is composed as

ϕpm(n)={sign⁡(r~m(n)),n∈L∗0,otherwise(14)\phi_{p_m}(n)= \begin{cases} \operatorname{sign}(\tilde{r}_m(n)), & n\in\mathcal{L}^{*}\\ 0, & \text{otherwise} \end{cases} \tag*{(14)}

Bit Plane Depth Selection

At the mm-th iteration, Q(⋅)Q(\cdot) performs the quantization of the projection coefficient, apma_{p_m}. It consists of finding kmk_m that best approximates apm≈2−kma_{p_m}\approx2^{-k_m}. By bounding apma_{p_m} by 2−km−12^{-k_m-1} and 2−km+12^{-k_m+1}, we have

2−km+2−km−12≤ϕpmTr~mL<2−km+2−km+12\frac{2^{-k_m}+2^{-k_m-1}}{2}\leq\frac{\boldsymbol{\phi}_{p_m}^{T}\tilde{\mathbf{r}}_m}{L}<\frac{2^{-k_m}+2^{-k_m+1}}{2}
km≥−log⁡2(4ϕpmTr~m3L)>km−1,(15)k_m\geq-\log_2\left(\frac{4\boldsymbol{\phi}_{p_m}^{T}\tilde{\mathbf{r}}_m}{3L}\right)>k_m-1, \tag*{(15)}

Algorithm 2 MP for accurate rotation approximation

Input: w ∈ ℂ^N, L ∈ ℕ, L_max ∈ ℕ, k_max ∈ ℕ
Output: r̂_M ∈ ℝ^N, k_m, φ_m ∀m
1: m ← 0, r̂_0 ← 0                         ▷ Initialization
2: r_0 ← arctan(ℑ{x} ⊘ ℜ{x})                ▷ Initialization
3: M ← ⌊L_max/L⌋                            ▷ Initialization
4: while m < M do
5:   r̃_m ← tan(r_m)
6:   ℒ* ← arg max_{ℒ⊆𝒩,|ℒ|=L} ∑_{n∈ℒ}|r̃_m(n)| ▷ Eq. (13)
7:   φ_m(n) ← { sign(r̃_m(n)), n ∈ ℒ*
               0, otherwise }               ▷ Eq. (14)
8:   k_m ← ⌈−log₂((4/(3L))φ_m^T r̃_m)⌉      ▷ Eq. (16)
9:   r̂_{m+1} ← r̂_m + arctan(2^{−k_m})φ_m  ▷ Eq. (11)
10:  r_{m+1} ← r_m − arctan(2^{−k_m})φ_m    ▷ Eq. (10)
11:  if k_m > k_max or ε < (r_{m+1}^T r_{m+1})/N then
12:    M ← m
13:  end if
14:  m ← m + 1
15: end while

yielding,

km=⌈−log⁡2(4ϕpmTr~m3L)⌉.(16)k_m=\left\lceil-\log_2\left(\frac{4\boldsymbol{\phi}_{p_m}^{T}\tilde{\mathbf{r}}_m}{3L}\right)\right\rceil. \tag*{(16)}

Algorithm and Implementation Constraints

We propose Algorithm 2 as an MP for accurate rotation approximation (MPARA), summarized in the pseudocode.

Parameter Considerations

The algorithm requires four extra parameters, which are described as follows. (i) LL specifies the number of non-zero elements in the codewords; it determines how many elements are changed at each iteration. (ii) Lmax⁡L_{\max} sets the maximum number of non-zero elements in the bit planes; it is a complexity constraint for the final inner product. For a rotation, each non-zero element is equivalent to 2 shifts and 2 additions. (iii) kmax⁡k_{\max} sets the maximum bit plane depth, or the maximum length of the bit shifts. (iv) ϵ\epsilon sets a minimum approximation error for the total rotation on the vector.

Input Normalization

The input signal, w∈CN\mathbf{w}\in\mathbb{C}^{N} is normalized to have elements of amplitude ∣w(n)∣=1|w(n)|=1 and phase ∣θ∣<π4|\theta|<\frac{\pi}{4}. In preprocessing, we can normalize the amplitude and phase. Although amplitude normalization might add extra shift-and-add in the final implementation, phase normalization is achieved through trivial rotations of π\pi and π2\frac{\pi}{2} requiring only signal inversions and changes between real and imaginary values.

This is mapped in the solution as rotations that require no extra additions.

Amplitude Correction

In CORDIC, the accumulated amplitude gain is calculated as

again=lim⁡kmax⁡→∞∏k=0kmax⁡1+2−2k≈1.6468,(17)a_{\mathrm{gain}}=\lim_{k_{\max}\to\infty}\prod_{k=0}^{k_{\max}}\sqrt{1+2^{-2k}}\approx1.6468, \tag*{(17)}

where againa_{\mathrm{gain}} is the accumulated amplitude gain. Although our proposition uses only a subset of the product in (17), the value remains bounded in (1,again](1,a_{\mathrm{gain}}]. Because rotations in shallower bit planes incur larger amplitude gains, we set the shallowest bit plane to k=0k=0 and propose the heuristic in Table 1 for amplitude correction.

bit planeCorrectionAmplitude Gain
01−2−2−2−4+2−61-2^{-2}-2^{-4}+2^{-6}0.9944
11−2−3+2−61-2^{-3}+2^{-6}0.9957
21−2−51-2^{-5}0.9986
k≥3k \ge3111.0078>ak>11.0078 > a_k > 1

Table 1. Heuristic for the amplitude gain correction.

Using a few supplementary shift-and-add operations when bit planes 0, 1, and 2 are active, significantly mitigates amplitude gain. In our proposition, we use no corrections in deeper bit planes, and the amplitude gain is limited to 1.0078 in the worst-case scenario, which is obtained by activating the depths k={k∈N:k≠0,1,2}k=\{k\in\mathbb{N}:k\ne0,1,2\}. The proposed heuristic incurs a gain in the interval [0.9887,1.0078][0.9887,1.0078].

Results

Several FFT hardware designs exist [13], and each benefits from an optimization criterion; however, they still rely on twiddle-factor multiplications. We approximate the twiddle factors of a 256-point FFT. We use the radix-16 FFT for the 256-point FFT and the radix-4 for the 16-point FFT

F256=P256(I16⊗F16)diag⁡(t256)(F16⊗I16)F16=P16(I4⊗F4)diag⁡(t16)(F4⊗I4),(18)\begin{aligned} F_{256}&=P_{256}(I_{16}\otimes F_{16})\operatorname{diag}(t_{256})(F_{16}\otimes I_{16})\\ F_{16}&=P_{16}(I_{4}\otimes F_{4})\operatorname{diag}(t_{16})(F_{4}\otimes I_{4}), \tag*{(18)} \end{aligned}

where FN∈CNF_N\in\mathbb{C}^{N} is a NN-point DFT matrix defined as

{FN}k,l=e−j2πklN,\{F_N\}_{k,l}=e^{-j2\pi\frac{kl}{N}},

⊗\otimes is the Kronecker product, IN∈RN×NI_N\in\mathbb{R}^{N\times N} is the identity matrix, tN∈CNt_N\in\mathbb{C}^{N} is a vector containing the twiddle factors,

tN(n)=e−j2π⌊nN⌋n  (mod⁡  k),(19)t_N(n)=e^{-j2\pi\left\lfloor\frac{n}{N}\right\rfloor^{n\;(\operatorname{mod}\;k)}}, \tag*{(19)}

with kk as the radix and PN∈RN×NP_N\in\mathbb{R}^{N\times N} is a permutation matrix defined

{PN}l,m={1,m=k⌊lk⌋+(l(modk)),0,otherwise.(20)\{P_N\}_{l,m}= \begin{cases} 1, & m=k\left\lfloor\frac{l}{k}\right\rfloor+(l\pmod{k}),\\ 0, & \text{otherwise}. \end{cases} \tag*{(20)}
Average squared error outside the main diagonal

(a) Average squared error outside the main diagonal.

Average squared error in the main diagonal

(b) Average squared error in the main diagonal.

Figure 2. Study on the orthogonality of the transform.

We select L=7L=7 in a binary search for minimal reconstruction phase error degradation, Lmax⁡L_{\max} is variable so that the number of MR per element varies, and kmax⁡=6k_{\max}=6 is fixed for a maximum bit shift of 6. We define

J^=1256F^256HF^256,(21)\hat{J}=\frac{1}{256}\hat{F}_{256}^{H}\hat{F}_{256}, \tag*{(21)}

where F^N∈CN×N\hat{F}_N\in\mathbb{C}^{N\times N} is the approximated FFT matrix, and J^∈CN×N\hat{J}\in\mathbb{C}^{N\times N}. The matrix J^\hat{J} should approach INI_N to maintain the transform’s property of orthogonality between frequencies. We define J^des∈CN×N\hat{J}_{\mathrm{des}}\in\mathbb{C}^{N\times N} as

{J^des}l,m≜{{J^des}l,m,l=m,0,otherwise.(22)\{\hat{J}_{\mathrm{des}}\}_{l,m}\triangleq \begin{cases} \{\hat{J}_{\mathrm{des}}\}_{l,m}, & l=m,\\ 0, & \text{otherwise}. \end{cases} \tag*{(22)}

Figure 2a and Figure 2b present the mean squared error outside the main diagonal and on the main diagonal, respectively. These are calculated using the square of the Frobenius norm and averaged by NN. Our method better approximates the FFT than the other solutions. In our solution, the error increases with the number of additions because of additional MR allocated at bit planes of depth k≥3k\ge3, which incur additional amplitude gain.

Conclusion

The paper proposes a greedy complex-valued vector approximation algorithm based on the phase shift, or rotation, of each element, enabling a multiplierless architecture. The MPARA algorithm is a vector approximation method that allocates MRs into elements that most minimize the phase error, yielding approximations with mixed-precision quantization in the phase domain. Our proposition outperforms the CSD and the MPGBP in the approximation of a radix-16 256-point FFT with radix-4 sub-decomposition of the butterflies.

References

References

  1. [1]Mikael Henriksson, Hugo Winbladh, and Oscar Gustafsson, “Multi-stream fft architectures for a distributed mimo large intelligent surfaces testbed,” in 2024 IEEE Nordic Circuits and Systems Conference (NorCAS), 2024, pp. 1–6.DOI
  2. [2]Cheolyong Bae and Oscar Gustafsson, “Architectural trade-offs for high-speed real-time chromatic dispersion compensation fir filters with time-multiplexed streaming ffts,” Journal of Lightwave Technology, vol. 43, no. 14, pp. 6744–6753, 2025.DOI
  3. [3]Bah-Hwee Gwee, Joseph S. Chang, Yiqiong Shi, Chien-Chung Chua, and Kwen-Siong Chong, “A low-voltage micropower asynchronous multiplier with shift–add multiplication approach,” IEEE Transactions on Circuits and Systems I: Regular Papers, vol. 56, no. 7, pp. 1349–1359, 2009.DOI
  4. [4]Eduardo A. B. da Silva, Lisandro Livoloso, Alessandro J. S. Dutra, and Paulo S. R. Diniz, “Fir filter design based on successive approximation of vectors,” IEEE Transactions on Signal Processing, vol. 62, no. 15, pp. 3833–3848, 2014.DOI
  5. [5]R.I. Hartley, “Subexpression sharing in filters using canonic signed digit multipliers,” IEEE Transactions on Circuits and Systems II: Analog and Digital Signal Processing, vol. 43, no. 10, pp. 677–688, 1996.DOI
  6. [6]Ray Andraka, “A survey of cordic algorithms for fpga based computers,” in Proceedings of the 1998 ACM/SIGDA Sixth International Symposium on Field Programmable Gate Arrays, New York, NY, USA, 1998, FPGA ’98, pp. 191–200, Association for Computing Machinery.DOI
  7. [7]Pramod K. Meher, Javier Valls, Tso-Bing Juang, K. Sridharan, and Koushik Maharatna, “50 years of cordic: Algorithms, architectures, and applications,” IEEE Transactions on Circuits and Systems I: Regular Papers, vol. 56, no. 9, pp. 1893–1907, 2009.DOI
  8. [8]Mario Garrido, Fahad Qureshi, and Oscar Gustafsson, “Low-complexity multiplierless constant rotators based on combined coefficient selection and shift-and-add implementation (ccssi),” IEEE Transactions on Circuits and Systems I: Regular Papers, vol. 61, no. 7, pp. 2002–2012, 2014.DOI
  9. [9]Cheng-Shing Wu, An-Yeu Wu, and Chih-Hsiu Lin, “A high-performance/low-latency vector rotational cordic architecture based on extended elementary angle set and trellis-based searching schemes,” IEEE Transactions on Circuits and Systems II: Analog and Digital Signal Processing, vol. 50, no. 9, pp. 589–601, 2003.DOI
  10. [10]Mario Garrido, Daniel Medina, Pedro Paz, and Marisa López-Vallejo, “Uniformly distributed cordic,” IEEE Transactions on Circuits and Systems I: Regular Papers, vol. 72, no. 11, pp. 6948–6961, 2025.DOI
  11. [11]Naveen Jones and M. Surya Prakash, “Sam-cordic: A scaling free accurate memoryless cordic for logarithm computation,” IEEE Transactions on Circuits and Systems I: Regular Papers, vol. 73, no. 8, pp. 5501–5514, 2026.DOI
  12. [12]Chengyang Han, Jifeng Luo, Qianjian Xing, and Feng Yu, “Cordic-based computation of arcsine/arccosine integrated with prefix binary tree mapping,” IEEE Transactions on Circuits and Systems II: Express Briefs, vol. 73, no. 5, pp. 593–597, 2026.DOI
  13. [13]Guang-Ting Deng, Mario Garrido, Sau-Gee Chen, and Shen-Jui Huang, “Radix-2 k msc fft architectures,” IEEE Access, vol. 11, pp. 81497–81510, 2023.DOI

Paper details

vlnc:W_c64pvpa8
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 5

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Engineering

Not recorded for this paper

View statement
Looking for related papers…
Contents