A Low-Latency CORDIC Algorithm Based on Pre-Rotation and Its Application on Computation of Arctangent Function

Abstract

This paper presents a low-latency coordinate rotation digital computer (CORDIC) algorithm to accelerate the computation of arctangent functions, and it describes the corresponding iterative and pipelined architecture of this novel algorithm. As compared to the existing methods based on CORDIC, the proposed method can effectively reduce the number of iterations by dedicated pre-rotation and comparison processes. Moreover, the proposed CORDIC algorithm supports all vectors with arbitrary angles while maintaining convergence. By error analysis, the proposed algorithm can achieve the same accuracy as the conventional CORDIC algorithm during floating-point arctangent function computation and reduce the number of iterations by approximately 50%. This paper presents two new architectures—the iterative architecture, which can be more resource efficient, and the pipelined architecture, which can achieve a throughput rate of one datum per clock. Finally, the experimental comparison results indicate that the proposed method outperforms extant methods as it exhibits low latency, requires fewer resources to compute the arctangent function for floating-point inputs, and necessitates no digital signal processing (DSP) and memory for fixed-point inputs.

1. Introduction

The inverse tangent, commonly termed the arctangent or atan, is a fundamental mathematical function with diverse applications in many fields, ranging from engineering and physics to computer science and signal processing. In early hardware algorithms, the primary methods for computing trigonometric functions such as arctangents involved techniques based on look-up tables (LUTs) [1] and the approximate transformation of trigonometric functions [2,3]. With the continuous development of information technology, the demand for computing arctangent functions suitable for high-precision or floating-point numbers concurrently increases. However, these methods often consume significant storage and computational resources or may lack sufficient precision when computing high-precision numbers. To address the aforementioned challenges, the coordinate rotation digital computer (CORDIC) algorithm has emerged as a solution.

CORDIC was first described by Volder in 1959 for the computation of trigonometric functions, multiplication, and division [4] and later generalized  [5] to calculate a broader range of equations involving logarithms, exponentials, and square roots, among others. Owing to its hardware implementation being highly efficient and not resource-intensive (one iteration can be performed with basic shift-add operations), CORDIC has undergone rapid development [6,7] and extensive application [8,9,10,11].

When calculating trigonometric functions, the conventional CORDIC algorithm employs an iterative method to incrementally approach the theoretical values. Owing to the sequential nature of the iterations, each iteration must wait for the previous one to complete, and the number of iterations depends on the data precision required. Consequently, latency has become a major drawback of the CORDIC algorithm when performing calculations on high-bit-width data.

Throughout the developmental trajectory of CORDIC, many researchers have invested substantial efforts to enhance the algorithm. These efforts have focused on improving computational accuracy, expanding the range of angles covered, reducing the number of iterations, and minimizing resource consumption. Hu and Naganathan proposed an angle recoding (AR) method based on the greedy algorithm [12], which achieves optimality at each iteration by encoding the theoretical results as a set of linear combinations of steps, which was then developed as a branch of CORDIC [13]. However, the necessity of encoding in advance restricts the applicability to when the result is known, such as in discrete Fourier transform. In addition, the method of reducing the total number of iterations by adding specific comparisons and calculations into a single iteration, such as by using the radix-4 [14] and higher radix [15] CORDIC algorithms, the double-step branching algorithm [16], the hybrid CORDIC [17], CORDIC II [18], and binary CORDIC algorithms [19], can effectively reduce latency. Moreover, in the case of fixed-point inputs, the specific calculation process can be simplified by analyzing the binary bits. However, the specific computation in these algorithms consumes copious resources when calculating a single floating-point number. The TCORDIC algorithm, combining a low-latency CORDIC algorithm with the Taylor expansion, has been proposed, utilizing sign prediction, compressed iteration, and parallel iteration techniques to reduce latency and errors at the boundary [20]. Nevertheless, it simultaneously incurs a substantial resource overhead and has not been applied to the computation of arctangents. In [21], the decision-based CORDIC also reduced latency by skipping some redundant iterations, but it is only used for fixed-point numbers, and its method of skipping iterations cannot achieve optimality.

To realize floating-point calculations of the arctangent function with fewer resources and low latency, the pre-rotation-based CORDIC (PR-CORDIC) algorithm proposed herein applies a more appropriate rotation angle at each iteration by pre-rotating the input vector and comparing the results. Moreover, the PR-CORDIC algorithm selects the micro-rotation angle from a limited number of pre-rotation angles rather than finding an optimal solution for all angles to avoid overusing the resources. The PR-CORDIC algorithm applies the comparison result of the pre-rotations to select the better angle and determines the angle for the subsequent pre-rotation to maximize the utilization of the results. Therefore, it utilizes fewer resources more efficiently to select a better rotation angle at each iteration. Another benefit of the flexible selection of the rotation angle is the expansion of the input angle range.

