Analysis and Reduction for Angle Calculation Using the CORDIC Algorithm.
AbstractIn this paper, we consider the errors appearing in angle computations with the CORDIC algorithm (circular and hyperbolic coordinate systems) using fixed-point arithmetic. We include errors arising not only from the finite number of iterations and the finite width of the data path, but also from the finite number of bits of the input. We show that this last contribution is significant when both operands are small and that the error is acceptable only if an input normalization stage is included, making unsatisfactory other previous proposals to reduce the error. We propose a method based on the prescaling of the input operands and a modified CORDIC recurrence and show that it is a suitable alternative to the input normalization with a smaller hardware cost. This solution can also be used in pipelined architectures with redundant carry-save arithmetic.
INTRODUCTION
The CORDIC (Coordinate Rotation DIgital Computer) algorithm is an iterative technique that
permits computing several transcendental functions using only additions and shifts operations
[15] [16]. Among these functions are included trigonometric functions, like sine, cosine, tan-
gent, arctangent and module of a vector, hyperbolic functions, like sinh, cosh, tanh, arctanh,
and several arithmetic functions. Due to the simplicity of its hardware implementation several
signal processing algorithms, such as digital filters, orthogonal transforms and matrix factorization
have been formulated with Cordic arithmetic and, therefore, several Cordic-based VLSI
architectures have been proposed to solve these related signal processing problems [7].
In applications requiring high speed, pipelining and/or redundant arithmetic are introduced
in the implementation of the Cordic algorithm, in such a way that each iteration of the
algorithm is evaluated in a different stage of the pipeline. On the other hand, carry ripple
adders are replaced by redundant adders, carry save (CS) or signed digit (SD), where the carry
propagation within the adders is eliminated [4] [11] [13] [14]. As the control of the algorithm
requires the exact determination of the sign of some variable, a Modified Cordic algorithm
which facilitates the determination of the sign with redundant arithmetic has been proposed
[5].
analysis of the Cordic algorithm is fundamental for the efficient design of Cordic-
based architectures. To achieve a good performance, it is important to know the behaviour of
the error and to take into account the effect that it will have on the hardware implementation
to obtain a specified accuracy. The different sources of error of the Cordic algorithm have been
analyzed in detail [8] [9] [10].
In this paper we will focus on the errors appearing in the computation of the inverse tangent
function (angle calculation) with fixed-point arithmetic. This operation can be computed
with the Cordic algorithm in the vectoring mode and does not require the final scaling inherent
to the Cordic algorithm, since no scale factor is introduced in this mode of operation. The
angle calculation is useful in algorithms for matrix factorization like eigenvalue and singular
value decomposition (SVD) [6] and in the implementation of some digital filters [1] [12]. Matrix
factorization requires the angle computation in the circular coordinate system, while digital
filters may need angle computation in both circular and hyperbolic coordinates.
The rounding error that is accumulated in the control coordinate through all the iterations
of the Cordic algorithm may result in large error in the evaluation of the inverse tangent. This
error can be important in applications such the Cordic based SVD algorithm, where the inverse
tangent function is evaluated using fixed-point format with unnormalized data [10], or in some
kind of filters where hyperbolic inverse tangent need to be computed [1] [12]. In [10] a technique,
called partial normalization, is proposed to bound this error. However, this technique is hard
to implement with redundant arithmetic and does not take into consideration the initial error
due to the rounding of the input operands.
We perform an analysis of the error considering the following three components:
ffl Error due to the rounding of the input data
ffl Error due to the finite number of iterations
ffl Error due to the finite datapath width.
We show that the first of these components, which has not been considered in previous
analyses, is significant when both input operands are small. As a consequence, the solution
proposed in [10] might not be appropriate.
Because of the above, for small input operands it seems that the only suitable solution is
to perform a normalization of the input operands which includes additional bits. We present a
solution that performs a prescaling of the operands and modifies the CORDIC recurrence [5].
We show that this solution is simpler than normalization and produces a smaller total error.
The Cordic algorithm consists in the rotation of a vector in a circular or hyperbolic coordinate
system. The rotation is performed by decomposing the angle into a sequence of preselected
elementary angles. Specifically, the basic Cordic iteration or microrotation is [15] [16]
where m is an integer taking values +1 or \Gamma1 for circular or hyperbolic coordinates, respectively,
are the variables x, y and z before the microrotation,
tan
is the microrotation angle. The shifting sequence s(m; i) in a circular
coordinate system is s(1; in a hyperbolic coordinate system a sequence such as
may be chosen, starting with microrotations have to be repeated.
The Cordic iterations in coordinates x and y can be rewritten in matrix notation as,
being the input vector at iteration i, v[i the output vector
and
Depending on parameter m, the Cordic algorithm may evaluate trigonometric functions
selecting
the y coordinate is reduced to zero. This permits evaluating the angle of a vector that is
accumulated in z n+1 , in such a way that z coordinates and
z coordinates.
In the following we derive numerical bounds for the overall error in the computation of the
inverse tangent function in the circular,
coordinate systems. In these cases, the y coordinate is reduced to zero by chosing according
to equation (4) and the angle computed, ', is stored in variable z. We follow the notation
introduced in [8] and [10].
The accuracy of the Cordic algorithm and its influence on processor design was first
analyzed by Walther [16]. He concluded that, to obtain a precision of n bits, data paths with
bits are needed. Later, more precise bounds in all the modes of the Cordic algorithm
have been obtained [8] [9] [10].
Hu [8] performs a thorough analysis of several errors in all the modes of the Cordic
algorithm and derives numerical error bounds for each type of error. However, no results on the
inverse tangent and inverse hyperbolic tangent computations are included. In [10] it has been
shown that the numerical errors in inverse tangent computation using fixed point arithmetic
with small operands can be too large.
The overall error is split into two components, an approximation error and a rounding
error. The approximation error is due to the angle quantization. That is, the decomposition of
the angle into a finite number of microrotation angles produces an error in the representation
of the angle. On the other hand, the rounding error is caused by the finite word length of any
data path.
If we denote as ideal Cordic the mathematically defined Cordic algorithm, with infinite
precision in the data path and infinite number of microrotations, and as real Cordic the practical
implementation of the Cordic algorithm, with finite precision in the data path and finite number
of microrotations, it is possible to define an intermediate Cordic that uses infinite precision
arithmetic and the same number of microrotations as the real Cordic. Figure 1 shows the
relationship among the three definitions. In this way, the approximation error is the difference
between the output of the ideal Cordic and the output of the intermediate Cordic. The rounding
error is the difference between the output of the intermediate Cordic and that of the real Cordic.
Usually, the error due to the rounding of the input operands has been neglected. That
is, it has been considered that there are no rounding errors in the input data. But often, the
real situation is that the input data is obtained from another hardware module or from the
rounding of variables with larger precision. In such cases, there is as initial rounding error in
the input data that has to be considered when deriving the bounds. This source of error can
become very important in applications involving small inputs.
We consider fixed-point arithmetic with n fractional bits in the input operands and b
fractional bits in the representation of the x, y and z data paths inside the Cordic, to obtain
n-bit results. The wordlengths used are illustrated in figure 2. This way, the initial rounding
error in the input operands is and the rounding error introduced in
each microrotation is
For circular coordinates the value of coordinate y obtained with the intermediate Cordic
after microrotations is
being ff the angle calculated with the intermediate Cordic. On the other hand, the angle '
computed by the ideal Cordic is given by
Then, the approximation error is [10]
being jv[0]j the module of the input vector
On the other hand,
jy
y n+1 is the value of y n+1 with finite precision and f c
n+1 is the rounding error in coordinate
y after microrotations. For convergence,
j"y
Then, considering the rounding error in the z datapath ((n conclude that
the angle error is bounded by,
Now, we have to find a bound for f c
n+1 . Following the derivation in [8], the rounding error
is bounded by,
Y
Y
where P 1 (i) is given by equation (3) and k \Delta k is the l 2 norm, defined as the square root of
the largest eigenvalue of the matrix [8]. The rounding error is composed of two parts: the
rounding error produced by the initial rounding error in the input operands (first term), and
the rounding error accumulated in n+ 1 microrotations considering no initial rounding error in
the input data (second and third terms). Therefore,
where
\Gamman is due to the initial rounding error (first term of equation (11)) and
1:5 is due to the accumulated rounding error (second and third terms of equation
(11)).
Then, replacing equation (12) in equation (10) the bound for the overall error in the
computation of the inverse tangent function is obtained,
\Gamman
1:5
Equation 13 shows that the error in the computation of the inverse tangent does not have
a constant bound as it depends on the norm of the input vector, jv[0]j. The error becomes
larger the smaller the norm of the input vector, in such a way that when x 0 and y 0 are close
to zero, a large error results. Consequently, the error is not bounded if the input operands are
not bounded.
A similar equation may be obtained for the overall error of the hyperbolic vectoring
being m the number of Cordic iterations in hyperbolic coordinates [16] and ' max is the maximum
input angle. In this case, the error becomes large when the hyperbolic norm of the input vector,
0 , is small.
By means of the input normalization, the error can be bounded since a lower bound on
jv[0]j is enforced. However, the implementation of the normalization requires extra hardware to
determine the amount by which the components of the vector can be shifted, two leading-zero
encoders and a comparator, and barrel shifters to perform the shifts in a single cycle. Therefore,
the normalization is very hardware consuming.
In [10] an alternative solution is proposed for the circular vectoring, the partial normal-
ization, that involves the modification of the Cordic unit to include a normalization step, which
is integrated with the Cordic iterations. This solution bounds the error. The main drawbacks
of this solution are that the initial rounding error is not considered and it is very difficult to
implement efficiently with redundant arithmetic.

Figure

3 illustrates the partial normalization. As the input normalization is distributed
along the Cordic iterations, the normalization is performed by introducing zeros, and not real
bits, in the least significant positions of the input data. That is, when the input data is known
with a precision larger than the precision used in the Cordic iteration, b bits, only b bits of the
input are considered for normalization and the extra bits of the input are ignored, resulting in
a large error not considered in the analysis performed in [10].

Figure

4 shows the error produced with the partial normalization when an initial rounding
error is considered, the error with the conventional Cordic algorithm and the error produced
using the Cordic with input normalization. In this latter case, the error considering normalization
introducing zeros and normalization with real bits are considered. The figure plots the
error, expressed as the precision obtained in the angle, versus the module of the input vector.
Although the error is lower than the error produced with the standard Cordic algorithm, it is
still very significant for small inputs, and higher than the error of the Cordic algorithm with
input normalization, because the partial normalization is performed introducing zeros.
On the other hand, the microrotations are modifed to include the normalization, resulting
in microrotations that include comparisons to choose the maximum and minimum of two variables
and variable shifts to perform the normalization. Therefore, this solution is not adequate
for redundant arithmetic and/or pipelined architectures.
In the next sections, new approaches are developed to bound the error of the angle calcu-
lation. These approaches are suitable for word-serial or pipelined architectures with redundant
or non-redundant arithmetic, and require little extra hardware cost.
4 MODIFIED CORDIC ALGORITHM
The introduction of redundant arithmetic in the angle computation with the Cordic algorithm
has motivated the development of modified Cordic microrotations for the circular coordinate
system [5], where the recurrences are transformed making
Then the microrotations (equation (1)) are transformed into
and the selection of the ffi i is performed according to the following equation

Figure

5 illustrates the modified Cordic algorithm. The w coordinate is not reduced to
zero, because of the left shift that is performed over this coordinate at each microrotation.
This transformation facilitates the implementation of the Cordic algorithm with redundant
arithmetic. In redundant arithmetic, CSA or SDA, the exact determination of the sign of
coordinate y is time consuming because of the redundant representation of this coordinate.
With this transformation it is possible to use an estimate of the redundant representation of
w i in the determination of ffi i , instead of its fully assimilated value. To make this possible
it is necessary to use a redundant representation of the angle, allowing ffi i to take values in
the set \Gamma1; 0:1. The corresponding selection functions for using carry-save or signed-digit
representations can be found in [5]. Moreover, the hardware is reduced since one of the shifters
is eliminated.
In this work, we propose this same change in the Cordic equations but with the aim of
reducing the errors in the computation of the inverse tangent function. In the following, we
obtain the error bounds of the angle computation with the modified Cordic algorithm, based
on variable w, in the circular and hyperbolic coordinates. We take into account the initial
rounding error in the input operands.
4.1 Angle Error Analysis in Circular Coordinate System
The modified Cordic iterations in circular coordinate system, given by equation (16), can be
rewritten as
being the input vector, v[i the output vector and Pw;1 (i) the
transformation matrix
Following a similar derivation as for the standard Cordic algorithm, it is possible to find
a bound for the overall error. This way, the value of coordinate w after microrotations is
being ff the angle calculated with the intermediate Cordic. Then, equation (20) can be rewritten
as,
where ' is the angle of vector v[0]. Therefore,
and the approximation error is
Then, considering the rounding error in the z datapath, the angle error with the modified
algorithm in circular coordinates is bounded by,
w;n+1 is the rounding error in coordinate w after
Now, we have to find a bound for f c
w;n+1 . We can use equation (11), but considering that
the transformation matrix is given by equation 19,
Y
Y
Moreover, the rounding error introduced in each microrotation of the modified Cordic algorithm
is bounded by that is, no rounding error is introduced in coordinate w, as it
is multiplied by a factor of 2 each microrotation and there are no right shifts.
To evaluate the l 2 norm of the matrix product, k
i=j Pw;1 (i) k, the following relation [2]
has to be taken into account n
Y
Y
where
and
As k
the rounding error in the modified Cordic algorithm is bounded by
being the first term the contribution of the initial rounding error and the second one the
accumulated error in the microrotations.
Replacing this result in equation (24) the error in the computation of the angle with the
modified algorithm is obtained,
As it can be seen by comparing equations (13) and (30), there is a reduction in the error
of the computation of the angle, tan using the modified Cordic iterations. This
is due, mainly, to the elimination of the rounding error in the w coordinate, that results in
a lower accumulated rounding error after n iterations. Figure 6a shows the errors observed
for several initial values with the standard and the modified Cordic algorithms, with
and several different values of b. In both cases, the error becomes more important as jv[0]j
decreases, although the error with the standard Cordic is always slighty larger than the error
with the modified Cordic.
However, although the diference between the errors with the standard and the modified
algorithms is small, the modified Cordic algorithm results in a simpler hardware imple-
mentation, since one shifter is eliminated, and is suitable for implementations with redundant
arithmetic.
4.2 Angle Error Analysis in Hyperbolic Coordinate System
The analysis that has been developed in the previous section can be extended to the evaluation
of the error in the angle computation in hyperbolic coordinates. Now, the function we are
calculating is tanh iteration i=0 is not evaluated. Similarly to circular coordinates,
we can define the modified Cordic algorithm, by means of the transformation given in equation
(15). Then, the modified microrotation is
Similarly to the circular coordinate case, we find that the quantization error is given by
Therefore, to obtain a bound in the error of the angle calculation, we have to find a bound
for the accumulated rounding error, f h
w;n+1 . We use equation (25), but considering that the
transformation matrix, Pw;\Gamma1 (i), is
Similarly to the case of circular coordinate system, to evaluate k
into account equation (26) with matrix A(nj) defined as in equation (27) and matrix Q(ij)
defined as
where the values of q 0 and q 1 depend on the type of microrotation performed as follows
if is a repetition and
is a repetition and i ? j
Therefore, the l 2 norm of this matrix is
if it is a repetition and
This way, the rounding error in hyperbolic coordinates is obtained as
Then, considering the rounding error of the z data path, the overall error in the hyperbolic
angle computation with the modified Cordic algorithm is
The errors of the standard and modified Cordic algorithms operating in hyperbolic vectoring
with are shown in figure 6b. As in the circular vectoring mode of operation, the
error is reduced by means of the utilization of the modified Cordic algorithm as the rounding
error in the w coordinate is eliminated.
On the other hand, from the observation of figure 6, we find that the error in hyperbolic
vectoring is larger than in circular vectoring. The hyperbolic coordinate scale factor, K h , is less
than unity and reduces the operands and the hyperbolic module of the vector decreases with
the mapping of the vector over the x-axis. Therefore, the rounding error is more important in
hyperbolic coordinates than in circular coordinates.
According to equation (38), the hyperbolic vectoring error would be large even with
normalized inputs, when x 1 and y 1 are similar. However, the range of convergence of the
algorithm imposes a limit to the value of x
considering the basic sequence of microrotations of the Cordic algorithm for hyperbolic coordinates
[16], which results in ' Therefore, the error will only be significant when the
inputs operands are small.
Although the modified Cordic algorithm reduces the overall error in the angle computa-
tion, both in circular and in hyperbolic coordinate system, this error is still unbounded and it
becomes very important when the module of the input vector is small. The smaller the module
of the input vector, the larger the error. Therefore, it is necessary to develop solutions that
efficiently reduce the error, with a low hardware and timing cost.
The error in the angle calculation with the modified Cordic algorithm is still unbounded and
large when the module of the input vector is small. The more natural solution to this problem
is the normalization of the input operands, however this requires two leading-zeros coders, a
comparator and two barrel shifters. That is, it is very hardware consuming.
We propose a solution for the minimization of the angle calculation error with the modified
algorithm in circular and hyperbolic coordinates, both in non-redundant and redundant
arithmetic. We develop a solution based in an operand pre-scaling, where the error is bounded
and close to the precision of the algorithm. The hardware implementation is simpler than the
implementation of the partial normalization technique and the standard input normalization.
Moreover, unlike to the solution developed in [10], this solution may applied to the Cordic
algorithm with redundant arithmetic.
The angle calculation error is only important when the module of the input vector is
small. Therefore, if the input vector module is forced to take large values, the angle error is
reduced and the output of the Cordic algorithm is within the precision required. The operand
pre-scaling technique multiplies the module of the input vector by a constant factor, in such
a way that the resulting module is large enough to minimize the angle calculation error. The
pre-scaling is carried out before starting the Cordic iterations, thus being a preprocessing stage.
In the following we consider that, to perform the operand pre-scaling, b bits of the input
operands are known, where b is the internal wordlength of the Cordic and the p least significant
bits are used in the pre-scaling to shift to the right the input vectors, as shown in figure 7.
As it has been shown before, with the solution presented in [10] is not possible to perform the
normalization considering additional bits of the input.
Taking into account these considerations, the pre-scaling is as follows
being (x in ; w in ) the input variables and the inputs to the Cordic processor after the
pre-scaling. Then,
the module of the input vector is multiplied by a scaling factor M . This way, the error in the
computation of the inverse tangent function is reduced by an important factor, because we are
reducing the rounding error and we are also imposing a lower bound for v in of M \Delta 2 \Gamman .
The pre-scaling should only be carried out when the input vector module is small. There-
fore, M is defined as,
1 if jx in j  2 \Gammas or jw in j  2 \Gammas
That is, the pre-scaling is only performed if the module of the input vector is lower than 2 \Gammas .
In this case, we multiply the input vector times 2 s to obtain a large module. The value of s
should be chosen in such a way that the error is minimized. That is, the error in the angle
computation of an input vector with module jv in j  2 \Gammas must already be bounded and close to
the precision of the algorithm.
This way, the maximum overall error for the angle computation in circular coordinates
with pre-scaling is obtained by replacing jv[0]j in equation
considering in this later case that the minimum input vector module is jv in
This results in
sin
sin
K1 \Delta2 \Gamma(16\Gammas)

Figure

8 shows the error with several different pre-scalings, corresponding to
pre-scaling), 9. The precision of the algorithm is and the internal
precision of the modified Cordic arquitecture is Moreover, the input operands are
rounded to bits after the pre-scaling; that is, the pre-scaling is carried out considering
that, at least, b bits of the input are known. While the module of the input vector is
less than 2 \Gammas , since the module is not modified, the error is the same as without pre-scaling
when the module is larger than 2 \Gammas , that is, the pre-scaling is carried out, the
error is significantly reduced, since the module has been enlarged with the pre-scaling. Similar
results can be obtained for hyperbolic coordinate system.
However, the error in the angle, although has been reduced, is still large in vectors with
module jv in j ! 2 \Gamma2s . For example, when the pre-scaling is performed with the error
is large for input vectors with a small module, less than, approximately 2 \Gamma10 . On the other
hand, when the scaling factor is large, some input vectors with module less than 2 \Gammas present
an important error. For example, with pre-scaling the error is large when the module is
between 2 \Gamma6 and 2 \Gamma9 , since the pre-scaling has not been carried out.
From expression (43) and the illustration of Figure 8, it can be seen that there is no single
value of s that produces an acceptable error for the whole range of jv[0]j. This can be achieved
by a double pre-scaling in which two different scaling factors are used
so that
1 if jx in j  2 \Gammas1 or jw in j  2 \Gammas1
with s1  s2.

Figure

9 shows the error for circular and hyperbolic coordinates, respectively, considering
double pre-scaling with 9. This way, the maximum error has been reduced
to, approximately, 2 \Gamma15 , that is very close to the precision of the algorithm, for every input
vector module. Moreover, a common pre-scaling for hyperbolic and circular coordinates has
been used, which facilitates the VLSI implementation of the modified Cordic architecture.

Figure

compares the error in the angle calculation using the partial normalization
technique, described in [10], and the pre-scaling technique with double pre-scaling and modified
equations. The error with the pre-scaling technique is always lower than the error with
the partial normalization, because, as said before, the partial normalization can not use bits,
corresponding to precision less than 2 \Gammab , of the input to perform the normalization.
The pre-scaling can be extended to other precision, although for high
precision, n  32, it is necessary to consider at least three values for the scaling factor.
5.1 Pre-Scaling Technique with Non-Redundant Arithmetic
If the Cordic algorithm is implemented using non-redundant arithmetic, the hardware implementation
of the pre-scaling technique consists in the comparison of the module of the vector
to the scaling factors and the corresponding shifting of the input operands. The comparison of
the module to the scaling factor is performed according equation (44), that is, the two input
coordinates are compared to 2 \Gammas1 and 2 \Gammas2 , and the corresponding scaling factor is obtained.
As an example, the implementation of the double pre-scaling technique with
shown in figure 11. As it can be seen, it is necessary to include only a small number of
control gates and two rows of multiplexers, that are in charge of selecting the scaled or unscaled
operand. The first row of multiplexers performs the shift 2 5 , according to the result of checking
bits 0 to 5 of x in and w in , in such a way that the shift is carried out if these bits are equal to 1
or 0, that is, negative positive numbers less than 2 \Gamma5 . In the second pair of multiplexers an
additional shift of 2 4 is performed if bits 6 to 9 are also 1 or 0, performing in this case a total
shift of 2 9 .
5.2 Pre-Scaling Technique with Redundant Arithmetic
The implementation of the Cordic algorithm with redundant arithmetic requires the assimilation
of a certain number of bits of the w variable, to obtain an estimation of the sign, which is used
in the determination of the direction of each microrotation [5] [11] [13]. This can only be applied
to normalized data because the position of the more significant bit has to be known, in such a
way that if the data is not normalized it is necessary to perform a previous normalization.
In [3] a Cordic architecture that avoids the assimilation and checking of a certain number
of bits is proposed. This architecture is based on the More-Significant-Bit-First calculation
of the absolute value of the y coordinate and in the detection of magnitude changes in this
calculation. The calculation of the direction of the microrotation requires the propagation of
a "carry" from the most-significant to the least-significant bit of the y coordinate. For this
reason additional registers are needed for the skew of the data. An important characteristic of
this architecture is that the input data do not need to be normalized. The angle calculation
error is as described in previous sections. Although this architecture uses the y coordinate as
control variable, it can be modified to use variable w instead of the y coordinate, resulting in
an high-speed implementation of the modified Cordic algorithm.
On the other hand, the pre-scaling can be performed with the scheme shown in figure
11. This way, the pre-scaling technique may be incorporated as a pre-processing stage of this
architecture to obtain a pipelined redundant arithmetic Cordic which permits the computation
of the inverse tangent function in circular and hyperbolic coordinates without errors over
unnormalized data, without any need for performing an initial normalization.
5.3 Evaluation of the Pre-Scaling Technique
The hardware complexity of the double pre-scaling is lower than the complexity of a standard
normalization stage. Actually, the pre-scaling technique can be considered as an incomplete
normalization, where only two different shifts are possible.
On the other hand, this hardware complexity is also lower than the partial normalization
[10]. The partial normalization implies the introduction of additional hardware into the Cordic
architecture. If the x-y registers are b bits long, it is necessary to introduce two normalization
shift registers with a maximum shift of (m=2) 1=2 . In addition two leading-zero encoders which
operate over the (m=2) 1=2 most significant digits of coordinates x and y are required. An
increase in the clock cycle is produced because of the inclusion of two normalization barrel
shifters in the critical path of the word-serial implementation.
The solution we have presented, the pre-scaling technique, does not introduce additional
hardware in the Cordic processors, since the pre-scaling is a pre-processing stage. Moreover,
the utilization of variable w instead of coordinate y permits reducing the global hardware cost
of the Cordic architecture because one of the shifters is eliminated.
Finally, the pre-scaling technique can be used in pipelined processors with redundant
arithmetic, whereas the partial normalization technique is restricted to a word-serial architecture
with conventional non-redundant arithmetic. A pipelined architecture for the Cordic
algorithm with the partial normalization technique would need two barrel shifters in each stage
of the pipeline, in addition to the hardware implementation of the Cordic microrotations. The
implementation of the partial normalization with redundant arihtmetic is inefficient, since there
are several comparisons involved.
6 CONCLUSIONS
A thorough analysis of the errors appearing in the calculation of the inverse tangent and the
hyperbolic inverse tangent functions with the Cordic algorithm shows that large numerical
errors can result when the inputs are unnormnalized and the module of the input vector is
small.
We have shown, by means of an error analysis, that the utilization of a modified Cordic
algorithm based on the w iteration siginificantly reduces the numerical errors in the angle
computation with circular and hyperbolic coordinates. In this analysis the rounding error in
the input operands has been taken into account, error source neglected in some previous analyse
in the literature, and it has been shown that this error becomes very important in applications
involving unnormalized inputs.
On the other hand, we propose a solution to the problem, operand pre-scaling, that
results in a low cost VLSI implementation. The operand pre-scaling technique consists of a
pre-processing stage, before the cordic microrotations, where the the input vector is scaled by a
constant factor if the module is small enough to result in a large error in the angle computation.
This solution can be used in pipelined and word-serial cordic processors with redundant or non-redundant
arithmetic. Moreover, the pre-scaling can be chosen in such a way that the same
scale factor is used for circular and hyperbolic coordinate systems.



--R

"A VLSI Speech Analysis Chip Set Based on Square-Root Normalized Ladder Forms"
"Unnormalized Fixed-Point Cordic Arithmetic for SVD Processors"
"High Speed Bit-Level Pipelined Architectures for Redundant Cordic Implementations"
"The Cordic Algorithm: New Results for Fast VLSI Implementation"
"Redundant and On-Line Cordic: Application to Matrix Triangularization and SVD"
"Redundant and On-Line Cordic for Unitary Transforma- tions"
"Cordic-Based VLSI Architectures for Digital Signal Processing"
"The Quantization Effects of the Cordic Algorithm"
"A Neglected Error Source in the Cordic Algorithm"
"Numerical Accuracy and Hardware Tradeoffs for Cordic Arithmetic for Special-Purpose Processors"
"Constant-Factor Redundant Cordic for Angle Calculation and Rotation"
"2-Fold Normalized Square-Root Schur RLS Adaptive Filter"
"Redundant Cordic Methods with a Constant Scale Factor for Sine and Cosine Computation"
"Low Latency Time Cordic Algorithms"
"The Cordic Trigonometric Computing Technique"
"A Unified Algorithm for Elementary Functions"
--TR

--CTR
Toms Lang , Elisardo Antelo, CORDIC Vectoring with Arbitrary Target Value, IEEE Transactions on Computers, v.47 n.7, p.736-749, July 1998
error analysis;operand normalization;angle computation;redundant arithmetic;CORDIC algorithm