The remainder of this paper is organized as follows. Section 2 presents an overview of the CORDIC algorithm. The PR-CORDIC algorithm is detailed in Section 3. Section 4 primarily discusses the performance of the proposed CORDIC algorithm regarding error rates. Section 5 presents selected corresponding architectures for the proposed algorithm. In Section 6, the proposed approach is compared with other methods, and its implementation is demonstrated regarding area and performance. Section 7 concludes the paper.

2. Overview of CORDIC

2.1. CORDIC Algorithm

The CORDIC algorithm comprises three categories: the circular, linear, and hyperbolic coordinate systems, as well as the rotation and vector modes. To compute the arctangent function, we focus on the vector mode of the CORDIC operation by using a circular trajectory. On a computer, when a 2D vector ${\mathit{V}}_{\mathbf{0}}$ must be rotated to another vector ${\mathit{V}}_{\mathit{n}}$ by an angle $\alpha$, the process is that the coordinate matrix of ${\mathit{V}}_{\mathbf{0}}$ is multiplied by another matrix comprising sin $\alpha$ and cos $\alpha$. To simplify the hardware implementation for computing this process, the circular CORDIC algorithm decomposes the rotation into a sequence of elementary rotations through predefined angles. Then, the angle between ${\mathit{V}}_{\mathbf{0}}$ and ${\mathit{V}}_{\mathit{n}}$ can be obtained on the basis of the angle sequence.

In vector mode, as shown in Figure 1, the initial vector ${\mathit{V}}_{\mathbf{0}}=(x_0,y_0)$ is rotated to the final vector ${\mathit{V}}_{\mathit{n}}=(x_n,y_n)$; then, $y_n=0$ and the phase is zero. Once the rotation is completed, the phase information of the initial vector can be obtained.

According to [22], the generalized circular CORDIC algorithm is specified by the following iterative equation:

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}{x}_{i+1}\hfill & =x_i-{\sigma }_i·2^{-i}·y_i,\hfill \\ y_{i+1}\hfill & =y_i+{\sigma }_i·2^{-i}·x_i,\hfill \\ {\omega }_{i+1}\hfill & ={\omega }_i-{\sigma }_i·{\alpha }_i,\hfill \end{array}\right.\end{array}$$

(1)

where ${\alpha }_i=ta{n}^{-1}\left(2^{-i}\right)$ and ${\sigma }_i=-sign\left(y_i\right)$ in vector mode and ${\sigma }_i=sign\left({\omega }_i\right)$ in rotation mode.

The outputs following m iterations of the CORDIC algorithm are displayed in

Table 1. Generalized circular CORDIC algorithm.

	Rotation	Vector
$x_m$	$K_c(x_0$ cos ${\omega }_0-y_0$ sin ${\omega }_0)$	$K_c\sqrt{x_0^2+y_0^2}$
$y_m$	$K_c(y_0$ cos ${\omega }_0+x_0$ sin ${\omega }_0)$	0
${\omega }_m$	0	${\omega }_0+ta{n}^{-1}(y_0/x_0)$

. $K_c$ is the scale factor, which is defined as

$$\begin{array}{cc}\hfill K_c& =\prod _{k=0}^m\sqrt{1+2^{-2·k}}.\hfill \end{array}$$

(2)

Table 1 shows that circular CORDIC in vector mode (VC-CORDIC) can evaluate an arctangent when the initial phase ${\omega }_0=0$.

2.2. Pipeline Architecture for Arctangent Computation

Figure 2 illustrates the conventional architecture used to compute the arctangent function, where n determines the precision of the result. Theoretically, after n iterations, the final result has an accuracy of $2^{-n+1}$ and a maximum value of

$$\begin{array}{c}\hfill ta{n}^{-1}\left(2^0\right)+ta{n}^{-1}\left(2^{-1}\right)+\cdots +ta{n}^{-1}\left(2^{-n}\right),\end{array}$$

(3)

which is ${99.88}^{\circ }$ in terms of angle. In other words, when the angle of the input vector $(x_0,y_0)$ falls outside the range of [−99.88, 99.88] $x_0$ and $y_0$ must first be preprocessed (by rotating by 90 or 180 degrees, which are trivial transformations), allowing for the architecture to adapt to random inputs in all quadrants.

During the iteration of the CORDIC algorithm, although the modulus of the vector scales gradually, it does not affect the correct operation of the iteration, since the direction of the micro-rotation is derived from the sign bit of $y_i$. Meanwhile, as shown in Table 1, the result of the arctangent function can be derived directly from the final ${\omega }_n$, independently of the scale-factor $K_c$. In summary, the scale factor can be ignored throughout the computation of the arctangent.

3. Proposed Algorithm

To accelerate the iteration of the CORDIC algorithm, the proposed algorithm skips some unnecessary iterations by pre-rotation. In Figure 3, when the initial vector is $V_0$, it arrives at positions $V_1$ and $V_2$ after rotations, which, in radians, are $ta{n}^{-1}\left(2^0\right)$ and $ta{n}^{-1}\left(2^{-1}\right)$, respectively. Evidently, the value of the vertical coordinate of $V_2$ is closer to zero; this implies that the rotation from $V_0$ to $V_1$ can potentially be skipped. Therefore, the proposed algorithm performs pre-rotation before each iteration and compares the obtained results to select the most suitable rotation angle.

3.1. Single Iteration Process

The iterative equation for the proposed PR-CORDIC algorithm in vector mode is presented in (4):

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}{x}_n\hfill & =x_c+{\sigma }_c·y_c·2^{-k},\hfill \\ y_n\hfill & =y_c-{\sigma }_c·x_c·2^{-k},\hfill \\ {\omega }_n\hfill & ={\omega }_c+{\sigma }_c·{\alpha }_k,\hfill \end{array}\right.\end{array}$$

(4)

where the subscripts c and n represent the current and next values, respectively, k is an integer determined by the pre-rotations, and the value of ${\sigma }_c$ is either $sign\left(y_c\right)$ or 0 as determined by the pre-rotations. The r pre-rotations in one iteration are described in (5):

$$\begin{array}{c}\hfill \left\{\begin{array}{cc}{y}_1\hfill & =y_c-{\sigma }_{y_c}·x_c·2^{-i},\hfill \\ y_2\hfill & =y_c-{\sigma }_{y_c}·x_c·2^{-i-1},\hfill \\ \hfill & :\hfill \\ y_r\hfill & =y_c-{\sigma }_{y_c}·x_c·2^{-i-r+1},\hfill \end{array}\right.\end{array}$$

(5)

where i is determined by the previous iteration and ${\sigma }_{y_c}=sign\left(y_c\right)$.

In contrast with the previous algorithm, wherein the value of k is mechanically related to the number of iteration layers, in the PR-CORDIC algorithm it is related to the pre-rotation result. The pre-rotation and comparison processes are described in the pseudocode of Algorithm 1. The number of pre-rotations is set to $r=2$ for a simplified description:

Algorithm 1 Pre-rotation and Comparison
Input: $i_c$, $x_c$, $y_c$, ${\omega }_c$
Output: $i_n$, $x_n$, $y_n$, ${\omega }_n$
Function: $[i_n,x_n,y_n,{\omega }_n]$ = Compare$(i_c,x_c,y_c,{\omega }_c)$
1: ${\sigma }_{y_c}=sign\left(y_c\right)$.
2: $y_1=y_c+{\sigma }_{y_c}·x_c·2^{-i_c}$.
3: $y_2=y_c+{\sigma }_{y_c}·x_c·2^{-i_c-1}$.
4: ${\sigma }_{y_1}=sign\left(y_1\right),{\sigma }_{y_2}=sign\left(y_2\right)$.
5: if ${\sigma }_{y_c}={\sigma }_{y_1}$ then
6:     $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c}$
7:     ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c}\right)$	▹ Case 1
8:     $y_n=y_1$, $i_n=i_c$
9: else if ${\sigma }_{y_c}\ne {\sigma }_{y_1},{\sigma }_{y_c}={\sigma }_{y_2},|y_1|<|y_2|$ then
10:     $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c}$
11:     ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c}\right)$	▹ Case 2
12:     $y_n=y_1$, $i_n=i_c+2$
13: else if ${\sigma }_{y_c}\ne {\sigma }_{y_1},{\sigma }_{y_c}={\sigma }_{y_2},|y_1|>=|y_2|$ then
14:     $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c-1}$
15:     ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c-1}\right)$	▹ Case 3
16:     $y_n=y_2$, $i_n=i_c+2$
17: else if ${\sigma }_{y_c}\ne {\sigma }_{y_2},|y_2|<|y_c|$ then
18:     $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c-1}$
19:     ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c-1}\right)$	▹ Case 4
20:     $y_n=y_2$, $i_n=i_c+2$
21: else if ${\sigma }_{y_c}\ne {\sigma }_{y_2},|y_2|>=|y_c|$ then
22:     $x_n=x_c$, ${\omega }_n={\omega }_c$	▹ Case 5
23:     $y_n=y_c$, $i_n=i_c+2$
24: end if
25: return $i_n$, $x_n$, $y_n$, ${\omega }_n$

For better illustration, we provide examples for each of the five cases in Figure 4. When $y_c$ is negative, all cases are the same as when $y_c$ is positive.

In the proposed algorithm, the entire calculation process can be divided into two major stages. In the first stage, the rotation angle is fixed, and the number of iterations varies based on the angle of the input vector. In this stage, by using the initial angle for multiple iterations, we can rotate the input vector more greatly and expand the algorithm’s vector angle range. In Algorithm 1, the comparison results in this stage always correspond to Case 1. In the second stage, the rotation angle is not fixed, and we select the most suitable rotation angle by comparing the comparison results of r pre-rotations.

These two stages do not repeat, meaning there will be no transition from the second stage back to the first stage in the entire calculation process. This will be explained in the convergence proof section later.

3.2. Convergence of Proposed Algorithm

To prove the convergence of the proposed PR-CORDIC algorithm, it is necessary to demonstrate that the resultant vector is within the range of convergence for the following iterations. In Algorithm 1, it can be observed that when the angle of the resultant vector is excessively large, potentially exceeding the convergence range of the algorithm, Case 1 in the comparison arises. Therefore, in the convergence proof, we argue that Case 1 (the increase in $i_c$ being zero) only occurs in the initial few iterations.

The proof entails two steps. First, at the beginning of the algorithm, the number of iterations that $i_c$ remains unchanged (first major stage) is no more than three when the initial $i_c$ is 0. As $ta{n}^{-1}\left(2^0\right)={45.00}^{\circ }$ the angle of the current vector must be within ($-{45.00}^{\circ },{45.00}^{\circ }$) after no more than three rotations, which angle is ${45.00}^{\circ }$. Correspondingly, if the initial $i_c$ is 1, the iterations in the first stage will not exceed two times.

Second, when the increase in i in the algorithm is not zero, the increase in i cannot be zero in subsequent iterations. This is described in Theorem 1 and the proof is provided:

Theorem 1.

When ${\sigma }_{y_c}\ne {\sigma }_{y_1}$, (Cases 2–5), then $sign(y_n-sign\left(y_n\right)·x_n·2^{-i_n})\ne sign\left(y_n\right)$; that is, the condition ${\sigma }_{y_c}\ne {\sigma }_{y_1}$ will also be satisfied in the following iteration.

Proof of Theorem 1. 

Substituting (4) into the proof leads to

$$sign(y_c-{\sigma }_c·x_c·2^{-i_c-q}-sign\left(y_n\right)·(x_c+{\sigma }_c·y_c·2^{-i_c-q})·2^{-i_c-2})\ne sign\left(y_n\right),$$

(6)

where q denotes the increase in $i_c$. Furthermore, since $x_c$ is always positive in Case 2–5, simplifying the left side of (6) yields

$$sign({\sigma }_{y_c}·|tan\left({\omega }_c\right)|-{\sigma }_c·2^{-i_c-q}-sign\left(y_n\right)·(1+{\sigma }_c·{\sigma }_{y_c}·|tan\left({\omega }_c\right)|·2^{-i_c-q})·2^{-i_c-2}).$$

(7)

In Case 2, ${\sigma }_c={\sigma }_{y_c},q=0,{\sigma }_{y_n}=-{\sigma }_{y_c},3·2^{-i_c-2}<\left|tan\left({\omega }_c\right)\right|<2^{-i_c}$. Therefore, (7) in Case 2 is equal to:

$${\sigma }_{y_c}·sign\left(\right|tan\left({\omega }_c\right)|-3·2^{-i_c-2}+|tan\left({\omega }_c\right)|·2^{-i_c}·2^{-i_c-2}).$$

(8)

It is evident that (8) is equal to ${\sigma }_{y_c}$ and is opposite to ${\sigma }_{y_n}$. This indicates that Theorem 1 holds in Case 2. All possible scenarios are listed in

Table 2. Possible cases in proof of Theorem 1.

	${\mathit{\sigma }}_{\mathit{c}}$	q	${\mathit{\sigma }}_{{\mathit{y}}_{\mathit{n}}}$	$\left|\mathit{tan}\right({\mathit{\omega }}_{\mathit{c}}\left)\right|$	Sign of (7)
Case 2	${\sigma }_{y_c}$	0	$-{\sigma }_{y_c}$	$(3·R$ 1$,4·R)$	${\sigma }_{y_c}$
Case 3	${\sigma }_{y_c}$	1	${\sigma }_{y_c}$	$[2·R,3·R]$	$-{\sigma }_{y_c}$
Case 4	${\sigma }_{y_c}$	1	$-{\sigma }_{y_c}$	$(R,2·R)$	${\sigma }_{y_c}$
Case 5	0	−	${\sigma }_{y_c}$	$[0,R]$	$-{\sigma }_{y_c}$

¹ $R=2^{-i_c-2}$

. The sign of $y_n$ always differs from (7). Therefore, Case 1 only occurs in the initial few iterations in the entire calculation process.    □

On the basis of the aforedescribed proof, it can be concluded that the increase in $i_c$ would not always be zero, implying that the algorithm converges in all quadrants.

3.3. Other Pre-Rotation Counts

To illustrate the algorithm for different pre-rotation counts, we provide details of the algorithm for $r=3$ in Algorithm 2. Compared to Algorithm 1, Case 6 and Case 7 are additional in Algorithm 2. This is because there are three pre-rotation angles to be compared. After a more detailed comparison (Case 4–7), a more appropriate rotation angle can be obtained. The corresponding examples are shown in Figure 5, with Cases 1–3 not displayed as they are similar to those in Algorithm 1:

When the pre-rotation count r changes, the algorithm will involve more angle comparisons. However, simply increasing the pre-rotation count may not always effectively accelerate the iteration process. This will be explained in the next section.

Furthermore, in terms of convergence proof, although more pre-rotation counts lead to more cases, the proof process for convergence is similar to the one presented in the previous section for the algorithm of $r=2$. Therefore, we will no longer provide additional proofs.

Algorithm 2 Pre-rotation and Comparison for $r=3$
Input: $i_c$, $x_c$, $y_c$, ${\omega }_c$
Output: $i_n$, $x_n$, $y_n$, ${\omega }_n$
Function: $[i_n,x_n,y_n,{\omega }_n]$ = Compare$(i_c,x_c,y_c,{\omega }_c)$
1: ${\sigma }_{y_c}=sign\left(y_c\right)$.
2: $y_1=y_c+{\sigma }_{y_c}·x_c·2^{-i_c}$.
3: $y_2=y_c+{\sigma }_{y_c}·x_c·2^{-i_c-1}$.
4: $y_3=y_c+{\sigma }_{y_c}·x_c·2^{-i_c-2}$.
5: ${\sigma }_{y_1}=sign\left(y_1\right),{\sigma }_{y_2}=sign\left(y_2\right),{\sigma }_{y_3}=sign\left(y_3\right)$.
6: if ${\sigma }_{y_c}={\sigma }_{y_1}$ then
7:      $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c}$
8:      ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c}\right)$	▹ Case 1
9:      $y_n=y_1$, $i_n=i_c$
10: else if ${\sigma }_{y_c}\ne {\sigma }_{y_1},{\sigma }_{y_c}={\sigma }_{y_2},|y_1|<|y_2|$ then
11:      $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c}$
12:      ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c}\right)$	▹ Case 2
13:      $y_n=y_1$, $i_n=i_c+2$
14: else if ${\sigma }_{y_c}\ne {\sigma }_{y_1},{\sigma }_{y_c}={\sigma }_{y_2},|y_1|>=|y_2|$ then
15:      $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c-1}$
16:      ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c-1}\right)$	▹ Case 3
17:      $y_n=y_2$, $i_n=i_c+2$
18: else if ${\sigma }_{y_c}\ne {\sigma }_{y_2},{\sigma }_{y_c}={\sigma }_{y_3},|y_2|<|y_3|$ then
19:      $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c-1}$
20:      ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c-1}\right)$	▹ Case 4
21:      $y_n=y_2$, $i_n=i_c+3$
22: else if ${\sigma }_{y_c}\ne {\sigma }_{y_2},{\sigma }_{y_c}={\sigma }_{y_3},|y_2|>=|y_3|$ then
23:      $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c-2}$
24:      ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c-2}\right)$	▹ Case 5
25:      $y_n=y_3$, $i_n=i_c+3$
26: else if ${\sigma }_{y_c}\ne {\sigma }_{y_3},|y_3|<|y_c|$ then
27:      $x_n=x_c+{\sigma }_{y_c}·y_c·2^{-i_c-2}$
28:      ${\omega }_n={\omega }_c+{\sigma }_{y_c}·ta{n}^{-1}\left(2^{-i_c-2}\right)$	▹ Case 6
29:      $y_n=y_3$, $i_n=i_c+3$
30: else if ${\sigma }_{y_c}\ne {\sigma }_{y_3},|y_3|>=|y_c|$ then
31:      $x_n=x_c$, ${\omega }_n={\omega }_c$	▹ Case 7
32:      $y_n=y_c$, $i_n=i_c+3$
33: end if
34: return $i_n$, $x_n$, $y_n$, ${\omega }_n$

3.4. Number of Iterations

In this subsection, the number of iterations required by the PR-CORDIC algorithm is demonstrated. There are $n_1$ iterations from the first stage (where $i_c$ does not change) and $n_2$ iterations from the second stage.

The angle of the input vector and the fixed initial angle in the iteration determine the value of $n_1$. As shown in Figure 6, as the angle of the input vector changes, the value of $n_1$ could be 0, 1, 2 when the maximum rotation angle and also the fixed initial angle are set to $ta{n}^{-1}\left(2^1\right)\approx {63.43}^{\circ }$, while the value of $n_1$ could be 0, 1, 2, 3 when the maximum rotation angle is set to $ta{n}^{-1}\left(2^0\right)={45.00}^{\circ }$:

The value of $n_2$ is related to the growth rate of $i_c$ and the required accuracy of the result. From Algorithm 1, it is known that the greater the number of pre-rotations in each iteration, the greater would be the likely increase in $i_c$. If we approximate $arctan\left(2^{-i}\right)$ as twice $arctan\left(2^{-1-i}\right)$ then the average number of conventional CORDIC iterations that are equivalent to each PR-CORDIC iteration is denoted by

$$\begin{array}{c}\hfill 2·\frac{1}{2}+3·\frac{1}{4}+...+r·\frac{1}{2^{r-1}}+r·\frac{1}{2^{r-1}}=3-2^{2-r}.\end{array}$$

(9)

Therefore, when the accuracy of the result is required to be $2^{-t}$,

$$\begin{array}{c}\hfill n_2=\frac{t+1}{3-2^{2-r}},\end{array}$$

(10)

where r represents the number of pre-rotations. Therefore, the number of iterations does not decrease linearly when r increases.

In general, the proposed algorithm achieves a flexible selection of rotation angles through pre-rotation, thereby expanding the convergence range and reducing latency. However, since the rotations are not fixed as in traditional CORDIC, the scale factor is no longer constant. Therefore, in computations where the scale factor is needed, such as calculating the magnitude of a vector, the algorithm requires additional calculations, which may lead to a lack of efficiency. On the other hand, for computations that do not require the scale factor, such as arctangent, the proposed algorithm is more suitable.

4. Error Analysis

Errors in the CORDIC algorithm arise from two main sources: the word length used in the implementation and the number of iterations. For a more intuitive error analysis, a software simulation was used to analyze and compare the conventional algorithm against the proposed PR-CORDIC algorithm.

During the software simulation, the algorithmic error was characterized by the angle error defined as

$$\begin{array}{c}\hfill {\mu }_r=|{\alpha }_t-{\alpha }_e|,\end{array}$$

(11)

where ${\alpha }_t$ stands for the true values of $ta{n}^{-1}\left(\frac{y_0}{x_0}\right)$ and ${\alpha }_e$ represents the experimental values computed by CORDIC. All the arithmetic data were single floating-point numbers, except for ${\alpha }_t$ and ${\mu }_r$, which were double floating-point numbers. All the data and figures were generated using MATLAB R2016b software.

For a more reasoned analysis of the errors in PR-CORDIC, we initially simulated the computation of the arctangent function using conventional methods. During these simulations, the input range for $x_0$ was defined as [0, 10,000] and for $y_0$ as [−10,000, 10,000], and then 10,000 sets of data were randomly selected as inputs. The variation of maximum error and average error with the number of iterations is shown in Figure 7. Once the iteration count exceeded 23, further increases did not discernibly reduce either the maximum or average error. This is primarily attributable to the mantissa in the single-precision floating-point representation comprising only 23 bits.

In simulating the PR-CORDIC algorithm, the input range for $x_0$ was modified to [−10,000, 10,000], again with 10,000 data sets being input randomly. According to the discussion on the number of iterations in the preceding section, both the pre-rotation count r and the maximum rotation angle ${\alpha }_0$ are pivotal in shaping the relationship between iteration counts and precision. The experimental results depicted in Figure 8a,b indicate that while an increase in the pre-rotation count leads to a reduction in average error its impact on the maximum error is evidently negligible. Moreover, setting the maximum rotation angle to $ta{n}^{-1}\left(2\right)$ allows the algorithm to attain optimal error values comparable to conventional algorithms with a minimal number of iterations.

Figure 9 illustrates the relationship between the angle of the input vector and the associated error after 14 iterations of the proposed algorithm. Owing to the limited precision of single-precision floating-point numbers, with only 23 significant bits, the error increases with the angle of the vector. However, it does not exceed $5\times {10}^{-7}$.

In summary, the proposed PR-CORDIC algorithm demonstrates computational precision comparable to conventional algorithms while concurrently achieving a notable reduction in the number of iterations. Furthermore, a pre-rotation count of 2 exerts the most substantial influence on the maximum error. When the maximum rotation angle is set to $ta{n}^{-1}\left(2\right)$, the algorithm achieves the minimum number of iterations required to attain the theoretically optimal precision.

5. Proposed Architecture

In this section, we present two architectures based on the PR-CORDIC algorithm to compute the arctangent function. The first is an iterative architecture with low throughput and low resource requirements, while the other is a pipeline architecture with high throughput. The pipeline architecture optimizes a portion of the original algorithm to reduce the utilization of hardware.

5.1. Iterative Architecture

According to the discussion on errors in the previous section, when the pre-rotation count is set to r = 2 and the initial rotation angles ${\alpha }_0=ta{n}^{-1}\left(2\right)$, the algorithm reaches its minimum achievable error after the 13th iteration, and no further reduction is observed. The architecture we present employs single-precision floating-point arithmetic. Figure 10a shows the architecture of the pre-rotation process element. Figure 10b depicts the architecture of the process element for micro-rotation following comparison. The iterative architecture of the entire calculation process is illustrated in Figure 11.

The pre-rotation process element is used to obtain the results of (5). The comparator module is used to implement the comparison logic in Algorithm 1, which obtains the optimal rotation angle according to the input pre-rotation value. The ITERATION CNT serves as an iteration counter, controlling the initiation and termination of the entire computation process. The input data are updated and the output data ${\omega }_{final}$, $x_{final}$, $y_{final}$, $K_{final}$ are valid when all iterations are completed.

5.2. Pipeline Architecture

To enhance the data throughput, we propose a pipeline architecture for PR-CORDIC. Simply breaking down the iterative process into various stages within a pipeline architecture may unnecessarily increase resource usage. Therefore, in this architecture, the proposed algorithm is modified to simplify the pre-rotation process implementation.

Based on the error analysis from the previous section, when operating with single-precision floating-point data, the minimum rotational precision in the architecture is $ta{n}^{-1}\left(2^{-22}\right)$ and the rotation angle can be either one of two fixed angles or zero in each stage. Therefore, this pipelined architecture has 12 stages in total. Notably, owing to the fixed rotation angle per iteration in this architecture, its convergence domain is no longer arbitrary for any vector.

Its maximum input vector angle becomes

$$\begin{array}{c}\hfill ta{n}^{-1}\left(2^1\right)+ta{n}^{-1}\left(2^{-1}\right)+\cdots +ta{n}^{-1}\left(2^{-21}\right),\end{array}$$

(12)

which is approximated as ${99.51}^{\circ }$. To maintain the arbitrary nature of the input vectors, preprocessing and postprocessing of (13) are required before the data enter the iteration and after the iteration ends:

$$\begin{array}{c}\hfill \left\{\begin{array}{c}{x}_0=x_{in},{\omega }_{out}={\omega }_{n}if{x}_{in}\ge 0\hfill \\ x_0=-x_{in},{\omega }_{out}=\pi -{\omega }_{n}if{x}_{in}<0,y_{in}\ge 0\hfill \\ x_0=-x_{in},{\omega }_{out}=-\pi -{\omega }_{n}if{x}_{in}<0,y_{in}<0\hfill \end{array}\right.\end{array}$$

(13)

where $x_{in}$ and $x_{in}$ represent the input to the entire architecture, ${\omega }_{out}$ denotes the output, $x_0$ stands for the data entering the first iteration, and ${\omega }_n$ denotes the data output at the end of the iteration. After processing, the architecture can handle arbitrary vector inputs, producing output values within the range of $(-\pi ,\pi ]$.

Figure 12 illustrates the iterative process within the pipeline architecture when performing floating-point calculations. In contrast to the conventional CORDIC algorithm’s architecture depicted in Figure 2, each stage in Figure 12 incorporates additional adders, three multiplexers (MUXs) (with an extra one employed during the selection of $y_i$ in COMPARE), and two comparators (COMPs). Notwithstanding this observation, the total number of stages is reduced from 23 to 12. Figure 13 depicts the data preprocessing and postprocessing architecture designed to achieve (13). In this design, the sign bit of $x_{in}$ serves as the input controlling the iteration, and it also determines the final output after a delay of 12 cycles. Meanwhile, the sign bit of $y_{in}$ only influences the result after the delay. The primary resource consumption in this architecture involves three multiplexers and one adder.

Table 3. Comparison of hardware resource.

	Iterative		Pipeline
	Conventional	Proposed	Conventional	Proposed
adders	3	4	69	49
MUXs	4	5	0	39
COMPs	0	2	0	24
shifters	2	3	46	48

analyzes the comparative resource utilization of the proposed iterative/pipeline architecture and the conventional counterpart. The proposed architecture is shown to reduce markedly the reliance on adders, albeit by introducing a surplus of multiplexers and comparators. This distinctive feature substantially reduces resource requirements, particularly when employing single-precision floating-point calculations.

6. Implementation and Comparison

The proposed architecture was coded in the Verilog Hardware Description language (HDL), simulated using Xilinx Vivado 2017.4 software by applying 16-bit fixed-point inputs and float-point inputs, and implemented on an FPGA platform. To adequately compare the performance of PR-CORDIC with other algorithms in the computation of the arctangent function, we implemented the iterative and pipeline architectures for floating-point inputs, as well as the iterative architecture for 16-bit fixed-point inputs. The details of the estimated performance are discussed in this section.

As shown in

Table 4. Comparison of Implementation.

	Iterative		Pipeline
	Conventional	Proposed	Conventional	Proposed
Data Format	SFP 1	SFP	SFP	SFP
FPGA	Kintex-7	Kintex-7	Kintex-7	Kintex-7
LUTs	1837	2461	37,001	26,509
FFs	103	104	2087	1155
Throughput 2	1/23	1/13	1	1
Latency 3	23	13	23	12
Max Frequency	376 MHz	308 MHz	342 MHz	291 MHz
Range	[$-\pi /2,\pi /2$]	[$-\pi ,\pi$]	[$-\pi /2,\pi /2$]	[$-\pi ,\pi$]

¹ SFP: Single floating-point. ² The unit is the amount of data output per clock cycle. ³ The unit is clock cycles.

, we implemented iterative and pipeline architectures based on the PR-CORDIC and conventional CORDIC algorithms and compared them. The resource comparisons included LUTs, flip-flops (FFs), the iteration clock cycles, throughput rates, and other characteristics. It can be seen from the table that the proposed methods have a relatively lower maximum frequency, which is due to the addition of pre-rotation and COMPARE steps in each iteration. In the iterative architecture, the latency and throughput in computing the arctangent function are improved because PR-CORDIC can skip some unnecessary rotation angles compared to the conventional algorithm. In addition, the PR-CORDIC-based pipeline architecture reduces the resource usage and latency as the number of iterations is reduced from 23 to 12. Moreover, the input vector angle range of the proposed architecture is ($-\pi$, $\pi$), which is more consistent with the requirements of real-world usage. In summary, the proposed architecture guarantees accuracy in the results and reduces the resource usage and latency for standard single floating-point inputs.

To verify that the proposed method is state-of-the-art, we used several previous methods to compute arctangent functions for comparison. We again implemented the fixed-point PR-CORDIC based iterative architectures on FPGAs to better compare with the algorithm in [3].

As shown in

Table 5. Comparison of architecture for arctangent computation.

	[23,24]	[3]	[25]	Proposed	Proposed	Proposed
Algorithm	HA-CORDIC	Approximation	Preprocessing	PR-CORDIC	PR-CORDIC	PR-CORDIC
Precision (bits)	23	16	113	16	23	23
Data Format	FLP 1	FIP	QFLP	FIP	SFLP	SFLP
Architecture	Iterative	Table-based	Iterative	Iterative	Iterative	Pipeline
LUTs	1139	250	37,697	390	2461	26,490
FFs	498	128	-	56	104	1091
Memory	11	2	-	0	0	0
DSP	8	1	-	0	0	0
Throughput (data/clock)	1/26	1/8	1/32	1/8	1/13	1
Latency (clock cycles)	26	8	32	8	13	12

¹ FLP: floating-point, FIP: fixed-point, QFLP: quadruple-precision floating-point, SFLP: single floating-point.

, the first three rows present the performance of other work in computing the arctangent, and the last three rows present the performance of this paper. The main performance comparisons are LUTs, FFs, memory, DSP, throughput rate, latency. As observed, the proposed architectures can be flexibly used to compute arctangent functions for floating-point and fixed-point inputs. When fixed-point inputs are used, although the number of LUTs is increased in the proposed architecture compared to [3], the feature that does not require DSP and memory is maintained. In addition, the iterative architecture evidences less latency for floating-point inputs compared to the previous methods [23]. The data throughput rate of the pipeline architecture can process one data element per clock cycle, which facilitates its application in real-time systems.

7. Conclusions

This paper presents a CORDIC acceleration algorithm based on pre-rotation. The PR-CORDIC algorithm efficiently reduces the number of iterations, does not place restrictions on the input vector angle, and ensures the accuracy of the result. In addition, the corresponding iterative and pipeline architecture for the computation of the arctangent is detailed. The experimental results demonstrate that, in single-floating calculations, the proposed methods can effectively lower latency, reduce resource usage, and widen the input angle range compared to previous methods. And the proposed pipelined architecture can provide a higher throughput rate.